diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 094c1f3893..bec29abaf5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,6 +17,10 @@ on:
 env:
   CARGO_TERM_COLOR: always
   RUST_BACKTRACE: 1
+  # No test or fuzz run may print a page: the engine refuses to spool, and if something ever
+  # bypasses that, lp fails loudly on a printer that does not exist.
+  PHOTOCRAFT_NO_PRINT: "1"
+  LPDEST: photocraft-no-such-printer
   # Debug and test builds keep line tables (file:line in panic backtraces) but drop the rest of the
   # debug info: faster codegen and links (Windows PDBs most of all), and a target dir small enough
   # for the Linux job's second, craft-fonts build (it ran out of disk with full debug info).
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 85d0cd2c81..bfdca9e3e9 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -35,3 +35,9 @@ jobs:
       APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
       WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
       WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+      AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
+      AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
+      AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
+      AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md
index 1ea4034dbe..23629ff23b 100644
--- a/ATTRIBUTION.md
+++ b/ATTRIBUTION.md
@@ -10,6 +10,7 @@ next to them.
 
 | Path | Title | Author | Source | License |
 |---|---|---|---|---|
+| `crates/codecs/src/codecs/xpm/x11_colors.rs` | X11 `rgb.txt` color-name lookup table (normalized X.Org RGB values) | X.Org Foundation and X11 contributors | <https://cgit.freedesktop.org/xorg/app/rgb/tree/rgb.txt> | MIT (X.Org app/rgb) |
 | `crates/ui-egui/src/i18n/el.tsv` | Greek UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
 | `crates/ui-egui/src/i18n/de.tsv` | German UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
 | `crates/ui-egui/src/i18n/it.tsv` | Italian UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
@@ -19,10 +20,13 @@ next to them.
 | `crates/ui-egui/src/i18n/pt-br.tsv` | Brazilian Portuguese UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
 | `crates/ui-egui/src/i18n/uk.tsv` | Ukrainian UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
 | `crates/ui-egui/src/i18n/cs.tsv` | Czech UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
+| `crates/ui-egui/src/i18n/hu.tsv` | Hungarian UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
 | `crates/ui-egui/src/i18n/vi.tsv` | Vietnamese UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
+| `crates/ui-egui/src/i18n/tr.tsv` | Turkish UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
+| `crates/ui-egui/src/i18n/sr.tsv` | Serbian (Latin, Ekavian) UI translations | PhotoCraft contributors | Original translations of PhotoCraft's English labels | MIT OR Apache-2.0, [`LICENSE-translations.txt`](crates/ui-egui/src/i18n/LICENSE-translations.txt) |
 | `assets/fonts/Inter-Regular.ttf`, `Inter-Medium.ttf`, `Inter-SemiBold.ttf` | Inter 4.001 (UI font) | The Inter Project Authors (Rasmus Andersson) | <https://github.com/rsms/inter> | SIL OFL 1.1, [`assets/fonts/OFL-Inter.txt`](assets/fonts/OFL-Inter.txt) |
 | `assets/fonts/JetBrainsMono-Regular.ttf` | JetBrains Mono 2.305 (numeric font) | The JetBrains Mono Project Authors | <https://github.com/JetBrains/JetBrainsMono> | SIL OFL 1.1, [`assets/fonts/OFL-JetBrainsMono.txt`](assets/fonts/OFL-JetBrainsMono.txt) |
-| `assets/icons/*.svg` except `slice-knife.svg`, `sampler.svg`, `artboard.svg`, `perspective-crop.svg`, `frame-placeholder.svg`, `type-mask.svg`, `type-mask-vertical.svg`, `clip-below.svg`, `clip-release.svg`, `layer-mask.svg`, `adjustment-layer.svg`, `brush-replace.svg`, `eraser-background.svg`, `eraser-magic.svg`, `lasso-magnetic.svg`, `direct-select.svg`, `convert-point.svg`, `pen-add-anchor.svg`, `pen-delete-anchor.svg`, `pen-freeform.svg`, `pen-curvature.svg`, `bandage-sparkle.svg`, `painting-symmetry.svg`, `symmetry-*.svg` and `marquee-{row,column}.svg`, `align-edge-*.svg` and `distribute-*.svg` (113 files; `star-filled.svg` is `star.svg` with a solid fill) | Lucide icons | Lucide Icons and Contributors | <https://github.com/lucide-icons/lucide> (`icons/<name>.svg`; `align-*` are now named `text-align-*` upstream) | ISC, [`assets/icons/LICENSE-lucide.txt`](assets/icons/LICENSE-lucide.txt) |
+| `assets/icons/*.svg` except `slice-knife.svg`, `sampler.svg`, `artboard.svg`, `perspective-crop.svg`, `frame-placeholder.svg`, `gradient.svg`, `type-mask.svg`, `type-mask-vertical.svg`, `clip-below.svg`, `clip-release.svg`, `layer-mask.svg`, `adjustment-layer.svg`, `brush-replace.svg`, `eraser-background.svg`, `eraser-magic.svg`, `lasso-magnetic.svg`, `direct-select.svg`, `convert-point.svg`, `pen-add-anchor.svg`, `pen-delete-anchor.svg`, `pen-freeform.svg`, `pen-curvature.svg`, `bandage-sparkle.svg`, `painting-symmetry.svg`, `symmetry-*.svg` and `marquee-{row,column}.svg`, `align-edge-*.svg` and `distribute-*.svg` (113 files; `star-filled.svg` is `star.svg` with a solid fill) | Lucide icons | Lucide Icons and Contributors | <https://github.com/lucide-icons/lucide> (`icons/<name>.svg`; `align-*` are now named `text-align-*` upstream) | ISC, [`assets/icons/LICENSE-lucide.txt`](assets/icons/LICENSE-lucide.txt) |
 | `assets/icons/{check,chevron-down,chevron-left,chevron-right,chevron-up,chevrons-left,chevrons-right,circle,clock,compass,info,link,link-2,lock,minus,monitor,moon,move,navigation,plus,search,square,trash,triangle,type,x,zoom-in}.svg` | Lucide icons derived from Feather (subset of the row above) | Cole Bemis (Feather), Lucide Contributors | <https://github.com/feathericons/feather> via Lucide | MIT (Feather) and ISC (Lucide), [`assets/icons/LICENSE-lucide.txt`](assets/icons/LICENSE-lucide.txt) |
 | `assets/icons/slice-knife.svg` | Slice tool glyph | PhotoCraft contributors | Original work | MIT OR Apache-2.0 |
 | `assets/icons/sampler.svg` | Color Sampler tool glyph: a target reticle marking a sampled pixel | PhotoCraft contributors | Original work | MIT OR Apache-2.0 |
@@ -35,6 +39,7 @@ next to them.
 | `assets/icons/layer-mask.svg`, `assets/icons/adjustment-layer.svg` | Layers panel footer glyphs: Add a mask (a frame around a solid disc) and New Fill or Adjustment Layer (a circle, one half solid), drawn on Lucide's 24 px grid and stroke | PhotoCraft contributors | Original work | MIT OR Apache-2.0 |
 | `assets/icons/align-edge-*.svg`, `assets/icons/distribute-*.svg` | Move tool options-bar glyphs: Align (six edges/centres) and Distribute (edges, centres, spacing), a guide line or edge lines with bars, drawn on Lucide's 24 px grid and stroke | PhotoCraft contributors | Original work | MIT OR Apache-2.0 |
 | `assets/icons/frame-placeholder.svg` | Frame tool glyph: an empty placeholder frame, crossed corner to corner | PhotoCraft contributors | Original work | MIT OR Apache-2.0 |
+| `assets/icons/gradient.svg` | Gradient tool glyph: a rounded rectangle filled with a left-to-right linear ramp, drawn on Lucide's 24 px grid and stroke | PhotoCraft contributors | Original work | MIT OR Apache-2.0 |
 | `assets/icons/eraser-background.svg`, `assets/icons/eraser-magic.svg` | Background Eraser and Magic Eraser tool glyphs: Lucide `eraser` plus added marks | Lucide Icons and Contributors; marks by PhotoCraft contributors | Derived from <https://github.com/lucide-icons/lucide> `icons/eraser.svg` | ISC, [`assets/icons/LICENSE-lucide.txt`](assets/icons/LICENSE-lucide.txt) |
 | `assets/icons/brush-replace.svg` | Color Replacement tool glyph: Lucide `brush` plus two swap arrows | Lucide Icons and Contributors; arrows by PhotoCraft contributors | Derived from <https://github.com/lucide-icons/lucide> `icons/brush.svg` | ISC, [`assets/icons/LICENSE-lucide.txt`](assets/icons/LICENSE-lucide.txt) |
 | `assets/icons/bandage-sparkle.svg` | Remove tool glyph: Lucide `bandage` moved down, plus a sparkle mark | Lucide Icons and Contributors; mark by PhotoCraft contributors | Derived from <https://github.com/lucide-icons/lucide> `icons/bandage.svg` | ISC, [`assets/icons/LICENSE-lucide.txt`](assets/icons/LICENSE-lucide.txt) |
@@ -50,6 +55,7 @@ next to them.
 | `packaging/macos/dmg/` (all files) | PhotoCraft DMG window background and layout | @XusBadia, from the PhotoCraft app icon | Original work, see [`packaging/macos/dmg/README.md`](packaging/macos/dmg/README.md) | MIT OR Apache-2.0, like the code |
 | `crates/ui-egui/src/theme.rs` (Solarized Dark palette) | Solarized colour scheme used by the Solarized Dark theme | Ethan Schoonover | <https://ethanschoonover.com/solarized/> | MIT, [`LICENSE-solarized.txt`](crates/ui-egui/src/LICENSE-solarized.txt) |
 | `crates/ui-egui/src/theme.rs` (Breeze Light and Breeze Dark themes) | The Breeze Light and Breeze Dark themes are original colour values on PhotoCraft's Studio layout, chosen to look close to KDE Plasma's Breeze (cool blue-greys, blue accent, 5 px frame radius) so the app blends into a Plasma desktop. None of Breeze's colour values, files or code are copied; the values are a few levels away from its schemes and tuned for text contrast | PhotoCraft contributors | Inspired by the look of KDE Breeze, <https://invent.kde.org/plasma/breeze> (its colour schemes are LGPL-2.0-or-later) | Original work |
+| `crates/ui-egui/src/theme.rs` (Soft Dark and Soft Light themes) | Original colour values and radii for two low-contrast themes on PhotoCraft's Studio layout; no third-party palette, file or code is used | PhotoCraft contributors | Original | Original work |
 
 ### Optional build input: craft-fonts (not files in this repo)
 
diff --git a/Cargo.lock b/Cargo.lock
index dceb5602e1..6820d6dee5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1121,6 +1121,14 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "craft-print"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=d991bf6792f8ade99c51358bf3c1d902c8cd96b5#d991bf6792f8ade99c51358bf3c1d902c8cd96b5"
+dependencies = [
+ "tempfile",
+]
+
 [[package]]
 name = "craft-ui"
 version = "0.1.0"
@@ -1743,6 +1751,7 @@ dependencies = [
  "miniz_oxide 0.8.9",
  "num-complex",
  "pulp",
+ "rayon-core",
  "smallvec",
  "zune-inflate",
 ]
@@ -2331,9 +2340,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "heic-rs"
-version = "0.1.1"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adf9dde634bb6d5b718bacd01bef80192f2334306b2f785519a0136cca7b9618"
+checksum = "8883c3bfa6b4ff19a40e52a6dc051c5612cbe21bf408fc6d4875e8dfd777cb66"
 dependencies = [
  "rayon",
 ]
@@ -4182,7 +4191,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "arboard",
  "async-io",
@@ -4211,12 +4220,14 @@ dependencies = [
  "photocraft-raster",
  "photocraft-tablet",
  "photocraft-ui-egui",
+ "resvg",
  "rfd",
  "ron",
  "serde_json",
  "winit",
  "winresource",
  "winsafe",
+ "wl-clipboard-rs",
  "x11rb",
  "xcap",
  "zbus",
@@ -4224,7 +4235,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-affinity"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "crc32fast",
  "flate2",
@@ -4234,7 +4245,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-algo"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-color",
  "photocraft-geom",
@@ -4247,7 +4258,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-automation"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "base64",
  "cap-std",
@@ -4269,7 +4280,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-cli"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-automation",
  "photocraft-codecs",
@@ -4283,7 +4294,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-cms"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "moxcms",
  "rayon",
@@ -4291,7 +4302,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-codecs"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "exr",
  "flate2",
@@ -4312,7 +4323,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-color"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-cms",
  "serde",
@@ -4320,7 +4331,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-compose"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "criterion",
  "photocraft-color",
@@ -4335,7 +4346,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-doc"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-color",
  "photocraft-geom",
@@ -4346,9 +4357,10 @@ dependencies = [
 
 [[package]]
 name = "photocraft-engine"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "blake3",
+ "craft-print",
  "exr",
  "flate2",
  "photocraft-affinity",
@@ -4380,11 +4392,12 @@ dependencies = [
 
 [[package]]
 name = "photocraft-format"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "blake3",
  "crc32fast",
  "flate2",
+ "libc",
  "photocraft-codecs",
  "photocraft-color",
  "photocraft-doc",
@@ -4400,14 +4413,14 @@ dependencies = [
 
 [[package]]
 name = "photocraft-geom"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "photocraft-gpu"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "half",
  "log",
@@ -4424,14 +4437,14 @@ dependencies = [
 
 [[package]]
 name = "photocraft-heif"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "heic-rs",
 ]
 
 [[package]]
 name = "photocraft-io"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -4460,14 +4473,14 @@ dependencies = [
 
 [[package]]
 name = "photocraft-ops"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-doc",
 ]
 
 [[package]]
 name = "photocraft-paint"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-color",
  "photocraft-geom",
@@ -4478,7 +4491,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-plugins"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-color",
  "photocraft-geom",
@@ -4493,7 +4506,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-psd"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "flate2",
  "photocraft-psd",
@@ -4504,7 +4517,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-raster"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-color",
  "photocraft-geom",
@@ -4514,7 +4527,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-raw"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "flate2",
  "image",
@@ -4529,7 +4542,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-tablet"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "block2 0.6.2",
  "objc2 0.6.4",
@@ -4541,7 +4554,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-testkit"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "memory-stats",
  "photocraft-color",
@@ -4552,7 +4565,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-text"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "flate2",
  "parley",
@@ -4566,7 +4579,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-ui-egui"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "base64",
  "craft-ui",
@@ -4574,6 +4587,7 @@ dependencies = [
  "egui",
  "egui_extras",
  "egui_kittest",
+ "epaint_default_fonts",
  "flate2",
  "log",
  "photocraft-algo",
@@ -4605,7 +4619,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-vector"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "photocraft-color",
  "photocraft-doc",
@@ -4616,7 +4630,7 @@ dependencies = [
 
 [[package]]
 name = "photocraft-web"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "eframe",
  "egui",
@@ -7449,7 +7463,7 @@ checksum = "ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9"
 
 [[package]]
 name = "xtask"
-version = "0.7.0"
+version = "0.8.2"
 dependencies = [
  "serde",
  "serde_json",
diff --git a/Cargo.toml b/Cargo.toml
index 856d9372b6..f96b5cb468 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/photocraft", "apps/photocraft-cli", "xtask"]
 
 [workspace.package]
-version = "0.7.0"
+version = "0.8.2"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"
@@ -38,6 +38,7 @@ photocraft-testkit = { path = "crates/testkit" }
 photocraft-tablet = { path = "crates/tablet" }
 
 # external
+craft-print = { git = "https://github.com/storytold/craft-libs", rev = "d991bf6792f8ade99c51358bf3c1d902c8cd96b5" }
 thiserror = "2"
 serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1"
@@ -50,7 +51,9 @@ zune-core = "0.5"
 zune-jpeg = "0.5"
 proptest = "1"
 eframe = { version = "0.36", default-features = false }
-egui = "0.36"
+# Without `default_fonts`, which embeds egui's fonts uncompressed: ui-egui ships them deflated
+# (egui_fonts.rs; the web build's size gate).
+egui = { version = "0.36", default-features = false }
 egui_kittest = "0.36"
 rfd = "0.17"
 log = "0.4"
@@ -81,13 +84,14 @@ codegen-units = 1
 
 # The browser build (apps/photocraft-web, `data-cargo-profile` in its index.html). Hosts cap the
 # size of a single file (Cloudflare Pages/Workers: 25 MiB), and the wasm is downloaded on every
-# visit, so this profile optimizes for size: fat LTO, opt-level "z" for the UI, command, and I/O
-# shells, and "s" for other crates except pixel processing, which keeps opt-level 3. panic
-# stays the target default (wasm32-unknown-unknown aborts; AGENTS.md's `panic = "unwind"` is for
-# the native app shell). packaging/web/package.sh fails the build above 24 MiB.
+# visit, so this profile optimizes for size: fat LTO, opt-level "z" for PhotoCraft's own crates,
+# "s" for dependencies and for the crates that decode files, and 3 for pixel processing (filters
+# and compositing). Dependencies stay at "s": at "z" the whole wasm grows (by 0.4 MB, measured).
+# panic stays the target default (wasm32-unknown-unknown aborts; AGENTS.md's `panic = "unwind"`
+# is for the native app shell). packaging/web/package.sh fails the build above 24 MiB.
 [profile.wasm-release]
 inherits = "release"
-opt-level = "s"
+opt-level = "z"
 lto = "fat"
 codegen-units = 1
 strip = "debuginfo"
@@ -95,20 +99,35 @@ strip = "debuginfo"
 [profile.wasm-release.package."*"]
 opt-level = "s"
 
-# Keep the browser shell compact as shared panel controls grow. Pixel-processing crates below
-# retain their speed-oriented optimization level.
-[profile.wasm-release.package.photocraft-ui-egui]
-opt-level = "z"
+# Decoding and rasterizing keep their speed.
+[profile.wasm-release.package.photocraft-codecs]
+opt-level = "s"
+[profile.wasm-release.package.photocraft-raw]
+opt-level = "s"
+[profile.wasm-release.package.photocraft-heif]
+opt-level = "s"
+[profile.wasm-release.package.photocraft-vector]
+opt-level = "s"
 
-# Keep browser command dispatch, import/export glue, and the entry point compact. Native
-# builds and the speed-oriented pixel-processing overrides below retain their settings.
-[profile.wasm-release.package.photocraft-engine]
+# Large crates off the per-frame and per-pixel paths: the document model, file parsers run once
+# per open/save, JSON (settings, presets, control channel), SVG parsing, and shader translation
+# (runs when a pipeline is created). "z" keeps the wasm well under the size gate.
+[profile.wasm-release.package.photocraft-doc]
+opt-level = "z"
+[profile.wasm-release.package.photocraft-psd]
+opt-level = "z"
+[profile.wasm-release.package.photocraft-format]
+opt-level = "z"
+[profile.wasm-release.package.photocraft-affinity]
+opt-level = "z"
+[profile.wasm-release.package.serde_json]
 opt-level = "z"
-[profile.wasm-release.package.photocraft-io]
+[profile.wasm-release.package.usvg]
 opt-level = "z"
-[profile.wasm-release.package.photocraft-web]
+[profile.wasm-release.package.naga]
 opt-level = "z"
 
+# Pixel processing keeps its speed-oriented optimization level.
 [profile.wasm-release.package.photocraft-raster]
 opt-level = 3
 [profile.wasm-release.package.photocraft-color]
@@ -121,3 +140,4 @@ opt-level = 3
 opt-level = 3
 [profile.wasm-release.package.photocraft-paint]
 opt-level = 3
+
diff --git a/README.md b/README.md
index 0455744b05..5fd2650415 100644
--- a/README.md
+++ b/README.md
@@ -199,7 +199,7 @@ Every screenshot here is the real app at work on public-domain art, rendered off
     </td>
     <td width="33%" valign="top">
       <h4>🗂️ Formats</h4>
-      PSD and PSB, layered TIFF (Photoshop's layer data in the TIFF, read and written in either byte order), <a href="docs/pdn.md">Paint.NET PDN3 (read, with editable layers and all 14 blend modes)</a>, <a href="docs/ora.md">OpenRaster (read and write, with layers, groups and blend modes, for Krita, MyPaint and GIMP)</a>, SVG (opens as shape layers, places as a vector Smart Object), plus flat PNG, JPEG, TIFF, WebP (lossy and lossless), GIF, BMP, TGA, ICO, QOI, PNM, OpenEXR, Radiance HDR and FITS (astronomy images: 8/16-bit and 32-bit float, gray or RGB, header kept), and the native <code>.pcraft</code> format. Flat formats retain the depths they support: PNG keeps 8/16-bit samples, TIFF keeps 8/16-bit and 32-bit float samples, and OpenEXR keeps half/float samples; JPEG, WebP and the other 8-bit formats reduce higher-depth samples with an export warning. See the <a href="crates/codecs/README.md#capability-matrix-default-build">codec capability matrix</a> for each format. HEIC photos from iPhone and Mac are read-only (included in official builds; optional <code>--features heif</code> for source builds). AVIF is write-only with the optional <code>avif</code> build feature; AVIF decoding and JPEG XL are unavailable. Affinity documents (<code>.af</code>, <code>.afdesign</code>, <code>.afphoto</code>, <code>.afpub</code>) open natively, read only, with artboards, layers, vectors, text, images and masks; effects, adjustments and other unsupported parts are listed in a warning, and Affinity export is unavailable.
+      PSD and PSB, layered TIFF (Photoshop's layer data in the TIFF, read and written in either byte order), <a href="docs/pdn.md">Paint.NET PDN3 (read, with editable layers and all 14 blend modes)</a>, <a href="docs/ora.md">OpenRaster (read and write, with layers, groups and blend modes, for Krita, MyPaint and GIMP)</a>, <a href="docs/kra.md">Krita .kra (read, with paint layers, groups, blend modes and transparency masks)</a>, SVG (opens as shape layers, places as a vector Smart Object), plus flat PNG, JPEG, TIFF, WebP (lossy and lossless), GIF, BMP, TGA, ICO, QOI, PNM, OpenEXR, Radiance HDR and FITS (astronomy images: 8/16-bit and 32-bit float, gray or RGB, header kept), and the native <code>.pcraft</code> format. Flat formats retain the depths they support: PNG keeps 8/16-bit samples, TIFF keeps 8/16-bit and 32-bit float samples, and OpenEXR keeps half/float samples; JPEG, WebP and the other 8-bit formats reduce higher-depth samples with an export warning. See the <a href="crates/codecs/README.md#capability-matrix-default-build">codec capability matrix</a> for each format. HEIC photos from iPhone and Mac are read-only (included in official builds; optional <code>--features heif</code> for source builds). AVIF is write-only with the optional <code>avif</code> build feature; AVIF decoding and JPEG XL are unavailable. Affinity documents (<code>.af</code>, <code>.afdesign</code>, <code>.afphoto</code>, <code>.afpub</code>) open natively, read only, with artboards, layers, vectors, text, images and masks; effects, adjustments and other unsupported parts are listed in a warning, and Affinity export is unavailable.
     </td>
     <td width="33%" valign="top">
       <h4>🪄 The everyday essentials</h4>
@@ -331,8 +331,6 @@ sha256-verified. Fetch them with `cargo xtask corpus --all` and run the tests wi
 | arm64 (Snapdragon and other ARM PCs) | `photocraft-<ver>-windows-arm64.msi` | `photocraft-<ver>-windows-arm64-portable.zip` |
 | x86 (32-bit) | `photocraft-<ver>-windows-x86.msi` | `photocraft-<ver>-windows-x86-portable.zip` |
 
-Windows 10 or later is required. On Windows 7 and 8 the app can't start (the installer says so).
-
 Installers and executables are code-signed.
 
 ### macOS
diff --git a/apps/photocraft-cli/src/lib.rs b/apps/photocraft-cli/src/lib.rs
index fe8c62717a..a81cce61ce 100644
--- a/apps/photocraft-cli/src/lib.rs
+++ b/apps/photocraft-cli/src/lib.rs
@@ -15,19 +15,21 @@ pub const USAGE: &str = "\
 photocraft-cli: headless Photocraft
 
 USAGE:
-  photocraft-cli convert <in> <out> [--format <ext>] [--quality <1-100>] [--tiff-layers] [--tga-bits <24|32>]
+  photocraft-cli convert <in> <out> [--format <ext>] [--quality <1-100>] [--tiff-layers] [--tga-bits <24|32>] [--dpx-bits <8|10|12|16>]
       Convert between formats (.pcraft, .psd, .png, .jpg, .tif, .webp, .exr, …).
       TIFF output is flat unless --tiff-layers keeps the layers (Photoshop layer data).
       --quality sets the JPEG or WebP quality; a WebP written with a quality is lossy, without one lossless.
       --tga-bits sets a TGA's bits per pixel: 32 writes the alpha channel (or else the transparency) as
       its alpha, 24 none. Without it: 32 with an alpha channel or transparency, else 24.
+      --dpx-bits sets a DPX's bits per sample. Without it: 8 for an 8-bit document, else 16.
   photocraft-cli info <file> [--compact]
       Print the document as JSON (size, mode, depth, layer tree).
-  photocraft-cli run (<file> | --new <json>) --cmd <id> [--params <json>] [--cmd …] [--out <file>] [--format <ext>] [--quality <1-100>] [--tiff-layers] [--tga-bits <24|32>]
+  photocraft-cli run (<file> | --new <json>) --cmd <id> [--params <json>] [--cmd …] [--out <file>] [--format <ext>] [--quality <1-100>] [--tiff-layers] [--tga-bits <24|32>] [--dpx-bits <8|10|12|16>]
       Open a file, run engine commands in order, save the result. Each --params
       applies to the preceding --cmd. Prints each command's JSON result.
-  photocraft-cli batch --actions <actions.json> [--action <name>] --in <dir> --out <dir> [--format <ext>] [--quality <1-100>] [--in-place] [--tiff-layers] [--tga-bits <24|32>]
-      Apply an action list to every image in a directory. Steps are [id, params] pairs,
+  photocraft-cli batch --actions <actions.json|set.atn> [--action <name>] --in <dir> --out <dir> [--format <ext>] [--quality <1-100>] [--in-place] [--tiff-layers] [--tga-bits <24|32>] [--dpx-bits <8|10|12|16>]
+      Apply an action list to every image in a directory. A Photoshop Actions file (.atn) is a
+      set: its action --action names plays, as below. JSON steps are [id, params] pairs,
       {\"command\": id, \"params\": {…}} objects or bare ids, as a recorded action or droplet stores them
       (a list, or wrapped in {\"actions\": …}, {\"steps\": …} or a droplet). An Actions set (the Actions
       panel's actions.json, {\"actions\": [{\"name\", \"steps\"}…]}) plays the action --action names (needed
@@ -67,17 +69,17 @@ struct Subcommand {
 }
 
 const SUBCOMMANDS: &[Subcommand] = &[
-    Subcommand { name: "convert", values: &["--format", "--quality", "--tga-bits"], bare: &["--tiff-layers"], run: convert },
+    Subcommand { name: "convert", values: &["--format", "--quality", "--tga-bits", "--dpx-bits"], bare: &["--tiff-layers"], run: convert },
     Subcommand { name: "info", values: &[], bare: &["--compact"], run: |a, out, _| info(a, out) },
     Subcommand {
         name: "run",
-        values: &["--new", "--cmd", "--params", "--out", "--format", "--quality", "--tga-bits"],
+        values: &["--new", "--cmd", "--params", "--out", "--format", "--quality", "--tga-bits", "--dpx-bits"],
         bare: &["--tiff-layers"],
         run: run_cmds,
     },
     Subcommand {
         name: "batch",
-        values: &["--actions", "--action", "--in", "--out", "--format", "--quality", "--tga-bits"],
+        values: &["--actions", "--action", "--in", "--out", "--format", "--quality", "--tga-bits", "--dpx-bits"],
         bare: &["--in-place", "--tiff-layers"],
         run: batch,
     },
@@ -213,6 +215,10 @@ fn export_opts(a: &Args) -> Result<ExportOptions, String> {
     if let Some(b) = a.get("--tga-bits") {
         o.tga_bits = Some(b.parse().ok().and_then(photocraft_io::TgaBits::from_bits).ok_or_else(|| format!("bad --tga-bits `{b}`: expected 24 or 32"))?);
     }
+    if let Some(b) = a.get("--dpx-bits") {
+        o.encode.dpx_bits =
+            Some(b.parse().ok().and_then(photocraft_io::DpxBits::from_bits).ok_or_else(|| format!("bad --dpx-bits `{b}`: expected 8, 10, 12 or 16"))?);
+    }
     Ok(o)
 }
 
@@ -240,7 +246,7 @@ fn convert(a: &Args, _out: &mut dyn Write, err: &mut dyn Write) -> R {
     let opts = export_opts(a)?;
     let o = files::open(Path::new(input)).map_err(|e| e.to_string())?;
     warn_all(err, &o.warnings);
-    warn_all(err, &missing_font_warnings(photocraft_engine::type_extra_cmds::missing_fonts(&o.document)));
+    warn_all(err, &photocraft_engine::type_extra_cmds::missing_font_warnings(&o.document));
     let ws = files::save(&o.document, Path::new(output), a.get("--format"), &opts, None).map_err(|e| e.to_string())?;
     warn_all(err, &ws);
     Ok(())
@@ -292,11 +298,16 @@ fn command_list(a: &Args) -> Result<Vec<(String, Value)>, String> {
 fn run_cmds(a: &Args, out: &mut dyn Write, err: &mut dyn Write) -> R {
     let opts = export_opts(a)?;
     let mut h = Headless::trusted_local();
+    // Opening, running commands and exporting can all notice the same missing font:
+    // one `run` invocation reports each warning line at most once.
+    let mut reported_fonts = std::collections::HashSet::<String>::new();
     match (a.positional.as_slice(), a.get("--new")) {
         ([file], None) => {
             let o = h.open(Path::new(file)).map_err(|e| e.to_string())?;
             let ws: Vec<String> = serde_json::from_value(o["warnings"].clone()).unwrap_or_default();
+            reported_fonts.extend(ws.iter().cloned());
             warn_all(err, &ws);
+            reported_fonts.extend(ws);
         }
         ([], Some(new)) => {
             let p: Value = serde_json::from_str(new).map_err(|e| format!("bad --new JSON: {e}"))?;
@@ -308,9 +319,11 @@ fn run_cmds(a: &Args, out: &mut dyn Write, err: &mut dyn Write) -> R {
     if cmds.is_empty() && a.get("--out").is_none() {
         return Err("run needs at least one --cmd (or --out)".into());
     }
-    let mut reported_fonts = std::collections::HashSet::<String>::new();
     for (id, params) in cmds {
         let r = h.command_run(&id, params).map_err(|e| format!("`{id}`: {e}"))?;
+        if let Some(e) = photocraft_engine::actions_cmds::nested_failure(&id, &r) {
+            return Err(format!("`{id}`: {e}"));
+        }
         let new_warnings: Vec<String> = h
             .session
             .active()
@@ -339,6 +352,7 @@ fn run_cmds(a: &Args, out: &mut dyn Write, err: &mut dyn Write) -> R {
     if let Some(o) = a.get("--out") {
         let r = h.save(None, Some(Path::new(o)), a.get("--format"), &opts).map_err(|e| e.to_string())?;
         let ws: Vec<String> = serde_json::from_value(r["warnings"].clone()).unwrap_or_default();
+        let ws: Vec<String> = ws.into_iter().filter(|w| reported_fonts.insert(w.clone())).collect();
         warn_all(err, &ws);
     }
     Ok(())
@@ -384,6 +398,38 @@ pub fn load_actions(text: &str, name: Option<&str>) -> Result<(Steps, Vec<Action
     Ok((play, set))
 }
 
+/// [`load_actions`] for a file on disk: a Photoshop Actions file (`.atn`, by extension or by
+/// its version word) is converted first; the played action's steps with no PhotoCraft
+/// equivalent come back as warnings (they fail at playback, as in Photoshop when a step can't run).
+pub fn load_actions_file(path: &str, name: Option<&str>) -> Result<(Steps, Vec<Action>, Vec<String>), String> {
+    let bytes = std::fs::read(path).map_err(|e| format!("{path}: {e}"))?;
+    let is_atn = Path::new(path).extension().is_some_and(|e| e.eq_ignore_ascii_case("atn")) || bytes.starts_with(&[0, 0, 0, 16]);
+    if !is_atn {
+        let text = String::from_utf8(bytes).map_err(|e| format!("{path}: {e}"))?;
+        let (steps, set) = load_actions(&text, name)?;
+        return Ok((steps, set, Vec::new()));
+    }
+    let imp = photocraft_engine::atn_cmds::import(&bytes).map_err(|e| format!("{path}: {e}"))?;
+    let names = || imp.actions.iter().map(|a| format!("`{}`", a.name)).collect::<Vec<_>>().join(", ");
+    let action = match (name, imp.actions.as_slice()) {
+        (Some(n), _) => {
+            imp.actions.iter().find(|a| a.name == n).ok_or_else(|| format!("no action named `{n}` in the set `{}` (it holds {})", imp.set, names()))?
+        }
+        (None, [only]) => only,
+        (None, []) => return Err(format!("{path}: the set holds no actions")),
+        (None, _) => return Err(format!("the set `{}` holds {} actions: pick one with --action <name> ({})", imp.set, imp.actions.len(), names())),
+    };
+    let warnings = imp
+        .unsupported
+        .iter()
+        .filter(|u| u.action == action.name)
+        .map(|u| format!("`{}` step {}: Photoshop's \"{}\" ({}) has no PhotoCraft equivalent yet", u.action, u.step + 1, u.name, u.event))
+        .chain(imp.warnings.iter().cloned())
+        .collect();
+    let play = vec![("actions.play".to_string(), json!({"action": action.name}))];
+    Ok((play, imp.actions, warnings))
+}
+
 /// Whether `a` and `b` name the same existing folder, however they are spelt (relative, with a
 /// trailing separator, through a symbolic link).
 fn same_dir(a: &Path, b: &Path) -> bool {
@@ -392,7 +438,7 @@ fn same_dir(a: &Path, b: &Path) -> bool {
 
 fn is_input(p: &Path) -> bool {
     let known = |e: &str| {
-        matches!(e, "pcraft" | "psd" | "psb" | "pdn" | "ora" | "af" | "afdesign" | "afphoto" | "afpub")
+        matches!(e, "pcraft" | "psd" | "psb" | "pdn" | "ora" | "kra" | "krz" | "af" | "afdesign" | "afphoto" | "afpub")
             || photocraft_codecs::from_extension(e).is_some_and(|f| photocraft_codecs::caps(f).read)
     };
     p.is_file() && p.extension().is_some_and(|e| known(&e.to_string_lossy().to_ascii_lowercase()))
@@ -402,8 +448,10 @@ fn batch(a: &Args, out: &mut dyn Write, err: &mut dyn Write) -> R {
     let actions_path = a.get("--actions").ok_or("batch needs --actions <file>")?;
     let in_dir = PathBuf::from(a.get("--in").ok_or("batch needs --in <dir>")?);
     let out_dir = PathBuf::from(a.get("--out").ok_or("batch needs --out <dir>")?);
-    let text = std::fs::read_to_string(actions_path).map_err(|e| format!("{actions_path}: {e}"))?;
-    let (actions, set) = load_actions(&text, a.get("--action"))?;
+    let (actions, set, warnings) = load_actions_file(actions_path, a.get("--action"))?;
+    for w in &warnings {
+        let _ = writeln!(err, "warning: {w}");
+    }
     let opts = export_opts(a)?;
     // Results are saved as `<out>/<stem>.<ext>`, so an `--out` that is the `--in` folder would
     // replace the originals (#492).
@@ -626,6 +674,11 @@ mod missing_font_warning_tests {
         let (code, _, stderr) = invoke(&["convert", &ora, &png]);
         assert_eq!(code, 0, "{stderr}");
         assert!(is_input(std::path::Path::new(&ora)));
+        // Krita documents are batch inputs too (import-only).
+        for name in ["sketch.kra", "old.KRZ"] {
+            std::fs::write(folder.join(name), b"").unwrap();
+            assert!(is_input(&folder.join(name)), "{name}");
+        }
         let _ = std::fs::remove_dir_all(&folder);
     }
 
diff --git a/apps/photocraft-cli/tests/cli.rs b/apps/photocraft-cli/tests/cli.rs
index 5baa83fde3..231eb2c321 100644
--- a/apps/photocraft-cli/tests/cli.rs
+++ b/apps/photocraft-cli/tests/cli.rs
@@ -203,6 +203,50 @@ fn run_commands_and_save() {
     std::fs::remove_dir_all(d).unwrap();
 }
 
+#[test]
+fn run_stops_after_failed_action_without_exporting() {
+    let d = tmp("run-failed-action");
+    let out = d.join("result.png");
+    let result = bin()
+        .args(["run", "--new", r#"{"width":8,"height":8}"#])
+        .args(["--cmd", "layer.new.layer"])
+        .args(["--cmd", "actions.record", "--params", r#"{"name":"Delete"}"#])
+        .args(["--cmd", "layer.delete", "--cmd", "actions.stop"])
+        // The recorded deletion succeeded with two layers; replay cannot delete the last one.
+        .args(["--cmd", "actions.play", "--params", r#"{"action":"Delete"}"#])
+        .args(["--cmd", "document.inspect", "--out"])
+        .arg(&out)
+        .output()
+        .unwrap();
+    let error = String::from_utf8_lossy(&result.stderr);
+    assert_eq!(result.status.code(), Some(1), "stdout: {}\nstderr: {error}", String::from_utf8_lossy(&result.stdout));
+    assert!(error.contains("actions.play") && error.contains("Delete") && error.contains("step 1"), "{error}");
+    let rows: Vec<Value> = String::from_utf8_lossy(&result.stdout).lines().map(|line| serde_json::from_str(line).unwrap()).collect();
+    assert!(rows.iter().all(|row| row["command"] != "document.inspect"), "later commands must not run");
+    assert!(!out.exists(), "a failed action must not export a partial result");
+    std::fs::remove_dir_all(d).unwrap();
+}
+
+#[test]
+fn run_continues_after_successful_action_and_exports() {
+    let d = tmp("run-successful-action");
+    let out = d.join("result.png");
+    let (stdout, _) = ok(bin()
+        .args(["run", "--new", r#"{"width":8,"height":8}"#])
+        .args(["--cmd", "actions.record", "--params", r#"{"name":"Add"}"#])
+        .args(["--cmd", "layer.new.layer", "--cmd", "actions.stop"])
+        .args(["--cmd", "actions.play", "--params", r#"{"action":"Add"}"#])
+        .args(["--cmd", "document.inspect", "--out"])
+        .arg(&out));
+    let rows: Vec<Value> = stdout.lines().map(|line| serde_json::from_str(line).unwrap()).collect();
+    let playback = rows.iter().find(|row| row["command"] == "actions.play").unwrap();
+    assert_eq!(playback["result"]["ran"], 1);
+    assert!(playback["result"].get("failed").is_none());
+    assert!(rows.iter().any(|row| row["command"] == "document.inspect"));
+    assert!(out.is_file());
+    std::fs::remove_dir_all(d).unwrap();
+}
+
 #[test]
 fn run_errors() {
     let o = bin().args(["run", "--new", "{}", "--cmd", "no.such"]).output().unwrap();
@@ -411,6 +455,40 @@ fn quality_outside_1_to_100_is_refused() {
     assert!(sizes[0] <= sizes[1] && sizes[1] <= sizes[2], "{sizes:?}");
 }
 
+/// DPX converts both ways, `info` reports its size, mode and depth, and `--dpx-bits` picks the
+/// bits per sample (byte 803 of the header); anything but 8, 10, 12 or 16 is refused (#1049).
+#[test]
+fn dpx_converts_both_ways_with_the_bits_asked_for() {
+    let d = tmp("dpx");
+    let a = d.join("a.png");
+    write_png(&a, 8, 4, 3);
+    for (bits, want) in [(None, 8), (Some("10"), 10), (Some("12"), 12), (Some("16"), 16)] {
+        let out = d.join("a.dpx");
+        let mut convert = bin();
+        convert.arg("convert").arg(&a).arg(&out);
+        if let Some(b) = bits {
+            convert.args(["--dpx-bits", b]);
+        }
+        ok(&mut convert);
+        let bytes = std::fs::read(&out).unwrap();
+        assert_eq!((&bytes[..4], bytes[803]), (&b"SDPX"[..], want), "--dpx-bits {bits:?}");
+    }
+    let (info, _) = ok(bin().arg("info").arg(d.join("a.dpx")).arg("--compact"));
+    let v: Value = serde_json::from_str(&info).unwrap();
+    assert_eq!((v["width"].as_u64(), v["height"].as_u64()), (Some(8), Some(4)), "{v}");
+    assert!(info.contains("16") && info.to_lowercase().contains("rgb"), "{info}");
+    let back = d.join("back.png");
+    ok(bin().arg("convert").arg(d.join("a.dpx")).arg(&back));
+    assert!(back.exists());
+    for bad in ["24", "0", "abc"] {
+        let out = d.join("bad.dpx");
+        let o = bin().arg("convert").arg(&a).arg(&out).args(["--dpx-bits", bad]).output().unwrap();
+        assert_eq!(o.status.code(), Some(1), "--dpx-bits {bad}");
+        assert!(String::from_utf8_lossy(&o.stderr).contains(&format!("bad --dpx-bits `{bad}`: expected 8, 10, 12 or 16")), "--dpx-bits {bad}");
+        assert!(!out.exists(), "--dpx-bits {bad} wrote a file");
+    }
+}
+
 /// `--tga-bits` picks a TGA's bits per pixel (byte 16 of its header); anything but 24 or 32 is
 /// refused and nothing is written.
 #[test]
@@ -640,3 +718,33 @@ fn a_non_unicode_argument_is_a_usage_error_not_a_panic() {
         assert!(!err.contains("panicked"), "{err}");
     }
 }
+
+/// `batch --actions set.atn`: a Photoshop Actions file plays like an Actions set, and its steps
+/// PhotoCraft can't play are warned about up front.
+#[test]
+fn batch_plays_a_photoshop_actions_file() {
+    use photocraft_engine::actions_cmds::Action;
+    let d = tmp("atn");
+    let input = d.join("in");
+    std::fs::create_dir_all(&input).unwrap();
+    write_png(&input.join("a.png"), 8, 4, 3);
+    let invert = Action::new("Negative", vec![("image.adjustments.invert".into(), json!({})), ("select.all".into(), json!({}))]);
+    let odd = Action::new("Odd", vec![(photocraft_engine::atn_cmds::PHOTOSHOP_STEP.into(), json!({"event": "syntheticFill", "name": "Generative Fill"}))]);
+    let (bytes, skipped) = photocraft_engine::atn_cmds::export("Set", &[&invert, &odd], &[], false).unwrap();
+    assert!(skipped.is_empty());
+    let atn = d.join("Set.atn");
+    std::fs::write(&atn, bytes).unwrap();
+    let out_dir = d.join("out");
+    // Two actions: the set needs --action.
+    let o = bin().args(["batch", "--actions"]).arg(&atn).arg("--in").arg(&input).arg("--out").arg(&out_dir).output().unwrap();
+    assert!(!o.status.success());
+    assert!(String::from_utf8_lossy(&o.stderr).contains("--action"), "{}", String::from_utf8_lossy(&o.stderr));
+    let (_, err) = ok(bin().args(["batch", "--actions"]).arg(&atn).args(["--action", "Negative", "--in"]).arg(&input).arg("--out").arg(&out_dir));
+    assert!(out_dir.join("a.png").exists());
+    assert!(!err.contains("warning"), "{err}");
+    // The unsupported step is warned about, and fails the file as Photoshop would stop on it.
+    let o = bin().args(["batch", "--actions"]).arg(&atn).args(["--action", "Odd", "--in"]).arg(&input).arg("--out").arg(d.join("out2")).output().unwrap();
+    let err = String::from_utf8_lossy(&o.stderr);
+    assert!(err.contains("Generative Fill"), "{err}");
+    assert!(!o.status.success());
+}
diff --git a/apps/photocraft-web/Cargo.toml b/apps/photocraft-web/Cargo.toml
index 6b4c62797a..a4ded64181 100644
--- a/apps/photocraft-web/Cargo.toml
+++ b/apps/photocraft-web/Cargo.toml
@@ -29,7 +29,7 @@ log = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 # `wgpu` pulls egui-wgpu's defaults: WebGPU plus the WebGL2 fallback.
-eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit"] }
+eframe = { workspace = true, features = ["wgpu", "accesskit"] }
 rfd = { workspace = true }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
diff --git a/apps/photocraft-web/index.html b/apps/photocraft-web/index.html
index 5e734006be..d090cf47da 100644
--- a/apps/photocraft-web/index.html
+++ b/apps/photocraft-web/index.html
@@ -4,7 +4,7 @@
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
   <title>PhotoCraft</title>
-  <link data-trunk rel="rust" data-bin="photocraft-web" data-cargo-profile="wasm-release" data-cargo-features="heif" data-wasm-opt="z" data-weak-refs />
+  <link data-trunk rel="rust" data-bin="photocraft-web" data-cargo-profile="wasm-release" data-cargo-features="heif" data-wasm-opt="z" data-wasm-opt-params="--converge" data-weak-refs />
   <style>
     html, body { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background: #262626; }
     #photocraft_canvas { position: absolute; inset: 0; width: 100%; height: 100%; display: block; }
diff --git a/apps/photocraft-web/src/preset_bridge.rs b/apps/photocraft-web/src/preset_bridge.rs
index 6c9ef84add..a7445bbc14 100644
--- a/apps/photocraft-web/src/preset_bridge.rs
+++ b/apps/photocraft-web/src/preset_bridge.rs
@@ -337,6 +337,7 @@ mod tests {
         let b = Bridge::default();
         b.unavailable("SecurityError".into());
         let (mut s, _) = session(b.clone());
+        assert!(!b.unsaved(), "nothing is lost before the first change, so the web shell shows no banner");
         import(&mut s);
         assert!(s.tools.presets.iter().any(|p| p.name == "Browser seam brush"));
         assert!(b.unsaved());
diff --git a/apps/photocraft-web/src/web.rs b/apps/photocraft-web/src/web.rs
index 4f674560e8..a5c9d8a565 100644
--- a/apps/photocraft-web/src/web.rs
+++ b/apps/photocraft-web/src/web.rs
@@ -14,12 +14,12 @@ use wasm_bindgen::JsCast as _;
 
 type Inbox = Arc<Mutex<Vec<(String, Vec<u8>)>>>;
 
-/// Everything File › Open reads: PhotoCraft, Photoshop, OpenRaster and Affinity documents, flat images, and
+/// Everything File › Open reads: PhotoCraft, Photoshop, OpenRaster, Krita and Affinity documents, flat images, and
 /// Photoshop brushes (.abr), gradients (.grd) and swatches (.aco, .ase), which go to the preset libraries.
 const OPEN_EXTS: &[&str] = &[
-    "pcraft", "pdn", "ora", "psd", "psb", "psdt", "png", "jpg", "jpeg", "tif", "tiff", "webp", "gif", "bmp", "tga", "ico", "qoi", "exr", "hdr", "pbm", "pgm",
-    "ppm", "pam", "pfm", "fits", "fit", "fts", "heic", "heif", "hif", "dng", "cr2", "cr3", "nef", "nrw", "arw", "pef", "orf", "rw2", "raf", "abr", "grd",
-    "svg", "svgz", "aco", "ase", "af", "afdesign", "afphoto", "afpub",
+    "pcraft", "pdn", "ora", "kra", "krz", "psd", "psb", "psdt", "png", "jpg", "jpeg", "tif", "tiff", "webp", "gif", "bmp", "tga", "ico", "qoi", "exr", "hdr",
+    "pbm", "pgm", "ppm", "pam", "pfm", "dds", "fits", "fit", "fts", "dpx", "heic", "heif", "hif", "dng", "cr2", "cr3", "nef", "nrw", "arw", "pef", "orf",
+    "rw2", "raf", "abr", "grd", "svg", "svgz", "aco", "ase", "af", "afdesign", "afphoto", "afpub",
 ];
 const SVG_EXTS: &[&str] = &["svg", "svgz"];
 const CANVAS_ID: &str = "photocraft_canvas";
@@ -305,27 +305,27 @@ impl eframe::App for WebShell {
     }
 
     fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
-        let error = self.presets.error();
-        if error.is_some() || self.presets.unsaved() {
+        // Only while a preset change is unsaved. Storage the browser denies from the start (a
+        // sandboxed iframe, blocked site data) loses nothing until the first change, and that
+        // change brings the banner with the reason.
+        if self.presets.unsaved()
+            && let Some(error) = self.presets.error()
+        {
             egui::Panel::top("browser_preset_storage").show(ui, |ui| {
-                if let Some(error) = error {
-                    let tokens = photocraft_ui_egui::theme::Tokens::for_kind(self.app.ui.theme);
-                    // Put retry first so floating brush windows cannot cover the control.
-                    ui.horizontal_wrapped(|ui| {
-                        if self.database.is_some() && ui.button(i18n::t("Retry saving presets")).clicked() {
-                            self.presets.retry();
-                            ui.ctx().request_repaint();
-                        }
-                        ui.colored_label(tokens.warning, i18n::fmt(i18n::t("Brush preset changes are not saved: {error}"), &[("error", &error)]));
-                    });
-                    ui.label(if self.database.is_some() {
-                        i18n::t("Keep this tab open to retain your brushes.")
-                    } else {
-                        i18n::t("Browser storage is unavailable; brushes are session-only. Keep this tab open to retain them.")
-                    });
+                let tokens = photocraft_ui_egui::theme::Tokens::for_kind(self.app.ui.theme);
+                // Put retry first so floating brush windows cannot cover the control.
+                ui.horizontal_wrapped(|ui| {
+                    if self.database.is_some() && ui.button(i18n::t("Retry saving presets")).clicked() {
+                        self.presets.retry();
+                        ui.ctx().request_repaint();
+                    }
+                    ui.colored_label(tokens.warning, i18n::fmt(i18n::t("Brush preset changes are not saved: {error}"), &[("error", &error)]));
+                });
+                ui.label(if self.database.is_some() {
+                    i18n::t("Keep this tab open to retain your brushes.")
                 } else {
-                    ui.label(i18n::t("Saving brush presets… Keep this tab open until saving finishes."));
-                }
+                    i18n::t("Browser storage is unavailable; brushes are session-only. Keep this tab open to retain them.")
+                });
             });
         }
         self.app.ui(ui, frame);
@@ -352,6 +352,7 @@ fn services(inbox: Inbox) -> Services {
             opts.xmp = if settings.xmp_all { photocraft_io::XmpEmbed::All } else { photocraft_io::XmpEmbed::None };
             opts.tga_bits = settings.tga_bits;
             opts.image_previews = settings.image_previews;
+            opts.psd_maximize_compatibility = settings.psd_maximize_compatibility;
             photocraft_io::export(doc, path, &opts).map(|r| (r.bytes, r.warnings)).map_err(|e| e.to_string())
         })),
         file_dialog: Some(Box::new(|request, _parent, reply| match request {
@@ -382,6 +383,8 @@ fn services(inbox: Inbox) -> Services {
                 };
                 reply.send(answer);
             }),
+            // Browser folder handles cannot be represented as filesystem paths for engine commands.
+            FileDialogRequest::Folder { .. } => reply.send(None),
             // No save dialog on the web: the suggested name becomes the download name.
             FileDialogRequest::Save { suggested } => {
                 let name = std::path::Path::new(&suggested).file_name().map_or_else(|| suggested.clone(), |n| n.to_string_lossy().to_string());
@@ -443,6 +446,7 @@ fn mime_for(name: &str) -> &'static str {
         Some("gif") => "image/gif",
         Some("psd" | "psb") => "image/vnd.adobe.photoshop",
         Some("ora") => "image/openraster",
+        Some("kra" | "krz") => "application/x-krita",
         _ => "application/octet-stream",
     }
 }
diff --git a/apps/photocraft/Cargo.toml b/apps/photocraft/Cargo.toml
index 740a75b3f4..e5af663471 100644
--- a/apps/photocraft/Cargo.toml
+++ b/apps/photocraft/Cargo.toml
@@ -29,7 +29,7 @@ photocraft-automation = { workspace = true }
 photocraft-ui-egui = { workspace = true }
 # Pen tablet pressure/tilt on macOS and X11 (the workspace's one isolated unsafe helper crate).
 photocraft-tablet = { workspace = true }
-eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11", "persistence"] }
+eframe = { workspace = true, features = ["wgpu", "accesskit", "wayland", "x11", "persistence"] }
 egui = { workspace = true }
 serde_json = { workspace = true }
 log = { workspace = true }
@@ -66,8 +66,14 @@ dispatch2 = { version = "=0.3.1", default-features = false, features = ["std"] }
 [target.'cfg(target_os = "linux")'.dependencies]
 photocraft-cms = { workspace = true }
 x11rb = { version = "=0.13.2", default-features = false, features = ["image", "randr", "xkb"] }
+# Clipboard images in types other than PNG on Wayland (`services.rs`, #2546): arboard asks for
+# image/png only. Already in Cargo.lock (arboard's wayland-data-control); pinned exactly.
+wl-clipboard-rs = { version = "=0.9.4", default-features = false }
 # Wayland desktop color selection through the existing XDG portal transport.
 zbus = "=5.19.0"
+# Caption button glyphs from the desktop's icon theme (`caption_style.rs`): SVG paths only, no
+# text or images. Already in Cargo.lock (photocraft-io); pinned exactly.
+resvg = { version = "=0.45.1", default-features = false }
 # Already used by the portal stack; bounded waits let cancelling close the OS request.
 futures-lite = "=2.6.1"
 async-io = "=2.6.0"
diff --git a/apps/photocraft/src/appearance.rs b/apps/photocraft/src/appearance.rs
index 8389ee83eb..aaae41a1f2 100644
--- a/apps/photocraft/src/appearance.rs
+++ b/apps/photocraft/src/appearance.rs
@@ -6,7 +6,7 @@ const PORTAL_NAMESPACE: &str = "org.freedesktop.appearance";
 const PORTAL_KEY: &str = "color-scheme";
 
 #[cfg(target_os = "linux")]
-fn portal_proxy() -> Option<zbus::blocking::Proxy<'static>> {
+pub(crate) fn portal_proxy() -> Option<zbus::blocking::Proxy<'static>> {
     let conn = zbus::blocking::connection::Builder::session().ok()?.method_timeout(std::time::Duration::from_secs(2)).build().ok()?;
     zbus::blocking::Proxy::new(&conn, "org.freedesktop.portal.Desktop", "/org/freedesktop/portal/desktop", "org.freedesktop.portal.Settings").ok()
 }
@@ -14,7 +14,7 @@ fn portal_proxy() -> Option<zbus::blocking::Proxy<'static>> {
 #[cfg(target_os = "linux")]
 fn portal_theme(proxy: &zbus::blocking::Proxy<'_>) -> Option<egui::Theme> {
     let value: zbus::zvariant::OwnedValue = proxy.call("Read", &(PORTAL_NAMESPACE, PORTAL_KEY)).ok()?;
-    decode(portal_code(value)?)
+    portal_code(value).and_then(decode).or_else(gtk_theme)
 }
 
 #[cfg(target_os = "linux")]
@@ -39,8 +39,8 @@ fn decode(code: u32) -> Option<egui::Theme> {
     }
 }
 
-/// One-shot fallback for desktops without the settings portal. It runs once at start-up, by
-/// absolute path, and is never repeated.
+/// GNOME fallback when the portal has no preference. Read only on the appearance worker,
+/// using an absolute path rather than the shell's PATH.
 #[cfg(target_os = "linux")]
 fn gtk_theme() -> Option<egui::Theme> {
     let exe = ["/usr/bin/gsettings", "/bin/gsettings", "/usr/local/bin/gsettings"].into_iter().find(|p| std::path::Path::new(p).is_file())?;
@@ -55,7 +55,7 @@ fn gtk_theme() -> Option<egui::Theme> {
 fn parse_gtk_scheme(s: &str) -> Option<egui::Theme> {
     match s.trim().trim_matches('\'') {
         "prefer-dark" => Some(egui::Theme::Dark),
-        "prefer-light" => Some(egui::Theme::Light),
+        "prefer-light" | "default" => Some(egui::Theme::Light),
         _ => None,
     }
 }
@@ -97,7 +97,7 @@ pub fn service() -> Option<photocraft_ui_egui::SystemThemeFn> {
                 if namespace != PORTAL_NAMESPACE || key != PORTAL_KEY {
                     continue;
                 }
-                publisher.publish(portal_code(changed).and_then(decode));
+                publisher.publish(portal_code(changed).and_then(decode).or_else(gtk_theme));
             }
         })
     }
@@ -184,7 +184,10 @@ mod tests {
         assert_eq!(super::portal_code(zbus::zvariant::OwnedValue::try_from(nested).unwrap()), Some(2));
         assert_eq!(super::parse_gtk_scheme("'prefer-light'\n"), Some(egui::Theme::Light));
         assert_eq!(super::parse_gtk_scheme("'prefer-dark'\n"), Some(egui::Theme::Dark));
-        assert_eq!(super::parse_gtk_scheme("'default'\n"), None);
+        // GNOME's "default" appearance is light, even though the portal reports no preference.
+        assert_eq!(super::parse_gtk_scheme("'default'\n"), Some(egui::Theme::Light));
+        assert_eq!(super::parse_gtk_scheme("default"), Some(egui::Theme::Light));
+        assert_eq!(super::parse_gtk_scheme("'not-a-scheme'"), None);
     }
 
     /// #2798: a first read that misses the start-up wait still wakes the idle UI.
diff --git a/apps/photocraft/src/caption_style.rs b/apps/photocraft/src/caption_style.rs
new file mode 100644
index 0000000000..5ee16f9f96
--- /dev/null
+++ b/apps/photocraft/src/caption_style.rs
@@ -0,0 +1,399 @@
+//! Linux: which desktop the custom title bar's caption buttons look like, and which buttons go on
+//! which side (`photocraft_ui_egui::CaptionStyle`). GNOME gets libadwaita's buttons in the order of
+//! its `button-layout` setting (read through the settings portal, and followed as it changes); KDE
+//! gets Breeze's in KWin's order (`kwinrc`); other desktops get plain round buttons, or Adwaita's
+//! or Breeze's when their GTK theme is one of those, in GTK's `gtk-decoration-layout` order.
+//!
+//! `PHOTOCRAFT_CAPTION_STYLE` (`windows`, `adwaita`, `breeze`, `generic`) and
+//! `PHOTOCRAFT_CAPTION_LAYOUT` (a GTK layout such as `close,minimize:`) override what is found.
+
+#[cfg(target_os = "linux")]
+use photocraft_ui_egui::{CaptionFamily, CaptionIcon, CaptionIcons, CaptionStyle};
+
+#[cfg(target_os = "linux")]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum Desktop {
+    Gnome,
+    Kde,
+    Other,
+}
+
+/// The desktop, from the first of its variables that is set: `ubuntu:GNOME`, `Budgie:GNOME` and
+/// the like count as GNOME.
+#[cfg(target_os = "linux")]
+fn desktop(var: &dyn Fn(&str) -> Option<String>) -> Desktop {
+    for key in ["XDG_CURRENT_DESKTOP", "XDG_SESSION_DESKTOP", "DESKTOP_SESSION"] {
+        let Some(v) = var(key).map(|v| v.to_ascii_lowercase()).filter(|v| !v.trim().is_empty()) else { continue };
+        return if v.contains("gnome") {
+            Desktop::Gnome
+        } else if v.contains("kde") || v.contains("plasma") {
+            Desktop::Kde
+        } else {
+            Desktop::Other
+        };
+    }
+    if var("KDE_FULL_SESSION").is_some() {
+        Desktop::Kde
+    } else if var("GNOME_DESKTOP_SESSION_ID").is_some() {
+        Desktop::Gnome
+    } else {
+        Desktop::Other
+    }
+}
+
+/// GNOME's apps are libadwaita's whatever the GTK theme, and KWin draws Breeze; elsewhere the GTK
+/// theme says (Adwaita, adw-gtk3, Yaru, Breeze), and any other theme gets the plain buttons.
+#[cfg(target_os = "linux")]
+fn family(desktop: Desktop, gtk_theme: Option<&str>) -> CaptionFamily {
+    match desktop {
+        Desktop::Gnome => CaptionFamily::Adwaita,
+        Desktop::Kde => CaptionFamily::Breeze,
+        Desktop::Other => {
+            let theme = gtk_theme.unwrap_or_default().trim().to_ascii_lowercase();
+            if ["adwaita", "adw-gtk3", "yaru"].iter().any(|p| theme.starts_with(p)) {
+                CaptionFamily::Adwaita
+            } else if theme.starts_with("breeze") {
+                CaptionFamily::Breeze
+            } else {
+                CaptionFamily::Generic
+            }
+        }
+    }
+}
+
+/// The value of `key` in `[section]` of an INI-style file (GTK's `settings.ini`, KDE's `kwinrc`).
+#[cfg(target_os = "linux")]
+fn ini_value(text: &str, section: &str, key: &str) -> Option<String> {
+    let mut inside = false;
+    for line in text.lines().map(str::trim) {
+        if let Some(name) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) {
+            inside = name == section;
+        } else if inside
+            && let Some((k, v)) = line.split_once('=')
+            && k.trim() == key
+        {
+            return Some(v.trim().to_string());
+        }
+    }
+    None
+}
+
+/// KWin's button order (`[org.kde.kdecoration2]` `ButtonsOnLeft` / `ButtonsOnRight`, one letter a
+/// button: `I` minimize, `A` maximize, `X` close), as a GTK layout. Missing keys keep KWin's
+/// defaults: the window menu on the left, minimize, maximize and close on the right.
+#[cfg(target_os = "linux")]
+fn kwin_layout(kwinrc: &str) -> String {
+    let side = |key: &str, default: &str| {
+        let letters = ini_value(kwinrc, "org.kde.kdecoration2", key).unwrap_or_else(|| default.to_string());
+        letters
+            .chars()
+            .filter_map(|c| match c {
+                'I' => Some("minimize"),
+                'A' => Some("maximize"),
+                'X' => Some("close"),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join(",")
+    };
+    format!("{}:{}", side("ButtonsOnLeft", "MS"), side("ButtonsOnRight", "HIAX"))
+}
+
+/// What the style is worked out from.
+#[cfg(target_os = "linux")]
+#[derive(Clone, Default)]
+struct Found {
+    gtk_theme: Option<String>,
+    /// A GTK decoration layout.
+    layout: Option<String>,
+    icon_theme: Option<String>,
+}
+
+/// The icon theme the glyphs come from: `PHOTOCRAFT_CAPTION_ICONS` (`none` draws PhotoCraft's own),
+/// the desktop's setting, or its default theme.
+#[cfg(target_os = "linux")]
+fn icon_theme_name(desktop: Desktop, found: &Found, var: &dyn Fn(&str) -> Option<String>) -> Option<String> {
+    match var("PHOTOCRAFT_CAPTION_ICONS") {
+        Some(name) if name.trim().eq_ignore_ascii_case("none") => None,
+        Some(name) => Some(name.trim().to_string()),
+        None => Some(found.icon_theme.clone().unwrap_or_else(|| if desktop == Desktop::Kde { "breeze" } else { "Adwaita" }.into())),
+    }
+}
+
+/// The style from what was found; `icons` loads a theme's glyphs.
+#[cfg(target_os = "linux")]
+fn resolve(desktop: Desktop, found: &Found, var: &dyn Fn(&str) -> Option<String>, icons: &dyn Fn(&str) -> Option<CaptionIcons>) -> CaptionStyle {
+    let family = var("PHOTOCRAFT_CAPTION_STYLE").and_then(|s| CaptionFamily::parse(&s)).unwrap_or_else(|| family(desktop, found.gtk_theme.as_deref()));
+    // GNOME's own default shows Close only; GTK's shows all three.
+    let default = if desktop == Desktop::Gnome { "appmenu:close" } else { "menu:minimize,maximize,close" };
+    let layout = var("PHOTOCRAFT_CAPTION_LAYOUT").or_else(|| found.layout.clone()).unwrap_or_else(|| default.to_string());
+    let mut style = CaptionStyle::from_gtk_layout(family, &layout);
+    style.icons = icon_theme_name(desktop, found, var).and_then(|name| icons(&name));
+    style
+}
+
+#[cfg(target_os = "linux")]
+fn read_text(path: &std::path::Path) -> Option<String> {
+    crate::icon_theme::read_small(path).map(|b| String::from_utf8_lossy(&b).into_owned())
+}
+
+/// The themes and layout from the desktop's files: `kwinrc` and `kdeglobals` on KDE, GTK 3's
+/// `settings.ini` elsewhere (where GNOME's portal answers, read later, replace them).
+#[cfg(target_os = "linux")]
+fn from_files(desktop: Desktop, var: &dyn Fn(&str) -> Option<String>) -> Found {
+    let config = var("XDG_CONFIG_HOME")
+        .filter(|d| std::path::Path::new(d).is_absolute())
+        .map(std::path::PathBuf::from)
+        .or_else(|| var("HOME").map(|h| std::path::Path::new(&h).join(".config")));
+    let Some(config) = config else { return Found::default() };
+    let gtk = read_text(&config.join("gtk-3.0").join("settings.ini")).unwrap_or_default();
+    let gtk_theme = ini_value(&gtk, "Settings", "gtk-theme-name");
+    if desktop == Desktop::Kde {
+        let layout = Some(kwin_layout(&read_text(&config.join("kwinrc")).unwrap_or_default()));
+        let icon_theme = ini_value(&read_text(&config.join("kdeglobals")).unwrap_or_default(), "Icons", "Theme");
+        Found { gtk_theme, layout, icon_theme }
+    } else {
+        let layout = ini_value(&gtk, "Settings", "gtk-decoration-layout");
+        Found { gtk_theme, layout, icon_theme: ini_value(&gtk, "Settings", "gtk-icon-theme-name") }
+    }
+}
+
+/// The caption glyphs of icon theme `theme` (`window-*-symbolic.svg`), read now and rendered at
+/// whatever size the bar asks for. `None` when the theme (with its parents) has none of them.
+#[cfg(target_os = "linux")]
+fn load_icons(theme: &str) -> Option<CaptionIcons> {
+    use crate::icon_theme::{IconTheme, base_dirs, rasterize_mask, read_small};
+    let found = IconTheme::load(theme, &base_dirs(&|k: &str| std::env::var(k).ok()))?;
+    let svg = |name: &str| found.find_svg(name).and_then(|p| read_small(&p)).map(std::sync::Arc::<[u8]>::from);
+    let files = [svg("window-minimize-symbolic"), svg("window-maximize-symbolic"), svg("window-restore-symbolic"), svg("window-close-symbolic")];
+    if files.iter().all(Option::is_none) {
+        return None;
+    }
+    let render = move |icon: CaptionIcon, px: u32| {
+        let i = match icon {
+            CaptionIcon::Minimize => 0,
+            CaptionIcon::Maximize => 1,
+            CaptionIcon::Restore => 2,
+            CaptionIcon::Close => 3,
+        };
+        files.get(i)?.as_deref().and_then(|svg| rasterize_mask(svg, px))
+    };
+    Some(CaptionIcons { theme: theme.to_string(), render: std::sync::Arc::new(render) })
+}
+
+/// [`load_icons`] for the last theme asked for, kept, so a layout change doesn't reread it.
+#[cfg(target_os = "linux")]
+#[derive(Default)]
+struct IconCache(std::sync::Mutex<Option<(String, Option<CaptionIcons>)>>);
+
+#[cfg(target_os = "linux")]
+impl IconCache {
+    fn get(&self, theme: &str) -> Option<CaptionIcons> {
+        let mut last = self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+        if let Some((name, icons)) = last.as_ref()
+            && name == theme
+        {
+            return icons.clone();
+        }
+        let icons = load_icons(theme);
+        *last = Some((theme.to_string(), icons.clone()));
+        icons
+    }
+}
+
+#[cfg(target_os = "linux")]
+const WM_NAMESPACE: &str = "org.gnome.desktop.wm.preferences";
+#[cfg(target_os = "linux")]
+const LAYOUT_KEY: &str = "button-layout";
+#[cfg(target_os = "linux")]
+const INTERFACE_NAMESPACE: &str = "org.gnome.desktop.interface";
+#[cfg(target_os = "linux")]
+const ICONS_KEY: &str = "icon-theme";
+
+/// A string setting from the portal, unwrapping the variants some portals nest it in.
+#[cfg(target_os = "linux")]
+fn portal_string(value: zbus::zvariant::OwnedValue) -> Option<String> {
+    let mut value: zbus::zvariant::Value<'_> = value.into();
+    for _ in 0..4 {
+        match value {
+            zbus::zvariant::Value::Value(inner) => value = *inner,
+            zbus::zvariant::Value::Str(s) => return Some(s.to_string()),
+            _ => return None,
+        }
+    }
+    None
+}
+
+/// The caption style now, then with the icon theme's glyphs and (GNOME) the portal's settings,
+/// following the button layout and icon theme as they change. A worker does the file and D-Bus
+/// work and wakes the UI only when the style changes; the first answer usually lands before the
+/// first frame.
+pub fn service() -> Option<photocraft_ui_egui::CaptionStyleFn> {
+    #[cfg(target_os = "linux")]
+    {
+        use std::sync::{Arc, Mutex, OnceLock, PoisonError};
+        let var = |k: &str| std::env::var(k).ok();
+        let desktop = desktop(&var);
+        let mut found = from_files(desktop, &var);
+        // Icons need the theme read, which takes tens of milliseconds: the worker brings them.
+        let current = Arc::new(Mutex::new(resolve(desktop, &found, &var, &|_: &str| None)));
+        let wake: Arc<OnceLock<egui::Context>> = Arc::new(OnceLock::new());
+        let (shared, waker) = (Arc::clone(&current), Arc::clone(&wake));
+        let cache = IconCache::default();
+        let publish = move |found: &Found| {
+            let style = resolve(desktop, found, &|k: &str| std::env::var(k).ok(), &|t: &str| cache.get(t));
+            let mut cur = shared.lock().unwrap_or_else(PoisonError::into_inner);
+            if *cur != style {
+                *cur = style;
+                if let Some(ctx) = waker.get() {
+                    ctx.request_repaint();
+                }
+            }
+        };
+        let (ready, wait) = std::sync::mpsc::channel();
+        let spawned = std::thread::Builder::new().name("caption-style".into()).spawn(move || {
+            let proxy = if desktop == Desktop::Gnome { crate::appearance::portal_proxy() } else { None };
+            let Some(proxy) = proxy else {
+                publish(&found);
+                let _ = ready.send(());
+                return;
+            };
+            // Subscribe before the first read, so a change during start-up isn't lost.
+            let signals = proxy.receive_signal("SettingChanged").ok();
+            let read = |namespace: &str, key: &str| {
+                let value: Option<zbus::zvariant::OwnedValue> = proxy.call("Read", &(namespace, key)).ok();
+                value.and_then(portal_string)
+            };
+            found.layout = read(WM_NAMESPACE, LAYOUT_KEY).or(found.layout.take());
+            found.icon_theme = read(INTERFACE_NAMESPACE, ICONS_KEY).or(found.icon_theme.take());
+            publish(&found);
+            let _ = ready.send(());
+            for message in signals.into_iter().flatten() {
+                let Ok((namespace, key, value)) = message.body().deserialize::<(String, String, zbus::zvariant::OwnedValue)>() else { continue };
+                match (namespace.as_str(), key.as_str()) {
+                    (WM_NAMESPACE, LAYOUT_KEY) => found.layout = portal_string(value),
+                    (INTERFACE_NAMESPACE, ICONS_KEY) => found.icon_theme = portal_string(value),
+                    _ => continue,
+                }
+                publish(&found);
+            }
+        });
+        // A fast desktop answers before the first frame; a slow one updates the bar later.
+        if spawned.is_ok() {
+            let _ = wait.recv_timeout(std::time::Duration::from_millis(150));
+        }
+        Some(Box::new(move |ctx| {
+            let _ = wake.set(ctx.clone());
+            current.lock().unwrap_or_else(PoisonError::into_inner).clone()
+        }))
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        None
+    }
+}
+
+#[cfg(all(test, target_os = "linux"))]
+mod tests {
+    use super::*;
+    use photocraft_ui_egui::Caption::{Close, Maximize, Minimize};
+
+    fn env(pairs: &[(&str, &str)]) -> impl Fn(&str) -> Option<String> + use<> {
+        let pairs: Vec<(String, String)> = pairs.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect();
+        move |k| pairs.iter().find(|(key, _)| key == k).map(|(_, v)| v.clone())
+    }
+
+    #[test]
+    fn the_desktop_comes_from_the_first_variable_set() {
+        assert_eq!(desktop(&env(&[("XDG_CURRENT_DESKTOP", "ubuntu:GNOME")])), Desktop::Gnome);
+        assert_eq!(desktop(&env(&[("XDG_CURRENT_DESKTOP", "KDE")])), Desktop::Kde);
+        assert_eq!(desktop(&env(&[("XDG_CURRENT_DESKTOP", "X-Cinnamon"), ("KDE_FULL_SESSION", "true")])), Desktop::Other);
+        assert_eq!(desktop(&env(&[("XDG_CURRENT_DESKTOP", " "), ("DESKTOP_SESSION", "plasma")])), Desktop::Kde);
+        assert_eq!(desktop(&env(&[("KDE_FULL_SESSION", "true")])), Desktop::Kde);
+        assert_eq!(desktop(&env(&[("GNOME_DESKTOP_SESSION_ID", "this-is-deprecated")])), Desktop::Gnome);
+        assert_eq!(desktop(&env(&[])), Desktop::Other);
+    }
+
+    #[test]
+    fn the_family_follows_the_desktop_then_the_gtk_theme() {
+        assert_eq!(family(Desktop::Gnome, Some("Arc")), CaptionFamily::Adwaita);
+        assert_eq!(family(Desktop::Kde, None), CaptionFamily::Breeze);
+        assert_eq!(family(Desktop::Other, Some("adw-gtk3-dark")), CaptionFamily::Adwaita);
+        assert_eq!(family(Desktop::Other, Some("Yaru-blue")), CaptionFamily::Adwaita);
+        assert_eq!(family(Desktop::Other, Some("Breeze-Dark")), CaptionFamily::Breeze);
+        assert_eq!(family(Desktop::Other, Some("Mint-Y")), CaptionFamily::Generic);
+        assert_eq!(family(Desktop::Other, None), CaptionFamily::Generic);
+    }
+
+    #[test]
+    fn kwin_button_letters_become_a_gtk_layout() {
+        assert_eq!(kwin_layout(""), ":minimize,maximize,close", "KWin's defaults");
+        let rc = "[Desktops]\nButtonsOnLeft=X\n[org.kde.kdecoration2]\nButtonsOnLeft=XIA\nButtonsOnRight=\nlibrary=org.kde.breeze\n";
+        assert_eq!(kwin_layout(rc), "close,minimize,maximize:");
+        assert_eq!(ini_value(rc, "org.kde.kdecoration2", "library").as_deref(), Some("org.kde.breeze"));
+        assert_eq!(ini_value(rc, "nope", "library"), None);
+        // Garbage is just no buttons on that side, never a panic.
+        assert_eq!(kwin_layout("[org.kde.kdecoration2]\nButtonsOnRight=ÿ€=X\n"), ":close");
+    }
+
+    fn no_icons(_: &str) -> Option<CaptionIcons> {
+        None
+    }
+
+    #[test]
+    fn the_icon_theme_comes_from_the_override_the_setting_or_the_desktop() {
+        let found = Found { icon_theme: Some("Papirus".into()), ..Found::default() };
+        assert_eq!(icon_theme_name(Desktop::Gnome, &found, &env(&[])).as_deref(), Some("Papirus"));
+        assert_eq!(icon_theme_name(Desktop::Gnome, &Found::default(), &env(&[])).as_deref(), Some("Adwaita"));
+        assert_eq!(icon_theme_name(Desktop::Kde, &Found::default(), &env(&[])).as_deref(), Some("breeze"));
+        assert_eq!(icon_theme_name(Desktop::Kde, &found, &env(&[("PHOTOCRAFT_CAPTION_ICONS", " None ")])), None);
+        assert_eq!(icon_theme_name(Desktop::Kde, &found, &env(&[("PHOTOCRAFT_CAPTION_ICONS", "Tela")])).as_deref(), Some("Tela"));
+        // The style carries what the loader returns for that name.
+        let s = resolve(Desktop::Gnome, &found, &env(&[]), &|t| {
+            (t == "Papirus").then(|| CaptionIcons { theme: t.into(), render: std::sync::Arc::new(|_, _| None) })
+        });
+        assert_eq!(s.icons.map(|i| i.theme).as_deref(), Some("Papirus"));
+    }
+
+    #[test]
+    fn layouts_and_overrides_resolve_to_a_style() {
+        let none = env(&[]);
+        let gnome = resolve(Desktop::Gnome, &Found::default(), &none, &no_icons);
+        assert_eq!((gnome.family, gnome.left, gnome.right), (CaptionFamily::Adwaita, vec![], vec![Close]), "GNOME's default layout");
+        let kde = resolve(Desktop::Kde, &Found { layout: Some(kwin_layout("")), ..Found::default() }, &none, &no_icons);
+        assert_eq!((kde.family, kde.right), (CaptionFamily::Breeze, vec![Minimize, Maximize, Close]));
+        let found = Found { gtk_theme: Some("Mint-Y".into()), layout: Some("close:".into()), icon_theme: None };
+        let other = resolve(Desktop::Other, &found, &none, &no_icons);
+        assert_eq!((other.family, other.left, other.right), (CaptionFamily::Generic, vec![Close], vec![]));
+        let forced = env(&[("PHOTOCRAFT_CAPTION_STYLE", "Breeze"), ("PHOTOCRAFT_CAPTION_LAYOUT", "minimize,close:maximize")]);
+        let s = resolve(Desktop::Gnome, &found, &forced, &no_icons);
+        assert_eq!((s.family, s.left, s.right), (CaptionFamily::Breeze, vec![Minimize, Close], vec![Maximize]));
+        // An unknown override name falls back to what was found.
+        assert_eq!(resolve(Desktop::Kde, &found, &env(&[("PHOTOCRAFT_CAPTION_STYLE", "aqua")]), &no_icons).family, CaptionFamily::Breeze);
+    }
+
+    #[test]
+    fn portal_strings_unwrap_nested_variants() {
+        use zbus::zvariant::{OwnedValue, Value};
+        let nested = Value::Value(Box::new(Value::Value(Box::new(Value::from("appmenu:close")))));
+        assert_eq!(portal_string(OwnedValue::try_from(nested).unwrap()).as_deref(), Some("appmenu:close"));
+        assert_eq!(portal_string(OwnedValue::try_from(Value::U32(7)).unwrap()), None);
+    }
+
+    #[test]
+    fn settings_files_are_read_from_the_config_dir() {
+        let dir = std::env::temp_dir().join(format!("photocraft-caption-{}", std::process::id()));
+        std::fs::create_dir_all(dir.join("gtk-3.0")).unwrap();
+        std::fs::write(dir.join("gtk-3.0/settings.ini"), "[Settings]\ngtk-theme-name=Yaru\ngtk-decoration-layout=close,maximize:\n").unwrap();
+        std::fs::write(dir.join("kwinrc"), "[org.kde.kdecoration2]\nButtonsOnRight=AX\n").unwrap();
+        std::fs::write(dir.join("kdeglobals"), "[Icons]\nTheme=breeze-dark\n").unwrap();
+        let var = env(&[("XDG_CONFIG_HOME", dir.to_str().unwrap())]);
+        let other = from_files(Desktop::Other, &var);
+        assert_eq!((other.gtk_theme.as_deref(), other.layout.as_deref()), (Some("Yaru"), Some("close,maximize:")));
+        let kde = from_files(Desktop::Kde, &var);
+        assert_eq!((kde.layout.as_deref(), kde.icon_theme.as_deref()), (Some(":maximize,close"), Some("breeze-dark")));
+        // A relative XDG_CONFIG_HOME is ignored, as the XDG spec says; no HOME: nothing found.
+        assert_eq!(from_files(Desktop::Other, &env(&[("XDG_CONFIG_HOME", "rel")])).layout, None);
+        let _ = std::fs::remove_dir_all(dir);
+    }
+}
diff --git a/apps/photocraft/src/control_server.rs b/apps/photocraft/src/control_server.rs
index 932e31ee60..258d89e1ec 100644
--- a/apps/photocraft/src/control_server.rs
+++ b/apps/photocraft/src/control_server.rs
@@ -9,10 +9,10 @@ use std::time::Instant;
 
 use photocraft_automation::budgets::write_reply;
 use photocraft_automation::security::{
-    ConnectionLimiter, LineRead, MAX_CONNECTIONS, MAX_REQUEST_BYTES, authentication_reply, configure_stream, read_bounded_line,
+    ConnectionLimiter, LineRead, MAX_CONNECTIONS, MAX_REQUEST_BYTES, authentication_reply, configure_stream, read_bounded_line, repeat_auth_reply,
 };
 use photocraft_ui_egui::ControlRequest;
-use photocraft_ui_egui::control::{REPLY_DEADLINE, timeout_error};
+use photocraft_ui_egui::control::REPLY_DEADLINE;
 use serde_json::{Value, json};
 
 pub fn start(port: u16, token: String, ctx: egui::Context) -> Receiver<ControlRequest> {
@@ -79,6 +79,12 @@ fn serve(stream: TcpStream, token: &str, tx: Sender<ControlRequest>, ctx: egui::
             }
             continue;
         }
+        if let Some(reply) = repeat_auth_reply(&line) {
+            if write_reply(&mut out, &reply).is_err() || out.flush().is_err() {
+                break;
+            }
+            continue;
+        }
         let reply = match serde_json::from_str::<Value>(&line) {
             Ok(msg) => {
                 let id = msg.get("id").cloned().unwrap_or(Value::Null);
@@ -87,12 +93,13 @@ fn serve(stream: TcpStream, token: &str, tx: Sender<ControlRequest>, ctx: egui::
                 let deadline = Instant::now() + REPLY_DEADLINE;
                 let (mut req, rrx) = ControlRequest::new(method, params);
                 req.deadline = Some(deadline);
+                let dispatch = req.dispatch.clone();
                 if tx.send(req).is_err() {
                     break;
                 }
                 ctx.request_repaint();
                 let mut r =
-                    rrx.recv_timeout(deadline.saturating_duration_since(Instant::now())).unwrap_or_else(|_| json!({"ok": false, "error": timeout_error()}));
+                    rrx.recv_timeout(deadline.saturating_duration_since(Instant::now())).unwrap_or_else(|_| json!({"ok": false, "error": dispatch.give_up()}));
                 if let Some(o) = r.as_object_mut() {
                     o.insert("id".into(), id);
                 }
@@ -202,4 +209,44 @@ mod tests {
         handler.join().unwrap();
         server.join().unwrap();
     }
+
+    #[test]
+    fn repeat_auth_reports_already_authenticated_without_dispatching() {
+        const TOKEN: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+        let addr = listener.local_addr().unwrap();
+        let (tx, rx) = channel::<ControlRequest>();
+        let server = std::thread::spawn(move || {
+            let (stream, _) = listener.accept().unwrap();
+            serve(stream, TOKEN, tx, egui::Context::default());
+        });
+        let handler = std::thread::spawn(move || {
+            let req = rx.recv_timeout(Duration::from_secs(5)).unwrap();
+            assert_eq!(req.method, "test.after", "a repeat auth must not reach the UI dispatcher");
+            req.reply.send(json!({"ok": true, "result": "still serving"})).unwrap();
+        });
+        let mut stream = TcpStream::connect(addr).unwrap();
+        stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
+        let mut reader = BufReader::new(stream.try_clone().unwrap());
+        let mut line = String::new();
+        for id in ["auth", "again"] {
+            writeln!(stream, "{}", json!({"id": id, "method": "auth", "params": {"token": TOKEN}})).unwrap();
+            line.clear();
+            reader.read_line(&mut line).unwrap();
+        }
+        let again: Value = serde_json::from_str(&line).unwrap();
+        assert_eq!(again["id"], "again");
+        assert_eq!(again["ok"], false);
+        assert_eq!(again["error"], "already authenticated");
+        writeln!(stream, "{}", json!({"id": 9, "method": "test.after"})).unwrap();
+        line.clear();
+        reader.read_line(&mut line).unwrap();
+        let after: Value = serde_json::from_str(&line).unwrap();
+        assert_eq!(after["id"], 9);
+        assert_eq!(after["result"], "still serving");
+        drop(reader);
+        drop(stream);
+        handler.join().unwrap();
+        server.join().unwrap();
+    }
 }
diff --git a/apps/photocraft/src/gpu_startup.rs b/apps/photocraft/src/gpu_startup.rs
index 4a612d3a0e..8632fd2a55 100644
--- a/apps/photocraft/src/gpu_startup.rs
+++ b/apps/photocraft/src/gpu_startup.rs
@@ -177,6 +177,12 @@ pub fn plan_with_mode(pref: GpuBackend, mode: RenderingMode, crashed: Option<&Ma
     plan(backend, crashed, env, safe_gpu, os)
 }
 
+/// Persist successful hardware fallbacks, but never silently pin CPU mode.
+/// The recovery dialog explicitly stores CPU mode when the user chooses it.
+pub fn backend_to_remember(plan: &Plan) -> Option<GpuBackend> {
+    (plan.remember && plan.backend != GpuBackend::Cpu).then_some(plan.backend)
+}
+
 /// Instance backends for `plan` (`None`: egui's default, which honours `WGPU_BACKEND`).
 pub fn backends(plan: &Plan, os: Os) -> Option<wgpu::Backends> {
     if plan.env.is_some() {
@@ -541,6 +547,27 @@ mod tests {
         assert_eq!(plan(Auto, None, Some("dx12"), true, Os::Windows).backend, Cpu);
     }
 
+    /// #3483: A temporary CPU recovery must not change the next launch.
+    #[test]
+    fn cpu_recovery_requires_explicit_confirmation_to_persist() {
+        let gl_crash = crashed("gl", "gl");
+        let cpu = plan_with_mode(Auto, RenderingMode::Auto, Some(&gl_crash), None, false, Os::Other);
+        assert_eq!((cpu.backend, cpu.remember), (Cpu, true));
+        assert_eq!(backend_to_remember(&cpu), None);
+
+        let safe = plan_with_mode(Auto, RenderingMode::Auto, None, None, true, Os::Other);
+        assert_eq!(safe.backend, Cpu);
+        assert_eq!(backend_to_remember(&safe), None);
+        // An unconfirmed fallback leaves the original automatic selection intact.
+        assert_eq!(plan_with_mode(Auto, RenderingMode::Auto, None, None, false, Os::Other).backend, Auto);
+        // A working hardware fallback can still be remembered.
+        let vk_crash = crashed("auto", "vulkan");
+        let gl = plan_with_mode(Auto, RenderingMode::Auto, Some(&vk_crash), None, false, Os::Other);
+        assert_eq!(backend_to_remember(&gl), Some(Gl));
+        // CPU explicitly selected in preferences still works.
+        assert_eq!(plan_with_mode(Auto, RenderingMode::Cpu, None, None, false, Os::Other).backend, Cpu);
+    }
+
     #[test]
     fn safe_gpu_forces_the_cpu_for_one_launch() {
         let p = plan(Vulkan, Some(&crashed("vulkan", "vulkan")), None, true, Os::Other);
@@ -672,7 +699,7 @@ mod tests {
         } else {
             s.finish();
         }
-        let (prev, _s) = Sentinel::begin(&dir);
+        let (prev, _s) = begin_when_unlocked(&dir);
         assert_eq!(prev, Previous::Clean);
         assert_eq!(plan(Auto, prev.crashed(), None, false, Os::Other).backend, Auto);
         let _ = std::fs::remove_dir_all(&dir);
@@ -684,6 +711,22 @@ mod tests {
         d
     }
 
+    /// `Sentinel::begin`, called again up to 50 times, 10 ms apart, while it returns
+    /// `Previous::Busy`. Other tests in this binary spawn processes: between fork and exec a child
+    /// briefly shares the marker's flock, so `begin` can see the lock as busy just after a test
+    /// drops its sentinel.
+    fn begin_when_unlocked(dir: &Path) -> (Previous, Option<Sentinel>) {
+        let (mut prev, mut s) = Sentinel::begin(dir);
+        for _ in 0..50 {
+            if prev != Previous::Busy {
+                break;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+            (prev, s) = Sentinel::begin(dir);
+        }
+        (prev, s)
+    }
+
     #[test]
     fn sentinel_detects_a_crash_and_clears_on_success() {
         let dir = temp_dir("cycle");
@@ -699,16 +742,7 @@ mod tests {
         assert!(none.is_none());
         // The process dies in the driver: the lock goes, the marker stays.
         drop(s);
-        // Another test in this binary spawns a process: between its fork and exec the child briefly
-        // shares this file's flock, so `begin` can see the lock as busy. Retry for a moment.
-        let (mut prev, mut s) = Sentinel::begin(&dir);
-        for _ in 0..50 {
-            if prev != Previous::Busy {
-                break;
-            }
-            std::thread::sleep(std::time::Duration::from_millis(10));
-            (prev, s) = Sentinel::begin(&dir);
-        }
+        let (prev, s) = begin_when_unlocked(&dir);
         let m = prev.crashed().cloned().expect("crash detected");
         assert_eq!((m.adapter.as_str(), m.tried()), ("GPU", Some(Vulkan)));
         // This start succeeds: the next one finds nothing.
@@ -721,6 +755,29 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    #[test]
+    fn begin_when_unlocked_waits_for_a_briefly_held_lock() {
+        let dir = temp_dir("shared-lock");
+        let (_, s) = Sentinel::begin(&dir);
+        let mut s = s.expect("sentinel");
+        s.write(Marker { backend: "vulkan".into(), ..Default::default() }).unwrap();
+        // After the start dies, a second handle on the marker holds the lock for 50 ms, as a
+        // spawned child's copy of the descriptor does until the child calls exec.
+        let held = File::open(dir.join(MARKER_FILE)).unwrap();
+        drop(s);
+        held.lock().unwrap();
+        assert_eq!(Sentinel::begin(&dir).0, Previous::Busy);
+        let release = std::thread::spawn(move || {
+            std::thread::sleep(std::time::Duration::from_millis(50));
+            held.unlock().unwrap();
+        });
+        let (prev, s) = begin_when_unlocked(&dir);
+        release.join().unwrap();
+        assert_eq!(prev.crashed().map(|m| m.backend.as_str()), Some("vulkan"));
+        s.expect("sentinel").finish();
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     #[test]
     fn returned_non_graphics_errors_do_not_trigger_backend_recovery() {
         let cases = [
@@ -738,7 +795,7 @@ mod tests {
             } else {
                 s.finish();
             }
-            let (previous, s) = Sentinel::begin(&dir);
+            let (previous, s) = begin_when_unlocked(&dir);
             assert_eq!(previous.crashed().is_some(), keep, "{name}: {result:?}");
             if !keep {
                 assert_eq!(plan(Vulkan, previous.crashed(), None, false, Os::Other).backend, Vulkan);
diff --git a/apps/photocraft/src/icon_theme.rs b/apps/photocraft/src/icon_theme.rs
new file mode 100644
index 0000000000..cf2ede3b7b
--- /dev/null
+++ b/apps/photocraft/src/icon_theme.rs
@@ -0,0 +1,329 @@
+//! Linux: icons from the desktop's freedesktop icon theme (the Icon Theme Specification), for the
+//! caption buttons' glyphs (`caption_style.rs`). A theme is searched, then the themes it inherits,
+//! then `hicolor`; within each, its directories from the best fit for a 16 px icon down. Only SVG
+//! files are used: symbolic icons are drawn as a coverage mask in the button's ink colour.
+
+use std::path::{Path, PathBuf};
+
+/// Bounds on what a theme's files can make us do: themes in an inheritance chain, directories a
+/// theme lists, and the bytes read from one file.
+const MAX_THEMES: usize = 32;
+const MAX_DIRS: usize = 4096;
+/// How deep an index's unlisted directories are looked for (`symbolic/ui`, `16x16@2/actions`).
+const SCAN_DEPTH: usize = 3;
+const MAX_FILE: u64 = 1 << 20;
+/// The size the caption glyphs are drawn at, in the spec's units.
+const ICON_SIZE: i64 = 16;
+
+/// A theme or icon name that stays inside its directory.
+pub fn valid_name(name: &str) -> bool {
+    !name.is_empty() && name != "." && name != ".." && !name.contains(['/', '\\', '\0'])
+}
+
+/// At most [`MAX_FILE`] bytes of a file (settings, theme indexes and icons are small).
+pub fn read_small(path: &Path) -> Option<Vec<u8>> {
+    use std::io::Read;
+    let mut bytes = vec![];
+    std::fs::File::open(path).ok()?.take(MAX_FILE).read_to_end(&mut bytes).ok()?;
+    Some(bytes)
+}
+
+/// Where themes live, in the spec's order: `~/.icons`, `$XDG_DATA_HOME/icons`, then each
+/// `$XDG_DATA_DIRS/icons`. Relative paths in the variables are ignored, as the XDG spec says.
+pub fn base_dirs(var: &dyn Fn(&str) -> Option<String>) -> Vec<PathBuf> {
+    let absolute = |p: &String| Path::new(p).is_absolute();
+    let home = var("HOME").filter(absolute).map(PathBuf::from);
+    let mut dirs = vec![];
+    if let Some(home) = &home {
+        dirs.push(home.join(".icons"));
+    }
+    if let Some(data) = var("XDG_DATA_HOME").filter(absolute).map(PathBuf::from).or_else(|| home.map(|h| h.join(".local").join("share"))) {
+        dirs.push(data.join("icons"));
+    }
+    let data_dirs = var("XDG_DATA_DIRS").filter(|d| !d.trim().is_empty()).unwrap_or_else(|| "/usr/local/share:/usr/share".into());
+    dirs.extend(data_dirs.split(':').filter(|d| Path::new(d).is_absolute()).map(|d| Path::new(d).join("icons")));
+    dirs
+}
+
+/// One `[section]` of an `index.theme`, as (key, value) pairs.
+fn section<'a>(index: &'a str, name: &str) -> Vec<(&'a str, &'a str)> {
+    let mut inside = false;
+    let mut pairs = vec![];
+    for line in index.lines().map(str::trim) {
+        if let Some(s) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) {
+            if inside {
+                break;
+            }
+            inside = s == name;
+        } else if inside && let Some((k, v)) = line.split_once('=') {
+            pairs.push((k.trim(), v.trim()));
+        }
+    }
+    pairs
+}
+
+fn list(value: Option<&str>) -> impl Iterator<Item = &str> {
+    value.unwrap_or_default().split(',').map(str::trim).filter(|s| !s.is_empty())
+}
+
+/// How far a theme directory is from a 16 px icon at scale 1 (the spec's
+/// `DirectorySizeDistance`), then its scale: 0 is an exact fit.
+fn distance(keys: &[(&str, &str)]) -> (i64, i64) {
+    let get = |k: &str| keys.iter().find(|(key, _)| *key == k).map(|(_, v)| *v);
+    let num = |k: &str, default: i64| get(k).and_then(|v| v.parse::<i64>().ok()).unwrap_or(default).clamp(0, 1 << 16);
+    let size = num("Size", 0);
+    let scale = num("Scale", 1).max(1);
+    let d = match get("Type").unwrap_or("Threshold") {
+        "Fixed" => (size * scale - ICON_SIZE).abs(),
+        "Scalable" => {
+            let (min, max) = (num("MinSize", size) * scale, num("MaxSize", size) * scale);
+            (min - ICON_SIZE).max(ICON_SIZE - max).max(0)
+        }
+        _ => ((size * scale - ICON_SIZE).abs() - num("Threshold", 2) * scale).max(0),
+    };
+    (d, scale)
+}
+
+/// Every directory under `root`, at most [`SCAN_DEPTH`] levels down and [`MAX_DIRS`] in all, in
+/// path order: scalable and symbolic ones first, as icons there fit any size.
+fn subdirectories(root: &Path) -> Vec<PathBuf> {
+    let mut found = vec![];
+    let mut level = vec![root.to_path_buf()];
+    for _ in 0..SCAN_DEPTH {
+        let mut next = vec![];
+        for dir in &level {
+            let Ok(entries) = std::fs::read_dir(dir) else { continue };
+            for entry in entries.flatten().take(MAX_DIRS) {
+                let path = entry.path();
+                if found.len() + next.len() < MAX_DIRS && path.is_dir() {
+                    next.push(path);
+                }
+            }
+        }
+        found.extend(next.iter().cloned());
+        level = next;
+    }
+    let vector = |p: &PathBuf| !p.components().any(|c| matches!(c.as_os_str().to_str(), Some("scalable" | "symbolic")));
+    found.sort_by_key(|p| (vector(p), p.clone()));
+    found
+}
+
+/// One theme of a chain: its listed directories, best fit first, in every base directory that has
+/// the theme, and (looked for only when an icon isn't in those) the directories its index forgot.
+struct Theme {
+    roots: Vec<PathBuf>,
+    listed: Vec<PathBuf>,
+    unlisted: std::cell::OnceCell<Vec<PathBuf>>,
+}
+
+impl Theme {
+    /// The directories the index forgot to list: GTK still finds icons there, and custom themes
+    /// often add `symbolic/ui` without listing it.
+    fn unlisted(&self) -> &[PathBuf] {
+        self.unlisted.get_or_init(|| {
+            let listed: std::collections::HashSet<&PathBuf> = self.listed.iter().collect();
+            self.roots.iter().flat_map(|r| subdirectories(r)).filter(|d| !listed.contains(d)).collect()
+        })
+    }
+}
+
+/// A theme and the themes it inherits, in search order.
+pub struct IconTheme {
+    themes: Vec<Theme>,
+}
+
+impl IconTheme {
+    /// `name` and the themes it inherits, then `hicolor`. `None` when no theme in the chain has an
+    /// `index.theme`.
+    pub fn load(name: &str, bases: &[PathBuf]) -> Option<Self> {
+        let mut chain: Vec<String> = vec![name.to_string()];
+        let mut themes = vec![];
+        let mut i = 0;
+        loop {
+            let Some(theme) = chain.get(i).cloned() else {
+                // Every chain ends in hicolor, whether or not the themes before it exist.
+                if chain.iter().any(|t| t == "hicolor") {
+                    break;
+                }
+                chain.push("hicolor".into());
+                continue;
+            };
+            i += 1;
+            if !valid_name(&theme) {
+                continue;
+            }
+            let roots: Vec<PathBuf> = bases.iter().map(|b| b.join(&theme)).filter(|r| r.is_dir()).collect();
+            // The first index wins; a theme can still be spread over several base directories.
+            let Some(index) = roots.iter().find_map(|r| read_small(&r.join("index.theme"))) else { continue };
+            let index = String::from_utf8_lossy(&index);
+            let head = section(&index, "Icon Theme");
+            let get = |k: &str| head.iter().find(|(key, _)| *key == k).map(|(_, v)| *v);
+            let mut subdirs: Vec<((i64, i64), &str)> = list(get("Directories"))
+                .chain(list(get("ScaledDirectories")))
+                .filter(|d| !d.split('/').any(|part| part == ".." || part.is_empty()))
+                .take(MAX_DIRS)
+                .map(|d| (distance(&section(&index, d)), d))
+                .collect();
+            subdirs.sort_by_key(|(key, _)| *key);
+            // Not checked for existence: a theme lists hundreds, and the search stops at a hit.
+            let listed = subdirs.iter().flat_map(|(_, sub)| roots.iter().map(move |r| r.join(sub))).collect();
+            for parent in list(get("Inherits")) {
+                if chain.len() < MAX_THEMES && !chain.iter().any(|t| t == parent) {
+                    chain.push(parent.to_string());
+                }
+            }
+            themes.push(Theme { roots, listed, unlisted: std::cell::OnceCell::new() });
+        }
+        (!themes.is_empty()).then_some(Self { themes })
+    }
+
+    /// The first `<icon>.svg` in search order: each theme's listed directories, then its unlisted
+    /// ones, before its parent.
+    pub fn find_svg(&self, icon: &str) -> Option<PathBuf> {
+        if !valid_name(icon) {
+            return None;
+        }
+        let file = format!("{icon}.svg");
+        let hit = |dirs: &[PathBuf]| dirs.iter().map(|d| d.join(&file)).find(|p| p.is_file());
+        self.themes.iter().find_map(|t| hit(&t.listed).or_else(|| hit(t.unlisted())))
+    }
+}
+
+/// An SVG's coverage (alpha) as a `px` × `px` mask, the drawing fitted and centred. `None` for an
+/// unreadable SVG or an absurd size.
+pub fn rasterize_mask(svg: &[u8], px: u32) -> Option<Vec<u8>> {
+    use resvg::{tiny_skia, usvg};
+    if !(1..=256).contains(&px) {
+        return None;
+    }
+    // Glyphs are paths: no `<image>` is loaded, so an icon can't make us read another file
+    // (`/dev/zero`, a huge picture) or nest an SVG.
+    let opts = usvg::Options {
+        image_href_resolver: usvg::ImageHrefResolver { resolve_data: Box::new(|_, _, _| None), resolve_string: Box::new(|_, _| None) },
+        ..usvg::Options::default()
+    };
+    let tree = usvg::Tree::from_data(svg, &opts).ok()?;
+    let size = tree.size();
+    let side = size.width().max(size.height());
+    if !side.is_finite() || side <= 0.0 {
+        return None;
+    }
+    let s = px as f32 / side;
+    let (dx, dy) = ((px as f32 - size.width() * s) / 2.0, (px as f32 - size.height() * s) / 2.0);
+    let mut pixmap = tiny_skia::Pixmap::new(px, px)?;
+    resvg::render(&tree, tiny_skia::Transform::from_scale(s, s).post_translate(dx, dy), &mut pixmap.as_mut());
+    Some(pixmap.data().as_chunks::<4>().0.iter().map(|[_, _, _, a]| *a).collect())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A throwaway icon tree: `files` are (path under the base, contents).
+    fn tree(tag: &str, files: &[(&str, &str)]) -> PathBuf {
+        let base = std::env::temp_dir().join(format!("photocraft-icons-{tag}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&base);
+        for (path, text) in files {
+            let p = base.join(path);
+            std::fs::create_dir_all(p.parent().unwrap()).unwrap();
+            std::fs::write(p, text).unwrap();
+        }
+        base
+    }
+
+    const SQUARE: &str = r##"<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M4 4h8v8H4z" fill="#2e3436"/></svg>"##;
+
+    #[test]
+    fn icons_come_from_the_theme_then_its_parents_then_hicolor_best_size_first() {
+        let base = tree(
+            "chain",
+            &[
+                ("Child/index.theme", "[Icon Theme]\nInherits=Parent, Child\nDirectories=48,16\n[48]\nSize=48\nType=Fixed\n[16]\nSize=16\nType=Fixed\n"),
+                ("Child/48/a-symbolic.svg", "big"),
+                // Not in the index: still found, and before the parent's copy.
+                ("Child/symbolic/ui/d-symbolic.svg", SQUARE),
+                ("Parent/ui/d-symbolic.svg", SQUARE),
+                ("Child/16/a-symbolic.svg", SQUARE),
+                ("Parent/index.theme", "[Icon Theme]\nDirectories=ui\n[ui]\nSize=16\nMinSize=8\nMaxSize=512\nType=Scalable\n"),
+                ("Parent/ui/b-symbolic.svg", SQUARE),
+                ("hicolor/index.theme", "[Icon Theme]\nDirectories=s\n[s]\nSize=16\nType=Scalable\n"),
+                ("hicolor/s/c-symbolic.svg", SQUARE),
+            ],
+        );
+        let theme = IconTheme::load("Child", std::slice::from_ref(&base)).expect("the theme loads");
+        assert_eq!(theme.find_svg("a-symbolic"), Some(base.join("Child/16/a-symbolic.svg")), "16 px before 48 px");
+        assert_eq!(theme.find_svg("b-symbolic"), Some(base.join("Parent/ui/b-symbolic.svg")));
+        assert_eq!(theme.find_svg("c-symbolic"), Some(base.join("hicolor/s/c-symbolic.svg")));
+        assert_eq!(theme.find_svg("d-symbolic"), Some(base.join("Child/symbolic/ui/d-symbolic.svg")), "unlisted, but the theme's own");
+        assert_eq!(theme.find_svg("missing"), None);
+        assert_eq!(theme.find_svg("../Parent/ui/b-symbolic"), None);
+        assert!(IconTheme::load("Nowhere", std::slice::from_ref(&base)).is_some(), "hicolor still answers");
+        assert!(IconTheme::load("Nowhere", &[base.join("empty")]).is_none());
+        let _ = std::fs::remove_dir_all(base);
+    }
+
+    /// Hostile theme files: cycles, escapes and junk sizes end the search, never hang or panic.
+    #[test]
+    fn cyclic_or_hostile_indexes_are_harmless() {
+        let base = tree(
+            "hostile",
+            &[
+                (
+                    "A/index.theme",
+                    "[Icon Theme]\nInherits=B,../etc,\nDirectories=../../x,,/abs,ok\n[ok]\nSize=99999999999999999999\nScale=-3\nType=Threshold\n",
+                ),
+                ("A/ok/x.svg", SQUARE),
+                ("B/index.theme", "[Icon Theme]\nInherits=A\n"),
+            ],
+        );
+        let theme = IconTheme::load("A", std::slice::from_ref(&base)).expect("loads");
+        assert_eq!(theme.find_svg("x"), Some(base.join("A/ok/x.svg")));
+        assert!(IconTheme::load("..", std::slice::from_ref(&base)).is_none());
+        let _ = std::fs::remove_dir_all(base);
+    }
+
+    #[test]
+    fn distance_follows_the_spec() {
+        assert_eq!(distance(&[("Size", "16"), ("Type", "Fixed")]), (0, 1));
+        assert_eq!(distance(&[("Size", "22"), ("Type", "Fixed")]), (6, 1));
+        assert_eq!(distance(&[("Size", "16"), ("Scale", "2"), ("Type", "Fixed")]), (16, 2));
+        assert_eq!(distance(&[("Size", "32"), ("MinSize", "8"), ("MaxSize", "512"), ("Type", "Scalable")]), (0, 1));
+        assert_eq!(distance(&[("Size", "48"), ("Type", "Scalable")]), (32, 1));
+        assert_eq!(distance(&[("Size", "18")]), (0, 1), "Threshold 2 by default");
+    }
+
+    #[test]
+    fn masks_are_square_coverage() {
+        let mask = rasterize_mask(SQUARE.as_bytes(), 32).expect("renders");
+        assert_eq!(mask.len(), 32 * 32);
+        assert_eq!(mask[16 * 32 + 16], 255, "inside the square");
+        assert_eq!(mask[0], 0, "outside it");
+        assert!(rasterize_mask(b"not svg", 16).is_none());
+        assert!(rasterize_mask(SQUARE.as_bytes(), 0).is_none());
+        assert!(rasterize_mask(SQUARE.as_bytes(), 100_000).is_none());
+    }
+
+    /// An icon's `<image>` is never loaded: not a device file, not an embedded picture.
+    #[test]
+    fn masks_load_no_images() {
+        let svg = r##"<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="16" height="16">
+            <image href="/dev/zero" width="16" height="16"/>
+            <image xlink:href="data:image/svg+xml;utf8,&lt;svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'&gt;&lt;rect width='16' height='16'/&gt;&lt;/svg&gt;" width="16" height="16"/>
+        </svg>"##;
+        let mask = rasterize_mask(svg.as_bytes(), 16).expect("renders");
+        assert!(mask.iter().all(|a| *a == 0), "nothing drawn");
+    }
+
+    #[test]
+    fn base_dirs_follow_xdg() {
+        let var = |k: &str| match k {
+            "HOME" => Some("/home/u".to_string()),
+            "XDG_DATA_DIRS" => Some("/a:rel:/b".to_string()),
+            _ => None,
+        };
+        let dirs = base_dirs(&var);
+        let want: Vec<PathBuf> = ["/home/u/.icons", "/home/u/.local/share/icons", "/a/icons", "/b/icons"].iter().map(PathBuf::from).collect();
+        assert_eq!(dirs, want);
+        assert_eq!(base_dirs(&|_| None), vec![PathBuf::from("/usr/local/share/icons"), PathBuf::from("/usr/share/icons")]);
+    }
+}
diff --git a/apps/photocraft/src/main.rs b/apps/photocraft/src/main.rs
index a267673aa5..1739568159 100644
--- a/apps/photocraft/src/main.rs
+++ b/apps/photocraft/src/main.rs
@@ -26,11 +26,14 @@ mod appearance;
 #[cfg(target_os = "macos")]
 mod apple_events;
 mod caps_lock;
+mod caption_style;
 mod control_server;
 mod crash_guard;
 mod cursor;
 mod file_dialog_probe;
 mod gpu_startup;
+#[cfg(target_os = "linux")]
+mod icon_theme;
 #[cfg(target_os = "macos")]
 mod mac_menu;
 #[cfg(target_os = "macos")]
@@ -72,7 +75,8 @@ fn custom_titlebar(prefs_file: Option<&std::path::Path>) -> bool {
 /// The main window: 1440 × 900 (shrunk to fit the monitor, and maximized on the first frame
 /// when it still doesn't fit, `work_area::fit_window`), centred on the main monitor. Without
 /// `centered`, Windows cascades each new window from the top-left corner, so it opened at a
-/// different offset every launch (#419). Wayland compositors place windows themselves.
+/// different offset every launch (#419). A later launch restores the saved position instead
+/// (`main` turns `centered` off, #4826). Wayland compositors place windows themselves.
 fn native_options(custom_titlebar: bool) -> eframe::NativeOptions {
     eframe::NativeOptions {
         viewport: egui::ViewportBuilder::default()
@@ -90,11 +94,21 @@ fn native_options(custom_titlebar: bool) -> eframe::NativeOptions {
         // eframe saves native window geometry and egui panel/window sizes on exit.
         // Keep that state beside preferences, including config overrides and portable mode.
         persistence_path: services::config_dir().map(|dir| dir.join("ui.ron")),
-        window_builder: Some(Box::new(at_least_min_size)),
+        window_builder: Some(Box::new(restored_window)),
         ..Default::default()
     }
 }
 
+/// The window eframe restores from `ui.ron`, corrected before it is created: at least the
+/// minimum size, and never full screen. PhotoCraft always starts in Standard Screen Mode, but
+/// eframe also saves and restores full screen, and a window closed in a full-screen mode is
+/// saved full screen and maximized at once: the overlap `view_cmds::screen_mode_commands` keeps
+/// apart at run time. [OBSERVED 2026-10-12, Windows 11] Restored that way, View › Screen Mode ›
+/// Full Screen did nothing until `F` had cycled through Standard.
+fn restored_window(builder: egui::ViewportBuilder) -> egui::ViewportBuilder {
+    at_least_min_size(builder).with_fullscreen(false)
+}
+
 /// Grow a restored window that is smaller than the minimum size, keeping its centre. On
 /// Windows, eframe saves a minimized window's size (160 pt wide, 64 pt tall once eframe has
 /// clamped it), and the minimum size isn't applied to a restored one: PhotoCraft then reopened
@@ -317,6 +331,9 @@ fn main() -> eframe::Result {
     }
     // eframe restores the saved window layout before our code runs; drop values that would crash it.
     ui_state::sanitize(options.persistence_path.as_deref());
+    // Centre only the first window: eframe centres after restoring the saved position, so a
+    // window closed on another monitor reopened in the middle of the main one (#4826).
+    options.centered = !ui_state::has_saved_position(options.persistence_path.as_deref());
     // Crash-safe GPU startup (#4): pick the backend (a marker left by a start that died in the
     // driver moves to a safer one), and lock this start's marker until the first frames render.
     let t_sentinel = std::time::Instant::now();
@@ -436,24 +453,13 @@ fn main() -> eframe::Result {
                 photocraft_ui_egui::gpu_status::queue_fallback_notice(&mut app, &reason);
             }
             app.perf.span("gpuSentinel", sentinel_ms);
-            // Once the first frames rendered: clear the marker, and keep a crash fallback.
-            let remember_cpu =
-                std::env::var_os("PHOTOCRAFT_GPU_STARTUP_FAILURE").is_some() || (plan.remember && plan.backend == photocraft_engine::prefs::GpuBackend::Cpu);
-            let remember = plan.remember.then_some(plan.backend);
+            // CPU rendering after a failed GPU start is temporary. Only the
+            // recovery-dialog choice may persist it (#3483).
+            let remember = gpu_startup::backend_to_remember(&plan);
             app.on_started(move |app| {
                 if let Some(s) = started_sentinel.lock().unwrap_or_else(std::sync::PoisonError::into_inner).take() {
                     s.finish();
                 }
-                if remember_cpu
-                    && let Err(error) = app.run(
-                        "prefs.set",
-                        serde_json::json!({"values": {
-                            "performance.renderingMode": "cpu", "performance.useGpu": false
-                        }}),
-                    )
-                {
-                    log::warn!("couldn't remember CPU recovery: {error}");
-                }
                 if let Some(b) = remember
                     && app.session.prefs().performance.gpu_backend != b
                     && let Err(e) = app.run("prefs.set", serde_json::json!({"path": "performance.gpuBackend", "value": b.name()}))
@@ -482,6 +488,10 @@ fn main() -> eframe::Result {
             // The custom title bar's undecorated window must stay borderless, or its caption and
             // border offset the content and the pointer on some Windows systems (#2246).
             app.services.window_frame = window_frame::service(cc, custom_titlebar);
+            // Linux: the desktop's caption buttons (GNOME's, KDE's) on the sides its layout puts them.
+            if custom_titlebar {
+                app.services.caption_style = caption_style::service();
+            }
             // Caps Lock state (X11/Windows/macOS; `None` on native Wayland): the canvas shows the
             // precise crosshair for painting tools while it is toggled on (#1758).
             app.services.caps_lock = caps_lock::service(cc);
@@ -624,6 +634,22 @@ mod tests {
         assert_eq!(super::at_least_min_size(builder).inner_size, None);
     }
 
+    #[test]
+    fn a_window_saved_in_full_screen_reopens_maximized_not_full_screen() {
+        let hook = super::native_options(super::CUSTOM_TITLEBAR).window_builder.expect("a window builder hook");
+        // What eframe restores from a ui.ron saved in a full-screen mode on Windows.
+        let saved = super::native_options(super::CUSTOM_TITLEBAR)
+            .viewport
+            .with_inner_size([2560.0, 1392.0])
+            .with_position([0.0, 0.0])
+            .with_fullscreen(true)
+            .with_maximized(true);
+        let opened = hook(saved);
+        assert_eq!(opened.fullscreen, Some(false), "Standard Screen Mode is where PhotoCraft starts");
+        assert_eq!(opened.maximized, Some(true), "the rest of the saved geometry is kept");
+        assert_eq!(opened.inner_size, Some(egui::vec2(2560.0, 1392.0)));
+    }
+
     #[test]
     fn the_system_title_bar_preference_keeps_the_window_decorations() {
         // #1271, #1316: Preferences › Interface › System Title Bar gives the window back its
@@ -644,4 +670,13 @@ mod tests {
         }
         let _ = std::fs::remove_dir_all(&dir);
     }
+
+    /// X11 startup notification and docks match a window to its launcher by `StartupWMClass`,
+    /// so it has to be the class the window carries: the app id, on Wayland and X11 alike.
+    #[test]
+    fn the_desktop_entry_names_the_window_class() {
+        let entry = include_str!("../../../packaging/linux/ai.storyteller.photocraft.desktop");
+        let class = entry.lines().find_map(|line| line.strip_prefix("StartupWMClass="));
+        assert_eq!(class, Some(super::APP_ID));
+    }
 }
diff --git a/apps/photocraft/src/services.rs b/apps/photocraft/src/services.rs
index 5df122c4dc..d4a3869f31 100644
--- a/apps/photocraft/src/services.rs
+++ b/apps/photocraft/src/services.rs
@@ -16,13 +16,13 @@ use std::sync::Arc;
 #[cfg(test)]
 mod recovery_tests;
 
-/// Everything File › Open reads: PhotoCraft, Photoshop, OpenRaster and Affinity documents, flat images, and
+/// Everything File › Open reads: PhotoCraft, Photoshop, OpenRaster, Krita and Affinity documents, flat images, and
 /// Photoshop brushes (.abr), gradients (.grd), swatches (.aco, .ase) and keyboard shortcut sets
 /// (.kys), which go to the preset libraries and Edit › Keyboard Shortcuts.
 const OPEN_EXTS: &[&str] = &[
-    "pcraft", "pdn", "ora", "psd", "psb", "psdt", "png", "jpg", "jpeg", "tif", "tiff", "webp", "gif", "bmp", "tga", "ico", "qoi", "exr", "hdr", "pbm", "pgm",
-    "ppm", "pam", "pfm", "fits", "fit", "fts", "heic", "heif", "hif", "dng", "cr2", "cr3", "nef", "nrw", "arw", "pef", "orf", "rw2", "raf", "abr", "grd",
-    "svg", "svgz", "aco", "ase", "kys", "af", "afdesign", "afphoto", "afpub",
+    "pcraft", "pdn", "ora", "kra", "krz", "psd", "psb", "psdt", "png", "jpg", "jpeg", "tif", "tiff", "webp", "gif", "bmp", "tga", "ico", "qoi", "exr", "hdr",
+    "pbm", "pgm", "ppm", "pam", "pfm", "pcx", "dds", "xpm", "fits", "fit", "fts", "dpx", "heic", "heif", "hif", "dng", "cr2", "cr3", "nef", "nrw", "arw",
+    "pef", "orf", "rw2", "raf", "abr", "grd", "svg", "svgz", "aco", "ase", "kys", "af", "afdesign", "afphoto", "afpub",
 ];
 const SVG_EXTS: &[&str] = &["svg", "svgz"];
 
@@ -43,6 +43,7 @@ fn open_filters() -> Vec<(&'static str, Vec<String>)> {
         ("All Formats", open_filter_extensions(OPEN_EXTS)),
         ("PhotoCraft", open_filter_extensions(&["pcraft"])),
         ("OpenRaster", open_filter_extensions(&["ora"])),
+        ("Krita", open_filter_extensions(&["kra", "krz"])),
         ("SVG", open_filter_extensions(SVG_EXTS)),
     ]
 }
@@ -59,8 +60,13 @@ const SAVE_FILTERS: &[(&str, &[&str])] = &[
     ("WebP", &["webp"]),
     ("TIFF", &["tif"]),
     ("Targa", &["tga"]),
+    // Also in Photoshop's Save As list; ICO is PhotoCraft's own (#4357): up to 256×256, with alpha.
+    ("BMP", &["bmp"]),
+    ("GIF", &["gif"]),
+    ("ICO", &["ico"]),
     ("OpenEXR", &["exr"]),
     ("FITS", &["fits", "fit"]),
+    ("DPX", &["dpx"]),
 ];
 
 /// Non-document files the shell saves (Swatches panel exports): offered alone, so the dialog
@@ -76,8 +82,11 @@ fn save_filters(suggested: &str) -> Vec<(String, Vec<String>)> {
     let mut v: Vec<(String, Vec<String>)> = SAVE_FILTERS.iter().map(|(name, exts)| (name.to_string(), exts.iter().map(|e| e.to_string()).collect())).collect();
     match v.iter().position(|(_, exts)| exts.contains(&ext)) {
         Some(i) => {
-            let f = v.remove(i);
-            v.insert(0, f);
+            let (name, mut exts) = v.remove(i);
+            // Windows adds the first type's first extension to a bare name: `.psb`, not `.psd`.
+            exts.retain(|e| *e != ext);
+            exts.insert(0, ext);
+            v.insert(0, (name, exts));
         }
         None if !ext.is_empty() => v.insert(0, (ext.to_ascii_uppercase(), vec![ext])),
         None => {}
@@ -85,6 +94,21 @@ fn save_filters(suggested: &str) -> Vec<(String, Vec<String>)> {
     v
 }
 
+/// The name the save dialog starts with. On Windows a visible extension stays put when the user
+/// picks another type (with File name extensions shown, `image.psd` saved as PhotoCraft stayed
+/// `image.psd`, #4394), while a bare name gets the chosen type's extension, so there the dialog
+/// gets the stem and the suggested type (listed first by [`save_filters`]) supplies `.psd`. A
+/// stem that still has a dot (`scan.jpg.psd`: Windows could keep `scan.jpg`) or an upper-case
+/// extension (the user's spelling) keeps the whole name. Elsewhere the whole name is kept: the
+/// macOS panel has no type list, and on Linux rfd doesn't report which type was picked.
+fn dialog_file_name(suggested: &str, windows: bool) -> Option<String> {
+    let path = Path::new(suggested);
+    let name = path.file_name()?.to_string_lossy().into_owned();
+    let (Some(stem), Some(ext)) = (path.file_stem(), path.extension().and_then(|e| e.to_str())) else { return Some(name) };
+    let bare = windows && Path::new(stem).extension().is_none() && !ext.is_empty() && ext == ext.to_ascii_lowercase();
+    Some(if bare { stem.to_string_lossy().into_owned() } else { name })
+}
+
 /// Shows an Open or Save dialog without blocking the event loop (#673, #574): rfd's async dialog
 /// is created here, on the main thread, with the window as its parent (a sheet on macOS, an owned
 /// modal window elsewhere), and a helper thread waits for it and hands the answer to the app.
@@ -115,12 +139,19 @@ fn show_file_dialog(request: FileDialogRequest, parent: Option<&eframe::Frame>,
                 Box::pin(async move { picked.await.map(|file| FileDialogAnswer::Paths(vec![path_of(&file)])) })
             }
         }
+        FileDialogRequest::Folder { initial_dir } => {
+            if let Some(dir) = initial_dir {
+                dialog = dialog.set_directory(dir);
+            }
+            let picked = dialog.pick_folder();
+            Box::pin(async move { picked.await.map(|folder| FileDialogAnswer::FolderTo(path_of(&folder))) })
+        }
         FileDialogRequest::Save { suggested } => {
             for (name, exts) in save_filters(&suggested) {
                 dialog = dialog.add_filter(name, &exts);
             }
-            if let Some(name) = Path::new(&suggested).file_name() {
-                dialog = dialog.set_file_name(name.to_string_lossy());
+            if let Some(name) = dialog_file_name(&suggested, cfg!(windows)) {
+                dialog = dialog.set_file_name(name);
             }
             if let Some(dir) = Path::new(&suggested).parent().filter(|p| !p.as_os_str().is_empty()) {
                 dialog = dialog.set_directory(dir);
@@ -209,6 +240,7 @@ fn export_options(settings: &photocraft_ui_egui::ExportSettings) -> photocraft_i
     opts.xmp = if settings.xmp_all { photocraft_io::XmpEmbed::All } else { photocraft_io::XmpEmbed::None };
     opts.tga_bits = settings.tga_bits;
     opts.image_previews = settings.image_previews;
+    opts.psd_maximize_compatibility = settings.psd_maximize_compatibility;
     opts
 }
 
@@ -316,6 +348,43 @@ fn image_from_files(paths: &[PathBuf]) -> Option<(u32, u32, Vec<u8>)> {
     })
 }
 
+/// Largest clipboard image payload read on Wayland (1 GiB, a 16K × 16K RGBA BMP), so no real
+/// screenshot is turned away, while a broken or hostile source can't make us allocate without end.
+#[cfg(target_os = "linux")]
+const MAX_CLIPBOARD_IMAGE_BYTES: u64 = 4 * 16384 * 16384;
+
+/// The clipboard image arboard can't read on Wayland (#2546): arboard 3.6 asks for `image/png`
+/// only, so a screenshot tool or clipboard manager that offers just `image/jpeg`, `image/bmp` or
+/// `image/webp` pasted nothing. Reads the other `image/*` types through the same data-control
+/// protocol arboard uses, and decodes them with our own codecs. `None` off Wayland.
+#[cfg(target_os = "linux")]
+fn wayland_clipboard_image() -> Option<(u32, u32, Vec<u8>)> {
+    use std::io::Read;
+    use wl_clipboard_rs::paste::{ClipboardType, MimeType, Seat, get_contents, get_mime_types_ordered};
+    let offers = get_mime_types_ordered(ClipboardType::Regular, Seat::Unspecified).ok()?;
+    image_from_offers(&offers, |mime| {
+        let (pipe, _) = get_contents(ClipboardType::Regular, Seat::Unspecified, MimeType::Specific(mime)).ok()?;
+        let mut bytes = Vec::new();
+        pipe.take(MAX_CLIPBOARD_IMAGE_BYTES + 1).read_to_end(&mut bytes).ok()?;
+        (bytes.len() as u64 <= MAX_CLIPBOARD_IMAGE_BYTES).then_some(bytes)
+    })
+}
+
+/// The first clipboard offer, in the source's order, that `fetch` returns as a decodable image,
+/// upright as RGBA8. Only `image/*` types are fetched, so text offers are never transferred.
+#[cfg(any(target_os = "linux", test))]
+fn image_from_offers(offers: &[String], mut fetch: impl FnMut(&str) -> Option<Vec<u8>>) -> Option<(u32, u32, Vec<u8>)> {
+    offers.iter().filter(|mime| mime.starts_with("image/")).find_map(|mime| {
+        let bytes = fetch(mime)?;
+        // TGA has no magic number (see `image_from_files`), so trust it only when the type says so.
+        if photocraft_codecs::detect(&bytes)? == photocraft_codecs::Format::Tga && !mime.contains("tga") {
+            return None;
+        }
+        let img = photocraft_codecs::decode(&bytes).ok()?;
+        Some((img.width(), img.height(), img.to_rgba8()))
+    })
+}
+
 /// The shell command that starts this install under XWayland, where winit delivers file drops
 /// (winit 0.30 has none on Wayland, #386). A Flatpak gets the X11 socket only without the Wayland
 /// one, an AppImage relaunches by its own path, and anything else is `photocraft` on the PATH.
@@ -416,8 +485,13 @@ pub fn native(automation: Option<photocraft_automation::AuthorizedWorkspace>) ->
                 if let Some(img) = cb.get().file_list().ok().and_then(|paths| image_from_files(&paths)) {
                     return Some(img);
                 }
-                let img = cb.get_image().ok()?;
-                Some((img.width as u32, img.height as u32, img.bytes.into_owned()))
+                if let Ok(img) = cb.get_image() {
+                    return Some((img.width as u32, img.height as u32, img.bytes.into_owned()));
+                }
+                #[cfg(target_os = "linux")]
+                return wayland_clipboard_image();
+                #[cfg(not(target_os = "linux"))]
+                None
             })
         }),
         load_prefs: Some(Box::new(|| std::fs::read_to_string(prefs_file()?).ok())),
@@ -655,11 +729,66 @@ mod tests {
         .join(" ");
         assert_eq!(exts, want.split(' ').collect::<Vec<_>>());
         for (name, ext) in asked.iter().zip(exts) {
-            assert!(save_filters(name)[0].1.iter().any(|e| e == ext), "{name}: {:?}", save_filters(name)[0]);
+            // The first type's first extension is the one Windows adds to the bare name.
+            assert_eq!(save_filters(name)[0].1.first().map(String::as_str), Some(ext), "{name}: {:?}", save_filters(name)[0]);
         }
         assert_eq!(save_filters("Untitled")[0].0, "PSD Document", "no extension keeps the default");
     }
 
+    /// Every flat format Save As offers is one PhotoCraft writes, and ICO is among them (#4357).
+    #[test]
+    fn save_as_offers_only_writable_formats_including_ico() {
+        let layered = ["psd", "psb", "pcraft", "ora"];
+        for (name, exts) in SAVE_FILTERS {
+            for ext in exts.iter().filter(|e| !layered.contains(e)) {
+                let format = photocraft_codecs::from_extension(ext).unwrap_or_else(|| panic!("{name}: .{ext} is no known format"));
+                assert!(format.caps().write, "{name}: .{ext} can't be written");
+            }
+        }
+        for ext in ["ico", "gif", "bmp"] {
+            assert!(save_filters("Untitled-1.psd").iter().any(|(_, exts)| exts.iter().any(|e| e == ext)), ".{ext} is offered");
+        }
+        assert_eq!(save_filters("icon.ico")[0].0, "ICO", "an .ico name leads with its own type");
+        // What Save As writes there: an icon up to 256×256, and a clear error past that.
+        let doc = |side: u32| {
+            let mut s = Session::new();
+            s.execute("file.new", json!({"width": side, "height": side})).unwrap();
+            s.active().unwrap().doc.clone()
+        };
+        let opts = export_options(&photocraft_ui_egui::ExportSettings::default());
+        let icon = photocraft_io::export(&doc(256), "icon.ico", &opts).unwrap();
+        assert_eq!(icon.bytes[..4], [0, 0, 1, 0], "an ICO header");
+        let err = photocraft_io::export(&doc(300), "icon.ico", &opts).map(|_| ()).unwrap_err().to_string();
+        assert!(err.contains("256"), "{err}");
+    }
+
+    /// #4394: with File name extensions shown, Windows kept `image.psd` when the type was changed to
+    /// PhotoCraft. Given the bare `image`, it adds the extension of whichever type is picked
+    /// (checked by hand with rfd 0.17.2 on Windows 11), defaulting to the first type's.
+    #[test]
+    fn the_windows_save_dialog_gets_a_bare_name_so_the_type_picks_the_extension() {
+        for (suggested, name, first) in [
+            ("/pics/image.psd", "image", "psd"),
+            ("/pics/image.psb", "image", "psb"),
+            ("/pics/image.pcraft", "image", "pcraft"),
+            ("/pics/sky.fit", "sky", "fit"),
+            ("cat.jpeg", "cat", "jpeg"),
+            ("swatches.aco", "swatches", "aco"),
+        ] {
+            assert_eq!(dialog_file_name(suggested, true).as_deref(), Some(name), "{suggested}");
+            assert_eq!(save_filters(suggested)[0].1[0], first, "{suggested}");
+            // Elsewhere the dialogs keep the whole name (see `dialog_file_name`).
+            let whole = Path::new(suggested).file_name().unwrap().to_string_lossy().into_owned();
+            assert_eq!(dialog_file_name(suggested, false), Some(whole), "{suggested}");
+        }
+        // Kept whole: a second dot (Windows could keep `scan.jpg`), the user's upper case, no
+        // extension, and a dotfile.
+        for name in ["scan.jpg.psd", "my.photo.psd", "transparent.PNG", "Untitled", ".psd"] {
+            assert_eq!(dialog_file_name(name, true).as_deref(), Some(name));
+        }
+        assert_eq!(dialog_file_name("", true), None);
+    }
+
     #[test]
     fn block_on_waits_for_a_wake_from_another_thread() {
         let (tx, rx) = std::sync::mpsc::channel::<std::task::Waker>();
@@ -878,6 +1007,51 @@ mod tests {
         assert!(image_from_files(&[bad]).is_none());
     }
 
+    fn encoded(format: photocraft_codecs::Format, w: u32, h: u32) -> Vec<u8> {
+        let img = Image::from_u8(w, h, ChannelLayout::Rgba, [255u8, 0, 0, 255].repeat((w * h) as usize)).unwrap();
+        photocraft_codecs::encode(&img, format, &EncodeOptions::default()).unwrap()
+    }
+
+    #[test]
+    fn non_png_clipboard_images_paste() {
+        // #2546: a screenshot tool that offers only image/bmp or image/jpeg pasted nothing.
+        let bmp = encoded(photocraft_codecs::Format::Bmp, 3, 2);
+        let offers = vec!["text/plain".to_string(), "image/bmp".to_string()];
+        let mut asked = Vec::new();
+        let got = image_from_offers(&offers, |mime| {
+            asked.push(mime.to_string());
+            Some(bmp.clone())
+        });
+        assert_eq!(got, Some((3, 2, [255u8, 0, 0, 255].repeat(6))));
+        assert_eq!(asked, ["image/bmp"], "text offers are never fetched");
+
+        let jpeg = encoded(photocraft_codecs::Format::Jpeg, 16, 8);
+        let offers = vec!["image/jpeg".to_string()];
+        assert_eq!(image_from_offers(&offers, |_| Some(jpeg.clone())).map(|(w, h, _)| (w, h)), Some((16, 8)));
+    }
+
+    #[test]
+    fn undecodable_clipboard_offers_fall_through_to_the_next() {
+        let bmp = encoded(photocraft_codecs::Format::Bmp, 2, 2);
+        let cut = encoded(photocraft_codecs::Format::Png, 8, 8)[..20].to_vec();
+        let offers: Vec<String> = ["image/webp", "image/png", "image/x-tga", "image/bmp"].map(String::from).to_vec();
+        let got = image_from_offers(&offers, |mime| match mime {
+            "image/webp" => None,
+            "image/png" => Some(cut.clone()),
+            "image/x-tga" => Some(b"not an image".to_vec()),
+            _ => Some(bmp.clone()),
+        });
+        assert_eq!(got.map(|(w, h, _)| (w, h)), Some((2, 2)));
+        assert!(image_from_offers(&offers[..3], |_| Some(cut.clone())).is_none());
+        assert!(image_from_offers(&[], |_| Some(bmp.clone())).is_none());
+    }
+
+    #[test]
+    fn clipboard_tga_is_trusted_only_by_its_type() {
+        assert_eq!(image_from_offers(&["image/x-tga".to_string()], |_| Some(tga_1x1())), Some((1, 1, vec![255, 0, 0, 255])));
+        assert!(image_from_offers(&["image/x-unknown".to_string()], |_| Some(tga_1x1())).is_none());
+    }
+
     #[test]
     fn tga_is_trusted_only_with_its_extension() {
         let dir = temp("tga");
diff --git a/apps/photocraft/src/ui_state.rs b/apps/photocraft/src/ui_state.rs
index 4f226dcae4..c4de67a994 100644
--- a/apps/photocraft/src/ui_state.rs
+++ b/apps/photocraft/src/ui_state.rs
@@ -27,6 +27,23 @@ pub fn sanitize(path: Option<&Path>) {
     }
 }
 
+/// Whether `path` holds a window position from an earlier session, which eframe restores. Then
+/// `NativeOptions::centered` must be off: eframe applies it after restoring the saved geometry,
+/// so it moved the window back to the centre of the main monitor on every launch (#4826).
+pub fn has_saved_position(path: Option<&Path>) -> bool {
+    let Some(text) = path.and_then(|p| std::fs::read_to_string(p).ok()) else { return false };
+    saved_position(&text)
+}
+
+fn saved_position(text: &str) -> bool {
+    let Ok(kv) = ron::from_str::<std::collections::HashMap<String, String>>(text) else { return false };
+    let Some(window) = kv.get("window").and_then(|w| ron::from_str::<ron::Value>(w).ok()) else { return false };
+    // eframe restores the inner position on macOS and the outer position elsewhere
+    // (`egui_winit::WindowSettings::initialize_viewport_builder`).
+    let key = if cfg!(target_os = "macos") { "inner_position_pixels" } else { "outer_position_pixels" };
+    matches!(field(&window, key), Some(ron::Value::Option(Some(_))))
+}
+
 /// `Err` names the first value that would crash startup.
 fn check(text: &str) -> Result<(), String> {
     // eframe stores a map of key → RON string; a file that doesn't parse is ignored by eframe.
@@ -78,7 +95,7 @@ fn field<'a>(v: &'a ron::Value, name: &str) -> Option<&'a ron::Value> {
 
 #[cfg(test)]
 mod tests {
-    use super::check;
+    use super::{check, saved_position};
 
     fn file(window: &str, zoom: &str) -> String {
         let egui = format!("(options:(zoom_factor:{zoom},max_passes:2),data:([(18446744073709551615,(ron:\"(x:1.0)\"))]))");
@@ -105,6 +122,21 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_saved_window_position_is_detected() {
+        // #4826: the position from the report (Linux Mint, window moved to the third monitor).
+        let window = "(inner_position_pixels:Some((x:2048.0,y:1265.0)),outer_position_pixels:Some((x:2048.0,y:1228.0)),fullscreen:false,maximized:false,inner_size_points:Some((x:880.0,y:480.0)))";
+        assert!(saved_position(&file(window, "1.0")));
+        let no_position = "(inner_position_pixels:None,outer_position_pixels:None,fullscreen:false,maximized:false,inner_size_points:Some((x:880.0,y:480.0)))";
+        assert!(!saved_position(&file(no_position, "1.0")));
+        assert!(!saved_position(&format!("{{\"egui\":{:?}}}", "()")), "no window entry");
+        for text in ["", "not ron {{{", "{\"window\":\"(((\"}"] {
+            assert!(!saved_position(text), "{text:?}");
+        }
+        assert!(!super::has_saved_position(None));
+        assert!(!super::has_saved_position(Some(&std::env::temp_dir().join("photocraft-missing-ui.ron"))));
+    }
+
     #[test]
     fn unreadable_files_are_left_to_eframe() {
         // eframe ignores files and entries it can't parse, so they can't crash it.
diff --git a/assets/icons/contrast.svg b/assets/icons/contrast.svg
index 334f528170..86687392f2 100644
--- a/assets/icons/contrast.svg
+++ b/assets/icons/contrast.svg
@@ -10,5 +10,5 @@
   stroke-linejoin="round"
 >
   <circle cx="12" cy="12" r="10" />
-  <path d="M12 18a6 6 0 0 0 0-12v12z" />
+  <path d="M12 2a10 10 0 0 0 0 20z" fill="currentColor" stroke="none" />
 </svg>
diff --git a/assets/icons/gradient.svg b/assets/icons/gradient.svg
new file mode 100644
index 0000000000..8567fc675e
--- /dev/null
+++ b/assets/icons/gradient.svg
@@ -0,0 +1,19 @@
+<svg
+  xmlns="http://www.w3.org/2000/svg"
+  width="24"
+  height="24"
+  viewBox="0 0 24 24"
+  fill="none"
+  stroke="currentColor"
+  stroke-width="2"
+  stroke-linecap="round"
+  stroke-linejoin="round"
+>
+  <defs>
+    <linearGradient id="g" x1="3" y1="0" x2="20" y2="0" gradientUnits="userSpaceOnUse">
+      <stop offset="0%" stop-color="currentColor" stop-opacity="0.9" />
+      <stop offset="100%" stop-color="currentColor" stop-opacity="0" />
+    </linearGradient>
+  </defs>
+  <rect width="18" height="16" x="3" y="4" rx="2" fill="url(#g)" />
+</svg>
diff --git a/book/src/formats/raster-formats.md b/book/src/formats/raster-formats.md
index 7bca7f2fc2..2e65d51550 100644
--- a/book/src/formats/raster-formats.md
+++ b/book/src/formats/raster-formats.md
@@ -20,6 +20,15 @@ Every route that writes a document to a flat format (Save As, the CLI, MCP `doc_
 - Formats that can't embed an ICC profile (GIF, BMP, TGA, QOI, ICO, Netpbm/PFM) get RGB documents in another profile (linear light, Display P3, …) converted to sRGB through the colour engine (perceptual intent), since an untagged file is read as sRGB. OpenEXR and Radiance HDR get linear sRGB instead (linear gray for a grayscale OpenEXR), which is how they are tagged when opened.
 - TGA, as Photoshop's Targa: an RGB Targa is 24 or 32 bits per pixel. Save As and Save a Copy ask (Targa Options, starting at 32 with an alpha channel, else 24); Export As has a Resolution choice (Auto, 24 or 32 bits/pixel); scripts pass `tgaBits` (`--tga-bits` on the CLI). At 32 bits the document's alpha channel is the file's alpha when it has exactly one (spot channels don't count; with several, none is used), and the colours are written exactly, never premultiplied or cleared where the alpha is 0, so a game texture's mask and its colours both survive. Without a usable alpha channel the layers' transparency is the alpha (opaque without any). 24 bits write no alpha, compositing transparency over white. Without a choice: 32 with an alpha channel or transparency, else 24. A 32-bit Targa opens as an opaque Background with its alpha as "Alpha 1", so it round-trips. Grayscale Targas are 8-bit.
 
+Flat TIFF and JPEG exports of composited CMYK documents convert the RGB composite back through
+the document's CMYK ICC profile (relative colorimetric with black point compensation) and embed
+that exact profile. Untagged composites use and embed PhotoCraft's synthetic coated CMYK profile;
+invalid, non-CMYK or unusable embedded profiles are rejected before compositing. TIFF retains
+8/16/32f depth and straight alpha; JPEG reduces to 8-bit with a warning and mattes transparency
+over zero-ink white. A plain single raster layer retains its native samples. RGB-only formats use
+the RGB composite directly. This RGB composite roundtrip does **not** preserve original ink
+separations, black generation or native CMYK blending, and is not a claim of Photoshop parity.
+
 ## Implemented decode limits
 
 `DecodeOptions::default()` applies `Limits` before decoded pixel allocation:
diff --git a/contributors/people.toml b/contributors/people.toml
index 914c9ce303..6f630a0c12 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -17,6 +17,10 @@
 # To remove your names, delete your entry (or set fields empty) in a PR. The next
 # contributors.py run, and the next build, drop them.
 
+[people.jonathanwxh-cell]
+display_name = "jonathnwxh"
+sync_github_name = false
+
 [people.Skyfuller1303]
 display_name = "Skyfuller"
 sync_github_name = true
@@ -104,8 +108,53 @@ sync_github_name = true
 [people.timothydaly1]
 display_name = "SyntaxError"
 
+[people.atoslins]
+real_name = "Atos Lins"
+display_name = "Atos Lins"
+sync_github_name = false
+
 [people.axlecoffee]
 sync_github_name = true
 
 [people.Losminek]
 sync_github_name = true
+
+[people.FredApps]
+sync_github_name = true
+
+[people.arthurdeka]
+sync_github_name = true
+
+[people.aweussom]
+real_name = "Tommy Leonhardsen"
+
+[people.Furash]
+sync_github_name = true
+
+[people.lucAmbr0]
+sync_github_name = true
+
+[people.Hevarh1]
+sync_github_name = true
+
+[people.dotCooCoo]
+real_name = "Robert Lee"
+sync_github_name = true
+
+[people.deadmeu]
+sync_github_name = true
+
+[people.megaDon101]
+display_name = "megadon"
+sync_github_name = false
+
+[people.sssehnsuchttt]
+sync_github_name = true
+
+[people.VanTan666]
+display_name = "VanTan"
+sync_github_name = false
+
+[people.yeniufuklar-com]
+real_name = "Ufuk Efe"
+sync_github_name = true
diff --git a/crates/affinity/README.md b/crates/affinity/README.md
index a88b85bd4d..4f0f9afe52 100644
--- a/crates/affinity/README.md
+++ b/crates/affinity/README.md
@@ -16,7 +16,7 @@ Affinity files.
 | Artboards (legacy `ABEn`, or current `.af` `phrp`/`aprp` properties, including converted curves), with name, solid background, any transform | artboards (nested ones as groups with a vector mask; rotated/curved boards use their bounding rectangle) |
 | Layers (`Scop`), groups (`Grup`), pass-through or isolated | groups (pass-through or Normal) |
 | Curves (`PCrv`): cubic subpaths, closed flags, live corners (`CnrD`) | shape layers (multi-subpath curves fill even-odd) |
-| Rectangles with corner radii (relative or absolute), ellipses, polygons (smooth too), stars, square stars, pies, triangles, trapezoids, clouds, hearts, cogs, rounded and elliptical callouts, arrows, double stars, tears, crescents, diamonds and circular segments | shape layers |
+| Rectangles with corner radii (relative or absolute, locked or per corner) and round or straight corners, ellipses, polygons (smooth too), stars, square stars, pies, triangles, trapezoids, clouds, hearts, cogs, rounded and elliptical callouts, arrows, double stars, tears, crescents, diamonds and circular segments | shape layers |
 | Compound shapes (`Comp`, add and subtract) | one even-odd shape |
 | A shape or curve with children clips them | group with the outline as vector mask, the shape at its bottom |
 | Vector masks (`AdCh` curves and shapes) | vector masks |
@@ -34,7 +34,7 @@ Affinity files.
 Everything else is reported in the import warnings, one line per kind with a count, never
 dropped silently: layer effects, adjustment layers and live filters, brush and pressure strokes,
 transparency gradients, fill opacity, bitmap fills, master pages, unrecognized
-parametric shapes (imported as their bounding ellipses), corner types other than round, stars with
+parametric shapes (imported as their bounding ellipses), corner types other than round or straight, stars with
 rounded points, several fills or strokes on one object (one of each is used), strokes behind the
 fill, outlined or scaled text, text fields such as page numbers, frames with columns or a curved
 outline, grey/Lab/32-bit pixels, CMYK and Lab colour (converted to RGB without the document's
diff --git a/crates/affinity/src/shapes.rs b/crates/affinity/src/shapes.rs
index 5e825fa850..c7751da885 100644
--- a/crates/affinity/src/shapes.rs
+++ b/crates/affinity/src/shapes.rs
@@ -51,28 +51,44 @@ pub(crate) fn shape(r: &mut Reader, shape: ObjId, b: [f64; 4], world: Affine) ->
     let class = r.s.class(shape)?;
     let sub = match &class.0.to_be_bytes() {
         b"ShNR" | b"ShRR" => {
-            let rounded = matches!(last(r, shape, b"CTyp"), Some(Value::Array(a)) if !a.is_empty());
-            let radius = match last(r, shape, b"ShCR") {
-                Some(Value::Floats(v)) => v.first().copied().filter(|f| f.is_finite() && *f > 0.0),
-                _ => None,
+            let types = match last(r, shape, b"CTyp") {
+                Some(Value::Array(a)) => a.iter().map(|t| if let Value::Enum { id, .. } = t { Some(*id) } else { None }).collect(),
+                _ => Vec::new(),
             };
-            if let (true, Some(f)) = (rounded, radius) {
-                if let Some(Value::Array(types)) = last(r, shape, b"CTyp")
-                    && types.iter().any(|t| !matches!(t, Value::Enum { id: 0 | 4, .. }))
-                {
-                    r.warn("rectangles with straight, concave or other corner types (imported with round corners)");
-                }
-                let (crx, cry) = if r.s.bool(shape, b"AbSz") == Some(true) {
-                    // An absolute radius is in document pixels, whatever the node's scale.
-                    let [a, b2, c, d, ..] = world.0;
-                    let (sx, sy) = ((a * a + b2 * b2).sqrt(), (c * c + d * d).sqrt());
-                    if sx > 0.0 && sy > 0.0 { (f / sx, f / sy) } else { (0.0, 0.0) }
-                } else {
-                    (f * w.min(h), f * w.min(h))
-                };
-                rounded_rect(b, crx.min(w / 2.0), cry.min(h / 2.0))
-            } else {
+            let radii = match last(r, shape, b"ShCR") {
+                Some(Value::Floats(v)) => v.iter().map(|f| if f.is_finite() && *f > 0.0 { *f } else { 0.0 }).collect(),
+                _ => Vec::new(),
+            };
+            // Corners follow the first one (top left) unless they were unlocked; then each has
+            // its own radius and type, clockwise from the top left.
+            let locked = !matches!(last(r, shape, b"Lock"), Some(Value::Bool(false)));
+            let corners: [(f64, Option<u16>); 4] = std::array::from_fn(|i| {
+                let i = if locked { 0 } else { i };
+                (radii.get(i).copied().unwrap_or(0.0), types.get(i).copied().flatten())
+            });
+            if types.is_empty() || corners.iter().all(|(f, _)| *f == 0.0) {
                 polygon([pt(x0, y0), pt(x1, y0), pt(x1, y1), pt(x0, y1)])?
+            } else {
+                if corners.iter().any(|(f, t)| *f > 0.0 && !matches!(t, Some(0 | 1 | 4))) {
+                    r.warn("rectangles with concave or other corner types (imported with round corners)");
+                }
+                let absolute = r.s.bool(shape, b"AbSz") == Some(true);
+                let [a, b2, c, d, ..] = world.0;
+                let (sx, sy) = ((a * a + b2 * b2).sqrt(), (c * c + d * d).sqrt());
+                cornered_rect(
+                    b,
+                    corners.map(|(f, t)| {
+                        let (crx, cry) = if !absolute {
+                            (f * w.min(h), f * w.min(h))
+                        } else if sx > 0.0 && sy > 0.0 {
+                            // An absolute radius is in document pixels, whatever the node's scale.
+                            (f / sx, f / sy)
+                        } else {
+                            (0.0, 0.0)
+                        };
+                        (crx, cry, t == Some(1))
+                    }),
+                )
             }
         }
         b"ShpE" => ellipse(cx, cy, rx, ry),
@@ -115,13 +131,21 @@ pub(crate) fn shape(r: &mut Reader, shape: ObjId, b: [f64; 4], world: Affine) ->
             }))?
         }
         b"ShPi" => {
-            let start = num(r, shape, b"AngS").unwrap_or(0.0);
-            let mut end = num(r, shape, b"AngE").unwrap_or(TAU);
-            while end < start {
-                end += TAU;
-            }
+            let raw_start = num(r, shape, b"AngS").unwrap_or(0.0);
+            let raw_end = num(r, shape, b"AngE").unwrap_or(TAU);
+            // Normalize in constant time. Repeatedly adding TAU can hang on finite values
+            // large enough that floating-point addition no longer changes the endpoint.
+            let start = raw_start.rem_euclid(TAU);
+            let delta = raw_end - raw_start;
+            let sweep = if raw_end >= raw_start {
+                delta.min(TAU)
+            } else if delta.is_finite() {
+                delta.rem_euclid(TAU)
+            } else {
+                (raw_end.rem_euclid(TAU) - start).rem_euclid(TAU)
+            };
             let inner = num(r, shape, b"IRad").unwrap_or(0.0).clamp(0.0, 1.0);
-            pie(cx, cy, rx, ry, start, end.min(start + TAU), inner)
+            pie(cx, cy, rx, ry, start, start + sweep, inner)
         }
         b"ShpT" => {
             let p = num(r, shape, b"Pos ").unwrap_or(0.5);
@@ -346,22 +370,31 @@ fn ellipse(cx: f64, cy: f64, rx: f64, ry: f64) -> SubPath {
     }
 }
 
-fn rounded_rect([x0, y0, x1, y1]: [f64; 4], rx: f64, ry: f64) -> SubPath {
-    let (kx, ky) = ((1.0 - KAPPA) * rx, (1.0 - KAPPA) * ry);
-    SubPath {
-        start: pt(x0 + rx, y0),
-        segments: vec![
-            [pt(x1 - rx, y0), pt(x1 - rx, y0), pt(x1 - rx, y0)],
-            [pt(x1 - kx, y0), pt(x1, y0 + ky), pt(x1, y0 + ry)],
-            [pt(x1, y1 - ry), pt(x1, y1 - ry), pt(x1, y1 - ry)],
-            [pt(x1, y1 - ky), pt(x1 - kx, y1), pt(x1 - rx, y1)],
-            [pt(x0 + rx, y1), pt(x0 + rx, y1), pt(x0 + rx, y1)],
-            [pt(x0 + kx, y1), pt(x0, y1 - ky), pt(x0, y1 - ry)],
-            [pt(x0, y0 + ry), pt(x0, y0 + ry), pt(x0, y0 + ry)],
-            [pt(x0, y0 + ky), pt(x0 + kx, y0), pt(x0 + rx, y0)],
-        ],
-        closed: true,
+/// A rectangle whose corners (top left, top right, bottom right, bottom left) are each rounded,
+/// or cut straight across, by their (horizontal, vertical) radii. Two radii that don't fit along
+/// one side shrink in proportion until they do.
+fn cornered_rect([x0, y0, x1, y1]: [f64; 4], corners: [(f64, f64, bool); 4]) -> SubPath {
+    let fit = |r: f64, pair: f64, side: f64| if pair > side { side * (r / pair) } else { r };
+    let [tl, tr, br, bl] = corners;
+    let (w, h) = (x1 - x0, y1 - y0);
+    let rx = [fit(tl.0, tl.0 + tr.0, w), fit(tr.0, tl.0 + tr.0, w), fit(br.0, bl.0 + br.0, w), fit(bl.0, bl.0 + br.0, w)];
+    let ry = [fit(tl.1, tl.1 + bl.1, h), fit(tr.1, tr.1 + br.1, h), fit(br.1, tr.1 + br.1, h), fit(bl.1, tl.1 + bl.1, h)];
+    let (kx, ky) = (rx.map(|r| (1.0 - KAPPA) * r), ry.map(|r| (1.0 - KAPPA) * r));
+    // (where the corner leaves the previous side, its two handles, where it joins the next side)
+    let arcs = [
+        [pt(x1 - rx[1], y0), pt(x1 - kx[1], y0), pt(x1, y0 + ky[1]), pt(x1, y0 + ry[1])],
+        [pt(x1, y1 - ry[2]), pt(x1, y1 - ky[2]), pt(x1 - kx[2], y1), pt(x1 - rx[2], y1)],
+        [pt(x0 + rx[3], y1), pt(x0 + kx[3], y1), pt(x0, y1 - ky[3]), pt(x0, y1 - ry[3])],
+        [pt(x0, y0 + ry[0]), pt(x0, y0 + ky[0]), pt(x0 + kx[0], y0), pt(x0 + rx[0], y0)],
+    ];
+    let mut segments = Vec::with_capacity(8);
+    for ([s, c1, c2, e], straight) in arcs.into_iter().zip([tr.2, br.2, bl.2, tl.2]) {
+        segments.push([s, s, s]);
+        if s != e {
+            segments.push(if straight { [e, e, e] } else { [c1, c2, e] });
+        }
     }
+    SubPath { start: pt(x0 + rx[0], y0), segments, closed: true }
 }
 
 /// Elliptical arc from angle `a0` to `a1` (radians, measured y-up as Affinity's pie angles are),
diff --git a/crates/affinity/src/tests.rs b/crates/affinity/src/tests.rs
index f70648b42d..b28e30f3d6 100644
--- a/crates/affinity/src/tests.rs
+++ b/crates/affinity/src/tests.rs
@@ -349,3 +349,113 @@ mod archive {
         }
     }
 }
+
+mod shapes {
+    use crate::container::Limits;
+    use crate::model::{Document, Kind, Path, Point, SubPath};
+    use crate::stream::Tag;
+    use crate::synth::{self, F, Method, tag};
+
+    fn shape(id: u32, class: &[u8; 4], parameters: Vec<(Tag, F)>) -> F {
+        F::Def(
+            id,
+            vec![tag(b"ShpN")],
+            vec![(tag(b"ShpB"), F::F64s(vec![0.0, 0.0, 10.0, 20.0])), (tag(b"Shpe"), F::Def(id + 10_000, vec![tag(class)], parameters))],
+        )
+    }
+
+    /// Reads a document whose one page holds the object `top` from `definitions`, on a thread of
+    /// its own, and fails the test when reading takes more than 20 s.
+    fn read(definitions: Vec<F>, top: u32) -> Document {
+        let data = synth::stream(&[
+            (tag(b"Defs"), F::Shared(definitions)),
+            (
+                tag(b"DocR"),
+                F::Def(
+                    1,
+                    vec![tag(b"DocN")],
+                    vec![(
+                        tag(b"Chld"),
+                        F::Shared(vec![F::Def(
+                            2,
+                            vec![tag(b"Sprd")],
+                            vec![(tag(b"SprB"), F::F64s(vec![0.0, 0.0, 400.0, 300.0])), (tag(b"Chld"), F::Shared(vec![F::Ref(top)]))],
+                        )]),
+                    )],
+                ),
+            ),
+        ]);
+        let bytes = synth::container(&[("doc.dat", &data, Method::Zlib)], None);
+        let (tx, rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || tx.send(crate::model::read(&bytes, Limits::default())).ok());
+        rx.recv_timeout(std::time::Duration::from_secs(20)).unwrap_or_else(|_| panic!("reading the document did not finish")).unwrap()
+    }
+
+    fn path(document: &Document) -> &Path {
+        match &document.spreads[0].nodes[0].kind {
+            Kind::Shape { path, .. } => path,
+            other => panic!("expected shape, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn pie_angles_with_huge_finite_values_do_not_loop_or_emit_nonfinite_points() {
+        let document = read(vec![shape(100, b"ShPi", vec![(tag(b"AngS"), F::F64(1.0e308)), (tag(b"AngE"), F::F64(-1.0e308))])], 100);
+        for subpath in &path(&document).subpaths {
+            assert!(subpath.start.x.is_finite() && subpath.start.y.is_finite());
+            assert!(subpath.segments.len() <= 20);
+            assert!(subpath.segments.iter().flatten().all(|point| point.x.is_finite() && point.y.is_finite()));
+        }
+    }
+
+    #[test]
+    fn wrapped_pie_angles_keep_the_same_geometry_as_the_positive_span() {
+        let make = |end| read(vec![shape(100, b"ShPi", vec![(tag(b"AngS"), F::F64(0.0)), (tag(b"AngE"), F::F64(end))])], 100);
+        assert_eq!(path(&make(-std::f64::consts::FRAC_PI_2)), path(&make(3.0 * std::f64::consts::FRAC_PI_2)));
+    }
+
+    /// A 10×20 rectangle (`ShNR`) with the given parameters, read back as its outline.
+    fn rectangle(parameters: Vec<(Tag, F)>) -> (SubPath, Vec<String>) {
+        let node =
+            F::Def(3, vec![tag(b"ShpN")], vec![(tag(b"ShpB"), F::F64s(vec![0.0, 0.0, 10.0, 20.0])), (tag(b"Shpe"), F::Def(4, vec![tag(b"ShNR")], parameters))]);
+        let spread = F::Def(2, vec![tag(b"Sprd")], vec![(tag(b"SprB"), F::F64s(vec![0.0, 0.0, 400.0, 300.0])), (tag(b"Chld"), F::Shared(vec![node]))]);
+        let data = synth::stream(&[(tag(b"DocR"), F::Def(1, vec![tag(b"DocN")], vec![(tag(b"Chld"), F::Shared(vec![spread]))]))]);
+        let doc = crate::read(&synth::container(&[("doc.dat", &data, Method::Zlib)], None), Limits::default()).unwrap();
+        let Kind::Shape { path, .. } = &doc.spreads[0].nodes[0].kind else { panic!("expected a shape") };
+        (path.subpaths[0].clone(), doc.warnings)
+    }
+
+    /// `CTyp`: an array of corner-type enums (top left, top right, bottom right, bottom left).
+    fn corner_types(ids: [u16; 4]) -> F {
+        let mut raw = vec![0xaa];
+        raw.extend(tag(b"CTyp").0.to_le_bytes());
+        raw.extend(4u32.to_le_bytes());
+        raw.extend(0u16.to_le_bytes());
+        raw.extend(ids.iter().flat_map(|id| id.to_le_bytes()));
+        F::Raw(raw)
+    }
+
+    #[test]
+    fn unlocked_rectangle_corners_keep_their_own_radius_and_type() {
+        let p = |x: f64, y: f64| Point { x, y };
+        // Relative radii scale by 10. Round 5, round 1, straight 3, none.
+        let corners = |lock: Option<bool>| {
+            let mut fields = vec![(tag(b"ShCR"), F::F64s(vec![0.5, 0.1, 0.3, 0.0])), (tag(b"CTyp"), corner_types([0, 0, 1, 4]))];
+            fields.extend(lock.map(|l| (tag(b"Lock"), F::Bool(l))));
+            rectangle(fields)
+        };
+
+        let (sub, warnings) = corners(Some(false));
+        assert!(warnings.is_empty(), "{warnings:?}");
+        assert_eq!(sub.start, p(5.0, 0.0));
+        let ends: Vec<Point> = sub.segments.iter().map(|s| s[2]).collect();
+        assert_eq!(ends, [p(9.0, 0.0), p(10.0, 1.0), p(10.0, 17.0), p(7.0, 20.0), p(0.0, 20.0), p(0.0, 5.0), p(5.0, 0.0)]);
+        assert_eq!(sub.segments[3], [p(7.0, 20.0); 3], "the straight corner is a line");
+        assert_ne!(sub.segments[1][0], p(9.0, 0.0), "the round corner is a curve");
+
+        // Locked (the default): every corner follows the top left one.
+        let (sub, _) = corners(None);
+        assert_eq!(sub.segments.len(), 8);
+        assert_eq!(sub.segments[3][2], p(5.0, 20.0));
+    }
+}
diff --git a/crates/algo/examples/bench_liquify.rs b/crates/algo/examples/bench_liquify.rs
index a953463f07..2eea3b951b 100644
--- a/crates/algo/examples/bench_liquify.rs
+++ b/crates/algo/examples/bench_liquify.rs
@@ -59,6 +59,22 @@ fn main() {
         prev = p;
     }
     println!("forward-warp segment (600 px brush, 25 px moves) + proxy update: mean {:.2} ms, worst {:.2} ms", total / n as f64, worst);
+    // One 3000 px drag with a 200 px brush (a straight leg, then a diagonal one), as a slow
+    // (every 2 px) and a fast (every 60 px) pointer reports it: the field cost of the whole
+    // stroke, and how far the two results differ.
+    let mut drag = LiquifyStroke::new(LiquifyTool::ForwardWarp, 200.0);
+    let mut fields = Vec::new();
+    let along = |d: f64| if d <= 1500.0 { vec![1500.0 + d, 2000.0] } else { vec![3000.0 + (d - 1500.0) * 0.6, 2000.0 + (d - 1500.0) * 0.8] };
+    for step in [2.0, 60.0] {
+        drag.points = (0..=(3000.0 / step) as usize).map(|k| along(k as f64 * step)).collect();
+        let t = Instant::now();
+        let mut f = LiquifyField::new(b, cell);
+        f.apply_stroke(&drag);
+        println!("forward-warp 3000 px drag (200 px brush), an event every {step} px: {:.1} ms", t.elapsed().as_secs_f64() * 1e3);
+        fields.push(f);
+    }
+    let diff = fields[0].d.iter().zip(&fields[1].d).map(|(p, q)| (p[0] - q[0]).abs().max((p[1] - q[1]).abs())).fold(0.0f32, f32::max);
+    println!("  slow vs fast pointer: fields differ by at most {diff:.3} px (max displacement {:.1} px)", fields[0].max_displacement());
     st.tool = LiquifyTool::Bloat;
     let t = Instant::now();
     let mut d = Rect::EMPTY;
diff --git a/crates/algo/src/artistic_fx.rs b/crates/algo/src/artistic_fx.rs
index 7f75041b10..4d2e85ed1a 100644
--- a/crates/algo/src/artistic_fx.rs
+++ b/crates/algo/src/artistic_fx.rs
@@ -427,7 +427,7 @@ pub(crate) fn effect_reach(e: &GalleryEffect) -> i32 {
         F::Crosshatch => (g("strokeLength") / 3.0) as i32 + gs(1.0) + 2,
         F::DarkStrokes => 9,
         F::InkOutlines => (g("strokeLength") / 2.0) as i32 + 3,
-        F::Spatter => g("sprayRadius").ceil() as i32 + 2,
+        F::Spatter => (g("sprayRadius") * 1.5).ceil() as i32 + 2,
         F::SprayedStrokes => g("sprayRadius").ceil() as i32 + (g("strokeLength") / 2.0) as i32 + 3,
         F::SumiE => gs(g("strokeWidth") * 0.2) + (g("strokeWidth") / 2.0) as i32 + 2,
         F::Glass => (g("distortion") * 2.0).ceil() as i32 + 2,
@@ -768,9 +768,26 @@ fn apply(e: &GalleryEffect, win: &mut Win, ctx: &Ctx) {
                 win.c[i] = map(win.c[i], |v| (v + (1.0 - v) * lt) * (1.0 - dk) * (1.0 - clamp01(ink)));
             }
         }
-        F::Spatter | F::SprayedStrokes => {
+        F::Spatter => {
+            // Smoothness smooths the random displacement: a larger feature size and, as with any
+            // averaged noise, a smaller reach. Low smoothness sprays specks out to the full
+            // radius; high smoothness leaves a torn but attached, hard edge (what Photoshop
+            // shows at Smoothness 15).
             let rad = g("sprayRadius");
-            let sc = if e.filter == F::Spatter { 0.6 + g("smoothness") * 0.25 } else { 1.2 };
+            let feature = 1.0 + g("smoothness") * 0.35;
+            let reach = (rad * 1.2 / feature).min(rad);
+            let src = Win { r: win.r, w, h, c: win.c.clone() };
+            for i in 0..win.c.len() {
+                let (x, y) = win.xy(i);
+                let (fx, fy) = (x as f32 / feature, y as f32 / feature);
+                let dx = (fbm(fx, fy, 91) - 0.5) * 3.0 * reach;
+                let dy = (fbm(fx, fy, 92) - 0.5) * 3.0 * reach;
+                win.c[i] = src.sample(x as f32 + 0.5 + dx, y as f32 + 0.5 + dy);
+            }
+        }
+        F::SprayedStrokes => {
+            let rad = g("sprayRadius");
+            let sc = 1.2;
             let src = Win { r: win.r, w, h, c: win.c.clone() };
             for i in 0..win.c.len() {
                 let (x, y) = win.xy(i);
@@ -779,9 +796,7 @@ fn apply(e: &GalleryEffect, win: &mut Win, ctx: &Ctx) {
                 let dy = (vnoise(fx, fy, 92) - 0.5) * 2.0 * rad;
                 win.c[i] = src.sample(x as f32 + 0.5 + dx, y as f32 + 0.5 + dy);
             }
-            if e.filter == F::SprayedStrokes {
-                line_blur3(&mut win.c, w, h, direction(e.choice("strokeDirection")), (g("strokeLength") / 2.0) as usize);
-            }
+            line_blur3(&mut win.c, w, h, direction(e.choice("strokeDirection")), (g("strokeLength") / 2.0) as usize);
         }
         F::SumiE => {
             let sw = g("strokeWidth");
diff --git a/crates/algo/src/blur.rs b/crates/algo/src/blur.rs
index 606ee7dbc5..ae8b12f40a 100644
--- a/crates/algo/src/blur.rs
+++ b/crates/algo/src/blur.rs
@@ -992,8 +992,9 @@ mod tests {
         let mixed = crate::apply_in(&s, &p, canvas, canvas, Some(&half), canvas);
         for (x, y) in [(0, 0), (18, 11), (36, 22)] {
             let (o, f, m) = (s.pixel(x, y), full.pixel(x, y), mixed.pixel(x, y));
-            for c in 0..4 {
-                assert!((m[c] - (o[c] + f[c]) / 2.0).abs() < 1e-5, "({x},{y}) channel {c}");
+            assert!((m[3] - (o[3] + f[3]) / 2.0).abs() < 1e-5, "({x},{y}) alpha");
+            for c in 0..3 {
+                assert!((m[c] * m[3] - (o[c] * o[3] + f[c] * f[3]) / 2.0).abs() < 1e-5, "({x},{y}) premultiplied channel {c}");
             }
         }
         let cancel = || true;
diff --git a/crates/algo/src/blur/motion_apply.rs b/crates/algo/src/blur/motion_apply.rs
index cc2f3e84ee..166a1da5a2 100644
--- a/crates/algo/src/blur/motion_apply.rs
+++ b/crates/algo/src/blur/motion_apply.rs
@@ -169,7 +169,7 @@ fn apply_inner(
             return None;
         }
         if let Some(selection) = selection {
-            crate::mix_selection(&mut data, output, selection, &src);
+            crate::mix_selection(&mut data, output, selection, &src, fmt.alpha);
         }
         if ctl.cancelled() {
             return None;
diff --git a/crates/algo/src/blur/motion_fft_tests.rs b/crates/algo/src/blur/motion_fft_tests.rs
index 12271d7bc2..fd27434bc4 100644
--- a/crates/algo/src/blur/motion_fft_tests.rs
+++ b/crates/algo/src/blur/motion_fft_tests.rs
@@ -280,7 +280,7 @@ fn motion_fft_pipeline_supports_depths_models_edges_selections_and_tile_seams()
                     for mask in [None, Some(&selection)] {
                         let mut expected_data = filtered.clone();
                         if let Some(mask) = mask {
-                            crate::mix_selection(&mut expected_data, rect, mask, &src);
+                            crate::mix_selection(&mut expected_data, rect, mask, &src, alpha);
                         }
                         let mut expected = source.clone();
                         expected.write_region(rect, &expected_data);
@@ -362,7 +362,7 @@ fn motion_fft_production_crosses_real_tile_seams_and_leaves_other_pixels_untouch
                 let mut expected = source.clone();
                 let mut data = filtered.clone();
                 if let Some(mask) = mask {
-                    crate::mix_selection(&mut data, area, mask, &src);
+                    crate::mix_selection(&mut data, area, mask, &src, true);
                 }
                 expected.write_region(area, &data);
                 let expected = Image::read(&expected, check);
diff --git a/crates/algo/src/blur/motion_tests.rs b/crates/algo/src/blur/motion_tests.rs
index 822cbb755e..1141dec559 100644
--- a/crates/algo/src/blur/motion_tests.rs
+++ b/crates/algo/src/blur/motion_tests.rs
@@ -69,7 +69,7 @@ fn row_surface(surface: &Surface, params: &FilterParams, area: Rect, bounds: Rec
     let ctx = Ctx { bounds, mode: format.mode, alpha: format.alpha };
     let mut data = motion_rows(&src, area, &ctx, *angle, *distance);
     if let Some(selection) = selection {
-        crate::mix_selection(&mut data, area, selection, &src);
+        crate::mix_selection(&mut data, area, selection, &src, format.alpha);
     }
     let mut result = surface.clone();
     result.write_region(area, &data);
diff --git a/crates/algo/src/camera_raw.rs b/crates/algo/src/camera_raw.rs
index 2c1b0c9229..f855b08bfe 100644
--- a/crates/algo/src/camera_raw.rs
+++ b/crates/algo/src/camera_raw.rs
@@ -9,9 +9,10 @@
 //!    with the guided filter); negative amounts add haze toward the atmospheric light.
 //! 3. **Tone** on luminance with colour ratios kept: Highlights / Shadows as exposure changes
 //!    weighted by an edge-preserving base layer (guided filter: K. He, J. Sun, X. Tang, *Guided
-//!    Image Filtering*, ECCV 2010), so local contrast survives; Whites / Blacks move the ends of
-//!    the curve; Contrast is an S-curve about middle grey; Clarity (large radius, midtone
-//!    weighted) and Texture (small radius) add band-pass local contrast.
+//!    Image Filtering*, ECCV 2010), so local contrast survives; Contrast is an S-curve about
+//!    middle grey; Clarity (large radius, midtone weighted) and Texture (small radius) add
+//!    band-pass local contrast. Whites / Blacks follow as Photoshop's Camera Raw applies them:
+//!    image-adaptive global curves measured on Photoshop 25.4 (see `whites_blacks`).
 //! 4. **Presence**: Vibrance (weighted toward less saturated colours) and Saturation.
 //! 5. **Tone Curve**: parametric regions (Highlights, Lights, Darks, Shadows with movable splits)
 //!    then point curves (master and per channel), monotone cubic interpolation (F. Fritsch,
@@ -54,6 +55,38 @@ pub fn validate_curve(points: &[[f32; 2]]) -> Result<(), String> {
 
 use crate::photo_util::{hash01, linear_to_srgb, par_rows, srgb_to_linear};
 
+mod local_tone;
+mod whites_blacks;
+
+/// How the pixels encode light: the sRGB curve (gamma 0) or a pure power law (ProPhoto's 1.8,
+/// Adobe RGB's 2.2). The tone controls work on light, so the document's own curve decodes it.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct Encoding(f32);
+
+impl Encoding {
+    pub(crate) fn of(gamma: f32) -> Self {
+        Encoding(if gamma.is_finite() && gamma > 0.0 { gamma.clamp(0.5, 4.0) } else { 0.0 })
+    }
+    pub(crate) fn decode(self, v: f32) -> f32 {
+        if self.0 > 0.0 { v.max(0.0).powf(self.0) } else { srgb_to_linear(v) }
+    }
+    pub(crate) fn encode(self, v: f32) -> f32 {
+        if self.0 > 0.0 { v.max(0.0).powf(1.0 / self.0) } else { linear_to_srgb(v) }
+    }
+}
+
+fn srgb_encode(v: f32) -> f32 {
+    linear_to_srgb(v)
+}
+
+fn srgb_decode(v: f32) -> f32 {
+    srgb_to_linear(v)
+}
+
+fn luma_linear(c: [f32; 3]) -> f32 {
+    luma(c)
+}
+
 /// One colour grading wheel.
 #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Default)]
 #[serde(default)]
@@ -136,6 +169,9 @@ pub struct CameraRaw {
     pub seed: u32,
     /// Pixel-size multiplier for previews on downsampled proxies (radii in px scale by it).
     pub pixel_scale: f32,
+    /// The document's transfer curve: 0 for sRGB's, else the gamma of a power-law space (1.8
+    /// for ProPhoto). Set from the document's profile; Whites and Blacks act on light.
+    pub encoding_gamma: f32,
 }
 
 impl Default for CameraRaw {
@@ -191,6 +227,7 @@ impl Default for CameraRaw {
             vignette_style: "highlightPriority".into(),
             seed: 0,
             pixel_scale: 1.0,
+            encoding_gamma: 0.0,
         }
     }
 }
@@ -491,7 +528,11 @@ impl CameraRaw {
         self.temperature == 0.0 && self.tint == 0.0 && self.exposure == 0.0
     }
     fn tone_neutral(&self) -> bool {
-        [self.contrast, self.highlights, self.shadows, self.whites, self.blacks, self.texture, self.clarity].iter().all(|v| *v == 0.0)
+        self.local_tone_neutral() && self.whites == 0.0 && self.blacks == 0.0
+    }
+    /// Contrast, Highlights, Shadows, Texture and Clarity (the luminance stage).
+    fn local_tone_neutral(&self) -> bool {
+        [self.contrast, self.highlights, self.shadows, self.texture, self.clarity].iter().all(|v| *v == 0.0)
     }
     fn hsl_neutral(&self) -> bool {
         self.hsl_hue.iter().chain(&self.hsl_sat).chain(&self.hsl_lum).all(|v| *v == 0.0)
@@ -561,16 +602,13 @@ pub fn develop(px: &mut [[f32; 4]], w: usize, h: usize, p: &CameraRaw, float: bo
     if p.dehaze != 0.0 {
         dehaze(px, w, h, p.dehaze / 100.0);
     }
-    // 3. Tone on luminance.
-    if !p.tone_neutral() {
+    // 3. Tone. Highlights and Shadows: a local Laplacian filter (see `local_tone`).
+    if p.highlights != 0.0 || p.shadows != 0.0 {
+        local_tone::apply(px, w, h, p.shadows, p.highlights, Encoding::of(p.encoding_gamma));
+    }
+    if !p.local_tone_neutral() && [p.contrast, p.texture, p.clarity].iter().any(|v| *v != 0.0) {
         let l: Vec<f32> = px.iter().map(|q| luma([q[0], q[1], q[2]]).max(0.0)).collect();
         let lc: Vec<f32> = l.iter().map(|v| v.min(1.0)).collect();
-        let base = if p.highlights != 0.0 || p.shadows != 0.0 {
-            let r = ((long * 0.015) as usize).max(2);
-            Some(guided_fast(&lc, &lc, w, h, r, 0.02))
-        } else {
-            None
-        };
         let clar = (p.clarity != 0.0).then(|| guided_fast(&lc, &lc, w, h, ((long * 0.02) as usize).max(3), 0.005));
         let tex = (p.texture != 0.0).then(|| gauss(&lc, w, h, (long * 0.002).max(1.5 * ps)));
         let k_con = p.contrast / 100.0 * 0.6;
@@ -580,12 +618,6 @@ pub fn develop(px: &mut [[f32; 4]], w: usize, h: usize, p: &CameraRaw, float: bo
                 let i = y * w + x;
                 let l0 = l[i];
                 let mut lv = lc[i];
-                if let Some(b) = &base {
-                    let bv = b[i].clamp(0.0, 1.0);
-                    let hm = smoothstep(0.45, 0.95, bv);
-                    let sm = 1.0 - smoothstep(0.05, 0.5, bv);
-                    lv *= 2f32.powf(p.highlights / 100.0 * 1.2 * hm + p.shadows / 100.0 * 1.4 * sm);
-                }
                 if let Some(c) = &clar {
                     let mw = 1.0 - (2.0 * lv.clamp(0.0, 1.0) - 1.0).powi(2);
                     lv += p.clarity / 100.0 * 0.8 * (lc[i] - c[i]) * mw;
@@ -593,12 +625,6 @@ pub fn develop(px: &mut [[f32; 4]], w: usize, h: usize, p: &CameraRaw, float: bo
                 if let Some(t) = &tex {
                     lv += p.texture / 100.0 * 0.9 * (lc[i] - t[i]).clamp(-0.1, 0.1);
                 }
-                if p.whites != 0.0 {
-                    lv += p.whites / 100.0 * 0.25 * smoothstep(0.4, 1.0, lv);
-                }
-                if p.blacks != 0.0 {
-                    lv += p.blacks / 100.0 * 0.15 * (1.0 - smoothstep(0.0, 0.45, lv));
-                }
                 if k_con != 0.0 {
                     let xx = lv.clamp(0.0, 1.0);
                     lv += -k_con * (tau * xx).sin() / tau;
@@ -611,6 +637,13 @@ pub fn develop(px: &mut [[f32; 4]], w: usize, h: usize, p: &CameraRaw, float: bo
             }
         });
     }
+    // 3b. Whites and Blacks: global curves adapted to the image's black and white points.
+    if p.whites != 0.0 || p.blacks != 0.0 {
+        let enc = Encoding::of(p.encoding_gamma);
+        let (bp, wp) = luminance_points(px, w, h, enc);
+        let (xw, xb) = whites_blacks::amounts(p.whites.clamp(-100.0, 100.0), p.blacks.clamp(-100.0, 100.0), bp, wp);
+        whites_blacks::apply(px, w, xw, xb, enc);
+    }
     // 4–7: per-pixel colour stages.
     let need_color = p.vibrance != 0.0 || p.saturation != 0.0 || !p.curves_neutral() || !p.hsl_neutral() || !p.grade_neutral();
     if need_color {
@@ -732,6 +765,36 @@ pub fn develop(px: &mut [[f32; 4]], w: usize, h: usize, p: &CameraRaw, float: bo
     }
 }
 
+/// The image's black and white points as sRGB-encoded grey levels: the 3rd percentile of the
+/// luminance and the 99.5th of the brightest channel, on a copy at most 256 pixels across (so a
+/// preview proxy and the full image agree).
+fn luminance_points(px: &[[f32; 4]], w: usize, h: usize, enc: Encoding) -> (f32, f32) {
+    let f = w.max(h).div_ceil(256).max(1);
+    let (sw, sh) = (w.div_ceil(f), h.div_ceil(f));
+    let mut sum = vec![[0.0f64; 4]; sw * sh];
+    for y in 0..h {
+        for x in 0..w {
+            let q = px[y * w + x];
+            let s = &mut sum[(y / f) * sw + x / f];
+            for c in 0..3 {
+                s[c] += f64::from(enc.decode(q[c]).clamp(0.0, 1.0));
+            }
+            s[3] += 1.0;
+        }
+    }
+    let cells: Vec<[f32; 3]> = sum.iter().filter(|s| s[3] > 0.0).map(|s| [0, 1, 2].map(|c| (s[c] / s[3]) as f32)).collect();
+    if cells.is_empty() {
+        return (0.0, 1.0);
+    }
+    let pct = |mut v: Vec<f32>, q: f32| {
+        v.sort_by(f32::total_cmp);
+        v[((v.len() - 1) as f32 * q).round() as usize]
+    };
+    let bp = pct(cells.iter().map(|c| luma(*c)).collect(), 0.03);
+    let wp = pct(cells.iter().map(|c| c[0].max(c[1]).max(c[2])).collect(), 0.995);
+    (linear_to_srgb(bp), linear_to_srgb(wp))
+}
+
 fn value_noise(x: f32, y: f32, seed: u64) -> f32 {
     let (xi, yi) = (x.floor(), y.floor());
     let (tx, ty) = (x - xi, y - yi);
diff --git a/crates/algo/src/camera_raw/local_tone.rs b/crates/algo/src/camera_raw/local_tone.rs
new file mode 100644
index 0000000000..7844f8d74b
--- /dev/null
+++ b/crates/algo/src/camera_raw/local_tone.rs
@@ -0,0 +1,428 @@
+//! Shadows and Highlights as a local Laplacian filter.
+//!
+//! Adobe has said Camera Raw's process version 2012 rests on local Laplacian filters (S. Paris,
+//! S. W. Hasinoff, J. Kautz, *Local Laplacian Filters: Edge-aware Image Processing with a
+//! Laplacian Pyramid*, SIGGRAPH 2011). This follows that paper, in its fast form (M. Aubry et
+//! al., *Fast Local Laplacian Filters*, ACM TOG 2014: the remapping sampled at a few reference
+//! values, each pyramid coefficient interpolated between them), on the log2 luminance:
+//!
+//! - **Shadows** raises pixels darker than their surroundings, by an amount set by their own and
+//!   their surroundings' place in the image's range (1st to 99th percentile); **Highlights**
+//!   pulls pixels brighter than their surroundings toward them. Differences under a threshold
+//!   are left alone, so fine detail stays.
+//! - Shadows then keeps the image's 99th percentile, Highlights its 1st (Photoshop keeps the
+//!   brightest content under Shadows and the darkest under Highlights).
+//! - A uniform image is unchanged, edges keep no halo, and the result does not depend on the
+//!   image size.
+//!
+//! The strengths were fitted to Photoshop 25.4's Camera Raw Filter on ten public-domain photos
+//! (black-box measurements, no Adobe code or data). It is an approximation: on those photos the
+//! mean error against Photoshop is 2.8–9.4 levels (of 255) where the previous heuristic's was
+//! 3.7–14.3.
+
+use super::{Encoding, luma};
+use crate::photo_util::par_rows;
+
+/// Spacing of the fast filter's reference values in stops. Its remapping changes within about
+/// half a stop, and coefficients interpolated across wider gaps show as contour lines on smooth
+/// gradients (12 references over a whole raw's range left visible steps; at an eighth of a stop a
+/// ramp's slope varies by under a third, as the remapping itself makes it).
+const REF_STEP: f32 = 0.125;
+/// The filter runs on a copy at most this many pixels across; the change it makes is brought back
+/// to full size by a guided upsampling, so a preview and the full image agree.
+const WORK_SIDE: usize = 1600;
+/// Knots of the strength curves over the surroundings' place in the image range (0 … 1).
+const KNOTS: usize = 5;
+
+/// Shadows: how far a pixel darker than its surroundings rises, in stops per unit slider, as
+/// a function of its own place in the image range (`own`) times a factor of its surroundings'
+/// place (`around`); it rises fully once it is `sigma` stops below them. The lift depends on
+/// the pixel's tone, not on the size of the difference, so it is the same at every pyramid
+/// level and a big edge keeps no halo. Lowering (negative values) is `down` times as strong.
+const SHADOWS: Lift = Lift { own: [-0.017, 0.466, 0.886, 1.221, -0.081], around: [4.566, 4.067, 1.088, 0.149, 0.878], sigma: 0.571, down: 0.808 };
+const HIGHLIGHTS: Side = Side { pull: [0.179, 0.141, 0.196, 0.629, 2.07], push: [0.156, 0.08, 0.175, 0.049, 1.261], sigma: 0.05 };
+
+/// See [`SHADOWS`].
+struct Lift {
+    own: [f32; KNOTS],
+    around: [f32; KNOTS],
+    sigma: f32,
+    down: f32,
+}
+
+/// Highlights: strengths per unit slider over the surroundings' place in the image range, for
+/// lowering (`pull`, toward the surroundings) and raising (`push`), and the detail threshold in
+/// stops.
+struct Side {
+    pull: [f32; KNOTS],
+    push: [f32; KNOTS],
+    sigma: f32,
+}
+
+/// One channel, `w × h`.
+struct Plane {
+    w: usize,
+    h: usize,
+    v: Vec<f32>,
+}
+
+/// Mirrors `i` into `0..n` (the edge sample is not repeated).
+fn mirror(i: isize, n: usize) -> usize {
+    let n = n as isize;
+    if n == 1 {
+        return 0;
+    }
+    let p = 2 * (n - 1);
+    let m = i.rem_euclid(p);
+    (if m >= n { p - m } else { m }) as usize
+}
+
+const TAPS: [f32; 5] = [1.0 / 16.0, 4.0 / 16.0, 6.0 / 16.0, 4.0 / 16.0, 1.0 / 16.0];
+
+/// The binomial 5-tap blur, sampled every `step` pixels from 0 (1 = full resolution).
+fn blur_step(p: &Plane, step: usize) -> Plane {
+    let (w2, h2) = (p.w.div_ceil(step), p.h.div_ceil(step));
+    // Columns first at the kept rows, then rows at the kept columns.
+    let mut tmp = vec![0.0f32; p.w * h2];
+    par_rows(&mut tmp, p.w, 1, |y2, row| {
+        let y = (y2 * step) as isize;
+        for (x, o) in row.iter_mut().enumerate() {
+            *o = (0..5).map(|k| TAPS[k] * p.v[mirror(y + k as isize - 2, p.h) * p.w + x]).sum();
+        }
+    });
+    let mut out = vec![0.0f32; w2 * h2];
+    par_rows(&mut out, w2, 1, |y2, row| {
+        let src = &tmp[y2 * p.w..(y2 + 1) * p.w];
+        for (x2, o) in row.iter_mut().enumerate() {
+            let x = (x2 * step) as isize;
+            *o = (0..5).map(|k| TAPS[k] * src[mirror(x + k as isize - 2, p.w)]).sum();
+        }
+    });
+    Plane { w: w2, h: h2, v: out }
+}
+
+/// The next coarser level.
+fn down(p: &Plane) -> Plane {
+    blur_step(p, 2)
+}
+
+/// `p` brought up to `w × h`: zeros between samples, then the blur times four.
+fn up(p: &Plane, w: usize, h: usize) -> Plane {
+    let mut z = Plane { w, h, v: vec![0.0; w * h] };
+    for y in 0..p.h.min(h.div_ceil(2)) {
+        for x in 0..p.w.min(w.div_ceil(2)) {
+            z.v[2 * y * w + 2 * x] = p.v[y * p.w + x] * 4.0;
+        }
+    }
+    blur_step(&z, 1)
+}
+
+/// Levels down to about 2 pixels on the short side.
+fn depth(w: usize, h: usize) -> usize {
+    let mut s = w.min(h);
+    let mut n = 1;
+    while s > 2 {
+        s = s.div_ceil(2);
+        n += 1;
+    }
+    n
+}
+
+fn gaussian(p: Plane, n: usize) -> Vec<Plane> {
+    let mut g = vec![p];
+    for _ in 1..n {
+        let next = down(&g[g.len() - 1]);
+        g.push(next);
+    }
+    g
+}
+
+/// The local Laplacian filter of `u` with `remap(value, reference)`; the coarsest level is kept.
+fn llf(u: &Plane, remap: impl Fn(f32, f32) -> f32 + Sync) -> Plane {
+    let n = depth(u.w, u.h);
+    let g = gaussian(Plane { w: u.w, h: u.h, v: u.v.clone() }, n);
+    // References span the image's tones; the deepest 0.1 % (noise down to the floor) share the
+    // lowest reference instead of stretching the spacing.
+    let hi = u.v.iter().fold(f32::NEG_INFINITY, |a, &v| a.max(v));
+    let lo = quantile(&u.v, 0.001).min(hi);
+    if hi - lo <= 1e-6 || (hi - lo).is_nan() {
+        return Plane { w: u.w, h: u.h, v: u.v.clone() };
+    }
+    let refs = (((hi - lo) / REF_STEP).ceil() as usize + 1).clamp(2, 96);
+    let step = (hi - lo) / (refs - 1) as f32;
+    let mut lap: Vec<Vec<f32>> = g[..n - 1].iter().map(|p| vec![0.0; p.v.len()]).collect();
+    for k in 0..refs {
+        let r = lo + step * k as f32;
+        let mut m = Plane { w: u.w, h: u.h, v: u.v.clone() };
+        par_rows(&mut m.v, u.w, 1, |_, row| {
+            for v in row.iter_mut() {
+                *v = remap(*v, r);
+            }
+        });
+        let gr = gaussian(m, n);
+        for l in 0..n - 1 {
+            let coarse = up(&gr[l + 1], gr[l].w, gr[l].h);
+            let (gl, fine, lw) = (&g[l].v, &gr[l].v, g[l].w);
+            par_rows(&mut lap[l], lw, 1, |y, row| {
+                for (x, o) in row.iter_mut().enumerate() {
+                    let i = y * lw + x;
+                    let wgt = (1.0 - (gl[i].clamp(lo, hi) - r).abs() / step).max(0.0);
+                    if wgt > 0.0 {
+                        *o += wgt * (fine[i] - coarse.v[i]);
+                    }
+                }
+            });
+        }
+    }
+    let mut o = Plane { w: g[n - 1].w, h: g[n - 1].h, v: g[n - 1].v.clone() };
+    for l in (0..n - 1).rev() {
+        let mut next = up(&o, g[l].w, g[l].h);
+        for (a, b) in next.v.iter_mut().zip(&lap[l]) {
+            *a += b;
+        }
+        o = next;
+    }
+    o
+}
+
+/// The `q` quantile (0 … 1) of `v`.
+fn quantile(v: &[f32], q: f32) -> f32 {
+    let mut s = v.to_vec();
+    s.sort_by(f32::total_cmp);
+    s[((s.len() - 1) as f32 * q).round() as usize]
+}
+
+/// 1st and 99th percentiles of the log luminance on a copy at most 256 pixels across.
+fn range(u: &Plane) -> (f32, f32) {
+    let f = u.w.max(u.h).div_ceil(256).max(1);
+    let (sw, sh) = (u.w.div_ceil(f), u.h.div_ceil(f));
+    let mut sum = vec![(0.0f64, 0u32); sw * sh];
+    for y in 0..u.h {
+        for x in 0..u.w {
+            let c = &mut sum[(y / f) * sw + x / f];
+            c.0 += f64::from(u.v[y * u.w + x]);
+            c.1 += 1;
+        }
+    }
+    let cells: Vec<f32> = sum.iter().filter(|c| c.1 > 0).map(|c| (c.0 / f64::from(c.1)) as f32).collect();
+    (quantile(&cells, 0.01), quantile(&cells, 0.99))
+}
+
+/// `d` past the detail threshold: about 0 below `sigma`, `d − sigma` well above it.
+fn excess(d: f32, sigma: f32) -> f32 {
+    d - sigma * (d / sigma).tanh()
+}
+
+fn knot(t: f32, k: &[f32; KNOTS]) -> f32 {
+    let x = t.clamp(0.0, 1.0) * (KNOTS - 1) as f32;
+    let i = (x as usize).min(KNOTS - 2);
+    k[i] + (k[i + 1] - k[i]) * (x - i as f32)
+}
+
+/// The Highlights pass on the log luminance `u` (`amount` −1 … 1): pixels brighter than their
+/// surroundings move toward them (or away, for positive values) by the part of the difference
+/// past `sigma`, then the darkest content is put back where it was.
+fn highlights_pass(u: &Plane, amount: f32, side: &Side) -> Plane {
+    let (lo, hi) = range(u);
+    let span = (hi - lo).max(1.0);
+    let strengths = if amount < 0.0 { &side.pull } else { &side.push };
+    let o = llf(u, |x, g| x + knot((g - lo) / span, strengths) * amount * excess((x - g).max(0.0), side.sigma));
+    let shift = quantile(&u.v, 0.01) - quantile(&o.v, 0.01);
+    Plane { w: o.w, h: o.h, v: o.v.iter().map(|v| v + shift).collect() }
+}
+
+/// The Shadows pass on the log luminance `u` (`amount` −1 … 1).
+fn shadows_pass(u: &Plane, amount: f32) -> Plane {
+    let (lo, hi) = range(u);
+    let span = (hi - lo).max(1.0);
+    let k = if amount > 0.0 { amount } else { amount * SHADOWS.down };
+    let o = llf(u, |x, g| {
+        let below = ((g - x) / SHADOWS.sigma).clamp(0.0, 1.0);
+        if below == 0.0 {
+            return x;
+        }
+        let w = below * below * (3.0 - 2.0 * below);
+        x + k * knot((x - lo) / span, &SHADOWS.own) * knot((g - lo) / span, &SHADOWS.around) * w
+    });
+    // Keep the brightest content.
+    let shift = quantile(&u.v, 0.99) - quantile(&o.v, 0.99);
+    Plane { w: o.w, h: o.h, v: o.v.iter().map(|v| v + shift).collect() }
+}
+
+/// Applies Shadows and Highlights (−100 … 100) to straight RGBA pixels encoded with `enc`.
+pub(crate) fn apply(px: &mut [[f32; 4]], w: usize, h: usize, shadows: f32, highlights: f32, enc: Encoding) {
+    if (shadows == 0.0 && highlights == 0.0) || w < 2 || h < 2 {
+        return;
+    }
+    const FLOOR: f32 = 1.0 / 65536.0;
+    let u = Plane { w, h, v: px.iter().map(|q| (luma([0, 1, 2].map(|c| enc.decode(q[c]))).max(0.0) + FLOOR).log2()).collect() };
+    // The filter on a copy at most WORK_SIDE across (box-averaged in log).
+    let f = w.max(h).div_ceil(WORK_SIDE).max(1);
+    let small = if f == 1 { Plane { w, h, v: u.v.clone() } } else { shrink(&u, f) };
+    let mut o = Plane { w: small.w, h: small.h, v: small.v.clone() };
+    if highlights != 0.0 {
+        o = highlights_pass(&o, highlights.clamp(-100.0, 100.0) / 100.0, &HIGHLIGHTS);
+    }
+    if shadows != 0.0 {
+        o = shadows_pass(&o, shadows.clamp(-100.0, 100.0) / 100.0);
+    }
+    // The change in log luminance, at full size.
+    let change: Vec<f32> = if f == 1 {
+        o.v.iter().zip(&u.v).map(|(a, b)| a - b).collect()
+    } else {
+        let d: Vec<f32> = o.v.iter().zip(&small.v).map(|(a, b)| a - b).collect();
+        guided_upsample(&small, &d, &u)
+    };
+    par_rows(px, w, 1, |y, row| {
+        for (x, q) in row.iter_mut().enumerate() {
+            let gain = change[y * w + x].exp2();
+            for c in 0..3 {
+                q[c] = enc.encode(enc.decode(q[c]) * gain);
+            }
+        }
+    });
+}
+
+/// `u` averaged over `f × f` blocks.
+fn shrink(u: &Plane, f: usize) -> Plane {
+    let (sw, sh) = (u.w.div_ceil(f), u.h.div_ceil(f));
+    let mut v = vec![0.0f32; sw * sh];
+    par_rows(&mut v, sw, 1, |y, row| {
+        for (x, o) in row.iter_mut().enumerate() {
+            let (x0, y0) = (x * f, y * f);
+            let (x1, y1) = ((x0 + f).min(u.w), (y0 + f).min(u.h));
+            let mut s = 0.0f64;
+            for yy in y0..y1 {
+                for xx in x0..x1 {
+                    s += f64::from(u.v[yy * u.w + xx]);
+                }
+            }
+            *o = (s / ((x1 - x0) * (y1 - y0)) as f64) as f32;
+        }
+    });
+    Plane { w: sw, h: sh, v }
+}
+
+/// The change `d` computed on `small` brought to the size of `full`, following its edges: a local
+/// linear model of the change against the log luminance (the guided filter of K. He, J. Sun,
+/// *Fast Guided Filter*, 2015), fitted on the small copy and evaluated on the full one.
+fn guided_upsample(small: &Plane, d: &[f32], full: &Plane) -> Vec<f32> {
+    let (sw, sh) = (small.w, small.h);
+    let r = 2;
+    let eps = 0.01;
+    let mean = |v: &[f32]| super::box_mean(v, sw, sh, r);
+    let ud: Vec<f32> = small.v.iter().zip(d).map(|(a, b)| a * b).collect();
+    let uu: Vec<f32> = small.v.iter().map(|a| a * a).collect();
+    let (mu, md, mud, muu) = (mean(&small.v), mean(d), mean(&ud), mean(&uu));
+    let a: Vec<f32> = (0..sw * sh).map(|i| (mud[i] - mu[i] * md[i]) / (muu[i] - mu[i] * mu[i] + eps)).collect();
+    let b: Vec<f32> = (0..sw * sh).map(|i| md[i] - a[i] * mu[i]).collect();
+    let (ma, mb) = (mean(&a), mean(&b));
+    let (fx, fy) = (sw as f32 / full.w as f32, sh as f32 / full.h as f32);
+    let mut out = vec![0.0f32; full.w * full.h];
+    par_rows(&mut out, full.w, 1, |y, row| {
+        let sy = (y as f32 + 0.5) * fy - 0.5;
+        for (x, o) in row.iter_mut().enumerate() {
+            let sx = (x as f32 + 0.5) * fx - 0.5;
+            let av = crate::photo_util::bilinear(&ma, sw, sh, 1, 0, sx, sy);
+            let bv = crate::photo_util::bilinear(&mb, sw, sh, 1, 0, sx, sy);
+            *o = av * full.v[y * full.w + x] + bv;
+        }
+    });
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SRGB: Encoding = Encoding(0.0);
+
+    fn grey(w: usize, h: usize, f: impl Fn(usize, usize) -> f32) -> Vec<[f32; 4]> {
+        (0..w * h).map(|i| f(i % w, i / w)).map(|v| [v, v, v, 1.0]).collect()
+    }
+
+    #[test]
+    fn a_flat_image_is_unchanged() {
+        let mut px = grey(64, 48, |_, _| 0.4);
+        apply(&mut px, 64, 48, 100.0, -100.0, SRGB);
+        assert!(px.iter().all(|q| (q[0] - 0.4).abs() < 1e-5));
+    }
+
+    #[test]
+    fn shadows_raise_a_dark_area_without_a_halo() {
+        // A 0.1 | 0.6 step (the dark half is the image's black point, which Photoshop barely
+        // moves either): the bright half stays, and no halo forms on either side of the edge.
+        let (w, h) = (256, 128);
+        let mut px = grey(w, h, |x, _| if x < w / 2 { 0.1 } else { 0.6 });
+        apply(&mut px, w, h, 100.0, 0.0, SRGB);
+        let row = &px[64 * w..65 * w];
+        assert!((row[w / 2 + 1][0] - 0.6).abs() < 0.002 && (row[w - 5][0] - 0.6).abs() < 0.002);
+        let (far, near) = (row[10][0], row[w / 2 - 1][0]);
+        assert!((far - 0.1).abs() < 0.004 && (far - near).abs() < 0.004, "{far} {near}");
+    }
+
+    #[test]
+    fn grey_moves_as_in_photoshop() {
+        // Mid-grey with 1 % black (0.015) and white (0.97) corners, Photoshop 25.4: Shadows +100
+        // takes the grey from 127.5 to 165.3, Highlights −100 to 89.6 (of 255).
+        let n = 256;
+        let image = |c: f32| {
+            grey(n, n, |x, y| {
+                if x >= n - 26 && y >= n - 26 {
+                    0.97
+                } else if x >= n - 26 && y < 26 {
+                    0.015
+                } else {
+                    c
+                }
+            })
+        };
+        for (s, hl, want) in [(100.0, 0.0, 165.3), (0.0, -100.0, 89.6)] {
+            let mut px = image(0.5);
+            apply(&mut px, n, n, s, hl, SRGB);
+            let got = px[175 * n + 100][0] * 255.0;
+            assert!((got - want).abs() < 5.0, "{s} {hl}: {got} vs {want}");
+        }
+    }
+
+    #[test]
+    fn highlights_lower_a_bright_area_and_keep_the_darkest() {
+        let (w, h) = (192, 192);
+        let mut px = grey(w, h, |x, y| if (64..128).contains(&x) && (64..128).contains(&y) { 0.8 } else { 0.2 });
+        apply(&mut px, w, h, 0.0, -100.0, SRGB);
+        assert!(px[96 * w + 96][0] < 0.75, "{}", px[96 * w + 96][0]);
+        assert!((px[5 * w + 5][0] - 0.2).abs() < 0.01, "{}", px[5 * w + 5][0]);
+    }
+
+    #[test]
+    fn smooth_gradients_stay_smooth() {
+        // A soft ramp over eight stops, as in an out-of-focus background. Coefficients interpolated
+        // between references too far apart drew contour lines across such ramps (Shadows +100 on
+        // a D4 raw): the output must rise steadily, without ripples.
+        let (w, h) = (640, 48);
+        let mut px = grey(w, h, |x, _| crate::photo_util::linear_to_srgb((x as f32 / (w - 1) as f32 * 8.0 - 9.0).exp2()));
+        for (s, hl) in [(100.0, 0.0), (0.0, -100.0), (-100.0, 100.0)] {
+            let mut p = px.clone();
+            apply(&mut p, w, h, s, hl, SRGB);
+            let row: Vec<f32> = (0..w).map(|x| crate::photo_util::srgb_to_linear(p[24 * w + x][0]).max(1e-6).log2()).collect();
+            let steps: Vec<f32> = row.windows(2).map(|d| d[1] - d[0]).collect();
+            assert!(steps.iter().all(|d| *d > 0.0), "{s} {hl}: the ramp reverses");
+            let jumps: Vec<f32> = steps.windows(2).map(|d| (d[1] - d[0]).abs()).collect();
+            let ripple = jumps[16..jumps.len() - 16].iter().fold(0.0f32, |a, b| a.max(*b));
+            // The ramp rises 0.0125 stops per pixel; its slope may change by a third at most.
+            assert!(ripple < 0.004, "{s} {hl}: slope jumps by {ripple} stops per pixel");
+        }
+        px.clear();
+    }
+
+    #[test]
+    fn the_result_does_not_depend_on_the_image_size() {
+        let at = |n: usize| {
+            let mut px = grey(n, n, |x, y| if x < n / 3 || y < n / 4 { 0.08 } else { 0.7 });
+            apply(&mut px, n, n, 70.0, -60.0, SRGB);
+            [px[(n / 8) * n + n / 8][0], px[(3 * n / 4) * n + 3 * n / 4][0]]
+        };
+        let (a, b) = (at(96), at(384));
+        assert!((a[0] - b[0]).abs() < 0.02 && (a[1] - b[1]).abs() < 0.02, "{a:?} {b:?}");
+    }
+}
diff --git a/crates/algo/src/camera_raw/whites_blacks.rs b/crates/algo/src/camera_raw/whites_blacks.rs
new file mode 100644
index 0000000000..382ade50e9
--- /dev/null
+++ b/crates/algo/src/camera_raw/whites_blacks.rs
@@ -0,0 +1,418 @@
+//! Whites and Blacks as Adobe Camera Raw (process version 2012) applies them.
+//!
+//! Measured as a black box on the Camera Raw Filter of Photoshop 25.4: grey blocks with chosen
+//! histograms went through the filter by script and came back exactly; no Adobe code or data
+//! was used.
+//!
+//! - Both are global curves of the grey level, applied after Shadows and Highlights, Whites
+//!   first. On an image whose darkest and lightest percent reach black and white the curve of a
+//!   slider value `x` is the measured row at `x` of [`WHITES`] or [`BLACKS`].
+//! - The direction that only compresses (Whites down, Blacks up) is that fixed curve on every
+//!   image. The direction that clips (Whites up, Blacks down) adapts: the row used is
+//!   `x · A(BP, WP)`. On the block images BP and WP are their darkest and lightest levels; on
+//!   photographs Photoshop's amounts follow best with BP the 3rd percentile of the luminance and
+//!   WP the 99.5th of the brightest channel, and Blacks at least 1.2 times. A low
+//!   white point makes Whites +100 stronger (up to 2.7 times), a raised black point Blacks
+//!   (up to 1.45 times at −40). Whites rows past +100 come from images where `A > 1`.
+//! - Not reproduced: past −40 Photoshop's Blacks grows faster on images with a raised black
+//!   point (on one spanning 0.6–1 its −100 blacks out everything below 0.74, here below about
+//!   0.15); its curves there are not rows of the full-range family.
+//! - Colour: the clipping directions act on each channel, the compressing ones scale the pixel
+//!   by the curve's change of its luminance (closest to Photoshop on saturated colours).
+
+use super::Encoding;
+use crate::photo_util::par_rows;
+
+/// Grey levels the curves are sampled at: 0, 1/32, …, 1 (sRGB-encoded).
+const STEPS: usize = 33;
+/// The first row's internal amount; rows are 10 apart.
+const WHITES_FROM: f32 = -100.0;
+const BLACKS_FROM: f32 = -100.0;
+// Measured levels; some happen to lie near π/8 and π/4.
+/// Whites curves at internal amounts -100, -90, …, 270 (rows) over grey levels 0, 1/32, …, 1.
+#[allow(clippy::approx_constant)]
+static WHITES: [[f32; 33]; 38] = [
+    [
+        0.0000, 0.0298, 0.0621, 0.0926, 0.1226, 0.1523, 0.1817, 0.2107, 0.2391, 0.2671, 0.2946, 0.3215, 0.3480, 0.3738, 0.3995, 0.4256, 0.4517, 0.4774, 0.5028,
+        0.5278, 0.5524, 0.5768, 0.6008, 0.6245, 0.6482, 0.6717, 0.6957, 0.7207, 0.7483, 0.7814, 0.8263, 0.8949, 0.9999,
+    ],
+    [
+        0.0000, 0.0298, 0.0621, 0.0926, 0.1226, 0.1523, 0.1817, 0.2107, 0.2392, 0.2672, 0.2947, 0.3217, 0.3482, 0.3742, 0.4000, 0.4263, 0.4526, 0.4785, 0.5042,
+        0.5296, 0.5548, 0.5797, 0.6044, 0.6291, 0.6539, 0.6789, 0.7046, 0.7317, 0.7617, 0.7969, 0.8425, 0.9074, 0.9999,
+    ],
+    [
+        0.0000, 0.0298, 0.0621, 0.0926, 0.1226, 0.1524, 0.1818, 0.2108, 0.2393, 0.2673, 0.2950, 0.3221, 0.3487, 0.3748, 0.4008, 0.4274, 0.4540, 0.4803, 0.5064,
+        0.5323, 0.5580, 0.5837, 0.6093, 0.6350, 0.6610, 0.6875, 0.7149, 0.7438, 0.7756, 0.8122, 0.8576, 0.9184, 0.9999,
+    ],
+    [
+        0.0000, 0.0298, 0.0621, 0.0926, 0.1226, 0.1524, 0.1818, 0.2109, 0.2395, 0.2677, 0.2954, 0.3227, 0.3495, 0.3759, 0.4022, 0.4291, 0.4561, 0.4828, 0.5094,
+        0.5360, 0.5624, 0.5888, 0.6154, 0.6423, 0.6695, 0.6973, 0.7261, 0.7566, 0.7897, 0.8271, 0.8716, 0.9280, 0.9999,
+    ],
+    [
+        0.0000, 0.0298, 0.0621, 0.0926, 0.1226, 0.1525, 0.1820, 0.2111, 0.2398, 0.2682, 0.2961, 0.3237, 0.3508, 0.3775, 0.4042, 0.4317, 0.4591, 0.4864, 0.5136,
+        0.5408, 0.5680, 0.5953, 0.6229, 0.6508, 0.6791, 0.7082, 0.7382, 0.7698, 0.8037, 0.8412, 0.8843, 0.9365, 0.9999,
+    ],
+    [
+        0.0000, 0.0298, 0.0621, 0.0927, 0.1227, 0.1527, 0.1822, 0.2116, 0.2404, 0.2690, 0.2972, 0.3251, 0.3527, 0.3799, 0.4071, 0.4351, 0.4630, 0.4910, 0.5189,
+        0.5469, 0.5749, 0.6031, 0.6316, 0.6605, 0.6899, 0.7199, 0.7509, 0.7832, 0.8174, 0.8544, 0.8958, 0.9439, 0.9999,
+    ],
+    [
+        0.0000, 0.0298, 0.0621, 0.0927, 0.1229, 0.1529, 0.1827, 0.2122, 0.2414, 0.2702, 0.2989, 0.3272, 0.3553, 0.3831, 0.4110, 0.4396, 0.4682, 0.4968, 0.5254,
+        0.5542, 0.5830, 0.6121, 0.6414, 0.6712, 0.7014, 0.7322, 0.7637, 0.7964, 0.8305, 0.8668, 0.9062, 0.9503, 0.9999,
+    ],
+    [
+        0.0000, 0.0298, 0.0622, 0.0928, 0.1231, 0.1534, 0.1834, 0.2132, 0.2427, 0.2720, 0.3011, 0.3300, 0.3587, 0.3872, 0.4160, 0.4452, 0.4745, 0.5038, 0.5332,
+        0.5627, 0.5923, 0.6221, 0.6522, 0.6826, 0.7134, 0.7447, 0.7765, 0.8092, 0.8429, 0.8781, 0.9155, 0.9559, 1.0000,
+    ],
+    [
+        0.0000, 0.0298, 0.0623, 0.0930, 0.1236, 0.1541, 0.1844, 0.2145, 0.2445, 0.2744, 0.3041, 0.3337, 0.3632, 0.3925, 0.4221, 0.4520, 0.4820, 0.5120, 0.5421,
+        0.5723, 0.6026, 0.6330, 0.6636, 0.6946, 0.7257, 0.7572, 0.7890, 0.8214, 0.8545, 0.8885, 0.9237, 0.9608, 1.0000,
+    ],
+    [
+        0.0000, 0.0298, 0.0624, 0.0934, 0.1242, 0.1551, 0.1858, 0.2164, 0.2470, 0.2775, 0.3080, 0.3383, 0.3687, 0.3989, 0.4293, 0.4600, 0.4906, 0.5213, 0.5520,
+        0.5827, 0.6136, 0.6445, 0.6755, 0.7067, 0.7380, 0.7694, 0.8011, 0.8330, 0.8652, 0.8978, 0.9310, 0.9651, 1.0000,
+    ],
+    [
+        0.0000, 0.0312, 0.0625, 0.0938, 0.1250, 0.1562, 0.1875, 0.2188, 0.2500, 0.2812, 0.3125, 0.3438, 0.3750, 0.4062, 0.4375, 0.4688, 0.5000, 0.5312, 0.5625,
+        0.5938, 0.6250, 0.6562, 0.6875, 0.7188, 0.7500, 0.7812, 0.8125, 0.8438, 0.8750, 0.9062, 0.9375, 0.9688, 1.0000,
+    ],
+    [
+        0.0000, 0.0299, 0.0626, 0.0940, 0.1253, 0.1567, 0.1881, 0.2195, 0.2510, 0.2825, 0.3140, 0.3456, 0.3772, 0.4089, 0.4405, 0.4720, 0.5036, 0.5351, 0.5667,
+        0.5983, 0.6298, 0.6613, 0.6929, 0.7244, 0.7559, 0.7874, 0.8189, 0.8503, 0.8816, 0.9128, 0.9438, 0.9742, 1.0000,
+    ],
+    [
+        0.0000, 0.0299, 0.0627, 0.0941, 0.1257, 0.1573, 0.1890, 0.2208, 0.2526, 0.2846, 0.3167, 0.3488, 0.3811, 0.4134, 0.4456, 0.4777, 0.5098, 0.5419, 0.5741,
+        0.6062, 0.6383, 0.6704, 0.7025, 0.7345, 0.7664, 0.7983, 0.8301, 0.8617, 0.8931, 0.9241, 0.9543, 0.9829, 1.0000,
+    ],
+    [
+        0.0000, 0.0299, 0.0628, 0.0944, 0.1262, 0.1582, 0.1903, 0.2225, 0.2550, 0.2876, 0.3204, 0.3534, 0.3867, 0.4200, 0.4529, 0.4858, 0.5186, 0.5516, 0.5845,
+        0.6174, 0.6502, 0.6830, 0.7157, 0.7482, 0.7807, 0.8131, 0.8451, 0.8769, 0.9082, 0.9385, 0.9673, 0.9928, 1.0000,
+    ],
+    [
+        0.0000, 0.0299, 0.0629, 0.0948, 0.1269, 0.1594, 0.1920, 0.2249, 0.2582, 0.2917, 0.3256, 0.3597, 0.3942, 0.4289, 0.4628, 0.4966, 0.5305, 0.5644, 0.5983,
+        0.6321, 0.6658, 0.6994, 0.7327, 0.7660, 0.7989, 0.8316, 0.8639, 0.8956, 0.9263, 0.9553, 0.9815, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0299, 0.0631, 0.0953, 0.1280, 0.1610, 0.1944, 0.2282, 0.2625, 0.2973, 0.3325, 0.3683, 0.4045, 0.4407, 0.4758, 0.5109, 0.5460, 0.5811, 0.6161,
+        0.6510, 0.6857, 0.7201, 0.7541, 0.7879, 0.8213, 0.8543, 0.8864, 0.9175, 0.9468, 0.9733, 0.9950, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0299, 0.0633, 0.0961, 0.1293, 0.1632, 0.1976, 0.2327, 0.2684, 0.3048, 0.3419, 0.3798, 0.4183, 0.4562, 0.4928, 0.5294, 0.5660, 0.6024, 0.6387,
+        0.6748, 0.7104, 0.7456, 0.7803, 0.8145, 0.8480, 0.8807, 0.9121, 0.9417, 0.9684, 0.9907, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0300, 0.0637, 0.0971, 0.1313, 0.1663, 0.2020, 0.2387, 0.2763, 0.3149, 0.3546, 0.3952, 0.4365, 0.4763, 0.5149, 0.5532, 0.5914, 0.6294, 0.6670,
+        0.7041, 0.7406, 0.7763, 0.8113, 0.8456, 0.8788, 0.9104, 0.9401, 0.9667, 0.9888, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0300, 0.0641, 0.0984, 0.1338, 0.1703, 0.2079, 0.2468, 0.2870, 0.3286, 0.3717, 0.4161, 0.4602, 0.5024, 0.5430, 0.5833, 0.6232, 0.6627, 0.7015,
+        0.7394, 0.7764, 0.8123, 0.8472, 0.8808, 0.9126, 0.9420, 0.9681, 0.9896, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0302, 0.0647, 0.1003, 0.1374, 0.1760, 0.2160, 0.2579, 0.3016, 0.3472, 0.3949, 0.4436, 0.4908, 0.5355, 0.5784, 0.6207, 0.6622, 0.7029, 0.7424,
+        0.7806, 0.8176, 0.8530, 0.8868, 0.9185, 0.9474, 0.9726, 0.9926, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0304, 0.0656, 0.1029, 0.1423, 0.1837, 0.2271, 0.2731, 0.3215, 0.3726, 0.4262, 0.4791, 0.5294, 0.5769, 0.6220, 0.6660, 0.7086, 0.7498, 0.7893,
+        0.8272, 0.8631, 0.8969, 0.9281, 0.9560, 0.9795, 0.9967, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0305, 0.0679, 0.1094, 0.1509, 0.1968, 0.2459, 0.2956, 0.3510, 0.4094, 0.4680, 0.5248, 0.5781, 0.6278, 0.6742, 0.7195, 0.7624, 0.8031, 0.8417,
+        0.8779, 0.9113, 0.9414, 0.9675, 0.9886, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0306, 0.0702, 0.1160, 0.1623, 0.2144, 0.2709, 0.3243, 0.3885, 0.4556, 0.5199, 0.5807, 0.6369, 0.6884, 0.7355, 0.7799, 0.8217, 0.8606, 0.8964,
+        0.9288, 0.9570, 0.9803, 0.9958, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0308, 0.0725, 0.1225, 0.1737, 0.2320, 0.2960, 0.3641, 0.4393, 0.5133, 0.5825, 0.6460, 0.7032, 0.7544, 0.8003, 0.8426, 0.8817, 0.9168, 0.9475,
+        0.9733, 0.9924, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0322, 0.0751, 0.1303, 0.1918, 0.2594, 0.3348, 0.4189, 0.5044, 0.5841, 0.6565, 0.7208, 0.7771, 0.8262, 0.8692, 0.9074, 0.9408, 0.9686, 0.9900,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0331, 0.0818, 0.1482, 0.2171, 0.2977, 0.3892, 0.4865, 0.5779, 0.6602, 0.7322, 0.7943, 0.8470, 0.8915, 0.9286, 0.9600, 0.9844, 0.9996, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0340, 0.0884, 0.1661, 0.2544, 0.3540, 0.4658, 0.5729, 0.6681, 0.7496, 0.8183, 0.8748, 0.9208, 0.9568, 0.9832, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.3356, 0.5799, 0.6166, 0.6166, 0.6166, 0.6166, 0.6624, 0.7556, 0.8321, 0.8935, 0.9411, 0.9755, 0.9970, 0.9998, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.5007, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.1655, 0.1655, 0.2972, 0.4728, 0.6327, 0.7616, 0.8598, 0.9317, 0.9790, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0457, 0.1830, 0.3836, 0.5790, 0.7379, 0.8549, 0.9360, 0.9869, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0520, 0.2329, 0.4864, 0.6989, 0.8449, 0.9403, 0.9884, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0773, 0.3027, 0.6040, 0.8058, 0.9302, 0.9930, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.1454, 0.4738, 0.7615, 0.9074, 0.9908, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.0000, 0.0964, 0.5416, 0.8589, 0.9897, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.1538, 0.1538, 0.7080, 0.9596, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.8439, 0.8439, 0.8439, 0.9993, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+    [
+        0.9228, 0.9228, 0.9228, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+        1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
+    ],
+];
+/// Blacks curves at internal amounts -100, …, 100 in steps of 10.
+#[allow(clippy::approx_constant)]
+static BLACKS: [[f32; 33]; 21] = [
+    [
+        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0290, 0.0572, 0.0879, 0.1222, 0.1580, 0.1935, 0.2287, 0.2636, 0.2988, 0.3355, 0.3741, 0.4151, 0.4571,
+        0.4990, 0.5406, 0.5818, 0.6226, 0.6631, 0.7031, 0.7424, 0.7811, 0.8192, 0.8568, 0.8937, 0.9300, 0.9655, 1.0000,
+    ],
+    [
+        0.0000, 0.0000, 0.0000, 0.0000, 0.0015, 0.0363, 0.0640, 0.0956, 0.1300, 0.1651, 0.2000, 0.2345, 0.2686, 0.3026, 0.3369, 0.3727, 0.4105, 0.4495, 0.4885,
+        0.5272, 0.5657, 0.6039, 0.6419, 0.6796, 0.7169, 0.7538, 0.7903, 0.8264, 0.8621, 0.8974, 0.9322, 0.9664, 1.0000,
+    ],
+    [
+        0.0000, 0.0000, 0.0000, 0.0000, 0.0346, 0.0625, 0.0934, 0.1271, 0.1616, 0.1959, 0.2298, 0.2635, 0.2969, 0.3301, 0.3638, 0.3990, 0.4357, 0.4727, 0.5094,
+        0.5460, 0.5824, 0.6187, 0.6547, 0.6906, 0.7262, 0.7615, 0.7965, 0.8313, 0.8657, 0.8998, 0.9336, 0.9671, 1.0000,
+    ],
+    [
+        0.0000, 0.0000, 0.0000, 0.0235, 0.0554, 0.0850, 0.1175, 0.1514, 0.1852, 0.2187, 0.2519, 0.2849, 0.3178, 0.3505, 0.3837, 0.4183, 0.4537, 0.4891, 0.5243,
+        0.5594, 0.5944, 0.6292, 0.6639, 0.6985, 0.7329, 0.7671, 0.8010, 0.8347, 0.8683, 0.9016, 0.9347, 0.9676, 1.0000,
+    ],
+    [
+        0.0000, 0.0000, 0.0020, 0.0438, 0.0724, 0.1035, 0.1365, 0.1699, 0.2030, 0.2359, 0.2686, 0.3011, 0.3336, 0.3659, 0.3986, 0.4327, 0.4669, 0.5011, 0.5352,
+        0.5692, 0.6031, 0.6369, 0.6706, 0.7043, 0.7378, 0.7711, 0.8043, 0.8373, 0.8702, 0.9029, 0.9355, 0.9679, 1.0000,
+    ],
+    [
+        0.0000, 0.0000, 0.0230, 0.0567, 0.0865, 0.1182, 0.1510, 0.1839, 0.2164, 0.2489, 0.2812, 0.3133, 0.3455, 0.3775, 0.4100, 0.4433, 0.4767, 0.5100, 0.5433,
+        0.5765, 0.6096, 0.6426, 0.6756, 0.7086, 0.7414, 0.7741, 0.8067, 0.8392, 0.8716, 0.9039, 0.9361, 0.9682, 1.0000,
+    ],
+    [
+        0.0000, 0.0000, 0.0368, 0.0670, 0.0976, 0.1294, 0.1619, 0.1943, 0.2265, 0.2586, 0.2906, 0.3225, 0.3544, 0.3862, 0.4184, 0.4512, 0.4839, 0.5166, 0.5492,
+        0.5818, 0.6144, 0.6469, 0.6793, 0.7117, 0.7441, 0.7763, 0.8085, 0.8406, 0.8727, 0.9046, 0.9365, 0.9683, 1.0000,
+    ],
+    [
+        0.0000, 0.0000, 0.0444, 0.0749, 0.1058, 0.1377, 0.1699, 0.2020, 0.2339, 0.2657, 0.2975, 0.3292, 0.3609, 0.3926, 0.4245, 0.4568, 0.4891, 0.5213, 0.5535,
+        0.5857, 0.6179, 0.6499, 0.6820, 0.7140, 0.7460, 0.7779, 0.8098, 0.8416, 0.8734, 0.9052, 0.9368, 0.9685, 1.0000,
+    ],
+    [
+        0.0000, 0.0086, 0.0511, 0.0817, 0.1128, 0.1445, 0.1763, 0.2080, 0.2397, 0.2713, 0.3029, 0.3344, 0.3660, 0.3975, 0.4292, 0.4611, 0.4930, 0.5249, 0.5567,
+        0.5886, 0.6204, 0.6522, 0.6839, 0.7157, 0.7475, 0.7791, 0.8108, 0.8424, 0.8740, 0.9056, 0.9371, 0.9686, 1.0000,
+    ],
+    [
+        0.0000, 0.0198, 0.0564, 0.0874, 0.1186, 0.1501, 0.1817, 0.2133, 0.2447, 0.2762, 0.3076, 0.3390, 0.3705, 0.4018, 0.4333, 0.4649, 0.4965, 0.5281, 0.5597,
+        0.5912, 0.6227, 0.6543, 0.6858, 0.7173, 0.7488, 0.7802, 0.8117, 0.8431, 0.8745, 0.9059, 0.9373, 0.9686, 1.0000,
+    ],
+    [
+        0.0000, 0.0312, 0.0625, 0.0938, 0.1250, 0.1562, 0.1875, 0.2188, 0.2500, 0.2812, 0.3125, 0.3438, 0.3750, 0.4062, 0.4375, 0.4688, 0.5000, 0.5312, 0.5625,
+        0.5938, 0.6250, 0.6562, 0.6875, 0.7188, 0.7500, 0.7812, 0.8125, 0.8438, 0.8750, 0.9062, 0.9375, 0.9688, 1.0000,
+    ],
+    [
+        0.0000, 0.0313, 0.0650, 0.0979, 0.1303, 0.1624, 0.1942, 0.2260, 0.2576, 0.2891, 0.3206, 0.3520, 0.3833, 0.4146, 0.4455, 0.4763, 0.5070, 0.5378, 0.5684,
+        0.5991, 0.6298, 0.6605, 0.6912, 0.7219, 0.7526, 0.7833, 0.8141, 0.8450, 0.8758, 0.9067, 0.9377, 0.9688, 1.0000,
+    ],
+    [
+        0.0000, 0.0326, 0.0677, 0.1022, 0.1357, 0.1686, 0.2010, 0.2332, 0.2652, 0.2969, 0.3286, 0.3601, 0.3915, 0.4227, 0.4532, 0.4835, 0.5138, 0.5440, 0.5741,
+        0.6042, 0.6344, 0.6645, 0.6946, 0.7248, 0.7550, 0.7853, 0.8156, 0.8461, 0.8766, 0.9072, 0.9380, 0.9689, 1.0000,
+    ],
+    [
+        0.0000, 0.0341, 0.0706, 0.1066, 0.1413, 0.1749, 0.2079, 0.2405, 0.2728, 0.3048, 0.3366, 0.3682, 0.3996, 0.4307, 0.4608, 0.4906, 0.5203, 0.5500, 0.5796,
+        0.6092, 0.6387, 0.6683, 0.6979, 0.7276, 0.7573, 0.7871, 0.8170, 0.8472, 0.8773, 0.9077, 0.9382, 0.9690, 1.0000,
+    ],
+    [
+        0.0000, 0.0354, 0.0736, 0.1113, 0.1472, 0.1814, 0.2149, 0.2479, 0.2805, 0.3127, 0.3446, 0.3763, 0.4077, 0.4385, 0.4681, 0.4974, 0.5267, 0.5558, 0.5849,
+        0.6139, 0.6429, 0.6720, 0.7011, 0.7303, 0.7595, 0.7889, 0.8184, 0.8481, 0.8780, 0.9081, 0.9384, 0.9690, 1.0000,
+    ],
+    [
+        0.0000, 0.0368, 0.0768, 0.1162, 0.1531, 0.1881, 0.2221, 0.2554, 0.2882, 0.3206, 0.3527, 0.3843, 0.4158, 0.4461, 0.4753, 0.5041, 0.5328, 0.5615, 0.5900,
+        0.6185, 0.6470, 0.6755, 0.7041, 0.7328, 0.7616, 0.7906, 0.8197, 0.8491, 0.8787, 0.9085, 0.9386, 0.9691, 1.0000,
+    ],
+    [
+        0.0000, 0.0381, 0.0802, 0.1214, 0.1593, 0.1949, 0.2293, 0.2630, 0.2961, 0.3286, 0.3607, 0.3924, 0.4236, 0.4536, 0.4823, 0.5106, 0.5388, 0.5669, 0.5949,
+        0.6229, 0.6509, 0.6789, 0.7070, 0.7352, 0.7636, 0.7922, 0.8209, 0.8500, 0.8793, 0.9089, 0.9388, 0.9691, 1.0000,
+    ],
+    [
+        0.0000, 0.0394, 0.0837, 0.1267, 0.1656, 0.2018, 0.2367, 0.2707, 0.3039, 0.3365, 0.3686, 0.4003, 0.4314, 0.4608, 0.4890, 0.5168, 0.5445, 0.5721, 0.5996,
+        0.6271, 0.6546, 0.6822, 0.7098, 0.7375, 0.7655, 0.7937, 0.8221, 0.8509, 0.8799, 0.9092, 0.9390, 0.9692, 1.0000,
+    ],
+    [
+        0.0000, 0.0407, 0.0875, 0.1322, 0.1720, 0.2088, 0.2441, 0.2784, 0.3118, 0.3444, 0.3765, 0.4082, 0.4389, 0.4679, 0.4955, 0.5229, 0.5501, 0.5771, 0.6042,
+        0.6312, 0.6582, 0.6853, 0.7124, 0.7398, 0.7673, 0.7952, 0.8233, 0.8517, 0.8804, 0.9096, 0.9391, 0.9692, 1.0000,
+    ],
+    [
+        0.0000, 0.0421, 0.0915, 0.1379, 0.1786, 0.2160, 0.2516, 0.2861, 0.3196, 0.3523, 0.3844, 0.4159, 0.4462, 0.4747, 0.5019, 0.5287, 0.5554, 0.5820, 0.6085,
+        0.6351, 0.6616, 0.6882, 0.7149, 0.7419, 0.7690, 0.7965, 0.8243, 0.8524, 0.8810, 0.9099, 0.9393, 0.9693, 1.0000,
+    ],
+    [
+        0.0000, 0.0436, 0.0957, 0.1438, 0.1853, 0.2232, 0.2592, 0.2938, 0.3274, 0.3601, 0.3922, 0.4235, 0.4533, 0.4813, 0.5080, 0.5343, 0.5605, 0.5866, 0.6127,
+        0.6387, 0.6648, 0.6910, 0.7173, 0.7439, 0.7707, 0.7978, 0.8253, 0.8532, 0.8815, 0.9102, 0.9394, 0.9693, 1.0000,
+    ],
+];
+const BPS: [f32; 9] = [0.0000, 0.0200, 0.0500, 0.1000, 0.2000, 0.3000, 0.4500, 0.6000, 0.8000];
+const WPS: [f32; 8] = [0.1000, 0.2000, 0.3000, 0.4500, 0.6000, 0.8000, 0.9000, 1.0000];
+static AW: [[f32; 8]; 9] = [
+    [1.7750, 2.3875, 2.4000, 2.1625, 1.9438, 1.6125, 1.3875, 1.0000],
+    [1.8125, 2.5250, 2.3937, 2.1688, 1.9375, 1.6062, 1.3938, 0.9875],
+    [2.7000, 2.4688, 2.2750, 2.0688, 1.8875, 1.6000, 1.3875, 0.9938],
+    [2.3250, 2.3250, 2.1875, 1.9750, 1.7937, 1.5188, 1.3250, 1.0437],
+    [2.0187, 2.0187, 2.0187, 1.8625, 1.7063, 1.4062, 1.2250, 0.9250],
+    [1.7500, 1.7500, 1.7500, 1.7500, 1.6438, 1.3562, 1.1687, 0.8625],
+    [1.4937, 1.4937, 1.4937, 1.4937, 1.4937, 1.2875, 1.1000, 0.7875],
+    [1.1687, 1.1687, 1.1687, 1.1687, 1.1687, 1.1687, 1.0375, 0.7562],
+    [0.8250, 0.8250, 0.8250, 0.8250, 0.8250, 0.8250, 0.8250, 0.7562],
+];
+static AB: [[f32; 8]; 9] = [
+    [0.9938, 0.9812, 1.0000, 1.0125, 0.9563, 0.9688, 1.0437, 1.0000],
+    [1.0437, 1.0250, 1.0125, 1.0000, 1.0000, 1.0375, 1.0000, 0.9938],
+    [1.2312, 1.2063, 1.1875, 1.1625, 1.1438, 1.1438, 1.1375, 1.1250],
+    [1.2500, 1.2500, 1.2312, 1.2125, 1.2125, 1.2375, 1.2375, 1.2375],
+    [1.1750, 1.1750, 1.1750, 1.1750, 1.2063, 1.2688, 1.3125, 1.3375],
+    [1.1812, 1.1812, 1.1812, 1.1812, 1.2125, 1.2812, 1.3313, 1.4125],
+    [1.2375, 1.2375, 1.2375, 1.2375, 1.2375, 1.3062, 1.3562, 1.4375],
+    [1.3250, 1.3250, 1.3250, 1.3250, 1.3250, 1.3250, 1.3687, 1.4500],
+    [1.3938, 1.3938, 1.3938, 1.3938, 1.3938, 1.3938, 1.3938, 1.4312],
+];
+
+/// A curve row at a fractional internal amount `x`, at grey level `v` (both interpolated).
+fn curve(rows: &[[f32; STEPS]], from: f32, x: f32, v: f32) -> f32 {
+    if v >= 1.0 {
+        return 1.0;
+    }
+    let r = ((x - from) / 10.0).clamp(0.0, (rows.len() - 1) as f32);
+    let i = (r as usize).min(rows.len() - 2);
+    let t = r - i as f32;
+    let at = |row: &[f32; STEPS]| {
+        let p = v.max(0.0) * (STEPS - 1) as f32;
+        let j = (p as usize).min(STEPS - 2);
+        let s = p - j as f32;
+        row[j] + (row[j + 1] - row[j]) * s
+    };
+    at(&rows[i]) * (1.0 - t) + at(&rows[i + 1]) * t
+}
+
+/// Whites at internal amount `x` (−100 … 270) of grey level `v`.
+pub(crate) fn whites(v: f32, x: f32) -> f32 {
+    curve(&WHITES, WHITES_FROM, x, v)
+}
+
+/// Blacks at internal amount `x` (−100 … 100) of grey level `v`.
+pub(crate) fn blacks(v: f32, x: f32) -> f32 {
+    curve(&BLACKS, BLACKS_FROM, x, v)
+}
+
+/// The least Blacks adaptation on photographs.
+const PHOTO_BLACKS: f32 = 1.2;
+
+/// Bilinear lookup of an adaptation table at black point `bp` and white point `wp`.
+fn adapt(table: &[[f32; 8]; 9], bp: f32, wp: f32) -> f32 {
+    let idx = |grid: &[f32], v: f32| {
+        let v = v.clamp(grid[0], grid[grid.len() - 1]);
+        let i = grid.windows(2).position(|w| v <= w[1]).unwrap_or(grid.len() - 2);
+        (i, (v - grid[i]) / (grid[i + 1] - grid[i]))
+    };
+    let (i, s) = idx(&BPS, bp);
+    let (j, t) = idx(&WPS, wp);
+    let row = |i: usize| table[i][j] * (1.0 - t) + table[i][j + 1] * t;
+    row(i) * (1.0 - s) + row(i + 1) * s
+}
+
+/// The internal amounts of the Whites and Blacks sliders (−100 … 100) for an image whose 1st
+/// and 99th luminance percentiles are the grey levels `bp` and `wp` (sRGB-encoded).
+pub(crate) fn amounts(whites: f32, blacks: f32, bp: f32, wp: f32) -> (f32, f32) {
+    let w = if whites > 0.0 { whites * adapt(&AW, bp, wp) } else { whites };
+    // On photographs Photoshop's Blacks is about 1.2 times the block images' amount even where
+    // their black point is 0 (ten public-domain photos: 1.08–1.36).
+    let b = if blacks < 0.0 { blacks * adapt(&AB, bp, wp).max(PHOTO_BLACKS) } else { blacks };
+    (w.clamp(-100.0, 270.0), b.clamp(-100.0, 100.0))
+}
+
+/// Applies Whites and Blacks (internal amounts `w`, `b`) to straight RGBA pixels (`width` per
+/// row) encoded with `enc`. Values above 1 (float documents) keep their excess.
+pub(crate) fn apply(px: &mut [[f32; 4]], width: usize, w: f32, b: f32, enc: Encoding) {
+    if w == 0.0 && b == 0.0 {
+        return;
+    }
+    // A grey level's new level, both sRGB-encoded.
+    let grey = |v: f32| {
+        let v = if w != 0.0 { whites(v, w) } else { v };
+        if b != 0.0 { blacks(v, b) } else { v }
+    };
+    let per_channel = w > 0.0 || b < 0.0;
+    par_rows(px, width, 1, |_, row| {
+        for q in row.iter_mut() {
+            let lin = [0, 1, 2].map(|c| enc.decode(q[c]));
+            if per_channel {
+                for c in 0..3 {
+                    let over = (lin[c] - 1.0).max(0.0);
+                    q[c] = enc.encode(super::srgb_decode(grey(super::srgb_encode(lin[c].min(1.0)))) + over);
+                }
+            } else {
+                let y = super::luma_linear(lin).max(0.0);
+                if y <= 1e-7 {
+                    continue;
+                }
+                let y2 = super::srgb_decode(grey(super::srgb_encode(y.min(1.0)))) + (y - 1.0).max(0.0);
+                let k = y2 / y;
+                for c in 0..3 {
+                    q[c] = enc.encode(lin[c] * k);
+                }
+            }
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn full_range_rows_match_photoshop() {
+        // Photoshop 25.4 on a 64-level block image spanning black to white (sRGB levels).
+        assert!((whites(97.1 / 255.0, 100.0) * 255.0 - 137.4).abs() < 0.6);
+        assert!((whites(194.3 / 255.0, -100.0) * 255.0 - 167.6).abs() < 0.6);
+        assert!((blacks(97.1 / 255.0, -100.0) * 255.0 - 60.0).abs() < 0.6);
+        assert!((blacks(48.6 / 255.0, 100.0) * 255.0 - 67.0).abs() < 0.6);
+        // The compressing directions keep black and white.
+        assert_eq!(whites(1.0, -100.0), 1.0);
+        assert_eq!(blacks(0.0, 100.0), 0.0);
+    }
+
+    #[test]
+    fn the_clipping_directions_adapt_to_the_image() {
+        // A dark, low-contrast image needs more: Whites +50 acts like +94.5 on [0.05, 0.6].
+        let (w, _) = amounts(50.0, 0.0, 0.05, 0.6);
+        assert!((w - 94.5).abs() < 2.0, "{w}");
+        // A raised black point strengthens Blacks −40 to −58 on [0.6, 1].
+        let (_, b) = amounts(0.0, -40.0, 0.6, 1.0);
+        assert!((b + 58.0).abs() < 1.0, "{b}");
+        // Never below the photographs' 1.2.
+        assert!((amounts(0.0, -50.0, 0.0, 1.0).1 + 60.0).abs() < 1e-3);
+        // The compressing directions never adapt.
+        assert_eq!(amounts(-50.0, 50.0, 0.3, 0.6), (-50.0, 50.0));
+    }
+}
diff --git a/crates/algo/src/content_aware.rs b/crates/algo/src/content_aware.rs
index 5000ad2e7c..ecdb308624 100644
--- a/crates/algo/src/content_aware.rs
+++ b/crates/algo/src/content_aware.rs
@@ -662,6 +662,26 @@ mod tests {
         assert!(err < 0.12, "mean error {err}");
     }
 
+    /// A vertical sky gradient (each row one colour) filled at every adaptation level stays the
+    /// gradient: no tinted blotch where the copied rows' colours were shifted per channel.
+    #[test]
+    fn color_adaptation_leaves_a_smooth_gradient_untinted() {
+        let (w, h) = (120, 60);
+        let row = |y: usize| {
+            let t = y as f32 / (h - 1) as f32;
+            [0.27 + 0.45 * t, 0.53 + 0.32 * t, 0.86 + 0.1 * t]
+        };
+        let img: Vec<f32> = (0..w * h).flat_map(|i| row(i / w)).collect();
+        let hole: Vec<bool> = (0..w * h).map(|i| (50..70).contains(&(i % w)) && (20..40).contains(&(i / w))).collect();
+        let src = vec![true; w * h];
+        for level in ["none", "default", "high", "veryHigh"] {
+            let out = fill(w, h, 3, &img, &hole, &src, &FillOptions { color_adaptation: color_level(level), ..Default::default() });
+            let (out, img) = (&out, &img);
+            let worst = (0..w * h).filter(|i| hole[*i]).flat_map(|i| (0..3).map(move |c| (out[i * 3 + c] - img[i * 3 + c]).abs())).fold(0.0f32, f32::max);
+            assert!(worst < 3.0 / 255.0, "{level}: off by {}", worst * 255.0);
+        }
+    }
+
     /// I.i.d. noise: every value occurs once, so a filled pixel equal to an image pixel was copied.
     fn noise(w: usize, h: usize, seed: u64) -> Vec<f32> {
         let mut z = seed;
diff --git a/crates/algo/src/dff.rs b/crates/algo/src/dff.rs
new file mode 100644
index 0000000000..c1cf05af63
--- /dev/null
+++ b/crates/algo/src/dff.rs
@@ -0,0 +1,990 @@
+//! Depth from focus for Edit › Auto-Blend Layers › Stack Images: a dense, sub-layer depth map
+//! from the aligned stack, the index of the layer each pixel is sharpest in.
+//!
+//! The pipeline is the non-learned "focus volume" recipe, written from the papers:
+//!
+//! 1. **Focus measure** per layer on luminance at full resolution: the *ring difference filter*
+//!    of Jeon, Surh, Im & Kweon, *Ring Difference Filter for Fast and Noise Robust Depth From
+//!    Focus*, IEEE TIP 29 (2019), the magnitude of the difference between the mean of a small
+//!    disk and the mean of the ring around it, a band-pass whose support averages sensor noise
+//!    away while staying local. Block-averaged to a working grid (half resolution).
+//! 2. **Cost aggregation**: each slice of the focus volume is filtered with the *guided filter*
+//!    (He, Sun & Tang, PAMI 2013) using the all-in-focus luminance as guide, edge-aware
+//!    aggregation as in fast cost-volume filtering (Hosni et al., PAMI 2013).
+//! 3. **Peak search** per pixel over the layer axis, one slice at a time: the global peak and its
+//!    two neighbours for the *Gaussian interpolation* of Nayar & Nakagawa, *Shape from Focus*,
+//!    PAMI 1994 (sub-layer depth), the second-best local maximum for a peak-ratio confidence,
+//!    the profile mean for a prominence term and the profile minimum for a noise gate.
+//! 4. **Regularisation**: the sub-layer depth is smoothed and holes filled by an edge-aware
+//!    weighted least squares energy (Farbman, Fattal, Lischinski & Szeliski, SIGGRAPH 2008)
+//!    whose data term is the confidence, solved by conjugate gradients preconditioned by a
+//!    multigrid V-cycle from the separable sweeps of the *fast global smoother* (Min, Choi, Lu,
+//!    Ham, Sohn & Do, IEEE TIP 2014) as the start, with one Huber reweighting so isolated
+//!    outliers stop pulling.
+//! 5. **Upsampling** to full resolution with the guided filter's linear coefficients.
+//!
+//! Everything is deterministic; the slices are folded one at a time, so memory is one working
+//! grid per layer plus a few planes.
+
+use crate::photo_util::{par_map, par_rows, par_rows2};
+
+/// Depth-from-focus settings.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct DepthParams {
+    /// The working grid is `1 / 2^scale` of full resolution (1 = half).
+    pub scale: usize,
+    /// Ring difference filter radii: the disk `r ≤ r_in`, the ring `r_in < r ≤ r_out`.
+    pub r_in: usize,
+    pub r_out: usize,
+    /// Guided-filter aggregation radius (working-grid pixels) and regulariser.
+    pub agg_radius: usize,
+    pub agg_eps: f32,
+    /// Smoothness weight and guide-edge sensitivity (luminance units) of the regularisation.
+    pub lambda: f32,
+    pub sigma_c: f32,
+    /// Noise gate: full confidence needs a peak ≥ `(1 + gate) ×` the noise floor (the median
+    /// over pixels of the profile minimum). 0 = off.
+    pub gate: f32,
+    /// Robust data term: after the first solve the data weights are scaled by the Huber factor
+    /// `min(1, robust / |d − u|)` (in layers) and the system is solved once more. 0 = off.
+    pub robust: f32,
+}
+
+impl Default for DepthParams {
+    fn default() -> Self {
+        DepthParams { scale: 1, r_in: 1, r_out: 3, agg_radius: 3, agg_eps: 1e-4, lambda: 3.0, sigma_c: 0.04, gate: 1.0, robust: 1.0 }
+    }
+}
+
+/// The result of [`depth_from_focus`].
+#[derive(Clone, Debug, PartialEq)]
+pub struct DepthMap {
+    /// Full-resolution fractional layer index per pixel, in `0 ..= n − 1`.
+    pub depth: Vec<f32>,
+    /// Full-resolution confidence in `0 ..= 1`.
+    pub conf: Vec<f32>,
+    pub w: usize,
+    pub h: usize,
+}
+
+/// Mean over `k × k` blocks (partial blocks at the far edges use their own count).
+pub fn block_mean(src: &[f32], w: usize, h: usize, k: usize) -> (Vec<f32>, usize, usize) {
+    let k = k.max(1);
+    let (dw, dh) = (w.div_ceil(k), h.div_ceil(k));
+    if k == 1 {
+        return (src.to_vec(), dw, dh);
+    }
+    let mut out = vec![0.0f32; dw * dh];
+    par_rows(&mut out, dw, 1, |oy, row| {
+        let (y0, y1) = (oy * k, (oy * k + k).min(h));
+        for y in y0..y1 {
+            let s = &src[y * w..y * w + w];
+            for (ox, o) in row.iter_mut().enumerate() {
+                *o += s[ox * k..(ox * k + k).min(w)].iter().sum::<f32>();
+            }
+        }
+        for (ox, o) in row.iter_mut().enumerate() {
+            *o /= ((y1 - y0) * ((ox * k + k).min(w) - ox * k)) as f32;
+        }
+    });
+    (out, dw, dh)
+}
+
+/// Bilinear resampling of a working-grid plane (block size `k`, samples at block centres) to
+/// `w × h`.
+pub fn upsample_bilinear(g: &[f32], dw: usize, dh: usize, w: usize, h: usize, k: usize) -> Vec<f32> {
+    let mut out = vec![0.0f32; w * h];
+    if dw == 0 || dh == 0 {
+        return out;
+    }
+    let inv = 1.0 / k.max(1) as f32;
+    par_rows(&mut out, w, 1, |y, row| {
+        let fy = ((y as f32 + 0.5) * inv - 0.5).clamp(0.0, (dh - 1) as f32);
+        let y0 = fy as usize;
+        let y1 = (y0 + 1).min(dh - 1);
+        let ty = fy - y0 as f32;
+        let (r0, r1) = (&g[y0 * dw..y0 * dw + dw], &g[y1 * dw..y1 * dw + dw]);
+        for (x, o) in row.iter_mut().enumerate() {
+            let fx = ((x as f32 + 0.5) * inv - 0.5).clamp(0.0, (dw - 1) as f32);
+            let x0 = fx as usize;
+            let x1 = (x0 + 1).min(dw - 1);
+            let tx = fx - x0 as f32;
+            let top = r0[x0] + (r0[x1] - r0[x0]) * tx;
+            let bot = r1[x0] + (r1[x1] - r1[x0]) * tx;
+            *o = top + (bot - top) * ty;
+        }
+    });
+    out
+}
+
+/// Box means over a `(2r + 1)²` window clamped to the plane (partial windows at the borders use
+/// their own count): a horizontal moving sum per row in parallel, then a vertical moving sum
+/// carried down the rows as one accumulator row.
+struct BoxFilter {
+    w: usize,
+    h: usize,
+    r: usize,
+    inv_count: Vec<f32>,
+}
+
+impl BoxFilter {
+    fn new(w: usize, h: usize, r: usize) -> BoxFilter {
+        let cnt = |n: usize, i: usize| ((i + r + 1).min(n) - i.saturating_sub(r)) as f32;
+        let mut inv_count = vec![0.0f32; w * h];
+        par_rows(&mut inv_count, w, 1, |y, row| {
+            let cy = cnt(h, y);
+            for (x, o) in row.iter_mut().enumerate() {
+                *o = 1.0 / (cy * cnt(w, x));
+            }
+        });
+        BoxFilter { w, h, r, inv_count }
+    }
+
+    fn mean(&self, src: &[f32]) -> Vec<f32> {
+        let (w, h, r) = (self.w, self.h, self.r);
+        let mut tmp = vec![0.0f32; w * h];
+        par_rows(&mut tmp, w, 1, |y, row| {
+            let s = &src[y * w..y * w + w];
+            let mut acc: f64 = s[..(r + 1).min(w)].iter().map(|v| f64::from(*v)).sum();
+            for x in 0..w {
+                row[x] = acc as f32;
+                if x + r + 1 < w {
+                    acc += f64::from(s[x + r + 1]);
+                }
+                if x >= r {
+                    acc -= f64::from(s[x - r]);
+                }
+            }
+        });
+        let mut out = vec![0.0f32; w * h];
+        let mut acc = vec![0.0f64; w];
+        for y in 0..(r + 1).min(h) {
+            for (a, v) in acc.iter_mut().zip(&tmp[y * w..y * w + w]) {
+                *a += f64::from(*v);
+            }
+        }
+        for y in 0..h {
+            for ((o, a), c) in out[y * w..y * w + w].iter_mut().zip(&acc).zip(&self.inv_count[y * w..y * w + w]) {
+                *o = *a as f32 * c;
+            }
+            if y + r + 1 < h {
+                for (a, v) in acc.iter_mut().zip(&tmp[(y + r + 1) * w..(y + r + 2) * w]) {
+                    *a += f64::from(*v);
+                }
+            }
+            if y >= r {
+                for (a, v) in acc.iter_mut().zip(&tmp[(y - r) * w..(y - r + 1) * w]) {
+                    *a -= f64::from(*v);
+                }
+            }
+        }
+        out
+    }
+}
+
+/// Guided filter (He, Sun & Tang 2013) with a fixed grayscale guide: made once per guide and
+/// radius, it keeps the guide's statistics so a slice costs only the arithmetic.
+struct GuidedFilter {
+    guide: Vec<f32>,
+    mean_i: Vec<f32>,
+    var_i: Vec<f32>,
+    bf: BoxFilter,
+    eps: f32,
+}
+
+impl GuidedFilter {
+    fn new(guide: Vec<f32>, w: usize, h: usize, r: usize, eps: f32) -> GuidedFilter {
+        let bf = BoxFilter::new(w, h, r);
+        let mean_i = bf.mean(&guide);
+        let ii: Vec<f32> = guide.iter().map(|v| v * v).collect();
+        let var_i: Vec<f32> = bf.mean(&ii).iter().zip(&mean_i).map(|(v, m)| (v - m * m).max(0.0)).collect();
+        GuidedFilter { guide, mean_i, var_i, bf, eps }
+    }
+
+    /// The box-averaged linear coefficients `(ā, b̄)` such that `q ≈ ā·I + b̄`.
+    fn coeffs(&self, p: &[f32]) -> (Vec<f32>, Vec<f32>) {
+        let mean_p = self.bf.mean(p);
+        let ip: Vec<f32> = self.guide.iter().zip(p).map(|(i, p)| i * p).collect();
+        let corr_ip = self.bf.mean(&ip);
+        let (mut a, mut b) = (vec![0.0f32; p.len()], vec![0.0f32; p.len()]);
+        for k in 0..p.len() {
+            let cov = corr_ip[k] - self.mean_i[k] * mean_p[k];
+            a[k] = cov / (self.var_i[k] + self.eps);
+            b[k] = mean_p[k] - a[k] * self.mean_i[k];
+        }
+        (self.bf.mean(&a), self.bf.mean(&b))
+    }
+
+    fn filter(&self, p: &[f32]) -> Vec<f32> {
+        let (a, b) = self.coeffs(p);
+        (0..p.len()).map(|k| a[k] * self.guide[k] + b[k]).collect()
+    }
+}
+
+/// Ring difference filter taps `(dy, dx, weight)`: `+1/|disk|` for `r ≤ r_in`, `−1/|ring|` for
+/// `r_in < r ≤ r_out`.
+fn rdf_taps(r_in: usize, r_out: usize) -> Vec<(i64, i64, f32)> {
+    let (ri2, ro2) = ((r_in * r_in) as i64, (r_out * r_out) as i64);
+    let (mut disk, mut ring) = (Vec::new(), Vec::new());
+    let r = r_out as i64;
+    for dy in -r..=r {
+        for dx in -r..=r {
+            let d2 = dx * dx + dy * dy;
+            if d2 <= ri2 {
+                disk.push((dy, dx));
+            } else if d2 <= ro2 {
+                ring.push((dy, dx));
+            }
+        }
+    }
+    let (wd, wr) = (1.0 / disk.len().max(1) as f32, -1.0 / ring.len().max(1) as f32);
+    disk.into_iter().map(|(y, x)| (y, x, wd)).chain(ring.into_iter().map(|(y, x)| (y, x, wr))).collect()
+}
+
+/// Per-pixel focus measure of a luminance plane: the magnitude of the ring difference filter,
+/// clamped borders.
+pub fn focus_measure(y: &[f32], w: usize, h: usize, r_in: usize, r_out: usize) -> Vec<f32> {
+    let taps = rdf_taps(r_in, r_out.max(r_in + 1));
+    let mut out = vec![0.0f32; w * h];
+    if w == 0 || h == 0 {
+        return out;
+    }
+    par_rows(&mut out, w, 1, |yy, row| {
+        for &(dy, dx, wt) in &taps {
+            let sy = (yy as i64 + dy).clamp(0, h as i64 - 1) as usize;
+            let s = &y[sy * w..sy * w + w];
+            for (x, o) in row.iter_mut().enumerate() {
+                *o += wt * s[(x as i64 + dx).clamp(0, w as i64 - 1) as usize];
+            }
+        }
+        row.iter_mut().for_each(|v| *v = v.abs());
+    });
+    out
+}
+
+/// Per-pixel state of the focus profile, updated one slice at a time.
+#[derive(Clone, Copy)]
+struct Px {
+    /// Best local maximum (value, left neighbour, right neighbour; −1 = none) and its index.
+    c1: f32,
+    l1: f32,
+    r1: f32,
+    i1: u32,
+    /// Second-best local maximum (−1 = none).
+    c2: f32,
+    /// The last two slice values.
+    prev: f32,
+    prev2: f32,
+    sum: f32,
+    cmin: f32,
+}
+
+impl Px {
+    fn register(&mut self, val: f32, idx: u32, l: f32, r: f32) {
+        if val > self.c1 {
+            if self.c1 >= 0.0 {
+                self.c2 = self.c1;
+            }
+            (self.c1, self.i1, self.l1, self.r1) = (val, idx, l, r);
+        } else if val > self.c2 {
+            self.c2 = val;
+        }
+    }
+}
+
+/// The streaming peak search over the layer axis.
+struct PeakTracker {
+    px: Vec<Px>,
+    m: usize,
+}
+
+impl PeakTracker {
+    fn new(n: usize) -> PeakTracker {
+        PeakTracker { px: vec![Px { c1: -1.0, l1: -1.0, r1: -1.0, i1: 0, c2: -1.0, prev: 0.0, prev2: 0.0, sum: 0.0, cmin: f32::INFINITY }; n], m: 0 }
+    }
+
+    /// Fold the next slice (aggregated focus values ≥ 0).
+    fn push(&mut self, c: &[f32]) {
+        let m = self.m;
+        for (p, &v) in self.px.iter_mut().zip(c) {
+            if m >= 1 && (m == 1 || p.prev >= p.prev2) && p.prev > v {
+                let l = if m >= 2 { p.prev2 } else { -1.0 };
+                p.register(p.prev, (m - 1) as u32, l, v);
+            }
+            p.sum += v;
+            p.cmin = p.cmin.min(v);
+            (p.prev2, p.prev) = (p.prev, v);
+        }
+        self.m += 1;
+    }
+
+    /// Close the profiles: the sub-layer depth and the raw confidence per pixel.
+    fn finish(mut self, gate: f32) -> (Vec<f32>, Vec<f32>) {
+        let n = self.m;
+        if n == 0 {
+            return (vec![0.0; self.px.len()], vec![0.0; self.px.len()]);
+        }
+        for p in self.px.iter_mut() {
+            if n == 1 || p.prev >= p.prev2 {
+                let l = if n >= 2 { p.prev2 } else { -1.0 };
+                p.register(p.prev, (n - 1) as u32, l, -1.0);
+            }
+        }
+        // The noise floor: the median of the per-pixel profile minimum (subsampled).
+        let mut mins: Vec<f32> = self.px.iter().step_by(7).map(|p| if p.cmin.is_finite() { p.cmin } else { 0.0 }).collect();
+        let floor = if mins.is_empty() {
+            0.0
+        } else {
+            let mid = mins.len() / 2;
+            *mins.select_nth_unstable_by(mid, |a, b| a.total_cmp(b)).1
+        };
+        let inv_n = 1.0 / n as f32;
+        let out: Vec<(f32, f32)> = par_map(self.px.len(), |i| {
+            let p = &self.px[i];
+            let (c1, l, r) = (p.c1, p.l1, p.r1);
+            let mut delta = 0.0f32;
+            if l >= 0.0 && r >= 0.0 && c1 > 0.0 {
+                // Gaussian interpolation (Nayar & Nakagawa 1994): a parabola in the log domain.
+                let (ll, lc, lr) = (l.max(1e-12).ln(), c1.ln(), r.max(1e-12).ln());
+                let den = ll - 2.0 * lc + lr;
+                if den < 0.0 {
+                    delta = (0.5 * (ll - lr) / den).clamp(-0.5, 0.5);
+                }
+            }
+            let conf = if c1 > 0.0 {
+                let prom = (1.0 - p.sum * inv_n / c1).clamp(0.0, 1.0);
+                // A rival local maximum of similar height means an ambiguous profile.
+                let pkr = if p.c2 >= 0.0 { (1.0 - p.c2 / c1).clamp(0.0, 1.0) } else { 1.0 };
+                let g = if gate > 0.0 && floor > 0.0 { ((c1 - floor) / (gate * floor)).clamp(0.0, 1.0) } else { 1.0 };
+                prom * pkr * g
+            } else {
+                0.0
+            };
+            (p.i1 as f32 + delta, conf)
+        });
+        out.into_iter().unzip()
+    }
+}
+
+/// Scale the confidence so its 90th percentile maps to 1: `lambda` then means the same on every
+/// stack.
+fn normalize_conf(conf: &mut [f32]) {
+    let mut sample: Vec<f32> = conf.iter().step_by(7).copied().collect();
+    if sample.is_empty() {
+        return;
+    }
+    let k = (sample.len() * 9 / 10).min(sample.len() - 1);
+    let p90 = *sample.select_nth_unstable_by(k, |a, b| a.total_cmp(b)).1;
+    if p90 > 1e-6 {
+        conf.iter_mut().for_each(|c| *c = (*c / p90).min(1.0));
+    }
+}
+
+/// 3×3 median, clamped borders.
+fn median3(src: &[f32], w: usize, h: usize) -> Vec<f32> {
+    let mut out = vec![0.0f32; w * h];
+    par_rows(&mut out, w, 1, |y, row| {
+        let ys = [y.saturating_sub(1), y, (y + 1).min(h - 1)];
+        let mut v = [0.0f32; 9];
+        for (x, o) in row.iter_mut().enumerate() {
+            let xs = [x.saturating_sub(1), x, (x + 1).min(w - 1)];
+            for (k, (yy, xx)) in ys.iter().flat_map(|yy| xs.iter().map(move |xx| (*yy, *xx))).enumerate() {
+                v[k] = src[yy * w + xx];
+            }
+            v.sort_unstable_by(|a, b| a.total_cmp(b));
+            *o = v[4];
+        }
+    });
+    out
+}
+
+/// Edge weights between horizontal and vertical neighbours: `exp(−|ΔI| / σ)`; `ax[i]` sits
+/// between `(x, y)` and `(x + 1, y)`, `ay[i]` between `(x, y)` and `(x, y + 1)`.
+fn edge_weights(guide: &[f32], w: usize, h: usize, sigma: f32) -> (Vec<f32>, Vec<f32>) {
+    let inv = -1.0 / sigma.max(1e-6);
+    let (mut ax, mut ay) = (vec![0.0f32; w * h], vec![0.0f32; w * h]);
+    par_rows2(&mut ax, &mut ay, w, |y, rx, ry| {
+        let g = &guide[y * w..y * w + w];
+        for x in 0..w.saturating_sub(1) {
+            rx[x] = ((g[x] - g[x + 1]).abs() * inv).exp();
+        }
+        if y + 1 < h {
+            let g1 = &guide[(y + 1) * w..(y + 2) * w];
+            for x in 0..w {
+                ry[x] = ((g[x] - g1[x]).abs() * inv).exp();
+            }
+        }
+    });
+    (ax, ay)
+}
+
+/// One 1-D weighted-least-squares line `(wd_i + λ(a_{i−1} + a_i)) u_i − λ a_{i−1} u_{i−1} −
+/// λ a_i u_{i+1} = wd_i f_i` by the Thomas algorithm; `a[i]` is the weight between `i` and
+/// `i + 1`; `scratch` holds the sweep's two coefficient lines.
+fn solve_line(u: &mut [f32], f: &[f32], wd: &[f32], a: &[f32], lam: f32, scratch: &mut [f32]) {
+    let n = u.len();
+    if n == 0 || scratch.len() < 2 * n {
+        return;
+    }
+    let (cp, dp) = scratch.split_at_mut(n);
+    let mut prev_a = 0.0f32;
+    for i in 0..n {
+        let ai = if i + 1 < n { a[i] } else { 0.0 };
+        let diag = wd[i] + lam * (prev_a + ai);
+        let lower = -lam * prev_a;
+        let upper = -lam * ai;
+        let (c0, d0) = if i > 0 { (cp[i - 1], dp[i - 1]) } else { (0.0, 0.0) };
+        let m = diag - lower * c0;
+        let m = if m.abs() < 1e-12 { 1e-12 } else { m };
+        cp[i] = upper / m;
+        dp[i] = (wd[i] * f[i] - lower * d0) / m;
+        prev_a = ai;
+    }
+    u[n - 1] = dp[n - 1];
+    for i in (0..n - 1).rev() {
+        u[i] = dp[i] - cp[i] * u[i + 1];
+    }
+}
+
+/// The row sweeps of the fast global smoother, in parallel over rows.
+fn solve_rows(u: &mut [f32], f: &[f32], wd: &[f32], ax: &[f32], w: usize, lam: f32) {
+    par_rows(u, w, 1, |y, row| {
+        let o = y * w;
+        let mut scratch = vec![0.0f32; 2 * w];
+        solve_line(row, &f[o..o + w], &wd[o..o + w], &ax[o..o + w], lam, &mut scratch);
+    });
+}
+
+/// The column sweeps: the planes are transposed, swept as rows, and transposed back.
+fn solve_cols(u: &mut [f32], f: &[f32], wd: &[f32], ay: &[f32], w: usize, h: usize, lam: f32) {
+    let t = |p: &[f32]| -> Vec<f32> {
+        let mut o = vec![0.0f32; w * h];
+        par_rows(&mut o, h, 1, |x, col| {
+            for (y, v) in col.iter_mut().enumerate() {
+                *v = p[y * w + x];
+            }
+        });
+        o
+    };
+    let (ft, wdt, ayt) = (t(f), t(wd), t(ay));
+    let mut ut = vec![0.0f32; w * h];
+    solve_rows(&mut ut, &ft, &wdt, &ayt, h, lam);
+    par_rows(u, w, 1, |y, row| {
+        for (x, v) in row.iter_mut().enumerate() {
+            *v = ut[x * h + y];
+        }
+    });
+}
+
+/// The fast global smoother's three separable passes with the `λ_t` schedule of Min et al.
+/// 2014, the first pass carrying the data weights so holes are filled by interpolation, the
+/// later ones the previous output: the initial guess of [`wls_solve`].
+fn sweeps(d: &[f32], wd: &[f32], ex: &[f32], ey: &[f32], w: usize, h: usize, lambda: f32) -> Vec<f32> {
+    const T: i32 = 3;
+    let ones = vec![1.0f32; w * h];
+    let mut u = vec![0.0f32; w * h];
+    let mut f = d.to_vec();
+    for t in 1..=T {
+        let lam_t = 1.5 * lambda * 4f32.powi(T - t) / (4f32.powi(T) - 1.0);
+        let wt: &[f32] = if t == 1 { wd } else { &ones };
+        solve_rows(&mut u, &f, wt, ex, w, lam_t);
+        f.copy_from_slice(&u);
+        solve_cols(&mut u, &f, &ones, ey, w, h, lam_t);
+        f.copy_from_slice(&u);
+    }
+    u
+}
+
+/// The WLS operator `A = W + Σ λ a_pq` on one grid of the multigrid hierarchy, with the planes
+/// a V-cycle needs there.
+struct MgLevel {
+    w: usize,
+    h: usize,
+    /// Data weight per cell; on the coarse grids the sum over the block.
+    wd: Vec<f32>,
+    /// `λ·a` between `(x, y)` and `(x + 1, y)`, and between `(x, y)` and `(x, y + 1)`; on the
+    /// coarse grids the sum of the fine edges the block boundary cuts.
+    ax: Vec<f32>,
+    ay: Vec<f32>,
+    /// `1 / diag(A)`.
+    dinv: Vec<f32>,
+    x: Vec<f32>,
+    b: Vec<f32>,
+    r: Vec<f32>,
+}
+
+/// Damped-Jacobi weight (4/5 is the smoothing optimum of the 5-point stencil).
+const MG_OMEGA: f32 = 0.8;
+/// Smoothing sweeps before and after the coarse correction, and on the coarsest grid (where
+/// they are the solve).
+const MG_PRE: usize = 1;
+const MG_POST: usize = 1;
+const MG_COARSE: usize = 32;
+/// Coarsen until the grid is this small on its longer side.
+const MG_MIN: usize = 16;
+
+impl MgLevel {
+    fn new(w: usize, h: usize) -> MgLevel {
+        let n = w * h;
+        MgLevel { w, h, wd: vec![0.0; n], ax: vec![0.0; n], ay: vec![0.0; n], dinv: vec![0.0; n], x: vec![0.0; n], b: vec![0.0; n], r: vec![0.0; n] }
+    }
+
+    /// `out_i = f(i, (A x)_i)` over the grid.
+    fn apply<F: Fn(usize, f32) -> f32 + Sync + Send>(&self, x: &[f32], out: &mut [f32], f: F) {
+        let (w, h) = (self.w, self.h);
+        let (wd, ax, ay) = (&self.wd, &self.ax, &self.ay);
+        par_rows(out, w, 1, |y, row| {
+            let o = y * w;
+            for (i, r) in row.iter_mut().enumerate() {
+                let k = o + i;
+                let xk = x[k];
+                let mut v = wd[k] * xk;
+                if i > 0 {
+                    v += ax[k - 1] * (xk - x[k - 1]);
+                }
+                if i + 1 < w {
+                    v += ax[k] * (xk - x[k + 1]);
+                }
+                if y > 0 {
+                    v += ay[k - w] * (xk - x[k - w]);
+                }
+                if y + 1 < h {
+                    v += ay[k] * (xk - x[k + w]);
+                }
+                *r = f(k, v);
+            }
+        });
+    }
+
+    fn set_dinv(&mut self) {
+        let (w, h) = (self.w, self.h);
+        let (wd, ax, ay) = (&self.wd, &self.ax, &self.ay);
+        par_rows(&mut self.dinv, w, 1, |y, row| {
+            for (i, r) in row.iter_mut().enumerate() {
+                let k = y * w + i;
+                let mut v = wd[k];
+                if i > 0 {
+                    v += ax[k - 1];
+                }
+                if i + 1 < w {
+                    v += ax[k];
+                }
+                if y > 0 {
+                    v += ay[k - w];
+                }
+                if y + 1 < h {
+                    v += ay[k];
+                }
+                *r = 1.0 / v.max(1e-12);
+            }
+        });
+    }
+
+    /// One damped-Jacobi sweep on `x` for `b`: `x += ω D⁻¹ (b − A x)`.
+    fn jacobi(&mut self, zero_start: bool) {
+        if zero_start {
+            for ((x, b), d) in self.x.iter_mut().zip(&self.b).zip(&self.dinv) {
+                *x = MG_OMEGA * d * b;
+            }
+            return;
+        }
+        let mut r = std::mem::take(&mut self.r);
+        {
+            let (x, b, dinv) = (&self.x, &self.b, &self.dinv);
+            self.apply(x, &mut r, |k, ax| x[k] + MG_OMEGA * dinv[k] * (b[k] - ax));
+        }
+        self.r = std::mem::replace(&mut self.x, r);
+    }
+
+    /// The 2×2 aggregation of this grid: the Galerkin operator of a piecewise-constant
+    /// prolongation (data weights summed over the block, the fine edges cut by a block boundary
+    /// summed into the coarse edge).
+    fn coarsen(&self) -> MgLevel {
+        let (w, h) = (self.w, self.h);
+        let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));
+        let mut c = MgLevel::new(cw, ch);
+        self.coarsen_wd_into(&mut c);
+        let (ax, ay) = (&self.ax, &self.ay);
+        par_rows(&mut c.ax, cw, 1, |yy, row| {
+            for y in 2 * yy..(2 * yy + 2).min(h) {
+                for (xx, o) in row.iter_mut().enumerate() {
+                    if xx + 1 < cw {
+                        *o += ax[y * w + 2 * xx + 1];
+                    }
+                }
+            }
+        });
+        par_rows(&mut c.ay, cw, 1, |yy, row| {
+            if yy + 1 < ch {
+                let y = 2 * yy + 1;
+                for (xx, o) in row.iter_mut().enumerate() {
+                    *o = ay[y * w..y * w + w][2 * xx..(2 * xx + 2).min(w)].iter().sum::<f32>();
+                }
+            }
+        });
+        c
+    }
+
+    /// The data weights of the coarse grid `c` from this grid's (after a reweighting; the edges
+    /// do not change).
+    fn coarsen_wd_into(&self, c: &mut MgLevel) {
+        let (w, h, cw) = (self.w, self.h, c.w);
+        let wd = &self.wd;
+        par_rows(&mut c.wd, cw, 1, |yy, row| {
+            row.fill(0.0);
+            for y in 2 * yy..(2 * yy + 2).min(h) {
+                for (xx, o) in row.iter_mut().enumerate() {
+                    *o += wd[y * w..y * w + w][2 * xx..(2 * xx + 2).min(w)].iter().sum::<f32>();
+                }
+            }
+        });
+    }
+}
+
+/// `x += P x_c`: the coarse correction injected (piecewise constant).
+fn prolong_add(x: &mut [f32], w: usize, xc: &[f32], cw: usize) {
+    par_rows(x, w, 1, |y, row| {
+        let c = &xc[(y / 2) * cw..(y / 2) * cw + cw];
+        for (i, o) in row.iter_mut().enumerate() {
+            *o += c[i / 2];
+        }
+    });
+}
+
+/// `b_c = Pᵀ r`: the residual summed over each block.
+fn restrict(r: &[f32], w: usize, h: usize, bc: &mut [f32], cw: usize) {
+    par_rows(bc, cw, 1, |yy, row| {
+        row.fill(0.0);
+        for y in 2 * yy..(2 * yy + 2).min(h) {
+            let s = &r[y * w..y * w + w];
+            for (xx, o) in row.iter_mut().enumerate() {
+                *o += s[2 * xx..(2 * xx + 2).min(w)].iter().sum::<f32>();
+            }
+        }
+    });
+}
+
+/// One V-cycle from `levels[0]` (whose `b` is set) into its `x`.
+fn vcycle(levels: &mut [MgLevel]) {
+    let Some((top, rest)) = levels.split_first_mut() else { return };
+    let Some(next) = rest.first_mut() else {
+        for k in 0..MG_COARSE {
+            top.jacobi(k == 0);
+        }
+        return;
+    };
+    for k in 0..MG_PRE {
+        top.jacobi(k == 0);
+    }
+    {
+        let mut r = std::mem::take(&mut top.r);
+        let (x, b) = (&top.x, &top.b);
+        top.apply(x, &mut r, |k, ax| b[k] - ax);
+        top.r = r;
+    }
+    restrict(&top.r, top.w, top.h, &mut next.b, next.w);
+    vcycle(rest);
+    let Some(next) = rest.first() else { return };
+    prolong_add(&mut top.x, top.w, &next.x, next.w);
+    for _ in 0..MG_POST {
+        top.jacobi(false);
+    }
+}
+
+/// Edge-aware WLS: `argmin_u Σ w_p (u_p − d_p)² + λ Σ a_pq (u_p − u_q)²`, the 2-D system
+/// `(W + λL) u = W d` solved by conjugate gradients from the separable sweeps' guess,
+/// preconditioned by one multigrid V-cycle (2×2 aggregation, damped Jacobi), so the low modes
+/// converge where the confidence is low over a large area (a flat wall). The solver keeps its
+/// hierarchy between solves, so a reweighting costs no rebuild.
+struct WlsSolver {
+    w: usize,
+    h: usize,
+    lambda: f32,
+    /// Edge weights `exp(−|ΔI| / σ)` (without λ), for the separable sweeps.
+    ex: Vec<f32>,
+    ey: Vec<f32>,
+    levels: Vec<MgLevel>,
+}
+
+impl WlsSolver {
+    fn new(guide: &[f32], w: usize, h: usize, lambda: f32, sigma_c: f32) -> WlsSolver {
+        let (ex, ey) = edge_weights(guide, w, h, sigma_c);
+        let mut top = MgLevel::new(w, h);
+        for (a, e) in top.ax.iter_mut().zip(&ex) {
+            *a = lambda * e;
+        }
+        for (a, e) in top.ay.iter_mut().zip(&ey) {
+            *a = lambda * e;
+        }
+        let mut levels = vec![top];
+        while levels.last().is_some_and(|l| l.w.max(l.h) > MG_MIN) {
+            let Some(last) = levels.last() else { break };
+            let c = last.coarsen();
+            levels.push(c);
+        }
+        WlsSolver { w, h, lambda, ex, ey, levels }
+    }
+
+    /// The data weights: the confidence (plus a floor so the system is definite where nothing
+    /// is known), aggregated down the hierarchy.
+    fn set_weights(&mut self, conf: &[f32]) {
+        const EPS_DATA: f32 = 1e-4;
+        if let Some(top) = self.levels.first_mut() {
+            for (w, c) in top.wd.iter_mut().zip(conf) {
+                *w = c.max(0.0) + EPS_DATA;
+            }
+        }
+        for l in 0..self.levels.len() {
+            if l > 0 {
+                let (fine, coarse) = self.levels.split_at_mut(l);
+                if let (Some(f), Some(c)) = (fine.last(), coarse.first_mut()) {
+                    f.coarsen_wd_into(c);
+                }
+            }
+            self.levels[l].set_dinv();
+        }
+    }
+
+    /// Solve for the data `d`: the solution and its final relative residual.
+    fn solve(&mut self, d: &[f32], max_iters: usize) -> (Vec<f32>, f32) {
+        let (w, h, lambda) = (self.w, self.h, self.lambda);
+        let n = w * h;
+        let Some(top) = self.levels.first() else { return (vec![0.0; n], 0.0) };
+        let mut u = sweeps(d, &top.wd, &self.ex, &self.ey, w, h, lambda);
+        if w == 1 || h == 1 || n == 0 {
+            return (u, 0.0);
+        }
+        let dot = |a: &[f32], b: &[f32]| -> f64 { a.iter().zip(b).map(|(x, y)| f64::from(*x) * f64::from(*y)).sum() };
+        let b: Vec<f32> = top.wd.iter().zip(d).map(|(w, d)| w * d).collect();
+        let bnorm = dot(&b, &b).sqrt().max(1e-30);
+        let mut r = vec![0.0f32; n];
+        top.apply(&u, &mut r, |k, au| b[k] - au);
+        let precond = |levels: &mut [MgLevel], r: &[f32], z: &mut [f32]| {
+            if let Some(top) = levels.first_mut() {
+                top.b.copy_from_slice(r);
+            }
+            vcycle(levels);
+            if let Some(top) = levels.first() {
+                z.copy_from_slice(&top.x);
+            }
+        };
+        let mut z = vec![0.0f32; n];
+        precond(&mut self.levels, &r, &mut z);
+        let mut p = z.clone();
+        let mut ap = vec![0.0f32; n];
+        let mut rz = dot(&r, &z);
+        let mut rel = (dot(&r, &r).sqrt() / bnorm) as f32;
+        for _ in 0..max_iters {
+            if rel < 1e-5 {
+                break;
+            }
+            let Some(top) = self.levels.first() else { break };
+            top.apply(&p, &mut ap, |_, v| v);
+            let pap = dot(&p, &ap);
+            if pap <= 0.0 {
+                break;
+            }
+            let alpha = (rz / pap) as f32;
+            for (u, p) in u.iter_mut().zip(&p) {
+                *u += alpha * p;
+            }
+            for (r, ap) in r.iter_mut().zip(&ap) {
+                *r -= alpha * ap;
+            }
+            rel = (dot(&r, &r).sqrt() / bnorm) as f32;
+            if rel < 1e-5 {
+                break;
+            }
+            precond(&mut self.levels, &r, &mut z);
+            let rz_new = dot(&r, &z);
+            let beta = (rz_new / rz) as f32;
+            rz = rz_new;
+            for (p, z) in p.iter_mut().zip(&z) {
+                *p = z + beta * *p;
+            }
+        }
+        (u, rel)
+    }
+}
+
+/// Conjugate-gradient iteration cap of the regularisation.
+const CG_ITERS: usize = 200;
+
+/// Depth from focus over the `n` layers' luminance planes `luma` (`w × h`, aligned), guided by
+/// the all-in-focus luminance `guide` of the same size. Without layers, or when `guide` or a
+/// plane is not `w × h` long, the map is empty: depth 0 and confidence 0 everywhere.
+pub fn depth_from_focus(luma: &[&[f32]], guide: &[f32], w: usize, h: usize, p: &DepthParams) -> DepthMap {
+    let n = luma.len();
+    let empty = n == 0 || w == 0 || h == 0 || guide.len() != w * h || luma.iter().any(|l| l.len() != w * h);
+    if empty {
+        return DepthMap { depth: vec![0.0; w * h], conf: vec![0.0; w * h], w, h };
+    }
+    let k = 1usize << p.scale.min(8);
+    let (g, dw, dh) = block_mean(guide, w, h, k);
+    let gf = GuidedFilter::new(g.clone(), dw, dh, p.agg_radius, p.agg_eps);
+    let mut tracker = PeakTracker::new(dw * dh);
+    for l in luma {
+        let slice = block_mean(&focus_measure(l, w, h, p.r_in, p.r_out), w, h, k).0;
+        if p.agg_radius > 0 {
+            // The guided filter can undershoot; the profile statistics assume ≥ 0.
+            let agg: Vec<f32> = gf.filter(&slice).into_iter().map(|v| v.max(0.0)).collect();
+            tracker.push(&agg);
+        } else {
+            tracker.push(&slice);
+        }
+    }
+    let (depth_w, mut conf) = tracker.finish(p.gate);
+    let depth_w = median3(&depth_w, dw, dh);
+    normalize_conf(&mut conf);
+    let depth_w = if p.lambda > 0.0 {
+        let mut solver = WlsSolver::new(&g, dw, dh, p.lambda, p.sigma_c);
+        solver.set_weights(&conf);
+        let (u, _) = solver.solve(&depth_w, CG_ITERS);
+        if p.robust > 0.0 {
+            // One reweighted step with a Huber loss on the data residual.
+            let wd2: Vec<f32> = conf.iter().zip(&depth_w).zip(&u).map(|((c, d), u)| c * (p.robust / (d - u).abs().max(1e-6)).min(1.0)).collect();
+            solver.set_weights(&wd2);
+            solver.solve(&depth_w, CG_ITERS).0
+        } else {
+            u
+        }
+    } else {
+        depth_w
+    };
+    let max_d = (n - 1) as f32;
+    let up = GuidedFilter::new(g, dw, dh, 2, 1e-2);
+    let depth: Vec<f32> = if k == 1 {
+        up.filter(&depth_w)
+    } else {
+        let (a, b) = up.coeffs(&depth_w);
+        let a = upsample_bilinear(&a, dw, dh, w, h, k);
+        let b = upsample_bilinear(&b, dw, dh, w, h, k);
+        (0..w * h).map(|i| a[i] * guide[i] + b[i]).collect()
+    };
+    let depth = depth.into_iter().map(|v| v.clamp(0.0, max_d)).collect();
+    let conf = if k == 1 { conf } else { upsample_bilinear(&conf, dw, dh, w, h, k) };
+    DepthMap { depth, conf, w, h }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn lcg(seed: &mut u64) -> f32 {
+        *seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        ((*seed >> 33) % 10000) as f32 / 10000.0
+    }
+
+    #[test]
+    fn box_filter_matches_the_naive_window() {
+        let (w, h, r) = (23, 17, 3);
+        let mut s = 5u64;
+        let src: Vec<f32> = (0..w * h).map(|_| lcg(&mut s)).collect();
+        let m = BoxFilter::new(w, h, r).mean(&src);
+        for y in 0..h {
+            for x in 0..w {
+                let (mut acc, mut cnt) = (0.0, 0.0);
+                for yy in y.saturating_sub(r)..(y + r + 1).min(h) {
+                    for xx in x.saturating_sub(r)..(x + r + 1).min(w) {
+                        acc += src[yy * w + xx];
+                        cnt += 1.0;
+                    }
+                }
+                assert!((m[y * w + x] - acc / cnt).abs() < 1e-4, "({x},{y})");
+            }
+        }
+    }
+
+    #[test]
+    fn guided_filter_with_a_flat_guide_is_a_double_box_mean() {
+        let (w, h) = (40, 30);
+        let mut s = 9u64;
+        let p: Vec<f32> = (0..w * h).map(|_| lcg(&mut s)).collect();
+        let q = GuidedFilter::new(vec![0.5; w * h], w, h, 2, 1e-3).filter(&p);
+        let bf = BoxFilter::new(w, h, 2);
+        let m = bf.mean(&bf.mean(&p));
+        assert!(q.iter().zip(&m).all(|(a, b)| (a - b).abs() < 1e-4));
+    }
+
+    #[test]
+    fn ring_difference_is_zero_mean_and_sees_texture() {
+        let taps = rdf_taps(1, 3);
+        assert!(taps.iter().map(|t| t.2).sum::<f32>().abs() < 1e-6);
+        let (w, h) = (32, 32);
+        assert!(focus_measure(&vec![0.4; w * h], w, h, 1, 3).iter().all(|v| v.abs() < 1e-6));
+        let check: Vec<f32> = (0..w * h).map(|i| if ((i % w) / 2 + (i / w) / 2).is_multiple_of(2) { 0.2 } else { 0.8 }).collect();
+        assert!(focus_measure(&check, w, h, 1, 3).iter().cloned().fold(0.0, f32::max) > 0.1);
+        let (m, dw, dh) = block_mean(&check, w, h, 2);
+        assert_eq!((dw, dh, m.len()), (16, 16, 256));
+        assert!(m.iter().all(|v| (v - 0.2).abs() < 1e-6 || (v - 0.8).abs() < 1e-6));
+        let up = upsample_bilinear(&m, dw, dh, w, h, 2);
+        assert_eq!(up.len(), w * h);
+    }
+
+    #[test]
+    fn peak_search_interpolates_between_layers() {
+        // A profile peaking between layers 2 and 3 (log-parabola), one flat profile.
+        let mut t = PeakTracker::new(2);
+        for m in 0..6 {
+            let v = (-((m as f32 - 2.4).powi(2)) / 2.0).exp();
+            t.push(&[v, 0.1]);
+        }
+        let (d, c) = t.finish(0.0);
+        assert!((d[0] - 2.4).abs() < 0.05, "{d:?}");
+        assert!(c[0] > 0.5 && c[1] < 1e-6, "{c:?}");
+    }
+
+    #[test]
+    fn smoothing_fills_holes_and_respects_edges() {
+        let (w, h) = (40, 20);
+        // A guide with a hard edge at x = 20; data known only at two pixels, one per side.
+        let guide: Vec<f32> = (0..w * h).map(|i| if i % w < 20 { 0.0 } else { 1.0 }).collect();
+        let mut d = vec![0.0f32; w * h];
+        let mut wd = vec![1e-4f32; w * h];
+        (d[10 * w + 5], wd[10 * w + 5]) = (1.0, 1.0);
+        (d[10 * w + 35], wd[10 * w + 35]) = (5.0, 1.0);
+        let mut solver = WlsSolver::new(&guide, w, h, 3.0, 0.04);
+        solver.set_weights(&wd);
+        let (u, rel) = solver.solve(&d, CG_ITERS);
+        assert!(rel < 1e-4, "residual {rel}");
+        // Each side follows its own sample (the data floor on the unknown pixels pulls a little
+        // toward zero), and the edge keeps them apart.
+        assert!((u[3 * w + 15] - 1.0).abs() < 0.15, "left side follows its sample: {}", u[3 * w + 15]);
+        assert!((u[15 * w + 25] - 5.0).abs() < 0.6, "right side follows its sample: {}", u[15 * w + 25]);
+        assert!(u[10 * w + 19] < 1.5 && u[10 * w + 20] > 4.0, "the edge holds: {} | {}", u[10 * w + 19], u[10 * w + 20]);
+        // The sweeps alone leave the holes near zero; the solve fills them.
+        let guess = sweeps(&d, &wd, &solver.ex, &solver.ey, w, h, 3.0);
+        assert!(guess[3 * w + 15] < 0.5);
+        assert_eq!(median3(&[0.5; 9], 3, 3)[4], 0.5);
+    }
+
+    /// Three layers: the left third sharp in layer 0, the middle in 1, the right in 2. The depth
+    /// map says so, sub-layer in between, with high confidence on the texture.
+    #[test]
+    fn depth_from_focus_finds_the_sharp_layer() {
+        let (w, h) = (96, 48);
+        let texture = |x: usize, y: usize| if ((x / 2) + (y / 2)).is_multiple_of(2) { 0.2 } else { 0.8 };
+        let flat = 0.5;
+        let layers: Vec<Vec<f32>> = (0..3).map(|k| (0..w * h).map(|i| if (i % w) / 32 == k { texture(i % w, i / w) } else { flat }).collect()).collect();
+        let guide: Vec<f32> = (0..w * h).map(|i| texture(i % w, i / w)).collect();
+        let refs: Vec<&[f32]> = layers.iter().map(Vec::as_slice).collect();
+        let dm = depth_from_focus(&refs, &guide, w, h, &DepthParams::default());
+        assert_eq!((dm.w, dm.h, dm.depth.len()), (w, h, w * h));
+        for (x, want) in [(8, 0.0), (48, 1.0), (88, 2.0)] {
+            let d = dm.depth[24 * w + x];
+            assert!((d - want).abs() < 0.35, "x {x}: depth {d}, want {want}");
+            assert!(dm.conf[24 * w + x] > 0.3, "x {x}: conf {}", dm.conf[24 * w + x]);
+        }
+        assert!(dm.depth.iter().all(|v| (0.0..=2.0).contains(v)));
+        // Degenerate inputs are fine.
+        assert_eq!(depth_from_focus(&[], &guide, w, h, &DepthParams::default()).depth, vec![0.0; w * h]);
+        // A guide or a plane of the wrong length is no input: the empty map, never a panic.
+        let empty = DepthMap { depth: vec![0.0; w * h], conf: vec![0.0; w * h], w, h };
+        assert_eq!(depth_from_focus(&refs, &guide[1..], w, h, &DepthParams::default()), empty);
+        let short = &refs[0][..w * h - 1];
+        assert_eq!(depth_from_focus(&[refs[0], short], &guide, w, h, &DepthParams::default()), empty);
+        assert_eq!(depth_from_focus(&refs, &guide, w + 1, h, &DepthParams::default()).w, w + 1);
+        let one = depth_from_focus(&refs[..1], &guide, w, h, &DepthParams::default());
+        assert!(one.depth.iter().all(|v| *v == 0.0));
+    }
+}
diff --git a/crates/algo/src/distort.rs b/crates/algo/src/distort.rs
index 0c83085e75..664169afa4 100644
--- a/crates/algo/src/distort.rs
+++ b/crates/algo/src/distort.rs
@@ -160,19 +160,30 @@ pub(crate) fn polar(src: &Image, out: Rect, ctx: &Ctx, mode: PolarMode) -> Vec<f
     let (w, h) = (b.width().max(1) as f32, b.height().max(1) as f32);
     let (cx, cy) = (b.x0 as f32 + w / 2.0, b.y0 as f32 + h / 2.0);
     let rmax = w.min(h) / 2.0;
-    remap(src, out, ctx, Edge::Transparent, |x, y| match mode {
+    // Photoshop 27.11: the angle runs counter-clockwise from 12 o'clock, and points past the
+    // source's edge repeat its edge pixels (the corners outside the circle are filled, not empty).
+    // Photoshop evaluates the map at pixel corners and reads the source at the resulting index
+    // (half a pixel from `remap`'s centres): within 2 levels on a whole test chart in both directions.
+    remap(src, out, ctx, Edge::Repeat, |x, y| polar_map(x - 0.5, y - 0.5, mode, b, (w, h), (cx, cy), rmax))
+}
+
+fn polar_map(x: f32, y: f32, mode: PolarMode, b: Rect, (w, h): (f32, f32), (cx, cy): (f32, f32), rmax: f32) -> (f32, f32) {
+    let (sx, sy) = match mode {
         PolarMode::RectangularToPolar => {
-            // Output is polar: angle from 12 o'clock clockwise → source x,
-            // radius → source y.
+            // Output is polar: angle from 12 o'clock counter-clockwise → source x, radius → source y.
             let (dx, dy) = (x - cx, y - cy);
-            let theta = dx.atan2(-dy).rem_euclid(std::f32::consts::TAU);
+            // The 12 o'clock seam itself reads the source's right edge (360°, not 0°).
+            let theta = (-dx).atan2(-dy);
+            let theta = if theta <= 0.0 { theta + std::f32::consts::TAU } else { theta };
             let r = (dx * dx + dy * dy).sqrt();
             (b.x0 as f32 + theta / std::f32::consts::TAU * w, b.y0 as f32 + r / rmax * h)
         }
         PolarMode::PolarToRectangular => {
-            let theta = (x - b.x0 as f32) / w * std::f32::consts::TAU;
+            // Photoshop's angle is one column ahead of its radius row (fitted exactly).
+            let theta = (x + 1.0 - b.x0 as f32) / w * std::f32::consts::TAU;
             let r = (y - b.y0 as f32) / h * rmax;
-            (cx + r * theta.sin(), cy - r * theta.cos())
+            (cx - r * theta.sin(), cy - r * theta.cos())
         }
-    })
+    };
+    (sx + 0.5, sy + 0.5)
 }
diff --git a/crates/algo/src/erase.rs b/crates/algo/src/erase.rs
index 6f644d1191..75b2a4246c 100644
--- a/crates/algo/src/erase.rs
+++ b/crates/algo/src/erase.rs
@@ -18,7 +18,8 @@ pub fn magic_erase(target: &mut Surface, region: &Region, amount: f32, selection
     let amount = if amount.is_finite() { amount.clamp(0.0, 1.0) } else { 0.0 };
     let bbox = region.bbox;
     let bw = bbox.width() as usize;
-    if bbox.is_empty() || amount <= 0.0 || region.mask.len() != bw * bbox.height() as usize {
+    let Some(pixels) = bw.checked_mul(bbox.height() as usize) else { return Rect::EMPTY };
+    if bbox.is_empty() || amount <= 0.0 || region.mask.len() != pixels {
         return Rect::EMPTY;
     }
     let fmt = target.format();
@@ -147,6 +148,16 @@ mod tests {
         assert_eq!(l.rgba(5, 5), [1.0, 1.0, 1.0, 1.0]);
     }
 
+    #[test]
+    fn oversized_region_mask_is_rejected_without_overflow() {
+        let mut s = Surface::new(PixelFormat::RGBA8);
+        s.fill_rect(Rect::new(0, 0, 1, 1), &[1.0, 0.0, 0.0, 1.0]);
+        let before = s.pixel(0, 0);
+        let oversized = Region { bbox: Rect::new(i32::MIN, i32::MIN, i32::MAX, i32::MAX), mask: vec![255] };
+        assert_eq!(magic_erase(&mut s, &oversized, 1.0, None, None), Rect::EMPTY);
+        assert_eq!(s.pixel(0, 0), before);
+    }
+
     #[test]
     fn degenerate_inputs_do_nothing() {
         let mut s = Surface::new(PixelFormat::RGBA8);
diff --git a/crates/algo/src/inpaint.rs b/crates/algo/src/inpaint.rs
index 37e91da495..d7d43c032f 100644
--- a/crates/algo/src/inpaint.rs
+++ b/crates/algo/src/inpaint.rs
@@ -508,6 +508,9 @@ struct Solver<'a> {
     ctl: photocraft_raster::Interrupt<'a>,
 }
 
+/// A channel deviation under which a patch counts as flat for [`fit`] (about 5 levels of 255).
+const FLAT: f32 = 0.02;
+
 /// Gain and bias of one channel for target moments `(Σt, Σt²)` and source moments `(Σs, Σs²)`
 /// over `n` samples, within the limits.
 #[inline]
@@ -516,7 +519,20 @@ pub(crate) fn fit(a: Adapt, n: f32, st: f32, stt: f32, ss: f32, sss: f32) -> (f3
     let vt = (stt / n - mt * mt).max(0.0);
     let vs = (sss / n - ms * ms).max(0.0);
     let g = if vs > 1e-10 { (vt / vs).sqrt() } else { 1.0 };
-    let g = g.clamp(a.gain.0, a.gain.1);
+    let (mut lo, mut hi) = a.gain;
+    // Nearly flat patches of about the same colour (their means within the bias of each other):
+    // the ratio of their deviations is noise, so match the mean first, keeping the gain where the
+    // bias can still bring the source's mean to the target's. Gained about zero, a gain at its
+    // limit moved bright means further than the bias could bring back, and each channel by a
+    // different amount: a tinted blotch in a smooth gradient. Textured patches, and flat ones
+    // whose colours differ more (Content-Aware Move's Color), are fitted as before.
+    if vt.max(vs) < FLAT * FLAT && (mt - ms).abs() <= a.bias && ms > 1e-6 {
+        let (glo, ghi) = ((mt - a.bias) / ms, (mt + a.bias) / ms);
+        if glo.max(lo) <= ghi.min(hi) {
+            (lo, hi) = (glo.max(lo), ghi.min(hi));
+        }
+    }
+    let g = g.clamp(lo, hi);
     let b = (mt - g * ms).clamp(-a.bias, a.bias);
     (g, b)
 }
@@ -1959,6 +1975,21 @@ fn min_cut(across: usize, along: usize, err: impl Fn(usize, usize) -> f32) -> Ve
 mod tests {
     use super::*;
 
+    /// The mean is matched first: on a nearly flat bright patch with a noisy deviation ratio the
+    /// gain stays where the bias can still reach the target's mean.
+    #[test]
+    fn fit_matches_the_mean_before_the_contrast() {
+        let a = Adapt { gain: (0.9, 1.1), bias: 0.04 };
+        // Target mean 0.70, source mean 0.70; deviations 0.01 vs 0.004 (ratio 2.5).
+        let n = 25.0;
+        let (mt, ms, sdt, sds) = (0.70f32, 0.70f32, 0.01f32, 0.004f32);
+        let (g, b) = fit(a, n, mt * n, (sdt * sdt + mt * mt) * n, ms * n, (sds * sds + ms * ms) * n);
+        assert!((g * ms + b - mt).abs() < 1e-5, "mean {} vs {mt} (g {g}, b {b})", g * ms + b);
+        // Where the mean can't be reached anyway, the limits hold as before.
+        let (g, b) = fit(a, n, 0.2 * n, 0.04 * n, 0.9 * n, 0.81 * n);
+        assert!((a.gain.0..=a.gain.1).contains(&g) && b.abs() <= a.bias + 1e-6);
+    }
+
     /// Smooth gradient plus deterministic fine noise.
     fn texture(w: usize, h: usize) -> Vec<f32> {
         let mut rng = Rng::new(7);
diff --git a/crates/algo/src/lib.rs b/crates/algo/src/lib.rs
index ded4ad31a1..78dae7b06f 100644
--- a/crates/algo/src/lib.rs
+++ b/crates/algo/src/lib.rs
@@ -26,6 +26,7 @@ pub mod camera_raw;
 pub mod color_to_alpha;
 pub mod content_aware;
 mod denoise;
+pub mod dff;
 pub mod direct;
 mod distort;
 mod distort2;
@@ -552,7 +553,8 @@ impl FilterParams {
         let g = |sigma: f32| Halo::Radius((sigma.max(0.0) * 3.0).ceil() as i32 + 1);
         match self {
             FilterParams::GaussianBlur { radius } | FilterParams::HighPass { radius } => g(*radius),
-            FilterParams::UnsharpMask { radius, .. } | FilterParams::SmartSharpen { radius, .. } => g(*radius),
+            FilterParams::UnsharpMask { radius, .. } => Halo::Radius(sharpen::exact::halo(*radius)),
+            FilterParams::SmartSharpen { radius, .. } => g(*radius),
             FilterParams::BoxBlur { radius }
             | FilterParams::SurfaceBlur { radius, .. }
             | FilterParams::Median { radius }
@@ -740,7 +742,7 @@ pub fn kernel(params: &FilterParams, src: &Image, out: Rect, ctx: &Ctx) -> Vec<f
         FilterParams::Mosaic { cell_size } => stylize::mosaic(src, out, ctx, *cell_size),
         FilterParams::Emboss { angle, height, amount } => stylize::emboss(src, out, ctx, *angle, *height, *amount),
         FilterParams::FindEdges => stylize::find_edges(src, out, ctx),
-        FilterParams::Solarize => stylize::per_pixel(src, out, ctx, |v| if v > 0.5 { 1.0 - v } else { v }),
+        FilterParams::Solarize => stylize::solarize(src, out, ctx),
         FilterParams::Invert => stylize::per_pixel(src, out, ctx, |v| 1.0 - v),
         FilterParams::Desaturate => stylize::desaturate(src, out, ctx),
         FilterParams::Twirl { angle } => distort::twirl(src, out, ctx, *angle),
@@ -937,7 +939,8 @@ pub fn apply_in(surface: &Surface, params: &FilterParams, area: Rect, bounds: Re
 }
 
 /// [`apply_in`] that can be cancelled (checked before each tile) and reports progress per tile
-/// group. `None` when `ctl` was cancelled; the input surface is never modified.
+/// group. `None` when cancelled, or when a checked filter rejects geometry/allocation;
+/// the input surface is never modified.
 pub fn apply_in_with(
     surface: &Surface,
     params: &FilterParams,
@@ -969,13 +972,13 @@ pub fn apply_tiled(
     tile: i32,
     extent: Option<Rect>,
 ) -> Surface {
-    // Preserve the input if a checked Shape Blur allocation cannot be completed.
+    // Preserve the input if a checked filter allocation cannot be completed.
     apply_tiled_with(surface, params, area, bounds, selection, tile, extent, &photocraft_raster::Interrupt::NONE).unwrap_or_else(|| surface.clone())
 }
 
 /// [`apply_tiled`] with cancellation (checked before each tile, so a cancel takes effect within
 /// one tile's work) and progress (after each group of tiles). `None` when cancelled,
-/// or when Shape Blur cannot allocate a tile.
+/// or when a checked filter rejects geometry or cannot allocate a tile.
 #[allow(clippy::too_many_arguments)]
 pub fn apply_tiled_with(
     surface: &Surface,
@@ -1000,15 +1003,27 @@ fn apply_tiled_with_impl(
     tile: i32,
     extent: Option<Rect>,
     ctl: &photocraft_raster::Interrupt,
-    prepare_radial: bool,
+    prepare_fast_paths: bool,
 ) -> Option<Surface> {
     if ctl.cancelled() {
         return None;
     }
+    if let FilterParams::UnsharpMask { amount, radius, threshold } = *params
+        && (!sharpen::exact::valid_params(amount, radius, threshold)
+            || !sharpen::exact::valid_area(area)
+            || !sharpen::exact::valid_area(bounds)
+            || extent.is_some_and(|e| !sharpen::exact::valid_area(e)))
+    {
+        return None;
+    }
     let mut out = surface.clone();
     if area.is_empty() {
         return Some(out);
     }
+    #[cfg(not(target_arch = "wasm32"))]
+    if prepare_fast_paths && let Some(result) = sharpen::fft::apply(surface, params, area, selection, extent, ctl) {
+        return result;
+    }
     if let Some(boxes) = blur::box_widths(params) {
         return apply_box_blur(out, surface, area, extent, selection, &boxes, ctl);
     }
@@ -1016,15 +1031,15 @@ fn apply_tiled_with_impl(
         return result;
     }
     // The public tile override must not create a zero-step loop or an
-    // unbounded Shape Blur scratch buffer. Standard automatic tiles are unchanged.
-    let tile = if matches!(params, FilterParams::ShapeBlur { .. }) { tile.clamp(1, 2048) } else { tile };
+    // unbounded scratch buffer for these checked filters. Automatic tiles are unchanged.
+    let tile = if matches!(params, FilterParams::ShapeBlur { .. } | FilterParams::UnsharpMask { .. }) { tile.clamp(1, 2048) } else { tile };
     let fmt = surface.format();
     let ctx = Ctx { bounds, mode: fmt.mode, alpha: fmt.alpha };
     // Prepare the immutable sample transforms once for all output tiles. If the
     // optional table allocation fails, use the existing sampler; only a real
     // cancellation returns None. Source reads keep their upstream semantics.
     let radial = match params {
-        FilterParams::RadialBlur { amount, method, quality, center_x, center_y } if prepare_radial => {
+        FilterParams::RadialBlur { amount, method, quality, center_x, center_y } if prepare_fast_paths => {
             blur::radial::Plan::for_area(bounds, *amount, *method, *quality, (*center_x, *center_y), area, ctl)
         }
         _ => None,
@@ -1033,6 +1048,17 @@ fn apply_tiled_with_impl(
         return None;
     }
     let halo = params.halo_for(bounds);
+    if matches!(params, FilterParams::UnsharpMask { .. }) {
+        let Halo::Radius(reach) = halo else { return None };
+        let (w, h) = (area.width().min(tile as u32) as usize, area.height().min(tile as u32) as usize);
+        let read_samples = w.checked_add(2 * reach as usize)?.checked_mul(h.checked_add(2 * reach as usize)?)?.checked_mul(fmt.channels())?;
+        let tile_count = u64::from(area.width()).div_ceil(tile as u64).checked_mul(u64::from(area.height()).div_ceil(tile as u64))?;
+        // Reject hostile source-window sizes before Image::read allocates them.
+        // Ordinary filter parameters and automatic tiles fit these bounds.
+        if read_samples > 512 * 1024 * 1024 || read_samples.checked_mul(std::mem::size_of::<f32>())? > isize::MAX as usize || tile_count > 1_048_576 {
+            return None;
+        }
+    }
     let shared = (halo == Halo::Bounds).then(|| Image::read(surface, bounds.union(&area)));
     // Shape rasterization depends only on params, not on a tile's pixels.
     let shape = match params {
@@ -1090,12 +1116,15 @@ fn apply_tiled_with_impl(
                 None if ctl.cancelled() => None,
                 None => Some(kernel(params, src, *t, &ctx)),
             },
-            (None, None) => Some(kernel(params, src, *t, &ctx)),
+            (None, None) => match *params {
+                FilterParams::UnsharpMask { amount, radius, threshold } => sharpen::exact::run(src, *t, &ctx, amount, radius, threshold, ctl),
+                _ => Some(kernel(params, src, *t, &ctx)),
+            },
         }) else {
             return (*t, Vec::new());
         };
         if let Some(sel) = selection {
-            mix_selection(&mut data, *t, sel, src);
+            mix_selection(&mut data, *t, sel, src, fmt.alpha);
         }
         tick();
         (*t, data)
@@ -1123,9 +1152,11 @@ fn apply_tiled_with_impl(
         if ctl.cancelled() {
             return None;
         }
-        // Shape Blur can reject malformed geometry or an allocation failure.
+        // Checked filters can reject malformed geometry or an allocation failure.
         // Do not hand an incomplete tile to Surface::write_region.
-        if shape.is_some() && results.iter().any(|(t, data)| data.len() != t.width() as usize * t.height() as usize * fmt.channels()) {
+        if (shape.is_some() || matches!(params, FilterParams::UnsharpMask { .. }))
+            && results.iter().any(|(t, data)| data.len() != t.width() as usize * t.height() as usize * fmt.channels())
+        {
             return None;
         }
         for (t, data) in results {
@@ -1179,7 +1210,7 @@ fn apply_box_blur(
         let write = |(s, v): &mut (Surface, Vec<blur::Strip>)| {
             for (t, data) in v.iter_mut() {
                 if let Some(sel) = selection {
-                    mix_selection(data, *t, sel, &Image::read(surface, *t));
+                    mix_selection(data, *t, sel, &Image::read(surface, *t), fmt.alpha);
                 }
                 s.write_region(*t, data);
             }
@@ -1202,15 +1233,40 @@ fn apply_box_blur(
 }
 
 /// Mixes filtered `data` for `t` back toward the original pixels in `orig` by the selection's
-/// coverage (channel 0 of `sel`).
-fn mix_selection(data: &mut [f32], t: Rect, sel: &Surface, orig: &Image) {
+/// coverage (channel 0 of `sel`). Changing alpha requires premultiplied colour interpolation;
+/// otherwise hidden colours leak into feathered edges and alpha-removing filters darken them.
+fn mix_selection(data: &mut [f32], t: Rect, sel: &Surface, orig: &Image, alpha: bool) {
     let w = t.width() as usize;
+    // The selection over `t` read once, not a lookup and an allocation per pixel (#4533).
+    let mask = sel.read_region(t);
+    let sc = sel.channels().max(1);
     for (i, px) in data.chunks_exact_mut(orig.ch.max(1)).enumerate() {
         let (x, y) = (t.x0 + (i % w) as i32, t.y0 + (i / w) as i32);
-        let k = sel.pixel(x, y)[0].clamp(0.0, 1.0);
+        let k = mask.get(i * sc).copied().unwrap_or(0.0).clamp(0.0, 1.0);
         if k >= 1.0 {
             continue;
         }
+        if k <= 0.0 {
+            for (c, v) in px.iter_mut().enumerate() {
+                *v = orig.get(x, y, c);
+            }
+            continue;
+        }
+        if alpha {
+            let a = px.len() - 1;
+            let original_alpha = orig.get(x, y, a);
+            let filtered_alpha = px[a];
+            if original_alpha != filtered_alpha {
+                let mixed_alpha = original_alpha + (filtered_alpha - original_alpha) * k;
+                let original_weight = original_alpha * (1.0 - k);
+                let filtered_weight = filtered_alpha * k;
+                for (c, v) in px[..a].iter_mut().enumerate() {
+                    *v = if mixed_alpha > 0.0 { (orig.get(x, y, c) * original_weight + *v * filtered_weight) / mixed_alpha } else { 0.0 };
+                }
+                px[a] = mixed_alpha;
+                continue;
+            }
+        }
         for (c, v) in px.iter_mut().enumerate() {
             let o = orig.get(x, y, c);
             *v = o + (*v - o) * k;
@@ -1229,6 +1285,9 @@ mod tests_ext;
 #[cfg(test)]
 mod tests_mosaic;
 
+#[cfg(test)]
+mod tests_selection_mix;
+
 /// The current upstream sampler through the identical source/selection/tile pipeline.
 #[cfg(test)]
 #[allow(clippy::too_many_arguments)]
diff --git a/crates/algo/src/liquify.rs b/crates/algo/src/liquify.rs
index 7e3bb60644..adbca8680f 100644
--- a/crates/algo/src/liquify.rs
+++ b/crates/algo/src/liquify.rs
@@ -154,7 +154,7 @@ impl LiquifyStroke {
 }
 
 /// The displacement field plus the freeze mask, over `bounds` (document pixels).
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug)]
 pub struct LiquifyField {
     pub bounds: Rect,
     /// Document pixels per field node.
@@ -165,6 +165,38 @@ pub struct LiquifyField {
     pub d: Vec<[f32; 2]>,
     /// Freeze mask per node (0 = free, 1 = frozen).
     pub freeze: Vec<f32>,
+    /// Where the brush stroke in progress stands, so dab spacing runs on across its segments.
+    cursor: Option<StrokeCursor>,
+}
+
+/// Two fields are equal when their displacement and freeze mask are: the stroke cursor is
+/// transient brush state, not part of the result.
+impl PartialEq for LiquifyField {
+    fn eq(&self, o: &Self) -> bool {
+        self.bounds == o.bounds && self.cell == o.cell && self.w == o.w && self.h == o.h && self.d == o.d && self.freeze == o.freeze
+    }
+}
+
+/// The brush stroke in progress: the point its last segment ended at, its last dab and how far
+/// the brush has travelled along the path since that dab.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct StrokeCursor {
+    end: [f64; 2],
+    last_dab: [f64; 2],
+    carry: f64,
+}
+
+/// Distance between dabs along a stroke for brush radius `r`: a twentieth of the radius, so a
+/// drag is many small pushes and its edge stays smooth.
+fn dab_spacing(r: f64) -> f64 {
+    (r * 0.05).max(0.5)
+}
+
+/// Per-dab strength of a stationary tool (Twirl, Pucker, Bloat, Reconstruct, Smooth, Freeze,
+/// Thaw) while it moves: scaled to the spacing so its effect per distance travelled stays what it
+/// was with dabs a fifth of the radius apart.
+fn moving_weight(r: f64) -> f64 {
+    dab_spacing(r) / (r * 0.2).max(0.5)
 }
 
 /// The default field resolution for `bounds`: 2 px per node up to 4 MP, 4 px beyond.
@@ -177,7 +209,7 @@ impl LiquifyField {
         let cell = cell.clamp(1.0, 64.0);
         let w = (f64::from(bounds.width()) / cell).ceil() as usize + 2;
         let h = (f64::from(bounds.height()) / cell).ceil() as usize + 2;
-        LiquifyField { bounds, cell, w, h, d: vec![[0.0; 2]; w * h], freeze: vec![0.0; w * h] }
+        LiquifyField { bounds, cell, w, h, d: vec![[0.0; 2]; w * h], freeze: vec![0.0; w * h], cursor: None }
     }
 
     /// Document position of node (i, j) (node 0 sits on the first pixel centre).
@@ -220,6 +252,7 @@ impl LiquifyField {
 
     /// Applies one stroke. Returns the document rectangle whose output changed.
     pub fn apply_stroke(&mut self, s: &LiquifyStroke) -> Rect {
+        self.cursor = None;
         match s.tool {
             LiquifyTool::LassoMask => return self.apply_lasso(s),
             LiquifyTool::ReconstructAll => {
@@ -306,77 +339,120 @@ impl LiquifyField {
     /// callers use this plus [`Self::stroke_segment`] per new point, which is exactly what
     /// [`Self::apply_stroke`] does with the whole point list.
     pub fn stroke_begin(&mut self, s: &LiquifyStroke, p: [f64; 3]) -> Rect {
-        if s.tool.is_stationary() && !s.tool.is_global() { self.dab(s, [p[0], p[1]], [0.0, 0.0], p[2].clamp(0.0, 1.0)) } else { Rect::EMPTY }
+        self.cursor = Some(StrokeCursor { end: [p[0], p[1]], last_dab: [p[0], p[1]], carry: 0.0 });
+        if s.tool.is_stationary() && !s.tool.is_global() { self.dab(s, [p[0], p[1]], [0.0, 0.0], p[2].clamp(0.0, 1.0), 1.0) } else { Rect::EMPTY }
     }
 
-    /// Continues a stroke from `a` to `b`: dabs every fifth of the brush radius (a stationary
-    /// tool held still dabs once at `b`).
+    /// Continues a stroke from `a` to `b`. Dabs fall every [`dab_spacing`] of distance travelled
+    /// along the whole stroke, carried from one segment to the next, so the result is the same
+    /// however finely the pointer path was sampled (a fast and a slow mouse give one warp). A
+    /// stationary tool held still dabs once at `b`. When `a` is not where the previous segment
+    /// ended, the stroke starts afresh at `a`.
     pub fn stroke_segment(&mut self, s: &LiquifyStroke, a: [f64; 3], b: [f64; 3]) -> Rect {
+        self.walk_segment(s, a, b, true)
+    }
+
+    /// [`Self::stroke_segment`]; `skip` leaves out the dabs that cannot reach a field node (they
+    /// would change nothing), which tests compare with the full walk.
+    fn walk_segment(&mut self, s: &LiquifyStroke, a: [f64; 3], b: [f64; 3], skip: bool) -> Rect {
         let mut dirty = Rect::EMPTY;
         let (pa, pb) = (a[2].clamp(0.0, 1.0), b[2].clamp(0.0, 1.0));
-        let len = (b[0] - a[0]).hypot(b[1] - a[1]);
+        let stationary = s.tool.is_stationary();
+        let cur = match self.cursor {
+            Some(c) if c.end == [a[0], a[1]] => c,
+            _ => StrokeCursor { end: [a[0], a[1]], last_dab: [a[0], a[1]], carry: 0.0 },
+        };
+        let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
+        let len = dx.hypot(dy);
         if len == 0.0 {
-            return if s.tool.is_stationary() { self.dab(s, [b[0], b[1]], [0.0, 0.0], pb) } else { dirty };
+            self.cursor = Some(cur);
+            return if stationary { self.dab(s, [b[0], b[1]], [0.0, 0.0], pb, 1.0) } else { dirty };
+        }
+        // NaN or a length that overflowed: nothing sensible to walk; the next segment restarts.
+        if !len.is_finite() {
+            self.cursor = None;
+            return dirty;
         }
         let r = (s.size / 2.0).max(0.5);
-        let spacing = (r * 0.2).max(0.5);
-        let steps = (len / spacing).ceil().max(1.0) as usize;
-        // Walk only the steps whose dab can reach a field node: the rest return from `dab` before
-        // touching anything, and a segment to a far-off point has trillions of them (#937).
-        let Some((k0, k1)) = self.reachable_steps(a, b, steps, r, s.tool.is_stationary()) else { return dirty };
-        for k in k0..=k1 {
-            let t0 = (k - 1) as f64 / steps as f64;
-            let t1 = k as f64 / steps as f64;
-            let c = [a[0] + (b[0] - a[0]) * t1, a[1] + (b[1] - a[1]) * t1];
-            let delta = [(b[0] - a[0]) * (t1 - t0), (b[1] - a[1]) * (t1 - t0)];
-            let pr = pa + (pb - pa) * t1;
-            // Forward Warp centres the dab where the brush was (it drags what is under it).
-            let centre = if s.tool.is_stationary() { c } else { [c[0] - delta[0], c[1] - delta[1]] };
-            dirty = dirty.union(&self.dab(s, centre, delta, pr));
+        let spacing = dab_spacing(r);
+        let weight = if stationary { moving_weight(r) } else { 1.0 };
+        // Distance along this segment of its first dab, then one every `spacing`.
+        let first = (spacing - cur.carry).clamp(0.0, spacing);
+        // Distances are compared with a little slack: a dab that rounding puts a hair past the
+        // segment's end still falls on it, so cutting one segment in two never adds or drops a dab.
+        let slack = spacing * 1e-6;
+        if first > len + slack {
+            self.cursor = Some(StrokeCursor { end: [b[0], b[1]], last_dab: cur.last_dab, carry: cur.carry + len });
+            return dirty;
         }
+        let last_k = ((len - first + slack) / spacing).floor().max(0.0);
+        let at = |dist: f64| [a[0] + dx * dist / len, a[1] + dy * dist / len];
+        let (mut k0, mut k1) = (0.0f64, last_k);
+        if skip {
+            match self.reachable_span(a, [dx, dy], len, r) {
+                // A dragging dab is centred one spacing behind its position: pad by that and a step.
+                Some((d0, d1)) => {
+                    k0 = k0.max(((d0 - spacing - first) / spacing).floor() - 1.0);
+                    k1 = k1.min(((d1 + spacing - first) / spacing).ceil() + 1.0);
+                }
+                None => k1 = -1.0,
+            }
+        }
+        if k0 <= k1 {
+            let mut prev = if k0 > 0.0 { at(first + (k0 - 1.0) * spacing) } else { cur.last_dab };
+            for k in (k0 as u64)..=(k1 as u64) {
+                let dist = (first + k as f64 * spacing).min(len);
+                let c = at(dist);
+                let delta = [c[0] - prev[0], c[1] - prev[1]];
+                // Forward Warp centres the dab where the brush was (it drags what is under it).
+                let centre = if stationary { c } else { prev };
+                dirty = dirty.union(&self.dab(s, centre, delta, pa + (pb - pa) * dist / len, weight));
+                prev = c;
+            }
+        }
+        let last = (first + last_k * spacing).min(len);
+        self.cursor = Some(StrokeCursor { end: [b[0], b[1]], last_dab: at(last), carry: (len - last).clamp(0.0, spacing) });
         dirty
     }
 
-    /// The steps `k0..=k1` of a segment walked in `steps` whose dab can touch a field node, or
-    /// `None` when none can. Step `k` centres its dab at `a + (b - a)·(k - o)/steps`, with `o` = 1
-    /// for the dragging tools and 0 for the stationary ones (see `stroke_segment`). A dab reaches a
-    /// node only when its centre is within `r` plus a node of the node grid, so the window below
-    /// pads that by another node and a step: the dabs it leaves out would each change nothing.
-    fn reachable_steps(&self, a: [f64; 3], b: [f64; 3], steps: usize, r: f64, stationary: bool) -> Option<(usize, usize)> {
+    /// The distances along a segment from `a` (direction `dir`, length `len`) whose points lie
+    /// within a dab radius `r` plus two nodes of the node grid, or `None` when none do. Only dabs
+    /// near that span can touch a node; a segment to a far-off point has trillions of others
+    /// (#937).
+    fn reachable_span(&self, a: [f64; 3], dir: [f64; 2], len: f64, r: f64) -> Option<(f64, f64)> {
         if self.w == 0 || self.h == 0 {
             return None;
         }
         let pad = r + 2.0 * self.cell;
         let lo = [f64::from(self.bounds.x0) + 0.5 - pad, f64::from(self.bounds.y0) + 0.5 - pad];
         let hi = [lo[0] + (self.w - 1) as f64 * self.cell + 2.0 * pad, lo[1] + (self.h - 1) as f64 * self.cell + 2.0 * pad];
-        let (n, o) = (steps as f64, if stationary { 0.0 } else { 1.0 });
-        let (mut k0, mut k1) = (1.0f64, n);
+        let (mut u0, mut u1) = (0.0f64, 1.0f64);
         for ax in 0..2 {
-            let d = b[ax] - a[ax];
+            let d = dir[ax];
             if d == 0.0 {
                 if a[ax].is_nan() || a[ax] < lo[ax] || a[ax] > hi[ax] {
                     return None;
                 }
                 continue;
             }
-            let (u0, u1) = ((lo[ax] - a[ax]) / d, (hi[ax] - a[ax]) / d);
-            k0 = k0.max((u0.min(u1) * n + o).floor() - 1.0);
-            k1 = k1.min((u0.max(u1) * n + o).ceil() + 1.0);
+            let (v0, v1) = ((lo[ax] - a[ax]) / d, (hi[ax] - a[ax]) / d);
+            u0 = u0.max(v0.min(v1));
+            u1 = u1.min(v0.max(v1));
         }
-        // NaN: a segment whose length overflowed.
-        if k0.is_nan() || k1.is_nan() || k0 > k1 {
+        if u0.is_nan() || u1.is_nan() || u0 > u1 {
             return None;
         }
-        Some((k0 as usize, k1 as usize))
+        Some((u0 * len, u1 * len))
     }
 
-    /// One dab at `c` with brush motion `delta`. Returns the document rect it affected.
-    fn dab(&mut self, s: &LiquifyStroke, c: [f64; 2], delta: [f64; 2], point_pressure: f64) -> Rect {
+    /// One dab at `c` with brush motion `delta`, its strength scaled by `weight`. Returns the
+    /// document rect it affected.
+    fn dab(&mut self, s: &LiquifyStroke, c: [f64; 2], delta: [f64; 2], point_pressure: f64, weight: f64) -> Rect {
         if s.tool == LiquifyTool::LassoMask {
             return Rect::EMPTY; // the lasso is polygon-only; never a brush dab
         }
         let r = (s.size / 2.0).max(0.5);
-        let strength = (s.pressure / 100.0).clamp(0.0, 1.0) * point_pressure;
+        let strength = (s.pressure / 100.0).clamp(0.0, 1.0) * point_pressure * weight;
         let rate = (s.rate / 100.0).clamp(0.0, 1.0);
         let density = (s.density / 100.0).clamp(0.0, 1.0);
         if strength <= 0.0 {
@@ -921,21 +997,9 @@ mod tests {
     use super::*;
     use photocraft_color::{ColorMode, PixelFormat, SampleType};
 
-    /// The segment walk before #937: every step, whether or not its dab can reach the field.
+    /// The segment walk before #937: every dab, whether or not it can reach the field.
     fn full_walk(f: &mut LiquifyField, s: &LiquifyStroke, a: [f64; 3], b: [f64; 3]) -> Rect {
-        let mut dirty = Rect::EMPTY;
-        let (pa, pb) = (a[2].clamp(0.0, 1.0), b[2].clamp(0.0, 1.0));
-        let len = (b[0] - a[0]).hypot(b[1] - a[1]);
-        let r = (s.size / 2.0).max(0.5);
-        let steps = (len / (r * 0.2).max(0.5)).ceil().max(1.0) as usize;
-        for k in 1..=steps {
-            let (t0, t1) = ((k - 1) as f64 / steps as f64, k as f64 / steps as f64);
-            let c = [a[0] + (b[0] - a[0]) * t1, a[1] + (b[1] - a[1]) * t1];
-            let delta = [(b[0] - a[0]) * (t1 - t0), (b[1] - a[1]) * (t1 - t0)];
-            let centre = if s.tool.is_stationary() { c } else { [c[0] - delta[0], c[1] - delta[1]] };
-            dirty = dirty.union(&f.dab(s, centre, delta, pa + (pb - pa) * t1));
-        }
-        dirty
+        f.walk_segment(s, a, b, false)
     }
 
     #[test]
@@ -945,7 +1009,7 @@ mod tests {
         // every result bit-identical to the full walk.
         use LiquifyTool::*;
         let bounds = Rect::new(-7, 3, 89, 67);
-        let segments: [([f64; 3], [f64; 3]); 9] = [
+        let segments: [([f64; 3], [f64; 3]); 10] = [
             ([10.0, 20.0, 1.0], [70.0, 50.0, 0.5]),        // inside
             ([-900.0, 30.0, 1.0], [40.0, 31.0, 1.0]),      // in from far left
             ([40.0, 30.0, 1.0], [40.0, 4000.0, 0.2]),      // out downwards
@@ -955,6 +1019,7 @@ mod tests {
             ([88.5, -50.0, 1.0], [88.5, 120.0, 1.0]),      // vertical, along the right edge
             ([200.0, 200.0, 1.0], [201.0, 900.0, 1.0]),    // entirely outside
             ([0.0, 0.0, 1.0], [0.25, 0.1, 1.0]),           // shorter than one step
+            ([60.0, 40.0, 1.0], [-2000.0, 45.0, 1.0]),     // continues the stroke before it, out left
         ];
         for tool in [ForwardWarp, PushLeft, Reconstruct, Smooth, TwirlCw, TwirlCcw, Pucker, Bloat, Freeze, Thaw] {
             for size in [6.0, 40.0] {
@@ -973,6 +1038,81 @@ mod tests {
         }
     }
 
+    /// The same path sampled by `parts` pointer events per corner-to-corner leg, unevenly.
+    fn sampled(path: &[[f64; 3]], parts: usize) -> Vec<Vec<f64>> {
+        let mut out = vec![path[0].to_vec()];
+        for w in path.windows(2) {
+            let (a, b) = (w[0], w[1]);
+            // Uneven steps, as a real pointer gives: t grows quadratically.
+            for k in 1..=parts {
+                let t = (k * k) as f64 / (parts * parts) as f64;
+                out.push((0..3).map(|i| a[i] + (b[i] - a[i]) * t).collect());
+            }
+        }
+        out
+    }
+
+    /// #2606: dabs restarted at every pointer event, so a fast mouse (few far-apart events) and a
+    /// slow one (many close ones) warped the same path differently. Spacing now runs on along the
+    /// whole stroke: any sampling of a path gives the same field.
+    #[test]
+    fn the_result_does_not_depend_on_how_finely_the_path_was_sampled() {
+        use LiquifyTool::*;
+        let path = [[20.0, 20.0, 1.0], [62.0, 26.0, 0.6], [70.0, 50.0, 0.9], [28.0, 55.0, 1.0], [30.0, 30.0, 1.0]];
+        for tool in [ForwardWarp, PushLeft, TwirlCw, Bloat, Reconstruct, Smooth, Freeze] {
+            for size in [12.0, 40.0] {
+                let field = |parts: usize| {
+                    let mut warp = LiquifyStroke::new(ForwardWarp, 30.0);
+                    warp.points = vec![vec![30.0, 30.0], vec![50.0, 40.0]];
+                    let mut s = LiquifyStroke::new(tool, size);
+                    s.points = sampled(&path, parts);
+                    // Some displacement first, so Reconstruct and Smooth have something to change.
+                    LiquifyField::from_strokes(bounds(), 2.0, &[warp, s])
+                };
+                let coarse = field(1);
+                for parts in [3, 17, 60] {
+                    let fine = field(parts);
+                    let dd = coarse.d.iter().zip(&fine.d).map(|(p, q)| (p[0] - q[0]).abs().max((p[1] - q[1]).abs())).fold(0.0f32, f32::max);
+                    let df = coarse.freeze.iter().zip(&fine.freeze).map(|(p, q)| (p - q).abs()).fold(0.0f32, f32::max);
+                    assert!(dd < 1e-3 && df < 1e-4, "{tool:?} {size}px, {parts} events per leg: field differs by {dd} px, mask by {df}");
+                }
+            }
+        }
+    }
+
+    /// A long drag whose events land exactly on dab positions, along a diagonal: rounding must not
+    /// add or drop the dab at a segment's end, or the deep displacement a long Forward Warp builds
+    /// up differs by a whole dab between a slow and a fast pointer.
+    #[test]
+    fn a_long_diagonal_drag_gives_one_field_at_any_event_spacing() {
+        let field = |step: f64| {
+            let mut s = LiquifyStroke::new(LiquifyTool::ForwardWarp, 40.0);
+            s.points = (0..=(300.0 / step) as usize).map(|k| vec![40.0 + k as f64 * step * 0.6, 20.0 + k as f64 * step * 0.8]).collect();
+            LiquifyField::from_strokes(Rect::new(0, 0, 320, 300), 2.0, &[s])
+        };
+        let (slow, fast) = (field(2.0), field(60.0));
+        let dd = slow.d.iter().zip(&fast.d).map(|(p, q)| (p[0] - q[0]).abs().max((p[1] - q[1]).abs())).fold(0.0f32, f32::max);
+        assert!(slow.max_displacement() > 50.0, "the drag builds up a deep displacement");
+        assert!(dd < 1e-3, "slow and fast pointer fields differ by {dd} px");
+    }
+
+    #[test]
+    fn a_stroke_interrupted_by_a_jump_restarts_its_spacing() {
+        // A segment that does not start where the last one ended begins a new run of dabs there.
+        let s = LiquifyStroke::new(LiquifyTool::ForwardWarp, 20.0);
+        let mut f = LiquifyField::new(bounds(), 2.0);
+        f.stroke_begin(&s, [10.0, 10.0, 1.0]);
+        f.stroke_segment(&s, [10.0, 10.0, 1.0], [10.3, 10.0, 1.0]);
+        let mut g = LiquifyField::new(bounds(), 2.0);
+        f.stroke_segment(&s, [40.0, 30.0, 1.0], [50.0, 30.0, 1.0]);
+        g.stroke_begin(&s, [40.0, 30.0, 1.0]);
+        g.stroke_segment(&s, [40.0, 30.0, 1.0], [50.0, 30.0, 1.0]);
+        assert_eq!(f, g);
+        // Hostile points: nothing panics and the next segment starts afresh.
+        f.stroke_segment(&s, [f64::NAN, 3.0, 1.0], [4.0, f64::INFINITY, 1.0]);
+        f.stroke_segment(&s, [4.0, 3.0, f64::NAN], [9.0, 3.0, 1.0]);
+    }
+
     #[test]
     fn a_segment_to_a_far_off_point_returns() {
         // The issue's request: about 3.3e14 steps before the fix. Also a segment whose length
@@ -1110,8 +1250,8 @@ mod tests {
     /// dab's circle (a hard-edged block at Density 0, half strength at the default 50).
     #[test]
     fn forward_warp_leaves_the_brush_rim_in_place() {
-        // A drag of one dab spacing (a fifth of the radius): one dab, centred where it started.
-        let (r, drag) = (20.0, 4.0);
+        // A drag of one dab spacing (a twentieth of the radius): one dab, centred where it started.
+        let (r, drag) = (20.0, 1.0);
         for density in [0.0, 50.0, 100.0] {
             let mut s = LiquifyStroke::new(LiquifyTool::ForwardWarp, 2.0 * r);
             s.density = density;
diff --git a/crates/algo/src/matting.rs b/crates/algo/src/matting.rs
index a9dcac98b9..e40b687040 100644
--- a/crates/algo/src/matting.rs
+++ b/crates/algo/src/matting.rs
@@ -35,7 +35,8 @@ pub struct RefineParams {
     pub feather: f32,
     /// 0–100.
     pub contrast: f32,
-    /// −100–100 (% of `max(radius, 4 px)`).
+    /// −100–100. 100% moves the edge by `max(radius, 4)` pixels. Values between whole
+    /// pixels blend the two neighbouring shifts, so the slider does not jump.
     pub shift_edge: f32,
 }
 
@@ -59,8 +60,18 @@ impl RefineParams {
     fn feather_sigma(&self) -> f32 {
         self.feather.max(0.0) / 2.0
     }
+    /// Signed shift in pixels, fractional. 100% is `max(radius, 4)` px, clamped to ±64.
+    fn shift_amount(&self) -> f32 {
+        let px = self.shift_edge.clamp(-100.0, 100.0) / 100.0 * self.radius.max(4.0);
+        if px.is_finite() { px.clamp(-64.0, 64.0) } else { 0.0 }
+    }
+    /// How many pixels the mask can move: the farther of the two integer radii a fractional
+    /// shift blends. Whole-pixel amounts stay exact (`ceil(4) == 4`).
     fn shift_px(&self) -> i32 {
-        (self.shift_edge.clamp(-100.0, 100.0) / 100.0 * self.radius.max(4.0)).round().clamp(-64.0, 64.0) as i32
+        let px = self.shift_amount();
+        let reach = px.abs().ceil();
+        let signed = if px.is_sign_negative() { -reach } else { reach };
+        if signed.is_finite() { signed as i32 } else { 0 }
     }
     fn uses_image(&self) -> bool {
         self.radius > 0.0
@@ -370,13 +381,38 @@ where
             *v = ((*v - 0.5) * gain + 0.5).clamp(0.0, 1.0);
         }
     }
-    let d = p.shift_px();
-    if d != 0 {
-        a = morphology(&a, w, h, d.unsigned_abs() as usize, d > 0);
+    let amount = p.shift_amount();
+    if amount.abs() >= 1.0e-4 {
+        a = shift_mask(&a, w, h, amount, morphology);
     }
     a
 }
 
+/// Grow or shrink `src` by a fractional pixel distance. Whole pixels use one morphology;
+/// the remainder blends that result with the next pixel, so 0.3 px is not the same step as 1 px.
+fn shift_mask<F>(src: &[f32], w: usize, h: usize, amount: f32, morphology: F) -> Vec<f32>
+where
+    F: Fn(&[f32], usize, usize, usize, bool) -> Vec<f32> + Copy,
+{
+    let mag = amount.abs();
+    if !mag.is_finite() || mag < 1.0e-4 {
+        return src.to_vec();
+    }
+    let grow = amount > 0.0;
+    let whole = mag.floor() as usize;
+    let frac = mag - whole as f32;
+    if frac < 1.0e-4 {
+        return morphology(src, w, h, whole, grow);
+    }
+    let lo = if whole == 0 { src.to_vec() } else { morphology(src, w, h, whole, grow) };
+    let hi = morphology(src, w, h, whole + 1, grow);
+    let n = w.saturating_mul(h);
+    if lo.len() < n || hi.len() < n || lo.len() != hi.len() {
+        return hi;
+    }
+    lo.into_iter().zip(hi).map(|(a, b)| a + (b - a) * frac).collect()
+}
+
 /// Refines a selection mask. `mask(r)` returns coverage over `r` (row-major); `content` bounds
 /// its non-zero pixels; the result is clipped to `canvas`. `sampler` supplies the guide image
 /// (only read when `radius > 0`). Returns `None` when nothing remains selected.
@@ -720,6 +756,16 @@ mod tests {
         let shrunk = refine_buffer(None, &m, w, h, &RefineParams { shift_edge: -50.0, ..Default::default() });
         assert_eq!(shrunk[5 * w + 27], 1.0);
         assert_eq!(shrunk[5 * w + 28], 0.0);
+        // Radius 0 scales 100% to 4 px, so 12.5% is half a pixel and 25% is one pixel.
+        // The pixel just outside a hard edge fades in instead of snapping on.
+        let half = refine_buffer(None, &m, w, h, &RefineParams { shift_edge: 12.5, ..Default::default() });
+        let one = refine_buffer(None, &m, w, h, &RefineParams { shift_edge: 25.0, ..Default::default() });
+        assert_eq!(m[5 * w + 30], 0.0);
+        assert!((half[5 * w + 30] - 0.5).abs() < 0.02, "half pixel {}", half[5 * w + 30]);
+        assert_eq!(one[5 * w + 30], 1.0);
+        assert_eq!(half[5 * w + 31], 0.0, "the blend must not jump a second pixel");
+        let pulled = refine_buffer(None, &m, w, h, &RefineParams { shift_edge: -12.5, ..Default::default() });
+        assert!((pulled[5 * w + 29] - 0.5).abs() < 0.02, "half-pixel contract {}", pulled[5 * w + 29]);
         let sm = refine_buffer(None, &m, w, h, &RefineParams { smooth: 50.0, ..Default::default() });
         assert!(sm[5 * w + 10] == 1.0 && sm[5 * w + 50] == 0.0);
     }
diff --git a/crates/algo/src/other.rs b/crates/algo/src/other.rs
index 1db629a708..e0b11aceae 100644
--- a/crates/algo/src/other.rs
+++ b/crates/algo/src/other.rs
@@ -128,12 +128,32 @@ pub(crate) fn edge_of(u: UndefinedAreas) -> Edge {
 /// Shifts the bounds' content by whole pixels.
 pub(crate) fn offset(src: &Image, out: Rect, ctx: &Ctx, dx: i32, dy: i32, undefined: UndefinedAreas) -> Vec<f32> {
     let n = src.ch;
-    let edge = edge_of(undefined);
+    // Subtraction can leave i32 even for valid command parameters. Apply the edge
+    // policy before narrowing: saturating first would change the wrapped pixel.
+    let coordinate = |position: i32, distance: i32, start: i32, end: i32| -> Option<i32> {
+        if start >= end {
+            return None;
+        }
+        let p = i64::from(position) - i64::from(distance);
+        let (start, end) = (i64::from(start), i64::from(end));
+        let mapped = match undefined {
+            UndefinedAreas::Wrap => start + (p - start).rem_euclid(end - start),
+            UndefinedAreas::Repeat => p.clamp(start, end - 1),
+            UndefinedAreas::Transparent if p >= start && p < end => p,
+            UndefinedAreas::Transparent => return None,
+        };
+        i32::try_from(mapped).ok()
+    };
     let mut res = Vec::with_capacity(out.width() as usize * out.height() as usize * n);
     for y in out.y0..out.y1 {
+        let sy = coordinate(y, dy, ctx.bounds.y0, ctx.bounds.y1);
         for x in out.x0..out.x1 {
+            let sx = coordinate(x, dx, ctx.bounds.x0, ctx.bounds.x1);
             for c in 0..n {
-                res.push(src.get_edge(x - dx, y - dy, c, edge, ctx.bounds));
+                res.push(match (sx, sy) {
+                    (Some(sx), Some(sy)) => src.get(sx, sy, c),
+                    _ => 0.0,
+                });
             }
         }
     }
@@ -186,3 +206,61 @@ mod tests {
         }
     }
 }
+
+#[cfg(test)]
+mod offset_overflow_tests {
+    use super::*;
+
+    #[test]
+    fn offset_limits_match_equivalent_small_offsets_for_every_edge_policy() {
+        for bounds in [Rect::new(0, 0, 3, 5), Rect::new(-7, 11, -4, 16)] {
+            let mut src = Image::new(bounds, 4);
+            // Include signed/HDR values and varying alpha; offset must only move samples.
+            for (i, sample) in src.data.iter_mut().enumerate() {
+                *sample = i as f32 * 0.125 - 2.0;
+            }
+            let ctx = Ctx { bounds, mode: photocraft_color::ColorMode::Rgb, alpha: true };
+            for policy in [UndefinedAreas::Wrap, UndefinedAreas::Repeat, UndefinedAreas::Transparent] {
+                for dx in [i32::MIN, i32::MAX, -8, 0, 7] {
+                    for dy in [i32::MIN, i32::MAX, -9, 0, 6] {
+                        let reduce = |d: i32, size: i32| match policy {
+                            UndefinedAreas::Wrap => d.rem_euclid(size),
+                            _ => d.clamp(-100, 100),
+                        };
+                        let (rx, ry) = (reduce(dx, 3), reduce(dy, 5));
+                        let mut expected = Vec::new();
+                        for y in bounds.y0..bounds.y1 {
+                            for x in bounds.x0..bounds.x1 {
+                                for c in 0..4 {
+                                    expected.push(src.get_edge(x - rx, y - ry, c, edge_of(policy), bounds));
+                                }
+                            }
+                        }
+                        assert_eq!(offset(&src, bounds, &ctx, dx, dy, policy), expected, "{bounds:?} {policy:?} {dx} {dy}");
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn offset_wrap_handles_bounds_at_signed_coordinate_limits() {
+        for start in [i32::MIN, i32::MAX - 3] {
+            let bounds = Rect::new(start, start, start + 3, start + 3);
+            let mut src = Image::new(bounds, 1);
+            src.data = (0..9).map(|i| i as f32).collect();
+            let ctx = Ctx { bounds, mode: photocraft_color::ColorMode::Grayscale, alpha: false };
+            assert_eq!(offset(&src, bounds, &ctx, i32::MIN, i32::MIN, UndefinedAreas::Wrap), vec![8.0, 6.0, 7.0, 2.0, 0.0, 1.0, 5.0, 3.0, 4.0]);
+        }
+    }
+
+    #[test]
+    fn offset_wrap_accepts_minimum_signed_distance() {
+        let bounds = Rect::new(0, 0, 3, 1);
+        let mut src = Image::new(bounds, 1);
+        src.data = vec![0.1, 0.5, 0.9];
+        let ctx = Ctx { bounds, mode: photocraft_color::ColorMode::Grayscale, alpha: false };
+        let got = offset(&src, bounds, &ctx, i32::MIN, 0, UndefinedAreas::Wrap);
+        assert_eq!(got, vec![0.9, 0.1, 0.5]);
+    }
+}
diff --git a/crates/algo/src/paint.rs b/crates/algo/src/paint.rs
index 9376102efe..c32f28c648 100644
--- a/crates/algo/src/paint.rs
+++ b/crates/algo/src/paint.rs
@@ -63,6 +63,7 @@ fn composite_area(
     coverage: impl Fn(i32, i32) -> f32 + Sync,
     color: impl Fn(i32, i32) -> [f32; 4] + Sync,
     lock_transparency: bool,
+    inks: Option<[f32; 4]>,
 ) {
     // Composite tile by tile (in parallel on native); tiles with zero coverage are left untouched,
     // so their copy-on-write storage (and GPU residency) survives.
@@ -93,6 +94,14 @@ fn composite_area(
                     o[3] = d[3];
                 }
                 from_rgba_into(&fmt, o, &mut enc);
+                // A colour picked as CMYK inks replaces fully covered pixels of a CMYK target as it is.
+                if let Some(i) = inks
+                    && fmt.mode == photocraft_color::ColorMode::Cmyk
+                    && blend_mode == BlendMode::Normal
+                    && k >= 1.0
+                {
+                    enc[..4].copy_from_slice(&i);
+                }
                 px.copy_from_slice(&enc[..n]);
             }
         }
@@ -144,6 +153,7 @@ pub fn paint_gradient(
             c
         },
         lock_transparency,
+        None,
     );
 }
 
@@ -179,6 +189,25 @@ pub fn bucket_fill_src(
     selection: Option<&Surface>,
     lock_transparency: bool,
     src: impl Fn(i32, i32) -> [f32; 4] + Sync,
+) -> bool {
+    bucket_fill_inks(s, area, seed, tolerance, contiguous, anti_alias, opacity, selection, lock_transparency, src, None)
+}
+
+/// [`bucket_fill_src`] where `inks` (CMYK, 0..1) are what a fully covered pixel of a CMYK target
+/// gets instead of `src`'s sRGB stand-in (a colour that was picked as CMYK).
+#[allow(clippy::too_many_arguments)]
+pub fn bucket_fill_inks(
+    s: &mut Surface,
+    area: Rect,
+    seed: (i32, i32),
+    tolerance: f32,
+    contiguous: bool,
+    anti_alias: bool,
+    opacity: f32,
+    selection: Option<&Surface>,
+    lock_transparency: bool,
+    src: impl Fn(i32, i32) -> [f32; 4] + Sync,
+    inks: Option<[f32; 4]>,
 ) -> bool {
     if !area.contains(seed.0, seed.1) {
         return false;
@@ -186,7 +215,7 @@ pub fn bucket_fill_src(
     let img = crate::selection::rgba8_image(s, area);
     let Some(region) = crate::selection::wand_region(&img, area, seed, tolerance, contiguous, anti_alias) else { return false };
     drop(img);
-    bucket_fill_region_src(s, &region, opacity, selection, lock_transparency, src);
+    bucket_fill_region_inks(s, &region, opacity, selection, lock_transparency, src, inks);
     true
 }
 
@@ -199,10 +228,31 @@ pub fn bucket_fill_region_src(
     selection: Option<&Surface>,
     lock_transparency: bool,
     src: impl Fn(i32, i32) -> [f32; 4] + Sync,
+) {
+    bucket_fill_region_inks(s, region, opacity, selection, lock_transparency, src, None);
+}
+
+/// [`bucket_fill_region_src`] with the CMYK `inks` of [`bucket_fill_inks`].
+pub fn bucket_fill_region_inks(
+    s: &mut Surface,
+    region: &crate::selection::Region,
+    opacity: f32,
+    selection: Option<&Surface>,
+    lock_transparency: bool,
+    src: impl Fn(i32, i32) -> [f32; 4] + Sync,
+    inks: Option<[f32; 4]>,
 ) {
     // Composite only over the filled region's box.
     let b = region.bbox;
-    composite_area(s, b, BlendMode::Normal, |x, y| region.at(x, y) * opacity * selection.map_or(1.0, |m| m.sample_channel(x, y, 0)), src, lock_transparency);
+    composite_area(
+        s,
+        b,
+        BlendMode::Normal,
+        |x, y| region.at(x, y) * opacity * selection.map_or(1.0, |m| m.sample_channel(x, y, 0)),
+        src,
+        lock_transparency,
+        inks,
+    );
 }
 
 #[cfg(test)]
diff --git a/crates/algo/src/pixelate.rs b/crates/algo/src/pixelate.rs
index 1a1325975a..df6edb5fff 100644
--- a/crates/algo/src/pixelate.rs
+++ b/crates/algo/src/pixelate.rs
@@ -115,8 +115,11 @@ pub(crate) fn color_halftone(src: &Image, out: Rect, ctx: &Ctx, max_radius: f32,
     res
 }
 
-/// Crystallize: Voronoi cells around jittered points, each filled with the
-/// (premultiplied) average colour of its pixels.
+/// Crystallize: Voronoi cells around jittered points, each filled with the colour at its
+/// point, as Photoshop's are: cells stay solid, so a black-and-white image (a layer mask
+/// being distressed) keeps hard edges and its weight instead of greying where cells straddle
+/// an edge. A cell whose point falls outside the image takes the (premultiplied) average
+/// colour of its pixels.
 pub(crate) fn crystallize(src: &Image, out: Rect, ctx: &Ctx, cell_size: f32, seed: u32) -> Vec<f32> {
     let n = src.ch;
     let cell = cell_size.max(2.0);
@@ -177,6 +180,14 @@ pub(crate) fn crystallize(src: &Image, out: Rect, ctx: &Ctx, cell_size: f32, see
             continue;
         }
         let (cx, cy) = if win.contains(x, y) { owners[i] } else { owner(x, y) };
+        let (sx, sy) = cell_point(cx, cy, cell, seed, origin);
+        let (sx, sy) = (sx.floor() as i32, sy.floor() as i32);
+        if src.rect.contains(sx, sy) && b.contains(sx, sy) {
+            for (c, v) in px.iter_mut().enumerate() {
+                *v = src.get(sx, sy, c);
+            }
+            continue;
+        }
         if cx < c0.0 || cy < c0.1 || cx > c1.0 || cy > c1.1 {
             continue;
         }
diff --git a/crates/algo/src/pixelate/tests.rs b/crates/algo/src/pixelate/tests.rs
index 83d89bf303..c82d747326 100644
--- a/crates/algo/src/pixelate/tests.rs
+++ b/crates/algo/src/pixelate/tests.rs
@@ -153,7 +153,7 @@ fn tiled_filters_match_scalar_at_all_depths_with_soft_selection() {
                             FilterParams::ColorHalftone { max_radius, angles } => reference::halftone(&image, bounds, &ctx, max_radius, angles),
                             _ => Vec::new(),
                         };
-                        crate::mix_selection(&mut expected_data, bounds, &selection, &image);
+                        crate::mix_selection(&mut expected_data, bounds, &selection, &image, ctx.alpha);
                         let mut expected = surface.clone();
                         expected.write_region(bounds, &expected_data);
                         for tile in [1, 7, 17, 256] {
diff --git a/crates/algo/src/puppet.rs b/crates/algo/src/puppet.rs
index e21b7874ee..c3c5c3693c 100644
--- a/crates/algo/src/puppet.rs
+++ b/crates/algo/src/puppet.rs
@@ -1277,11 +1277,18 @@ pub const MAX_WARP_PIXELS: f64 = (1u64 << 30) as f64;
 /// Applies a puppet warp to `src` (content inside `bounds`). `None` when the deformed mesh would
 /// span more than [`MAX_WARP_PIXELS`].
 pub fn puppet_warp(src: &Surface, bounds: Rect, w: &PuppetWarp, interp: Interp) -> Option<Surface> {
+    puppet_warp_with_mask(src, bounds, w, interp, None).map(|(out, _)| out)
+}
+
+/// [`puppet_warp`], also moving `mask` (a one-channel layer mask linked to `src`) with the same
+/// mesh, as Photoshop moves a linked mask with its layer (#4910). The mask is `None` in the
+/// result when none was given.
+pub fn puppet_warp_with_mask(src: &Surface, bounds: Rect, w: &PuppetWarp, interp: Interp, mask: Option<&Surface>) -> Option<(Surface, Option<Surface>)> {
     let (solver, v, order) = deform(src, bounds, w, ITERATIONS);
     // No triangles (an expansion that shrinks every pixel away): nothing to warp. Rendering the
     // empty mesh would drop every pixel of the layer.
     if solver.mesh.tris.is_empty() {
-        return Some(src.clone());
+        return Some((src.clone(), mask.cloned()));
     }
     let (mut x0, mut y0, mut x1, mut y1) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
     for p in &v {
@@ -1291,7 +1298,57 @@ pub fn puppet_warp(src: &Surface, bounds: Rect, w: &PuppetWarp, interp: Interp)
     if area.is_nan() || area > MAX_WARP_PIXELS {
         return None;
     }
-    Some(render(src, bounds, &solver.mesh, &v, &order, interp))
+    let out = render(src, bounds, &solver.mesh, &v, &order, interp);
+    Some((out, mask.map(|m| render_mask(m, &solver.mesh, &v, &order, interp))))
+}
+
+/// Moves a one-channel layer mask with a deformed mesh: the mask under the mesh is lifted,
+/// deformed like the layer's pixels and laid over the rest. The area the mesh leaves takes the
+/// mask's default value (as [`crate::warp::warp_mesh_gray`] leaves it); outside the mesh the
+/// mask keeps its values.
+pub fn render_mask(mask: &Surface, mesh: &PuppetMesh, deformed: &[[f64; 2]], order: &[usize], interp: Interp) -> Surface {
+    let mut out = mask.clone();
+    if mesh.tris.is_empty() || deformed.len() != mesh.verts.len() || mask.format().channels() != 1 {
+        return out;
+    }
+    let (mut x0, mut y0, mut x1, mut y1) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
+    for p in &mesh.verts {
+        (x0, y0, x1, y1) = (x0.min(p[0]), y0.min(p[1]), x1.max(p[0]), y1.max(p[1]));
+    }
+    if !(x0.is_finite() && y0.is_finite() && x1.is_finite() && y1.is_finite()) {
+        return out;
+    }
+    // The mesh's source area, a pixel wider so its edge samples stay inside.
+    let lim = f64::from(1 << 20);
+    let src = Rect::new(x0.max(-lim).floor() as i32 - 1, y0.max(-lim).floor() as i32 - 1, x1.min(lim).ceil() as i32 + 1, y1.min(lim).ceil() as i32 + 1);
+    if src.is_empty() {
+        return out;
+    }
+    let default = mask.default_pixel().first().copied().unwrap_or(0.0);
+    let fmt = mask.format();
+    let mut tmp = Surface::new(photocraft_color::PixelFormat::new(fmt.mode, fmt.sample, true));
+    tmp.write_region(src, &mask.read_region(src).iter().flat_map(|g| [*g, 1.0]).collect::<Vec<f32>>());
+    let tris: Vec<[usize; 3]> = order.iter().filter_map(|&t| mesh.tris.get(t).copied()).collect();
+    // Lift: where the undeformed mesh covers the mask, the mask takes its default value.
+    let still: Vec<([f64; 2], [f64; 2])> = mesh.verts.iter().map(|s| (*s, *s)).collect();
+    let lifted = crate::warp::warp_triangles(&tmp, src, &still, &tris, Interp::Nearest);
+    let b = lifted.content_bounds();
+    if !b.is_empty() {
+        let under = out.read_region(b);
+        let flat: Vec<f32> = lifted.read_region(b).as_chunks::<2>().0.iter().zip(&under).map(|(p, u)| default * p[1] + u * (1.0 - p[1])).collect();
+        out.write_region(b, &flat);
+    }
+    // Lay the deformed mask over what is left.
+    let moved: Vec<([f64; 2], [f64; 2])> = deformed.iter().zip(&mesh.verts).map(|(d, s)| (*d, *s)).collect();
+    let warped = crate::warp::warp_triangles(&tmp, src, &moved, &tris, interp);
+    let b = warped.content_bounds();
+    if !b.is_empty() {
+        let under = out.read_region(b);
+        let flat: Vec<f32> = warped.read_region(b).as_chunks::<2>().0.iter().zip(&under).map(|(p, u)| p[0] * p[1] + u * (1.0 - p[1])).collect();
+        out.write_region(b, &flat);
+    }
+    out.prune();
+    out
 }
 
 #[cfg(test)]
@@ -1434,6 +1491,33 @@ mod tests {
         assert!(!near.content_bounds().is_empty());
     }
 
+    #[test]
+    fn a_linked_mask_moves_with_the_mesh_and_leaves_its_default_behind() {
+        // #4910. A hide-all mask (default 0) that reveals the bar's top (y 10..30): moved down by
+        // 8, the revealed patch moves along, what it left is hidden again, and the mask away
+        // from the puppet keeps its values.
+        let s = blob(SampleType::U8);
+        let b = s.content_bounds();
+        for sample in [SampleType::U8, SampleType::U16, SampleType::F32] {
+            let mut mask = Surface::with_default(PixelFormat::new(ColorMode::Grayscale, sample, false), &[0.0]);
+            mask.fill_rect(Rect::new(20, 10, 36, 30), &[1.0]);
+            mask.fill_rect(Rect::new(90, 90, 94, 94), &[0.5]);
+            let w = PuppetWarp {
+                pins: vec![PuppetPin { src: [28.0, 30.0], dst: [28.0, 38.0], rotate: None, depth: 0 }],
+                mode: PuppetMode::Rigid,
+                density: PuppetDensity::Normal,
+                expansion: 2.0,
+            };
+            let (_, moved) = puppet_warp_with_mask(&s, b, &w, Interp::Bilinear, Some(&mask)).expect("warps");
+            let m = moved.expect("a mask in, a mask out");
+            let at = |x, y| m.sample_channel(x, y, 0);
+            assert!(at(28, 20) > 0.99 && at(28, 36) > 0.99, "{sample:?}: the revealed patch moved down");
+            assert!(at(28, 15) < 0.01, "{sample:?}: its old top is hidden again");
+            assert!((at(91, 91) - 0.5).abs() <= 1.0 / 255.0, "{sample:?}: away from the mesh nothing changes");
+            assert!(puppet_warp_with_mask(&s, b, &w, Interp::Bilinear, None).expect("warps").1.is_none());
+        }
+    }
+
     #[test]
     fn a_single_pin_translates_rigidly() {
         let s = blob(SampleType::U8);
diff --git a/crates/algo/src/retouch.rs b/crates/algo/src/retouch.rs
index 12aac4c58a..f7c1c18557 100644
--- a/crates/algo/src/retouch.rs
+++ b/crates/algo/src/retouch.rs
@@ -117,49 +117,53 @@ pub fn sponge(c: [f32; 3], amount: f32, saturate: bool, vibrance: bool) -> [f32;
 pub fn local_blur(data: &[f32], w: usize, h: usize, ch: usize, alpha: Option<usize>, win: (usize, usize, usize, usize), sigma: f32) -> Vec<f32> {
     let (x0, y0, x1, y1) = win;
     let (ow, oh) = (x1 - x0, y1 - y0);
+    if ow == 0 || oh == 0 || ch == 0 {
+        return Vec::new();
+    }
     let r = (sigma * 3.0).ceil().max(1.0) as i32;
     let k: Vec<f32> = (-r..=r).map(|i| (-((i * i) as f32) / (2.0 * sigma * sigma).max(1e-6)).exp()).collect();
     let ks: f32 = k.iter().sum();
     let k: Vec<f32> = k.into_iter().map(|v| v / ks).collect();
-    let get = |x: i32, y: i32, out: &mut [f32]| {
-        let (xx, yy) = (x.clamp(0, w as i32 - 1) as usize, y.clamp(0, h as i32 - 1) as usize);
-        let i = (yy * w + xx) * ch;
-        out.copy_from_slice(&data[i..i + ch]);
-        if let Some(a) = alpha {
-            let av = out[a];
-            for (c, v) in out.iter_mut().enumerate() {
-                if c != a {
-                    *v *= av;
+    // Horizontal pass over the window rows extended vertically by r.
+    let th = oh + 2 * r as usize;
+    let stride = ow * ch;
+    let mut tmp = vec![0.0f32; stride * th];
+    let mut row = vec![0.0f32; (ow + 2 * r as usize) * ch];
+    for ty in 0..th {
+        let y = (y0 as i32 + ty as i32 - r).clamp(0, h as i32 - 1) as usize;
+        // Clamp and premultiply each source pixel once, rather than once for every kernel tap.
+        for (rx, px) in row.chunks_exact_mut(ch).enumerate() {
+            let x = (x0 as i32 + rx as i32 - r).clamp(0, w as i32 - 1) as usize;
+            let i = (y * w + x) * ch;
+            px.copy_from_slice(&data[i..i + ch]);
+            if let Some(a) = alpha {
+                let av = px[a];
+                for (c, v) in px.iter_mut().enumerate() {
+                    if c != a {
+                        *v *= av;
+                    }
                 }
             }
         }
-    };
-    // Horizontal pass over the window rows extended vertically by r.
-    let th = oh + 2 * r as usize;
-    let mut tmp = vec![0.0f32; ow * th * ch];
-    let mut px = vec![0.0f32; ch];
-    for ty in 0..th {
-        let y = y0 as i32 + ty as i32 - r;
-        for ox in 0..ow {
-            let o = (ty * ow + ox) * ch;
-            for (i, kv) in k.iter().enumerate() {
-                get(x0 as i32 + ox as i32 + i as i32 - r, y, &mut px);
-                for c in 0..ch {
-                    tmp[o + c] += px[c] * kv;
-                }
+        let dst = &mut tmp[ty * stride..(ty + 1) * stride];
+        // Contiguous accumulation can be vectorized for any channel layout. Each output still
+        // sums the same products in the same kernel order as the scalar convolution.
+        for (i, kv) in k.iter().enumerate() {
+            for (d, s) in dst.iter_mut().zip(&row[i * ch..i * ch + stride]) {
+                *d += s * kv;
             }
         }
     }
     let mut out = vec![0.0f32; ow * oh * ch];
     for oy in 0..oh {
+        let dst = &mut out[oy * stride..(oy + 1) * stride];
+        for (i, kv) in k.iter().enumerate() {
+            for (d, s) in dst.iter_mut().zip(&tmp[(oy + i) * stride..(oy + i + 1) * stride]) {
+                *d += s * kv;
+            }
+        }
         for ox in 0..ow {
             let o = (oy * ow + ox) * ch;
-            for (i, kv) in k.iter().enumerate() {
-                let s = ((oy + i) * ow + ox) * ch;
-                for c in 0..ch {
-                    out[o + c] += tmp[s + c] * kv;
-                }
-            }
             if let Some(a) = alpha {
                 let av = out[o + a];
                 for c in 0..ch {
diff --git a/crates/algo/src/segment/grabcut.rs b/crates/algo/src/segment/grabcut.rs
index 5e80791ff1..573c09079e 100644
--- a/crates/algo/src/segment/grabcut.rs
+++ b/crates/algo/src/segment/grabcut.rs
@@ -7,9 +7,10 @@
 //! `γ e^{−β‖z_m − z_n‖²} / dist(m, n)` (γ = 50, β from the mean squared neighbour difference).
 
 use photocraft_geom::Rect;
+use photocraft_raster::{Cancelled, Interrupt};
 
 use super::gmm::{DEFAULT_REG, Gmm};
-use super::{FREE, HARD_BG, HARD_FG, Region, RgbImage, Sampler, contrast_beta, data_costs, grid_cut, subsample};
+use super::{FREE, HARD_BG, HARD_FG, Region, RgbImage, Sampler, contrast_beta, data_costs, grid_cut_cancellable, subsample};
 
 /// Definite background.
 pub const BG: u8 = 0;
@@ -33,6 +34,13 @@ fn is_fg(t: u8) -> bool {
 /// Runs `iters` GrabCut iterations, updating the probable labels of `trimap` in place. Returns
 /// the final (foreground, background) models, or `None` if either side has no pixels.
 pub fn grabcut(img: &RgbImage, trimap: &mut [u8], iters: usize) -> Option<(Gmm, Gmm)> {
+    grabcut_with(img, trimap, iters, &Interrupt::NONE).unwrap_or_default()
+}
+
+/// [`grabcut`] that stops with `Err(Cancelled)` once `ctl` is cancelled, asked each iteration
+/// and inside its min cut. `trimap` is then partly updated.
+pub fn grabcut_with(img: &RgbImage, trimap: &mut [u8], iters: usize, ctl: &Interrupt) -> Result<Option<(Gmm, Gmm)>, Cancelled> {
+    let cancel = || ctl.cancelled();
     let beta = contrast_beta(img);
     let fixed: Vec<u8> = trimap
         .iter()
@@ -44,17 +52,22 @@ pub fn grabcut(img: &RgbImage, trimap: &mut [u8], iters: usize) -> Option<(Gmm,
         .collect();
     let mut models: Option<(Gmm, Gmm)> = None;
     for _ in 0..iters.max(1) {
+        ctl.check()?;
         let (mut fs, mut bs) = (Vec::new(), Vec::new());
         for (p, t) in img.px.iter().zip(trimap.iter()) {
             if is_fg(*t) { fs.push(*p) } else { bs.push(*p) }
         }
         let (fs, bs) = (subsample(&fs, MAX_SAMPLES), subsample(&bs, MAX_SAMPLES));
         let (fg, bg) = match &models {
-            None => (Gmm::fit(&fs, K, DEFAULT_REG)?, Gmm::fit(&bs, K, DEFAULT_REG)?),
+            None => match (Gmm::fit(&fs, K, DEFAULT_REG), Gmm::fit(&bs, K, DEFAULT_REG)) {
+                (Some(f), Some(b)) => (f, b),
+                _ => return Ok(None),
+            },
             Some((f, b)) => (f.refit(&fs).unwrap_or_else(|| f.clone()), b.refit(&bs).unwrap_or_else(|| b.clone())),
         };
         let (cf, cb) = data_costs(img, &fg, &bg);
-        let cut = grid_cut(img, &cf, &cb, &fixed, GAMMA, beta);
+        // `grid_cut`'s weight, with the cut stopping on cancel.
+        let cut = grid_cut_cancellable(img, &cf, &cb, &fixed, |d2| GAMMA * (-beta * d2).exp(), &cancel).ok_or(Cancelled)?;
         let mut changed = 0usize;
         for (t, fgnd) in trimap.iter_mut().zip(&cut) {
             if *t == PR_BG || *t == PR_FG {
@@ -68,7 +81,7 @@ pub fn grabcut(img: &RgbImage, trimap: &mut [u8], iters: usize) -> Option<(Gmm,
             break;
         }
     }
-    models
+    Ok(models)
 }
 
 /// Object Selection (rectangle mode): GrabCut initialised from `rect` (outside = background,
@@ -116,3 +129,147 @@ pub fn object_select(sampler: &dyn Sampler, canvas: Rect, rect: Rect, work_px: u
     let low = super::clean_mask(&low, lw, lh, 0.1, 0.002);
     super::finish_region(sampler, window, step, &low, lw, lh, Some((&fg, &bg)))
 }
+
+/// Working-resolution budget (pixels) for [`object_at`]: small enough to run while the pointer
+/// hovers.
+pub const OBJECT_AT_WORK_PX: usize = 60_000;
+
+/// Object Selection's Object Finder (hover / click): the object under document point `(x, y)`.
+///
+/// A heuristic, not a semantic segmenter (that is #2788): on a working-resolution copy of the
+/// canvas the area around the point is grown over pixels of similar colour (CIELAB, bounded both
+/// by the distance to the seed's running mean and by the local edge step), so it stops at the
+/// object's outline. A region that grows over most of the canvas is the background: nothing is
+/// found. Otherwise GrabCut refines it inside its padded bounding box (the grown area probable
+/// foreground, the cursor definite foreground, outside the box definite background), the part
+/// connected to the cursor is kept and the boundary is re-cut at full resolution, as the
+/// rectangle mode does.
+pub fn object_at(sampler: &dyn Sampler, canvas: Rect, x: f32, y: f32, work_px: usize) -> Option<Region> {
+    if canvas.width() < 4 || canvas.height() < 4 || !x.is_finite() || !y.is_finite() {
+        return None;
+    }
+    let (px, py) = (x.floor() as i32, y.floor() as i32);
+    if !canvas.contains(px, py) {
+        return None;
+    }
+    let step = super::scale_for(canvas, work_px.max(1024));
+    let img = sampler.rgb_scaled(canvas, step);
+    let (w, h) = (img.w, img.h);
+    if w < 2 || h < 2 {
+        return None;
+    }
+    // Lightly smoothed, so noise and texture don't stop the growth; edges survive.
+    let lab: Vec<[f32; 3]> = box3(&box3(&img.px, w, h), w, h).iter().map(|c| super::slic::rgb_to_lab(*c)).collect();
+    let sx = (((px - canvas.x0) as usize) / step).min(w - 1);
+    let sy = (((py - canvas.y0) as usize) / step).min(h - 1);
+    let grown = grow_similar(&lab, w, h, sx, sy);
+    let count = grown.iter().filter(|g| **g).count();
+    // Background (or a flat image): no single object under the cursor.
+    if count * 10 > w * h * 6 || count < 4 {
+        return None;
+    }
+    let (mut x0, mut y0, mut x1, mut y1) = (w, h, 0usize, 0usize);
+    for (i, g) in grown.iter().enumerate() {
+        if *g {
+            let (gx, gy) = (i % w, i / w);
+            (x0, y0, x1, y1) = (x0.min(gx), y0.min(gy), x1.max(gx + 1), y1.max(gy + 1));
+        }
+    }
+    let pad = ((x1 - x0).max(y1 - y0) / 6).max(2);
+    let (bx0, by0, bx1, by1) = (x0.saturating_sub(pad), y0.saturating_sub(pad), (x1 + pad).min(w), (y1 + pad).min(h));
+    let mut trimap = vec![BG; w * h];
+    let mut any_bg = false;
+    for yy in 0..h {
+        for xx in 0..w {
+            let i = yy * w + xx;
+            let inside = xx >= bx0 && xx < bx1 && yy >= by0 && yy < by1;
+            trimap[i] = if grown[i] {
+                PR_FG
+            } else if inside {
+                PR_BG
+            } else {
+                any_bg = true;
+                BG
+            };
+        }
+    }
+    if !any_bg {
+        // The box is the whole canvas: the frame is background.
+        for yy in 0..h {
+            for xx in 0..w {
+                if (xx == 0 || yy == 0 || xx + 1 == w || yy + 1 == h) && !(xx == sx && yy == sy) {
+                    trimap[yy * w + xx] = BG;
+                }
+            }
+        }
+    }
+    trimap[sy * w + sx] = FG;
+    let (fg, bg) = grabcut(&img, &mut trimap, 5)?;
+    let low: Vec<bool> = trimap.iter().map(|t| is_fg(*t)).collect();
+    let mut seeds = vec![false; w * h];
+    seeds[sy * w + sx] = true;
+    let low = super::keep_seeded(&low, &seeds, w, h);
+    let low = super::clean_mask(&low, w, h, 0.1, 0.01);
+    if !low.iter().any(|v| *v) {
+        return None;
+    }
+    super::finish_region(sampler, canvas, step, &low, w, h, Some((&fg, &bg)))
+}
+
+/// Region growing (4-connected) from `(sx, sy)` over pixels whose CIELAB colour is within a
+/// distance of the seed area's running mean and whose step from the neighbour it was reached
+/// from is small, so it stops at edges.
+fn grow_similar(lab: &[[f32; 3]], w: usize, h: usize, sx: usize, sy: usize) -> Vec<bool> {
+    const MEAN_DIST: f32 = 32.0;
+    const EDGE_STEP: f32 = 10.0;
+    let d = |a: [f32; 3], b: [f32; 3]| ((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2) + (a[2] - b[2]).powi(2)).sqrt();
+    let mut out = vec![false; w * h];
+    let Some(&seed) = lab.get(sy * w + sx) else { return out };
+    let (mut sum, mut n) = ([seed[0] as f64, seed[1] as f64, seed[2] as f64], 1.0f64);
+    let mut stack = vec![(sx, sy)];
+    out[sy * w + sx] = true;
+    while let Some((x, y)) = stack.pop() {
+        let c = lab[y * w + x];
+        let mean = [(sum[0] / n) as f32, (sum[1] / n) as f32, (sum[2] / n) as f32];
+        let nbrs = [(x.wrapping_sub(1), y), (x + 1, y), (x, y.wrapping_sub(1)), (x, y + 1)];
+        for (nx, ny) in nbrs {
+            if nx >= w || ny >= h {
+                continue;
+            }
+            let i = ny * w + nx;
+            if out[i] {
+                continue;
+            }
+            let q = lab[i];
+            if d(q, c) <= EDGE_STEP && d(q, mean) <= MEAN_DIST {
+                out[i] = true;
+                sum = [sum[0] + q[0] as f64, sum[1] + q[1] as f64, sum[2] + q[2] as f64];
+                n += 1.0;
+                stack.push((nx, ny));
+            }
+        }
+    }
+    out
+}
+
+/// 3×3 box blur (clamped at the edges).
+fn box3(px: &[[f32; 3]], w: usize, h: usize) -> Vec<[f32; 3]> {
+    let mut out = vec![[0.0f32; 3]; px.len()];
+    for y in 0..h {
+        for x in 0..w {
+            let (mut acc, mut n) = ([0.0f32; 3], 0.0f32);
+            for yy in y.saturating_sub(1)..(y + 2).min(h) {
+                for xx in x.saturating_sub(1)..(x + 2).min(w) {
+                    if let Some(p) = px.get(yy * w + xx) {
+                        acc = [acc[0] + p[0], acc[1] + p[1], acc[2] + p[2]];
+                        n += 1.0;
+                    }
+                }
+            }
+            if let Some(o) = out.get_mut(y * w + x) {
+                *o = acc.map(|v| v / n.max(1.0));
+            }
+        }
+    }
+    out
+}
diff --git a/crates/algo/src/segment/maxflow/push_relabel.rs b/crates/algo/src/segment/maxflow/push_relabel.rs
index 914645d4c9..1041f9ef51 100644
--- a/crates/algo/src/segment/maxflow/push_relabel.rs
+++ b/crates/algo/src/segment/maxflow/push_relabel.rs
@@ -71,7 +71,10 @@ impl Graph {
                     let ai = a as usize;
                     let j = self.head[ai] as usize;
                     work += 1;
-                    if self.r_cap[ai] > EPS && self.dist[i] == self.dist[j].saturating_add(1) {
+                    // `checked_add`: two nodes a global relabel left unreachable (`u32::MAX`) must
+                    // not count as admissible for each other, or float-stranded excess ping-pongs
+                    // between them forever.
+                    if self.r_cap[ai] > EPS && self.dist[j].checked_add(1) == Some(self.dist[i]) {
                         let delta = (excess[i] as f32).min(self.r_cap[ai]);
                         self.r_cap[ai] -= delta;
                         self.r_cap[ai ^ 1] += delta;
diff --git a/crates/algo/src/segment/maxflow/push_relabel/tests.rs b/crates/algo/src/segment/maxflow/push_relabel/tests.rs
index 6c7141572e..ce0c0b8628 100644
--- a/crates/algo/src/segment/maxflow/push_relabel/tests.rs
+++ b/crates/algo/src/segment/maxflow/push_relabel/tests.rs
@@ -179,3 +179,28 @@ fn solver_workload_release_comparison() {
         }
     }
 }
+
+#[test]
+fn stranded_excess_terminates_and_matches_bk() {
+    // Source capacities far beyond f32 precision (ulp 32 at 3e8) next to small links: rounding
+    // strands excess on nodes a global relabel finds reachable from neither terminal. Those
+    // nodes (height u32::MAX) used to count as admissible for each other and pushed the excess
+    // back and forth forever (Remove Background never finished on some photos).
+    let mut g = Graph::with_capacity(6, 7);
+    for (i, &(s, t)) in [(33123824.0, 0.0), (347622050.0, 0.0), (0.0, 5539047.5), (76592.22, 0.0), (3514.0022, 0.0), (0.0, 13670.268)].iter().enumerate() {
+        g.add_tweights(i, s, t);
+    }
+    for (i, j, c) in [(0, 1, 0.0), (0, 3, 0.0007301044), (1, 2, 2.803e-42), (1, 4, 8.160078), (2, 5, 3.1224866e-7), (3, 4, 28.512966), (4, 5, 4.099367)] {
+        g.add_edge(i, j, c, c);
+    }
+    let mut bk = g.clone();
+    let checks = std::cell::Cell::new(0);
+    let cancel = || {
+        checks.set(checks.get() + 1);
+        checks.get() > 1000
+    };
+    let flow = g.push_relabel(&cancel).expect("push/relabel did not terminate");
+    let bk_flow = bk.maxflow_bk();
+    assert!((flow - bk_flow).abs() <= 1e-6 * bk_flow, "{flow} vs {bk_flow}");
+    assert_eq!((0..6).map(|i| g.in_source(i)).collect::<Vec<_>>(), (0..6).map(|i| bk.in_source(i)).collect::<Vec<_>>());
+}
diff --git a/crates/algo/src/segment/mod.rs b/crates/algo/src/segment/mod.rs
index dba4ebfce5..5c190e643a 100644
--- a/crates/algo/src/segment/mod.rs
+++ b/crates/algo/src/segment/mod.rs
@@ -35,7 +35,7 @@ pub mod slic;
 pub mod subject;
 
 use photocraft_geom::Rect;
-use photocraft_raster::Surface;
+use photocraft_raster::{Cancelled, Interrupt, Surface};
 
 pub use crate::selection::Region;
 use gmm::Gmm;
@@ -288,6 +288,9 @@ fn grid_cut_impl<const OPTIMIZED: bool>(
     if count == 0 {
         return Some(out);
     }
+    if cancel() {
+        return None;
+    }
     let mut g = Graph::with_capacity(count as usize, count as usize * 4);
     for i in 0..n {
         if idx[i] != u32::MAX {
@@ -330,6 +333,9 @@ fn grid_cut_impl<const OPTIMIZED: bool>(
             }
         }
     }
+    if cancel() {
+        return None;
+    }
     if OPTIMIZED {
         g.maxflow_with(cancel)?;
     } else {
@@ -539,6 +545,22 @@ pub fn trim_region(r: Region) -> Option<Region> {
 /// pixels wide around the upsampled boundary, using the given colour models, tile by tile.
 /// The result is anti-aliased by one pixel.
 pub fn finish_region(sampler: &dyn Sampler, window: Rect, step: usize, low: &[bool], lw: usize, lh: usize, models: Option<(&Gmm, &Gmm)>) -> Option<Region> {
+    finish_region_with(sampler, window, step, low, lw, lh, models, &Interrupt::NONE).unwrap_or_default()
+}
+
+/// [`finish_region`] that stops with `Err(Cancelled)` once `ctl` is cancelled, asked before each
+/// band tile and inside its min cut.
+#[allow(clippy::too_many_arguments)]
+pub fn finish_region_with(
+    sampler: &dyn Sampler,
+    window: Rect,
+    step: usize,
+    low: &[bool],
+    lw: usize,
+    lh: usize,
+    models: Option<(&Gmm, &Gmm)>,
+    ctl: &Interrupt,
+) -> Result<Option<Region>, Cancelled> {
     let (w, h) = (window.width() as usize, window.height() as usize);
     let mut mask = vec![0u8; w * h];
     if step <= 1 {
@@ -576,16 +598,28 @@ pub fn finish_region(sampler: &dyn Sampler, window: Rect, step: usize, low: &[bo
         #[cfg(target_arch = "wasm32")]
         mask.chunks_mut(w).enumerate().for_each(|(y, r)| fill(y, r));
         if let Some((fg, bg)) = models {
-            refine_band(sampler, window, step, low, &band, lw, lh, fg, bg, &mut mask);
+            refine_band(sampler, window, step, low, &band, lw, lh, fg, bg, &mut mask, ctl)?;
         }
     }
     antialias_u8(&mut mask, w, h);
-    trim_region(Region { bbox: window, mask })
+    Ok(trim_region(Region { bbox: window, mask }))
 }
 
 /// Full-resolution graph cut restricted to the band blocks (see [`finish_region`]).
 #[allow(clippy::too_many_arguments)]
-fn refine_band(sampler: &dyn Sampler, window: Rect, step: usize, low: &[bool], band: &[bool], lw: usize, lh: usize, fg: &Gmm, bg: &Gmm, mask: &mut [u8]) {
+fn refine_band(
+    sampler: &dyn Sampler,
+    window: Rect,
+    step: usize,
+    low: &[bool],
+    band: &[bool],
+    lw: usize,
+    lh: usize,
+    fg: &Gmm,
+    bg: &Gmm,
+    mask: &mut [u8],
+    ctl: &Interrupt,
+) -> Result<(), Cancelled> {
     const T: i32 = 192;
     const HALO: i32 = 12;
     let w = window.width() as usize;
@@ -606,7 +640,9 @@ fn refine_band(sampler: &dyn Sampler, window: Rect, step: usize, low: &[bool], b
         }
         ty += T;
     }
-    let run = |t: &Rect| -> (Rect, Vec<bool>) {
+    let cancel = || ctl.cancelled();
+    let run = |t: &Rect| -> Result<(Rect, Vec<bool>), Cancelled> {
+        ctl.check()?;
         let r = t.inflate(HALO).intersect(&window);
         let img = sampler.rgb(r);
         let (rw, rh) = (r.width() as usize, r.height() as usize);
@@ -629,7 +665,8 @@ fn refine_band(sampler: &dyn Sampler, window: Rect, step: usize, low: &[bool], b
             }
         }
         let beta = contrast_beta(&img);
-        let cut = grid_cut(&img, &cfg, &cbg, &fixed, 50.0, beta);
+        // `grid_cut`'s weight, with the cut stopping on cancel.
+        let cut = grid_cut_cancellable(&img, &cfg, &cbg, &fixed, |d2| 50.0 * (-beta * d2).exp(), &cancel).ok_or(Cancelled)?;
         let (cw, ch) = (t.width() as usize, t.height() as usize);
         let mut core = Vec::with_capacity(cw * ch);
         for yy in 0..ch {
@@ -637,15 +674,16 @@ fn refine_band(sampler: &dyn Sampler, window: Rect, step: usize, low: &[bool], b
             let sx = (t.x0 - r.x0) as usize;
             core.extend_from_slice(&cut[sy * rw + sx..sy * rw + sx + cw]);
         }
-        (*t, core)
+        Ok((*t, core))
     };
+    // A cancelled tile ends the collect; tiles not yet started see `ctl` and return at once.
     #[cfg(not(target_arch = "wasm32"))]
     let results: Vec<(Rect, Vec<bool>)> = {
         use rayon::prelude::*;
-        tiles.par_iter().map(run).collect()
+        tiles.par_iter().map(run).collect::<Result<_, _>>()?
     };
     #[cfg(target_arch = "wasm32")]
-    let results: Vec<(Rect, Vec<bool>)> = tiles.iter().map(run).collect();
+    let results: Vec<(Rect, Vec<bool>)> = tiles.iter().map(run).collect::<Result<_, _>>()?;
     for (t, core) in results {
         let cw = t.width() as usize;
         for (yy, row) in core.chunks_exact(cw).enumerate() {
@@ -655,6 +693,7 @@ fn refine_band(sampler: &dyn Sampler, window: Rect, step: usize, low: &[bool], b
             }
         }
     }
+    Ok(())
 }
 
 /// Deterministic pseudo-random numbers (xorshift) for sampling and tests.
diff --git a/crates/algo/src/segment/quick.rs b/crates/algo/src/segment/quick.rs
index 859575b2cc..8306b6e662 100644
--- a/crates/algo/src/segment/quick.rs
+++ b/crates/algo/src/segment/quick.rs
@@ -88,6 +88,19 @@ pub fn quick_select_with(sampler: &dyn Sampler, canvas: Rect, points: &[(f32, f3
 }
 
 pub(super) fn quick_select_using<const OPTIMIZED: bool>(sampler: &dyn Sampler, canvas: Rect, points: &[(f32, f32)], size: f32, t: &Tuning) -> Option<Region> {
+    quick_select_batched::<OPTIMIZED>(sampler, canvas, points, size, t, SPECULATE).map(|(region, _)| region)
+}
+
+/// [`quick_select_using`] cutting `batch` window sizes at a time (1: one after another). Also
+/// returns how many window sizes, smallest first, it took to find the kept one.
+pub(super) fn quick_select_batched<const OPTIMIZED: bool>(
+    sampler: &dyn Sampler,
+    canvas: Rect,
+    points: &[(f32, f32)],
+    size: f32,
+    t: &Tuning,
+    batch: usize,
+) -> Option<(Region, usize)> {
     if points.is_empty() || canvas.is_empty() {
         return None;
     }
@@ -107,8 +120,15 @@ pub(super) fn quick_select_using<const OPTIMIZED: bool>(sampler: &dyn Sampler, c
     let step = working_step(canvas.width() as usize, canvas.height() as usize) as i32;
     let rw = r / step as f32;
     // Work in a window around the stroke; grow it while the selection runs into its border.
-    let mut margin = (48.0f32).max(2.0 * rw) as i32 * step;
-    loop {
+    // The window's sides are free like the canvas' edges, so a selection that stays clear of
+    // them is kept; one that reaches a side inside the canvas is recomputed in a larger window.
+    // Index of the smallest window kept so far in this batch: larger ones stop cutting.
+    let kept = std::sync::atomic::AtomicUsize::new(usize::MAX);
+    let attempt = |index: usize, margin: i32| -> Attempt {
+        let cancel = || kept.load(std::sync::atomic::Ordering::Relaxed) < index;
+        if cancel() {
+            return Attempt::Cancelled;
+        }
         let snap0 = |v: i32, o: i32| o + (v - o).div_euclid(step) * step;
         let grown = bbox.inflate(margin).intersect(&canvas);
         let window = Rect::new(snap0(grown.x0, canvas.x0), snap0(grown.y0, canvas.y0), grown.x1, grown.y1);
@@ -118,13 +138,13 @@ pub(super) fn quick_select_using<const OPTIMIZED: bool>(sampler: &dyn Sampler, c
         let pts: Vec<(f32, f32)> = points.iter().map(|&(x, y)| ((x - window.x0 as f32) / s, (y - window.y0 as f32) / s)).collect();
         let seeds = stroke_mask(&pts, rw.max(0.5), lw, lh);
         if !seeds.iter().any(|v| *v) {
-            return None;
+            return Attempt::NoSeeds;
+        }
+        if cancel() {
+            return Attempt::Cancelled;
         }
-        // The window's sides are free like the canvas' edges, so a selection that stays clear of
-        // them is the best over the whole canvas too (outside the window it could only add cost).
-        // One that reaches a side inside the canvas is recomputed in a larger window.
         let inner = [window.x0 > canvas.x0, window.y0 > canvas.y0, window.x1 < canvas.x1, window.y1 < canvas.y1];
-        let low = select_working_using::<OPTIMIZED>(&img, &seeds, rw, t);
+        let Some(low) = select_working_using::<OPTIMIZED>(&img, &seeds, rw, t, &cancel) else { return Attempt::Cancelled };
         let touches = |side: usize| match side {
             0 => (0..lh).any(|y| low[y * lw]),
             1 => (0..lw).any(|x| low[x]),
@@ -132,21 +152,87 @@ pub(super) fn quick_select_using<const OPTIMIZED: bool>(sampler: &dyn Sampler, c
             _ => (0..lw).any(|x| low[(lh - 1) * lw + x]),
         };
         if (0..4).any(|k| inner[k] && touches(k)) {
-            margin = margin.saturating_mul(2);
-            continue;
+            return Attempt::Touches;
         }
-        let mask = upsample(&low, lw, lh, step as usize, window.width() as usize, window.height() as usize);
-        return super::trim_region(Region { bbox: window, mask });
+        kept.fetch_min(index, std::sync::atomic::Ordering::Relaxed);
+        Attempt::Done { window, low, lw, lh }
+    };
+    let mut margin = (48.0f32).max(2.0 * rw) as i32 * step;
+    let mut sizes = 0;
+    loop {
+        // The attempts don't depend on each other, so a few window sizes are cut at once and the
+        // first in growing order that stays clear of its sides is kept: the same result as trying
+        // them one after another, without waiting for the smaller ones to fail first. Once one is
+        // kept, the larger ones still cutting stop, so a stroke settled by a small window costs
+        // about what that window alone costs.
+        let batch = margins_to_try(margin, bbox, canvas, batch);
+        kept.store(usize::MAX, std::sync::atomic::Ordering::Relaxed);
+        #[cfg(not(target_arch = "wasm32"))]
+        let results: Vec<Attempt> = {
+            use rayon::prelude::*;
+            batch.par_iter().enumerate().map(|(i, &m)| attempt(i, m)).collect()
+        };
+        #[cfg(target_arch = "wasm32")]
+        let results: Vec<Attempt> = batch.iter().enumerate().map(|(i, &m)| attempt(i, m)).collect();
+        for result in results {
+            sizes += 1;
+            match result {
+                Attempt::NoSeeds => return None,
+                // Only a window larger than one already kept is cancelled, and that one comes
+                // first in this order, so a cancelled attempt is never reached.
+                Attempt::Touches | Attempt::Cancelled => continue,
+                Attempt::Done { window, low, lw, lh } => {
+                    let mask = upsample(&low, lw, lh, step as usize, window.width() as usize, window.height() as usize);
+                    return super::trim_region(Region { bbox: window, mask }).map(|region| (region, sizes));
+                }
+            }
+        }
+        let &last = batch.last()?;
+        margin = last.saturating_mul(2);
     }
 }
 
+/// One window size's outcome in [`quick_select_using`].
+enum Attempt {
+    /// The stroke misses the window.
+    NoSeeds,
+    /// The selection reaches a side of the window inside the canvas.
+    Touches,
+    /// A smaller window of the same batch was kept first.
+    Cancelled,
+    Done {
+        window: Rect,
+        low: Vec<bool>,
+        lw: usize,
+        lh: usize,
+    },
+}
+
+/// Window sizes cut together: most strokes settle within this many doublings.
+const SPECULATE: usize = 4;
+
+/// The next `count` margins from `margin`, doubling, stopping at the first one whose window
+/// already covers the whole canvas (a larger one would be the same window).
+pub(super) fn margins_to_try(margin: i32, bbox: Rect, canvas: Rect, count: usize) -> Vec<i32> {
+    let mut out = Vec::with_capacity(count.max(1));
+    let mut m = margin;
+    for _ in 0..count.max(1) {
+        out.push(m);
+        if bbox.inflate(m).intersect(&canvas) == canvas {
+            break;
+        }
+        m = m.saturating_mul(2);
+    }
+    out
+}
+
 /// The model at working resolution: `seeds` (the brush footprint, `radius` working pixels) are
 /// selected; returns the selection.
 pub fn select_working(img: &RgbImage, seeds: &[bool], radius: f32, t: &Tuning) -> Vec<bool> {
-    select_working_using::<true>(img, seeds, radius, t)
+    select_working_using::<true>(img, seeds, radius, t, &|| false).unwrap_or_default()
 }
 
-fn select_working_using<const OPTIMIZED: bool>(img: &RgbImage, seeds: &[bool], radius: f32, t: &Tuning) -> Vec<bool> {
+fn select_working_using<const OPTIMIZED: bool>(img: &RgbImage, seeds: &[bool], radius: f32, t: &Tuning, cancel: &dyn Fn() -> bool) -> Option<Vec<bool>> {
     let (w, h) = (img.w, img.h);
     let d = crate::selection::edt(seeds, w, h);
     let grow = (t.grow + t.grow_frac * radius).max(0.0);
@@ -154,7 +240,10 @@ fn select_working_using<const OPTIMIZED: bool>(img: &RgbImage, seeds: &[bool], r
     let fixed: Vec<u8> = d.iter().map(|d| if *d <= grow { HARD_FG } else { FREE }).collect();
     let (floor, sigma, k) = (t.floor, t.sigma.max(1e-4), t.k);
     let weight = move |d2: f32| floor + 1.0 / (1.0 + (d2.sqrt() / sigma).powf(k));
-    cut_levels::<OPTIMIZED>(img, &fixed, &cost_fg, &weight, 1.0, t.direct_px.max(1024))
+    if cancel() {
+        return None;
+    }
+    cut_levels::<OPTIMIZED>(img, &fixed, &cost_fg, &weight, 1.0, t.direct_px.max(1024), cancel)
 }
 
 /// Band half-width (pixels) re-cut at each finer level.
@@ -164,11 +253,19 @@ const BAND: f32 = 3.0;
 /// problem (colours averaged, pixel costs summed, cut weights doubled since a coarse side spans two
 /// fine ones) gives a boundary, and the full-size cut is redone only within `BAND` of it. Seeds
 /// stay foreground.
-fn cut_levels<const OPTIMIZED: bool>(img: &RgbImage, fixed: &[u8], cost_fg: &[f32], weight: &dyn Fn(f32) -> f32, scale: f32, direct_px: usize) -> Vec<bool> {
+fn cut_levels<const OPTIMIZED: bool>(
+    img: &RgbImage,
+    fixed: &[u8],
+    cost_fg: &[f32],
+    weight: &dyn Fn(f32) -> f32,
+    scale: f32,
+    direct_px: usize,
+    cancel: &dyn Fn() -> bool,
+) -> Option<Vec<bool>> {
     let (w, h) = (img.w, img.h);
     let zeros = vec![0.0f32; w * h];
     if w * h <= direct_px || w < 8 || h < 8 {
-        return super::grid_cut_weighted::<OPTIMIZED>(img, cost_fg, &zeros, fixed, |d2| scale * weight(d2));
+        return super::grid_cut_impl::<OPTIMIZED>(img, cost_fg, &zeros, fixed, |d2| scale * weight(d2), cancel);
     }
     let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));
     let coarse_img = img.downsample(2);
@@ -183,7 +280,10 @@ fn cut_levels<const OPTIMIZED: bool>(img: &RgbImage, fixed: &[u8], cost_fg: &[f3
             }
         }
     }
-    let coarse = cut_levels::<OPTIMIZED>(&coarse_img, &cfix, &ccost, weight, scale * 2.0, direct_px);
+    let coarse = cut_levels::<OPTIMIZED>(&coarse_img, &cfix, &ccost, weight, scale * 2.0, direct_px, cancel)?;
+    if cancel() {
+        return None;
+    }
     let proj: Vec<bool> = (0..w * h).map(|i| coarse[(i / w / 2) * cw + (i % w) / 2]).collect();
     // Band: within BAND of the projected boundary.
     let edge: Vec<bool> = (0..w * h)
@@ -194,7 +294,7 @@ fn cut_levels<const OPTIMIZED: bool>(img: &RgbImage, fixed: &[u8], cost_fg: &[f3
         })
         .collect();
     if !edge.iter().any(|e| *e) {
-        return (0..w * h).map(|i| proj[i] || fixed[i] == HARD_FG).collect();
+        return Some((0..w * h).map(|i| proj[i] || fixed[i] == HARD_FG).collect());
     }
     let near = crate::selection::edt(&edge, w, h);
     let banded: Vec<u8> = (0..w * h)
@@ -210,7 +310,7 @@ fn cut_levels<const OPTIMIZED: bool>(img: &RgbImage, fixed: &[u8], cost_fg: &[f3
             }
         })
         .collect();
-    super::grid_cut_weighted::<OPTIMIZED>(img, cost_fg, &zeros, &banded, |d2| scale * weight(d2))
+    super::grid_cut_impl::<OPTIMIZED>(img, cost_fg, &zeros, &banded, |d2| scale * weight(d2), cancel)
 }
 
 /// Pixels within `radius` (working pixels) of the polyline `pts`, plus each point's own pixel.
diff --git a/crates/algo/src/segment/sky.rs b/crates/algo/src/segment/sky.rs
index 74fc62790d..a54bcf6772 100644
--- a/crates/algo/src/segment/sky.rs
+++ b/crates/algo/src/segment/sky.rs
@@ -132,9 +132,31 @@ pub fn sky_mask_low(img: &RgbImage, threshold: f32) -> Option<Vec<bool>> {
         }
     }
     let mask = clean_mask(&mask, w, h, 0.002, 0.01);
+    if is_backdrop(img, &mask, top) {
+        return None;
+    }
     mask.iter().any(|v| *v).then_some(mask)
 }
 
+/// A neutral region that also covers most of the bottom rows is a studio or product backdrop,
+/// not an overcast sky (which never reaches the bottom of a photo); blue sky is never one.
+fn is_backdrop(img: &RgbImage, mask: &[bool], rows: usize) -> bool {
+    let (w, h) = (img.w, img.h);
+    let bottom = (h - rows.min(h)) * w..h * w;
+    let Some(bottom_rows) = mask.get(bottom) else { return false };
+    let covered = bottom_rows.iter().filter(|m| **m).count();
+    if covered * 10 < bottom_rows.len() * 6 {
+        return false;
+    }
+    let (mut sat, mut n) = (0.0f32, 0usize);
+    for (p, _) in img.px.iter().zip(mask).filter(|(_, m)| **m) {
+        let (mx, mn) = (p[0].max(p[1]).max(p[2]), p[0].min(p[1]).min(p[2]));
+        sat += if mx > 1e-4 { (mx - mn) / mx } else { 0.0 };
+        n += 1;
+    }
+    n > 0 && sat / (n as f32) < 0.1
+}
+
 /// Selects the sky over `canvas`. `None` if no sky was found.
 pub fn select_sky(sampler: &dyn Sampler, canvas: Rect, p: SkyParams) -> Option<Region> {
     if canvas.width() < 4 || canvas.height() < 4 {
@@ -269,6 +291,18 @@ mod tests {
         assert!(r.at(30, 10) > 0.9 && r.at(30, 50) < 0.1);
     }
 
+    /// #4634: a near-white studio backdrop around a product is not an overcast sky, but blue sky
+    /// reaching the bottom (a photo taken upward) still is.
+    #[test]
+    fn a_white_backdrop_is_not_sky_but_a_blue_sky_down_to_the_bottom_is() {
+        let disc = |x: usize, y: usize| ((x as f32 - 75.0).powi(2) + (y as f32 - 50.0).powi(2)).sqrt() < 30.0;
+        let img = RgbImage::from_fn(150, 100, |x, y| if disc(x, y) { [0.12, 0.12, 0.12] } else { [0.95, 0.95, 0.94] });
+        assert!(select_sky(&ImageSampler { img: &img, origin: (0, 0) }, Rect::new(0, 0, 150, 100), SkyParams::default()).is_none());
+        let img = RgbImage::from_fn(150, 100, |x, y| if disc(x, y) { [0.12, 0.3, 0.1] } else { [0.35, 0.6, 0.95] });
+        let r = select_sky(&ImageSampler { img: &img, origin: (0, 0) }, Rect::new(0, 0, 150, 100), SkyParams::default()).expect("blue sky");
+        assert!(r.at(5, 95) > 0.9 && r.at(75, 50) < 0.1);
+    }
+
     #[test]
     fn colour_prior_ranks_sky_over_foliage() {
         assert!(colour_prior([0.4, 0.6, 0.95]) > 0.8);
diff --git a/crates/algo/src/segment/subject.rs b/crates/algo/src/segment/subject.rs
index 6002672adb..b117bb5ef6 100644
--- a/crates/algo/src/segment/subject.rs
+++ b/crates/algo/src/segment/subject.rs
@@ -23,6 +23,7 @@ use std::cmp::Ordering;
 use std::collections::BinaryHeap;
 
 use photocraft_geom::Rect;
+use photocraft_raster::{Cancelled, Interrupt};
 
 use super::grabcut::{self, BG, PR_BG, PR_FG};
 use super::slic::{rgb_to_lab, slic_lab};
@@ -35,13 +36,20 @@ const SIGMA_SPA: f32 = 0.25;
 
 /// Selects the most salient object on the canvas.
 pub fn select_subject(sampler: &dyn Sampler, canvas: Rect) -> Option<Region> {
+    select_subject_with(sampler, canvas, &Interrupt::NONE).unwrap_or_default()
+}
+
+/// [`select_subject`] that stops with `Err(Cancelled)` once `ctl` is cancelled, asked between
+/// stages and inside every min cut (the GrabCut iterations and the full-resolution re-cut).
+pub fn select_subject_with(sampler: &dyn Sampler, canvas: Rect, ctl: &Interrupt) -> Result<Option<Region>, Cancelled> {
     if canvas.width() < 4 || canvas.height() < 4 {
-        return None;
+        return Ok(None);
     }
     let step = super::scale_for(canvas, WORK_PX);
     let img = sampler.rgb_scaled(canvas, step);
     let (w, h) = (img.w, img.h);
     let sal = saliency(&img);
+    ctl.check()?;
     let t = otsu(&sal).clamp(0.15, 0.85);
     let mut trimap = vec![PR_BG; w * h];
     let mut any_fg = false;
@@ -60,15 +68,15 @@ pub fn select_subject(sampler: &dyn Sampler, canvas: Rect) -> Option<Region> {
         }
     }
     if !any_fg {
-        return None;
+        return Ok(None);
     }
-    let (fg, bg) = grabcut::grabcut(&img, &mut trimap, 6)?;
+    let Some((fg, bg)) = grabcut::grabcut_with(&img, &mut trimap, 6, ctl)? else { return Ok(None) };
     let low: Vec<bool> = trimap.iter().map(|v| *v == PR_FG || *v == grabcut::FG).collect();
     let low = super::clean_mask(&low, w, h, 0.2, 0.05);
     if !low.iter().any(|v| *v) {
-        return None;
+        return Ok(None);
     }
-    super::finish_region(sampler, canvas, step, &low, w, h, Some((&fg, &bg)))
+    super::finish_region_with(sampler, canvas, step, &low, w, h, Some((&fg, &bg)), ctl)
 }
 
 /// Per-pixel saliency in `0..=1` (see the module docs).
diff --git a/crates/algo/src/segment/tests.rs b/crates/algo/src/segment/tests.rs
index c3a37dc6dd..55ddc6cafd 100644
--- a/crates/algo/src/segment/tests.rs
+++ b/crates/algo/src/segment/tests.rs
@@ -344,6 +344,45 @@ fn quick_select_with_points_far_off_canvas_selects_nothing() {
     }
 }
 
+#[test]
+fn quick_select_cuts_window_sizes_in_parallel_with_the_same_result() {
+    // Soft gradients and faint blobs let a selection spread, so most strokes need more than one
+    // window size; cutting several at once must keep exactly what one-after-another keeps.
+    let (w, h) = (1200usize, 900usize);
+    let img = RgbImage::from_fn(w, h, |x, y| {
+        let (fx, fy) = (x as f32 / w as f32, y as f32 / h as f32);
+        let blob = (((fx * 9.0).sin() * (fy * 7.0).cos()) * 0.5 + 0.5) * 0.06;
+        [0.3 + 0.4 * fx + blob, 0.5 + 0.2 * fy, 0.7 - 0.3 * fx + blob]
+    });
+    let s = ImageSampler { img: &img, origin: (0, 0) };
+    let canvas = Rect::new(0, 0, w as i32, h as i32);
+    let t = quick::Tuning::default();
+    let strokes: [(&[(f32, f32)], f32); 4] = [
+        (&[(300.0, 300.0)], 30.0),
+        (&[(500.0, 400.0), (580.0, 400.0), (660.0, 420.0)], 60.0),
+        (&[(200.0, 700.0), (260.0, 650.0), (320.0, 700.0), (380.0, 650.0)], 30.0),
+        (&[(900.0, 200.0)], 120.0),
+    ];
+    let mut most = 0;
+    for (pts, size) in strokes {
+        let one = quick::quick_select_batched::<true>(&s, canvas, pts, size, &t, 1);
+        let many = quick::quick_select_batched::<true>(&s, canvas, pts, size, &t, 4);
+        assert_eq!(one.as_ref().map(|(r, n)| (r.bbox, &r.mask, n)), many.as_ref().map(|(r, n)| (r.bbox, &r.mask, n)), "{pts:?} size {size}");
+        most = most.max(one.map_or(0, |(_, n)| n));
+    }
+    assert!(most > 1, "no stroke needed a larger window, so the test exercises nothing");
+}
+
+#[test]
+fn quick_select_window_sizes_stop_at_the_canvas() {
+    let canvas = Rect::new(0, 0, 1000, 800);
+    let bbox = Rect::new(400, 300, 460, 360);
+    assert_eq!(quick::margins_to_try(96, bbox, canvas, 4), vec![96, 192, 384, 768]);
+    // 768 already covers the canvas: no larger (identical) window is cut.
+    assert_eq!(quick::margins_to_try(384, bbox, canvas, 4), vec![384, 768]);
+    assert_eq!(quick::margins_to_try(96, bbox, canvas, 0), vec![96]);
+}
+
 #[test]
 fn quick_select_grows_without_leaking() {
     let img = two_regions(140, 100);
@@ -526,6 +565,87 @@ fn select_subject_finds_centred_object() {
     assert!(v > 0.9, "IoU {v}");
 }
 
+/// Counts full-resolution reads; the working copy goes through `rgb_scaled` uncounted, so each
+/// read is one band tile of the full-resolution re-cut.
+struct TileReads<'a>(ImageSampler<'a>, std::sync::atomic::AtomicUsize);
+
+impl Sampler for TileReads<'_> {
+    fn rgba(&self, r: Rect) -> Vec<[f32; 4]> {
+        self.1.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        self.0.rgba(r)
+    }
+    fn rgb_scaled(&self, r: Rect, step: usize) -> RgbImage {
+        self.0.rgb_scaled(r, step)
+    }
+}
+
+#[test]
+fn finish_region_cancel_stops_inside_the_band_cut() {
+    use photocraft_raster::{Cancelled, Interrupt};
+    use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+    // One 180-pixel window is one band tile, and nothing asks after the band re-cut, so a cancel
+    // seen after the tile's own check can only have been seen inside its min cut.
+    let (n, step) = (180, 3);
+    let (img, truth) = disc_scene(n, n, 90.0, 90.0, 55.0, 4);
+    let s = ImageSampler { img: &img, origin: (0, 0) };
+    let ln = n / step;
+    let low: Vec<bool> = (0..ln * ln).map(|i| truth[((i / ln) * step + 1) * n + (i % ln) * step + 1]).collect();
+    let (fs, bs): (Vec<_>, Vec<_>) = img.px.iter().zip(&truth).partition(|(_, t)| **t);
+    let fit = |v: Vec<(&[f32; 3], &bool)>| Gmm::fit(&v.iter().map(|(p, _)| **p).collect::<Vec<_>>(), 5, gmm::DEFAULT_REG).unwrap();
+    let (fg, bg) = (fit(fs), fit(bs));
+    let window = Rect::new(0, 0, n as i32, n as i32);
+    let polls = AtomicUsize::new(0);
+    let finish = |cancel_from: usize| {
+        polls.store(0, SeqCst);
+        let cancel = || polls.fetch_add(1, SeqCst) + 1 >= cancel_from;
+        finish_region_with(&s, window, step, &low, ln, ln, Some((&fg, &bg)), &Interrupt::cancel_only(&cancel))
+    };
+    let reg = finish(usize::MAX).unwrap().unwrap();
+    assert!(polls.load(SeqCst) >= 2, "the cut polls too ({} polls)", polls.load(SeqCst));
+    assert!(iou(&reg, &truth, n, n) > 0.95);
+    assert_eq!(finish_region(&s, window, step, &low, ln, ln, Some((&fg, &bg))), Some(reg));
+    // Cancelled at the cut's first poll (the second in all): no region.
+    assert_eq!(finish(2), Err(Cancelled));
+    assert_eq!(polls.load(SeqCst), 2);
+    assert_eq!(finish(1), Err(Cancelled), "cancelled before the tile");
+}
+
+#[test]
+fn select_subject_cancelled_in_the_band_recut_reads_no_more_tiles() {
+    use photocraft_raster::{Cancelled, Interrupt};
+    use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+    let (w, h) = (3000, 2000);
+    let (img, truth) = disc_scene(w, h, 1500.0, 1000.0, 700.0, 6);
+    let canvas = Rect::new(0, 0, w as i32, h as i32);
+    let sampler = || TileReads(ImageSampler { img: &img, origin: (0, 0) }, AtomicUsize::new(0));
+
+    // Not cancelled: the same region as `select_subject`, and the band cuts themselves ask
+    // (more polls once tiles are read than the one check before each tile).
+    let s = sampler();
+    let band_polls = AtomicUsize::new(0);
+    let count = || {
+        if s.1.load(SeqCst) > 0 {
+            band_polls.fetch_add(1, SeqCst);
+        }
+        false
+    };
+    let reg = subject::select_subject_with(&s, canvas, &Interrupt::cancel_only(&count)).unwrap().unwrap();
+    let tiles = s.1.load(SeqCst);
+    assert!(tiles > 4, "{tiles} band tiles");
+    assert!(band_polls.load(SeqCst) > tiles, "{} polls over {tiles} tiles", band_polls.load(SeqCst));
+    assert!(iou(&reg, &truth, w, h) > 0.9);
+    assert_eq!(subject::select_subject(&sampler(), canvas), Some(reg));
+
+    // Cancelled once the first tile is read: the run stops there instead of re-cutting every
+    // tile. One thread, so no other tile is already in flight.
+    let s = sampler();
+    let cancel = || s.1.load(SeqCst) > 0;
+    let pool = rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    let r = pool.install(|| subject::select_subject_with(&s, canvas, &Interrupt::cancel_only(&cancel)));
+    assert_eq!(r, Err(Cancelled));
+    assert_eq!(s.1.load(SeqCst), 1, "tiles read after the cancel");
+}
+
 #[test]
 fn saliency_highlights_the_object() {
     let (img, truth) = disc_scene(120, 90, 60.0, 45.0, 22.0, 8);
@@ -620,3 +740,24 @@ fn dump_quick_scenes() {
     save("thin_line", &line);
     save("disc_scene", &disc_scene(600, 500, 300.0, 250.0, 180.0, 4).0);
 }
+
+#[test]
+fn object_at_finds_the_disc_under_the_cursor() {
+    let (img, truth) = disc_scene(320, 240, 160.0, 120.0, 70.0, 7);
+    let s = ImageSampler { img: &img, origin: (0, 0) };
+    let canvas = Rect::new(0, 0, 320, 240);
+    let reg = grabcut::object_at(&s, canvas, 165.0, 118.0, 20_000).unwrap();
+    let v = iou(&reg, &truth, 320, 240);
+    assert!(v > 0.9, "IoU {v}");
+}
+
+#[test]
+fn object_at_on_the_background_or_off_canvas_finds_nothing() {
+    let (img, _) = disc_scene(320, 240, 160.0, 120.0, 70.0, 7);
+    let s = ImageSampler { img: &img, origin: (0, 0) };
+    let canvas = Rect::new(0, 0, 320, 240);
+    assert!(grabcut::object_at(&s, canvas, 10.0, 10.0, 20_000).is_none());
+    assert!(grabcut::object_at(&s, canvas, -5.0, 10.0, 20_000).is_none());
+    assert!(grabcut::object_at(&s, canvas, f32::NAN, 10.0, 20_000).is_none());
+    assert!(grabcut::object_at(&s, canvas, 400.0, 10.0, 0).is_none());
+}
diff --git a/crates/algo/src/selection.rs b/crates/algo/src/selection.rs
index 4ce834d209..ad858df2a2 100644
--- a/crates/algo/src/selection.rs
+++ b/crates/algo/src/selection.rs
@@ -166,7 +166,8 @@ fn close(a: [f32; 4], b: [f32; 4], tol: f32) -> bool {
 /// around the seed. `px` covers `area`.
 pub fn magic_wand(px: &[[f32; 4]], area: Rect, seed: (i32, i32), tolerance: f32, contiguous: bool, anti_alias: bool) -> Vec<f32> {
     let (w, h) = (area.width() as usize, area.height() as usize);
-    let mut m = vec![0.0f32; w * h];
+    let Some(n) = w.checked_mul(h).filter(|&n| n <= px.len()) else { return Vec::new() };
+    let mut m = vec![0.0f32; n];
     if !area.contains(seed.0, seed.1) {
         return m;
     }
@@ -245,7 +246,9 @@ impl Region {
         if !self.bbox.contains(x, y) {
             return 0.0;
         }
-        self.mask[(y - self.bbox.y0) as usize * self.bbox.width() as usize + (x - self.bbox.x0) as usize] as f32 / 255.0
+        let row = (y.abs_diff(self.bbox.y0) as usize).checked_mul(self.bbox.width() as usize);
+        let value = row.and_then(|i| i.checked_add(x.abs_diff(self.bbox.x0) as usize)).and_then(|i| self.mask.get(i)).copied().unwrap_or(0);
+        f32::from(value) / 255.0
     }
 }
 
@@ -257,6 +260,9 @@ pub fn wand_region(img: &[[u8; 4]], area: Rect, seed: (i32, i32), tolerance: f32
         return None;
     }
     let (w, h) = (area.width() as usize, area.height() as usize);
+    if w.checked_mul(h).is_none_or(|n| n > img.len()) {
+        return None;
+    }
     let target = img[(seed.1 - area.y0) as usize * w + (seed.0 - area.x0) as usize];
     let tol = (tolerance + 1e-3).floor().max(0.0) as i32;
     // Copying a selection can leave RGB under zero alpha. Those invisible colours must not
@@ -692,6 +698,40 @@ pub fn hue_range(px: &[[f32; 4]], center: f32) -> Vec<f32> {
         .collect()
 }
 
+/// Color Range › Select: Skin Tones. Skin of every complexion falls in a compact region of the
+/// YCbCr chroma plane (Chai & Ngan, "Face segmentation using skin-color map", 1999: Cb about
+/// 77..127, Cr about 133..173, Rec. 601 on 0..255) that runs from pale (higher Cb, lower Cr) to
+/// saturated (lower Cb, higher Cr). Pixels inside an ellipse along that run are fully selected;
+/// outside, selection falls off linearly over `fuzziness` (0..200, as the dialog's Fuzziness: 100
+/// is one ellipse radius). Pale neutrals such as cream or beige sit just off its pale end, so they
+/// stay out. Near-black and near-white pixels, whose chroma is noise, are faded out.
+pub fn skin_tones(px: &[[f32; 4]], fuzziness: f32) -> Vec<f32> {
+    const CB: f32 = 104.0;
+    const CR: f32 = 158.0;
+    /// Radii along the run and across it, and the run's angle from the Cb axis.
+    const ALONG: f32 = 22.0;
+    const ACROSS: f32 = 14.0;
+    const ANGLE: f32 = -40.0;
+    let (sin, cos) = ANGLE.to_radians().sin_cos();
+    let ramp = (fuzziness / 100.0).max(1e-3);
+    px.iter()
+        .map(|&[r, g, b, a]| {
+            if a <= 0.0 {
+                return 0.0;
+            }
+            let [r, g, b] = [r, g, b].map(|v| v.clamp(0.0, 1.0) * 255.0);
+            let y = 0.299 * r + 0.587 * g + 0.114 * b;
+            let cb = 128.0 - 0.168_736 * r - 0.331_264 * g + 0.5 * b - CB;
+            let cr = 128.0 + 0.5 * r - 0.418_688 * g - 0.081_312 * b - CR;
+            let d = ((cos * cb + sin * cr) / ALONG).hypot((cos * cr - sin * cb) / ACROSS);
+            let chroma = (1.0 - (d - 1.0) / ramp).clamp(0.0, 1.0);
+            let dark = ((y - 25.0) / 30.0).clamp(0.0, 1.0);
+            let bright = ((250.0 - y) / 20.0).clamp(0.0, 1.0);
+            chroma * dark * bright
+        })
+        .collect()
+}
+
 /// Color Range › Select: Highlights, Midtones or Shadows. Pixels whose luminance (Rec. 601
 /// weights, 0..255) lies in `lo..=hi` are fully selected; outside, selection falls off linearly
 /// to 0 over `falloff` levels (the dialog's Fuzziness).
@@ -766,47 +806,84 @@ pub fn feather(m: &[f32], w: usize, h: usize, radius: f32) -> Vec<f32> {
 }
 
 /// Anti-aliased polygon (even-odd) coverage over `area`: exact horizontal
-/// coverage, 4 sub-rows per pixel row (or 1 when not anti-aliased).
+/// coverage, 4 sub-rows per pixel row (or 1 when not anti-aliased). Bands of
+/// rows are filled in parallel, and each sub-row tests only the edges that
+/// cross it (an active edge list over the edges sorted by their top).
 pub fn polygon(points: &[(f32, f32)], area: Rect, anti_alias: bool) -> Vec<f32> {
     let (w, h) = (area.width() as usize, area.height() as usize);
     let mut m = vec![0.0f32; w * h];
-    if points.len() < 3 {
+    if points.len() < 3 || w == 0 {
         return m;
     }
     let sub = if anti_alias { 4 } else { 1 };
-    let mut xs: Vec<f32> = Vec::new();
-    for py in 0..h {
-        for s in 0..sub {
-            let y = area.y0 as f32 + py as f32 + (s as f32 + 0.5) / sub as f32;
-            xs.clear();
-            for i in 0..points.len() {
-                let (a, b) = (points[i], points[(i + 1) % points.len()]);
-                if (a.1 <= y && b.1 > y) || (b.1 <= y && a.1 > y) {
-                    xs.push(a.0 + (y - a.1) / (b.1 - a.1) * (b.0 - a.0));
-                }
+    let sample_y = |py: usize, s: usize| area.y0 as f32 + py as f32 + (s as f32 + 0.5) / sub as f32;
+    // A sub-row at y crosses the edge a→b iff top <= y < bottom; horizontal and NaN edges
+    // never cross one.
+    struct Edge {
+        top: f32,
+        bottom: f32,
+        a: (f32, f32),
+        b: (f32, f32),
+    }
+    let mut edges: Vec<Edge> = points
+        .iter()
+        .zip(points.iter().cycle().skip(1))
+        .filter_map(|(&a, &b)| {
+            if a.1 < b.1 {
+                Some(Edge { top: a.1, bottom: b.1, a, b })
+            } else if b.1 < a.1 {
+                Some(Edge { top: b.1, bottom: a.1, a, b })
+            } else {
+                None
             }
-            xs.sort_by(|a, b| a.total_cmp(b));
-            for span in xs.as_chunks::<2>().0 {
-                let (x0, x1) = ((span[0] - area.x0 as f32).max(0.0), (span[1] - area.x0 as f32).min(w as f32));
-                if x1 <= x0 {
+        })
+        .collect();
+    edges.sort_by(|p, q| p.top.total_cmp(&q.top));
+    const BAND: usize = 64;
+    par_rows(&mut m, w, BAND, |bi, rows| {
+        let py0 = bi * BAND;
+        let (first, last) = (sample_y(py0, 0), sample_y(py0 + rows.len() / w - 1, sub - 1));
+        let reach = edges.partition_point(|e| e.top <= last);
+        let band_edges = edges.get(..reach).unwrap_or_default();
+        let mut pending = band_edges.iter().filter(|e| e.bottom > first).peekable();
+        let mut active: Vec<&Edge> = Vec::new();
+        let mut xs: Vec<f32> = Vec::new();
+        for (r, row) in rows.chunks_exact_mut(w).enumerate() {
+            for s in 0..sub {
+                // Sub-row ys never decrease, so an edge whose bottom is passed stays out.
+                let y = sample_y(py0 + r, s);
+                while let Some(e) = pending.next_if(|e| e.top <= y) {
+                    active.push(e);
+                }
+                active.retain(|e| e.bottom > y);
+                if active.is_empty() {
                     continue;
                 }
-                let (c0, c1) = (x0.floor() as usize, (x1.ceil() as usize).min(w));
-                for cx in c0..c1 {
-                    let cov = if anti_alias {
-                        ((cx + 1) as f32).min(x1) - (cx as f32).max(x0)
-                    } else {
-                        let c = cx as f32 + 0.5;
-                        if c >= x0 && c < x1 { 1.0 } else { 0.0 }
-                    };
-                    m[py * w + cx] += cov.max(0.0) / sub as f32;
+                xs.clear();
+                xs.extend(active.iter().map(|&&Edge { a, b, .. }| a.0 + (y - a.1) / (b.1 - a.1) * (b.0 - a.0)));
+                xs.sort_by(|a, b| a.total_cmp(b));
+                for span in xs.as_chunks::<2>().0 {
+                    let (x0, x1) = ((span[0] - area.x0 as f32).max(0.0), (span[1] - area.x0 as f32).min(w as f32));
+                    if x1 <= x0 {
+                        continue;
+                    }
+                    let (c0, c1) = (x0.floor() as usize, (x1.ceil() as usize).min(w));
+                    for (cx, v) in row.iter_mut().enumerate().take(c1).skip(c0) {
+                        let cov = if anti_alias {
+                            ((cx + 1) as f32).min(x1) - (cx as f32).max(x0)
+                        } else {
+                            let c = cx as f32 + 0.5;
+                            if c >= x0 && c < x1 { 1.0 } else { 0.0 }
+                        };
+                        *v += cov.max(0.0) / sub as f32;
+                    }
                 }
             }
         }
-    }
-    for v in &mut m {
-        *v = v.min(1.0);
-    }
+        for v in rows {
+            *v = v.min(1.0);
+        }
+    });
     m
 }
 
@@ -865,6 +942,28 @@ mod tests {
         }
     }
 
+    #[test]
+    fn skin_tones_selects_skin_and_not_cream_or_white() {
+        let px = |rgb: [u8; 3]| [rgb[0], rgb[1], rgb[2]].map(|v| f32::from(v) / 255.0);
+        let rgba = |rgb: [u8; 3]| {
+            let [r, g, b] = px(rgb);
+            [r, g, b, 1.0]
+        };
+        // Skin in light and shadow, then a cream shirt, a near-white wall, blue denim and black.
+        let skin =
+            [[183, 119, 81], [177, 132, 93], [180, 121, 84], [120, 76, 52], [173, 107, 75], [255, 219, 172], [194, 140, 104], [141, 85, 36], [92, 51, 23]]
+                .map(rgba);
+        let m = skin_tones(&skin, 40.0);
+        assert!(m.iter().all(|&v| v > 0.95), "skin {m:?}");
+        let other = [[231, 225, 202], [252, 253, 247], [40, 60, 110], [5, 5, 5], [128, 128, 128], [220, 40, 40], [200, 160, 40]].map(rgba);
+        let m = skin_tones(&other, 40.0);
+        assert!(m.iter().all(|&v| v < 0.05), "not skin {m:?}");
+        // Fuzziness widens the region; transparent pixels are never selected.
+        let pale = [rgba([230, 215, 200])];
+        assert!(skin_tones(&pale, 200.0)[0] > skin_tones(&pale, 0.0)[0]);
+        assert_eq!(skin_tones(&[[0.7, 0.45, 0.3, 0.0]], 40.0), vec![0.0]);
+    }
+
     #[test]
     fn color_range_falloff() {
         let px = vec![[1.0, 0.0, 0.0, 1.0], [0.9, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0], [1.0, 0.0, 0.0, 0.0]];
@@ -1161,6 +1260,107 @@ mod tests {
         assert!(polygon(&[(0.0, 0.0), (1.0, 1.0)], a, true).iter().all(|v| *v == 0.0));
     }
 
+    /// The previous polygon fill (every edge tested on every sub-row), kept as the oracle.
+    fn old_polygon(points: &[(f32, f32)], area: Rect, anti_alias: bool) -> Vec<f32> {
+        let (w, h) = (area.width() as usize, area.height() as usize);
+        let mut m = vec![0.0f32; w * h];
+        if points.len() < 3 {
+            return m;
+        }
+        let sub = if anti_alias { 4 } else { 1 };
+        let mut xs: Vec<f32> = Vec::new();
+        for py in 0..h {
+            for s in 0..sub {
+                let y = area.y0 as f32 + py as f32 + (s as f32 + 0.5) / sub as f32;
+                xs.clear();
+                for i in 0..points.len() {
+                    let (a, b) = (points[i], points[(i + 1) % points.len()]);
+                    if (a.1 <= y && b.1 > y) || (b.1 <= y && a.1 > y) {
+                        xs.push(a.0 + (y - a.1) / (b.1 - a.1) * (b.0 - a.0));
+                    }
+                }
+                xs.sort_by(|a, b| a.total_cmp(b));
+                for span in xs.as_chunks::<2>().0 {
+                    let (x0, x1) = ((span[0] - area.x0 as f32).max(0.0), (span[1] - area.x0 as f32).min(w as f32));
+                    if x1 <= x0 {
+                        continue;
+                    }
+                    let (c0, c1) = (x0.floor() as usize, (x1.ceil() as usize).min(w));
+                    for cx in c0..c1 {
+                        let cov = if anti_alias {
+                            ((cx + 1) as f32).min(x1) - (cx as f32).max(x0)
+                        } else {
+                            let c = cx as f32 + 0.5;
+                            if c >= x0 && c < x1 { 1.0 } else { 0.0 }
+                        };
+                        m[py * w + cx] += cov.max(0.0) / sub as f32;
+                    }
+                }
+            }
+        }
+        for v in &mut m {
+            *v = v.min(1.0);
+        }
+        m
+    }
+
+    #[test]
+    fn polygon_matches_the_every_edge_fill_bit_for_bit() {
+        let mut seed = 0x2545_f491_u32;
+        let mut rnd = move || {
+            seed ^= seed << 13;
+            seed ^= seed >> 17;
+            seed ^= seed << 5;
+            seed as f32 / u32::MAX as f32
+        };
+        // Taller than one 64-row band, offset, and a 1-pixel-wide area.
+        let areas = [Rect::new(0, 0, 90, 150), Rect::new(-13, 7, 60, 211), Rect::new(5, -40, 6, 30)];
+        let mut cases: Vec<Vec<(f32, f32)>> = vec![
+            // Self-intersecting star, horizontal edges, repeated points, collinear runs.
+            (0..11)
+                .map(|i| {
+                    let t = i as f32 * 4.0 * std::f32::consts::PI / 11.0;
+                    (40.0 + 35.0 * t.cos(), 80.0 + 70.0 * t.sin())
+                })
+                .collect(),
+            vec![(10.0, 10.0), (50.0, 10.0), (50.0, 10.0), (50.0, 60.0), (30.0, 60.0), (30.0, 30.0), (10.0, 30.0)],
+            vec![(0.0, 0.0), (20.0, 0.0), (40.0, 0.0), (40.0, 0.0), (0.0, 0.0)],
+            // Vertices on the sub-row centres and the pixel edges.
+            vec![(3.125, 2.375), (70.5, 2.375), (70.875, 140.625), (3.0, 140.0), (35.0, 64.0), (35.0, 64.125)],
+            // Entirely outside, and straddling every side.
+            vec![(-500.0, -500.0), (-400.0, -500.0), (-450.0, -300.0)],
+            vec![(-80.0, -60.0), (300.0, 20.0), (60.0, 400.0)],
+            // Non-finite coordinates and a negative zero.
+            vec![(10.0, 10.0), (f32::NAN, 40.0), (60.0, 70.0), (20.0, f32::INFINITY), (-0.0, -0.0), (0.0, 0.0)],
+        ];
+        for n in [3, 7, 40, 400] {
+            for spread in [1.0, 2.0] {
+                cases.push((0..n).map(|_| (rnd() * 100.0 * spread - 50.0 * (spread - 1.0), rnd() * 220.0 * spread - 60.0 * spread)).collect());
+                // Lasso-like: a random walk snapped to quarter pixels.
+                let (mut x, mut y) = (45.0f32, 75.0f32);
+                cases.push(
+                    (0..n)
+                        .map(|_| {
+                            x = ((x + (rnd() - 0.5) * 12.0 * spread) * 4.0).round() / 4.0;
+                            y = ((y + (rnd() - 0.5) * 12.0 * spread) * 4.0).round() / 4.0;
+                            (x, y)
+                        })
+                        .collect(),
+                );
+            }
+        }
+        for pts in &cases {
+            for &area in &areas {
+                for aa in [true, false] {
+                    let (new, old) = (polygon(pts, area, aa), old_polygon(pts, area, aa));
+                    assert_eq!(new.len(), old.len());
+                    let diff = new.iter().zip(&old).position(|(a, b)| a.to_bits() != b.to_bits());
+                    assert!(diff.is_none(), "{pts:?} {area:?} aa={aa}: first difference at {diff:?}");
+                }
+            }
+        }
+    }
+
     #[test]
     fn combine_modes() {
         let a = Rect::new(0, 0, 4, 1);
@@ -1262,6 +1462,37 @@ mod tests {
             .collect()
     }
 
+    #[test]
+    fn magic_wand_rejects_incomplete_and_overflowing_pixel_inputs() {
+        let area = Rect::new(0, 0, 4, 4);
+        let short = vec![[255u8, 0, 0, 255]; 4];
+        let floats: Vec<[f32; 4]> = short.iter().map(|p| p.map(|v| f32::from(v) / 255.0)).collect();
+        assert_eq!(magic_wand(&floats, area, (1, 1), 0.0, true, false), Vec::<f32>::new());
+        assert_eq!(wand_region(&short, area, (1, 1), 0.0, true, false), None);
+
+        let huge = Rect::new(i32::MIN, i32::MIN, i32::MAX, i32::MAX);
+        assert!(magic_wand(&floats, huge, (0, 0), 0.0, false, false).is_empty());
+        assert_eq!(wand_region(&short, huge, (0, 0), 0.0, false, false), None);
+
+        let valid = Rect::new(0, 0, 2, 2);
+        assert_eq!(magic_wand(&floats, valid, (0, 0), 0.0, false, false), vec![1.0; 4]);
+        assert!(wand_region(&short, valid, (0, 0), 0.0, false, false).is_some());
+    }
+
+    #[test]
+    fn region_coverage_outside_a_short_mask_is_zero() {
+        let region = Region { bbox: Rect::new(-2, -3, 1, -1), mask: vec![255, 128] };
+        assert_eq!(region.at(-2, -3), 1.0);
+        assert!((region.at(-1, -3) - 128.0 / 255.0).abs() < 1e-6);
+        assert_eq!(region.at(0, -3), 0.0);
+        assert_eq!(region.at(-2, -2), 0.0);
+        assert_eq!(region.at(-3, -3), 0.0);
+
+        let extreme = Region { bbox: Rect::new(i32::MIN, i32::MIN, i32::MAX, i32::MAX), mask: vec![] };
+        assert_eq!(extreme.at(i32::MAX - 1, i32::MAX - 1), 0.0);
+        assert_eq!(extreme.at(i32::MIN, i32::MIN), 0.0);
+    }
+
     #[test]
     fn wand_region_matches_reference_magic_wand() {
         let (w, h) = (37, 29);
diff --git a/crates/algo/src/selection_blur.rs b/crates/algo/src/selection_blur.rs
index 2a4100ac29..4c64250a68 100644
--- a/crates/algo/src/selection_blur.rs
+++ b/crates/algo/src/selection_blur.rs
@@ -569,11 +569,14 @@ pub(crate) fn feather(m: &[f32], w: usize, h: usize, radius: f32) -> Vec<f32> {
     let s = f64::from(sigma);
     let (kh, kv) = (Kernel::new(s, r, gw), Kernel::new(s, r, gh));
     // Rows: only the bounding box's rows are non-zero.
+    // The run table is scratch: one buffer per worker thread, reused across rows instead of
+    // one allocation per row (thousands of 8-byte-per-sample Vecs on a 24 MP mask).
+    thread_local! { static RUNS: std::cell::RefCell<Vec<usize>> = const { std::cell::RefCell::new(Vec::new()) } }
     let mut tmp = vec![0.0f32; b.h() * gw];
     par_rows(&mut tmp, gw, 1, |y, row| {
         let o = (b.y0 + y) * w + win.x0;
         if let Some(s) = m.get(o..o + gw) {
-            kh.line(s, row, &mut Vec::new());
+            RUNS.with(|runs| kh.line(s, row, &mut runs.borrow_mut()));
         }
     });
     // Columns, a strip of columns at a time.
diff --git a/crates/algo/src/shape_blur_tests.rs b/crates/algo/src/shape_blur_tests.rs
index 96f8f4c1e8..02bdb0b3ca 100644
--- a/crates/algo/src/shape_blur_tests.rs
+++ b/crates/algo/src/shape_blur_tests.rs
@@ -129,7 +129,7 @@ fn surfaces_exact_depth_models_alpha_selection_and_tile_boundaries() {
                             };
                             let spans = Spans::new(radius, shape_inside(shape));
                             let mut expected = conv_spans(&src, area, &ctx, &spans);
-                            crate::mix_selection(&mut expected, area, &selection, &src);
+                            crate::mix_selection(&mut expected, area, &selection, &src, alpha);
                             let mut reference = surface.clone();
                             reference.write_region(area, &expected);
                             for tile in [17, 256] {
diff --git a/crates/algo/src/sharpen.rs b/crates/algo/src/sharpen.rs
index 175de2b37a..9e87c6b841 100644
--- a/crates/algo/src/sharpen.rs
+++ b/crates/algo/src/sharpen.rs
@@ -6,6 +6,17 @@ use crate::Ctx;
 use crate::blur::{conv_sep, gaussian_kernel};
 use crate::image::Image;
 
+pub(crate) mod exact;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) mod fft;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod fft_bench;
+
 fn with_blur(src: &Image, out: Rect, ctx: &Ctx, radius: f32, mut f: impl FnMut(f32, f32) -> f32) -> Vec<f32> {
     let k = gaussian_kernel(radius);
     let blurred = conv_sep(src, out, &k, &k, ctx.alpha);
@@ -24,12 +35,7 @@ fn with_blur(src: &Image, out: Rect, ctx: &Ctx, radius: f32, mut f: impl FnMut(f
 }
 
 pub(crate) fn unsharp(src: &Image, out: Rect, ctx: &Ctx, amount: f32, radius: f32, threshold: f32) -> Vec<f32> {
-    let k = amount / 100.0;
-    let t = threshold / 255.0;
-    with_blur(src, out, ctx, radius, |o, b| {
-        let d = o - b;
-        if d.abs() + 1e-6 >= t { o + k * d } else { o }
-    })
+    exact::run(src, out, ctx, amount, radius, threshold, &photocraft_raster::Interrupt::NONE).unwrap_or_default()
 }
 
 pub(crate) fn smart(src: &Image, out: Rect, ctx: &Ctx, amount: f32, radius: f32, reduce_noise: f32) -> Vec<f32> {
diff --git a/crates/algo/src/sharpen/exact.rs b/crates/algo/src/sharpen/exact.rs
new file mode 100644
index 0000000000..7d74bc538f
--- /dev/null
+++ b/crates/algo/src/sharpen/exact.rs
@@ -0,0 +1,134 @@
+//! Exact separable convolution for Unsharp Mask: stream one source row and reuse
+//! the blurred output for the final arithmetic. Each sample retains its tap order.
+use crate::image::premultiply;
+use crate::{Ctx, Image};
+use photocraft_geom::Rect;
+use photocraft_raster::Interrupt;
+
+const MAX_SAMPLES: usize = 128 * 1024 * 1024;
+// The filter dialog caps radius at 1000. Preserve Details resampling can ask
+// for more; permit that while the unchanged kernel's i32 square is safe.
+const MAX_RADIUS: f32 = 15_446.0;
+
+pub(crate) fn valid_params(amount: f32, radius: f32, threshold: f32) -> bool {
+    amount.is_finite() && threshold.is_finite() && radius.is_finite() && (0.0..=MAX_RADIUS).contains(&radius)
+}
+
+pub(crate) fn halo(radius: f32) -> i32 {
+    if radius.is_finite() && (0.0..=MAX_RADIUS).contains(&radius) { (radius * 3.0).ceil() as i32 + 1 } else { 0 }
+}
+
+pub(crate) fn valid_area(r: Rect) -> bool {
+    r.x0 <= r.x1
+        && r.y0 <= r.y1
+        && r.width() <= 300_000
+        && r.height() <= 300_000
+        && [r.x0, r.x1, r.y0, r.y1].iter().all(|v| (-1_000_000..=1_000_000).contains(v))
+}
+
+fn zeros(len: usize) -> Option<Vec<f32>> {
+    if len > MAX_SAMPLES {
+        return None;
+    }
+    let mut data = Vec::new();
+    data.try_reserve_exact(len).ok()?;
+    data.resize(len, 0.0);
+    Some(data)
+}
+
+/// Checked contiguous row copy, with the same zero extension as Image::get.
+fn read_row(src: &Image, x0: i32, x1: i32, y: i32, dst: &mut [f32]) -> Option<()> {
+    dst.fill(0.0);
+    if y < src.rect.y0 || y >= src.rect.y1 {
+        return Some(());
+    }
+    let (lo, hi) = (x0.max(src.rect.x0), x1.min(src.rect.x1));
+    if lo >= hi {
+        return Some(());
+    }
+    let n = src.ch;
+    let count = usize::try_from(i64::from(hi) - i64::from(lo)).ok()?.checked_mul(n)?;
+    let offset = usize::try_from(i64::from(lo) - i64::from(x0)).ok()?.checked_mul(n)?;
+    let row = usize::try_from(i64::from(y) - i64::from(src.rect.y0)).ok()?;
+    let col = usize::try_from(i64::from(lo) - i64::from(src.rect.x0)).ok()?;
+    let start = row.checked_mul(src.rect.width() as usize)?.checked_add(col)?.checked_mul(n)?;
+    dst.get_mut(offset..offset.checked_add(count)?)?.copy_from_slice(src.data.get(start..start.checked_add(count)?)?);
+    Some(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn run(src: &Image, out: Rect, ctx: &Ctx, amount: f32, radius: f32, threshold: f32, ctl: &Interrupt) -> Option<Vec<f32>> {
+    if ctl.cancelled() || !valid_params(amount, radius, threshold) || !valid_area(out) || !valid_area(src.rect) {
+        return None;
+    }
+    let n = src.ch;
+    if n == 0 || n > crate::fxutil::MAXC {
+        return None;
+    }
+    if src.data.len() != (src.rect.width() as usize).checked_mul(src.rect.height() as usize)?.checked_mul(n)? {
+        return None;
+    }
+    if out.is_empty() {
+        return Some(Vec::new());
+    }
+    let kernel = super::gaussian_kernel(radius);
+    let r = kernel.len() / 2;
+    let (ow, oh) = (out.width() as usize, out.height() as usize);
+    let row_len = ow.checked_mul(n)?;
+    let th = oh.checked_add(2 * r)?;
+    let ww = ow.checked_add(2 * r)?;
+    let (x0, x1, y0) = (out.x0.checked_sub(r as i32)?, out.x1.checked_add(r as i32)?, out.y0.checked_sub(r as i32)?);
+    let mut row = zeros(ww.checked_mul(n)?)?;
+    let mut tmp = zeros(row_len.checked_mul(th)?)?;
+    let mut result = zeros(row_len.checked_mul(oh)?)?;
+    for (y, dst) in tmp.chunks_exact_mut(row_len).enumerate() {
+        if ctl.cancelled() {
+            return None;
+        }
+        read_row(src, x0, x1, y0.checked_add(y as i32)?, &mut row)?;
+        premultiply(&mut row, n, ctx.alpha);
+        // Tap-major traversal exposes contiguous independent samples to LLVM. No
+        // reduction, tap merging, symmetry or fused multiply-add changes the sums.
+        for (i, weight) in kernel.iter().enumerate() {
+            let start = i.checked_mul(n)?;
+            let samples = row.get(start..start.checked_add(row_len)?)?;
+            for (d, s) in dst.iter_mut().zip(samples) {
+                *d += s * weight;
+            }
+        }
+    }
+    let (amount, threshold) = (amount / 100.0, threshold / 255.0);
+    let cc = n - usize::from(ctx.alpha);
+    for (y, dst) in result.chunks_exact_mut(row_len).enumerate() {
+        if ctl.cancelled() {
+            return None;
+        }
+        for (i, weight) in kernel.iter().enumerate() {
+            let start = y.checked_add(i)?.checked_mul(row_len)?;
+            let samples = tmp.get(start..start.checked_add(row_len)?)?;
+            for (d, s) in dst.iter_mut().zip(samples) {
+                *d += s * weight;
+            }
+        }
+        let originals = row.get_mut(..row_len)?;
+        read_row(src, out.x0, out.x1, out.y0.checked_add(y as i32)?, originals)?;
+        for (blurred, original) in dst.chunks_exact_mut(n).zip(originals.chunks_exact(n)) {
+            if ctx.alpha && *original.last()? <= 0.0 {
+                blurred.copy_from_slice(original);
+                continue;
+            }
+            let a = if ctx.alpha { *blurred.last()? } else { 1.0 };
+            for (b, o) in blurred.iter_mut().zip(original).take(cc) {
+                // Keep the original unpremultiply cut-off and division, followed by
+                // the threshold epsilon and inclusive comparison, at every depth.
+                let b_value = if ctx.alpha { if a > 1e-7 { *b / a } else { 0.0 } } else { *b };
+                let d = o - b_value;
+                *b = if d.abs() + 1e-6 >= threshold { o + amount * d } else { *o };
+            }
+            if ctx.alpha {
+                *blurred.last_mut()? = *original.last()?;
+            }
+        }
+    }
+    Some(result)
+}
diff --git a/crates/algo/src/sharpen/fft.rs b/crates/algo/src/sharpen/fft.rs
new file mode 100644
index 0000000000..6fdf18c8b0
--- /dev/null
+++ b/crates/algo/src/sharpen/fft.rs
@@ -0,0 +1,325 @@
+//! Wide exact-kernel Gaussian convolution using FFTs. Summation order changes:
+//! positive thresholds and unstable samples retain the sequential f32 fallback.
+use crate::{FilterParams, Image};
+use photocraft_geom::Rect;
+use photocraft_raster::{Interrupt, Surface};
+use rayon::prelude::*;
+use rustfft::{Fft, FftPlanner, num_complex::Complex};
+use std::sync::{
+    Arc,
+    atomic::{AtomicUsize, Ordering},
+};
+
+const MAX_BYTES: usize = 1 << 30;
+const MAX_SIDE: usize = 32_768;
+const STRIPE: usize = 32;
+type Number = Complex<f64>;
+
+fn buffer<T: Clone>(len: usize, value: T) -> Option<Vec<T>> {
+    if len.checked_mul(std::mem::size_of::<T>())? > MAX_BYTES {
+        return None;
+    }
+    let mut data = Vec::new();
+    data.try_reserve_exact(len).ok()?;
+    data.resize(len, value);
+    Some(data)
+}
+
+struct Plan {
+    size: usize,
+    forward: Arc<dyn Fft<f64>>,
+    inverse: Arc<dyn Fft<f64>>,
+    spectrum: Vec<Number>,
+    scratch: usize,
+}
+impl Plan {
+    fn new(needed: usize, kernel: &[f32], planner: &mut FftPlanner<f64>) -> Option<Self> {
+        let size = needed.checked_next_power_of_two()?;
+        if size > MAX_SIDE || kernel.len() > size {
+            return None;
+        }
+        let forward = planner.plan_fft_forward(size);
+        let inverse = planner.plan_fft_inverse(size);
+        let scratch = forward.get_inplace_scratch_len().max(inverse.get_inplace_scratch_len());
+        let mut spectrum = buffer(size, Number::default())?;
+        for (dst, &weight) in spectrum.iter_mut().zip(kernel) {
+            dst.re = f64::from(weight) / size as f64;
+        }
+        forward.process_with_scratch(&mut spectrum, &mut buffer(scratch, Number::default())?);
+        Some(Self { size, forward, inverse, spectrum, scratch })
+    }
+    fn work(&self) -> Option<(Vec<Number>, Vec<Number>)> {
+        Some((buffer(self.size, Number::default())?, buffer(self.scratch, Number::default())?))
+    }
+    fn convolve(&self, data: &mut [Number], scratch: &mut [Number]) -> Option<()> {
+        if data.len() != self.size || scratch.len() < self.scratch {
+            return None;
+        }
+        self.forward.process_with_scratch(data, scratch);
+        for (d, k) in data.iter_mut().zip(&self.spectrum) {
+            *d *= k;
+        }
+        self.inverse.process_with_scratch(data, scratch);
+        Some(())
+    }
+}
+
+// Bound the complete temporary working set, including all concurrently live
+// column gathers, originals, FFT scratch and result stripes. Document tiles are
+// excluded, just as in the existing tile scheduler's scratch budget.
+fn group_size(resident: usize, worker: usize, count: usize, workers: usize) -> Option<usize> {
+    let group = MAX_BYTES.checked_sub(resident)?.checked_div(worker.max(1))?.min(workers).min(count);
+    (group > 0).then_some(group)
+}
+
+/// `None` declines the optimization, `Some(None)` propagates cancellation.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn apply(
+    surface: &Surface,
+    params: &FilterParams,
+    area: Rect,
+    selection: Option<&Surface>,
+    extent: Option<Rect>,
+    ctl: &Interrupt,
+) -> Option<Option<Surface>> {
+    let FilterParams::UnsharpMask { amount, radius, threshold } = *params else { return None };
+    // At a positive threshold, even a tiny sum-order difference can switch the
+    // entire sharpen contribution. Zero/negative thresholds always keep it.
+    if !(64.0..=1000.0).contains(&radius)
+        || threshold > 0.0
+        || amount == 0.0
+        || !super::exact::valid_params(amount, radius, threshold)
+        || !super::exact::valid_area(area)
+        || area.is_empty()
+        || u64::from(area.width()) * u64::from(area.height()) < 65_536
+        || !(1..=crate::fxutil::MAXC).contains(&surface.channels())
+        || selection.is_some_and(|s| s.channels() == 0)
+        || extent.is_some_and(|e| !super::exact::valid_area(e) || area.intersect(&e) != area)
+    {
+        return None;
+    }
+    if ctl.cancelled() {
+        return Some(None);
+    }
+    match run(surface, area, amount, radius, selection, extent, ctl) {
+        Some(out) => Some(Some(out)),
+        None if ctl.cancelled() => Some(None),
+        None => None,
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn run(surface: &Surface, area: Rect, amount: f32, radius: f32, selection: Option<&Surface>, extent: Option<Rect>, ctl: &Interrupt) -> Option<Surface> {
+    let (w, h, n) = (area.width() as usize, area.height() as usize, surface.channels());
+    let alpha = surface.format().alpha;
+    let kernel = super::gaussian_kernel(radius);
+    let r = kernel.len() / 2;
+    let reach = i32::try_from(r).ok()?;
+    let (x0, x1) = (area.x0.checked_sub(reach)?, area.x1.checked_add(reach)?);
+    let (y0, y1) = (area.y0.checked_sub(reach)?, area.y1.checked_add(reach)?);
+    let (read_x0, read_x1, read_y0, read_y1) = match extent {
+        Some(e) => (x0.max(e.x0), x1.min(e.x1), y0.max(e.y0), y1.min(e.y1)),
+        None => (x0, x1, y0, y1),
+    };
+    let rows = usize::try_from(i64::from(read_y1) - i64::from(read_y0)).ok()?;
+    let read_width = usize::try_from(i64::from(read_x1) - i64::from(read_x0)).ok()?;
+    let row_len = w.checked_mul(n)?;
+    let samples = row_len.checked_mul(rows)?;
+    let resident = samples.checked_mul(4)?;
+    let mut planner = FftPlanner::<f64>::new();
+    let horizontal = Plan::new(w.checked_add(2 * r)?, &kernel, &mut planner)?;
+    let vertical = Plan::new(h.checked_add(2 * r)?, &kernel, &mut planner)?;
+    // A conservative allowance includes FFT plans/twiddles in addition to spectra.
+    let plans = horizontal.size.checked_add(vertical.size)?.checked_mul(256)?;
+    let resident = resident.checked_add(plans)?;
+    let workers = rayon::current_num_threads().max(1);
+    let horizontal_worker = read_width.checked_mul(n)?.checked_mul(4)?.checked_add(horizontal.size.checked_add(horizontal.scratch)?.checked_mul(16)?)?;
+    let vertical_worker = STRIPE
+        .checked_mul(rows)?
+        .checked_mul(n)?
+        .checked_mul(4)?
+        .checked_add(STRIPE.checked_mul(h)?.checked_mul(n)?.checked_mul(12)?)?
+        .checked_add(vertical.size.checked_add(vertical.scratch)?.checked_mul(16)?)?;
+    let group = group_size(resident, horizontal_worker.max(vertical_worker), w.div_ceil(STRIPE), workers)?;
+    let mut tmp = buffer(samples, 0.0f32)?;
+    let finished = AtomicUsize::new(0);
+    // Read each needed real row once. Outside a repeated extent, horizontal
+    // results are repeated lazily by the vertical gather, not transformed again.
+    for band in tmp.chunks_mut(row_len.checked_mul(group)?) {
+        let first = finished.load(Ordering::Relaxed);
+        let ok: Option<Vec<()>> = band
+            .par_chunks_exact_mut(row_len)
+            .enumerate()
+            .map(|(offset, dst)| {
+                if ctl.cancelled() {
+                    return None;
+                }
+                let y = read_y0.checked_add(i32::try_from(first.checked_add(offset)?).ok()?)?;
+                let mut row = buffer(read_width.checked_mul(n)?, 0.0f32)?;
+                // Reservation above covers resize, so the reusable raster read cannot allocate.
+                surface.read_region_into(Rect::new(read_x0, y, read_x1, y.checked_add(1)?), &mut row);
+                let mut scales = [0.0f64; crate::fxutil::MAXC];
+                for px in row.chunks_exact_mut(n) {
+                    if px.iter().any(|v| !v.is_finite() || v.abs() > 1e6) || (alpha && !px.last().is_some_and(|a| (0.0..=1.0).contains(a))) {
+                        return None;
+                    }
+                    let a = if alpha { *px.last()? } else { 1.0 };
+                    for (c, v) in px.iter_mut().enumerate() {
+                        if alpha && c + 1 < n {
+                            *v *= a;
+                        }
+                        let scale = scales.get_mut(c)?;
+                        *scale = scale.max(f64::from(v.abs()));
+                    }
+                }
+                let (mut data, mut scratch) = horizontal.work()?;
+                for channel in (0..n).step_by(2) {
+                    if ctl.cancelled() {
+                        return None;
+                    }
+                    data.fill(Number::default());
+                    for (i, d) in data.iter_mut().take(w + 2 * r).enumerate() {
+                        let sx = x0.checked_add(i32::try_from(i).ok()?)?.clamp(read_x0, read_x1.checked_sub(1)?);
+                        let start = usize::try_from(sx - read_x0).ok()?.checked_mul(n)?;
+                        let px = row.get(start..start.checked_add(n)?)?;
+                        let sample = |c: usize| -> f64 {
+                            match (px.get(c), scales.get(c)) {
+                                (Some(v), Some(s)) if *s > 0.0 => f64::from(*v) / s,
+                                _ => 0.0,
+                            }
+                        };
+                        *d = Number::new(sample(channel), sample(channel + 1));
+                    }
+                    horizontal.convolve(&mut data, &mut scratch)?;
+                    for (px, d) in dst.chunks_exact_mut(n).zip(data.get(2 * r..2 * r + w)?) {
+                        *px.get_mut(channel)? = (d.re * scales.get(channel)?) as f32;
+                        if let Some(v) = px.get_mut(channel + 1) {
+                            *v = (d.im * scales.get(channel + 1)?) as f32;
+                        }
+                    }
+                }
+                finished.fetch_add(1, Ordering::Relaxed);
+                Some(())
+            })
+            .collect();
+        ok?;
+        ctl.progress(0.5 * finished.load(Ordering::Relaxed) as f32 / rows as f32);
+        if ctl.cancelled() {
+            return None;
+        }
+    }
+    let mut out = surface.clone();
+    let count = w.div_ceil(STRIPE);
+    for first in (0..count).step_by(group) {
+        let end = first.checked_add(group)?.min(count);
+        let results: Option<Vec<_>> = (first..end)
+            .into_par_iter()
+            .map(|index| {
+                if ctl.cancelled() {
+                    return None;
+                }
+                let x = index.checked_mul(STRIPE)?;
+                let width = STRIPE.min(w.checked_sub(x)?);
+                let mut columns = buffer(width.checked_mul(rows)?.checked_mul(n)?, 0.0f32)?;
+                for (y, row) in tmp.chunks_exact(row_len).enumerate() {
+                    if y % 64 == 0 && ctl.cancelled() {
+                        return None;
+                    }
+                    for (c, px) in row.get(x * n..(x + width) * n)?.chunks_exact(n).enumerate() {
+                        let start = (c * rows + y) * n;
+                        columns.get_mut(start..start + n)?.copy_from_slice(px);
+                    }
+                }
+                let rect = Rect::new(area.x0.checked_add(x as i32)?, area.y0, area.x0.checked_add((x + width) as i32)?, area.y1);
+                let len = width.checked_mul(h)?.checked_mul(n)?;
+                let mut result = buffer(len, 0.0f32)?;
+                let mut original = buffer(len, 0.0f32)?;
+                surface.read_region_into(rect, &mut original);
+                let (mut data, mut scratch) = vertical.work()?;
+                for (c, samples) in columns.chunks_exact(rows * n).enumerate() {
+                    if ctl.cancelled() {
+                        return None;
+                    }
+                    let mut scales = [0.0f64; crate::fxutil::MAXC];
+                    for px in samples.chunks_exact(n) {
+                        for (s, v) in scales.iter_mut().zip(px) {
+                            *s = s.max(f64::from(v.abs()));
+                        }
+                    }
+                    for channel in (0..n).step_by(2) {
+                        if ctl.cancelled() {
+                            return None;
+                        }
+                        data.fill(Number::default());
+                        for (i, d) in data.iter_mut().take(h + 2 * r).enumerate() {
+                            let sy = y0.checked_add(i as i32)?.clamp(read_y0, read_y1.checked_sub(1)?);
+                            let start = usize::try_from(sy - read_y0).ok()?.checked_mul(n)?;
+                            let px = samples.get(start..start + n)?;
+                            let sample = |c: usize| -> f64 {
+                                match (px.get(c), scales.get(c)) {
+                                    (Some(v), Some(s)) if *s > 0.0 => f64::from(*v) / s,
+                                    _ => 0.0,
+                                }
+                            };
+                            *d = Number::new(sample(channel), sample(channel + 1));
+                        }
+                        vertical.convolve(&mut data, &mut scratch)?;
+                        for (y, d) in data.get(2 * r..2 * r + h)?.iter().enumerate() {
+                            let start = (y * width + c) * n;
+                            *result.get_mut(start + channel)? = (d.re * scales.get(channel)?) as f32;
+                            if let Some(v) = result.get_mut(start + channel + 1).filter(|_| channel + 1 < n) {
+                                *v = (d.im * scales.get(channel + 1)?) as f32;
+                            }
+                        }
+                    }
+                }
+                for (px, o) in result.chunks_exact_mut(n).zip(original.chunks_exact(n)) {
+                    if alpha && *o.last()? <= 0.0 {
+                        px.copy_from_slice(o);
+                        continue;
+                    }
+                    let a = if alpha { *px.last()? } else { 1.0 };
+                    // Near the original unpremultiply cutoff, cancellation/FFT noise
+                    // or f32 sum order can expose colour. Decline the whole fast path.
+                    let uncertainty = 4.0 * kernel.len() as f32 * f32::EPSILON;
+                    if alpha && a <= 1e-7 + uncertainty {
+                        return None;
+                    }
+                    for (v, o) in px.iter_mut().zip(o).take(n - usize::from(alpha)) {
+                        let b = if alpha { *v / a } else { *v };
+                        *v = o + amount / 100.0 * (o - b);
+                        if !v.is_finite() {
+                            return None;
+                        }
+                    }
+                    if alpha {
+                        *px.last_mut()? = *o.last()?;
+                    }
+                }
+                if let Some(sel) = selection {
+                    crate::mix_selection(&mut result, rect, sel, &Image { rect, ch: n, data: original }, alpha);
+                }
+                Some((rect, result))
+            })
+            .collect();
+        for (rect, data) in results? {
+            if ctl.cancelled() {
+                return None;
+            }
+            out.try_write_region(rect, &data).ok()?;
+        }
+        ctl.progress(0.5 + 0.48 * end as f32 / count as f32);
+    }
+    if ctl.cancelled() {
+        return None;
+    }
+    out.prune();
+    if ctl.cancelled() {
+        return None;
+    }
+    ctl.progress(1.0);
+    Some(out)
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/algo/src/sharpen/fft/tests.rs b/crates/algo/src/sharpen/fft/tests.rs
new file mode 100644
index 0000000000..e1f7a26ed8
--- /dev/null
+++ b/crates/algo/src/sharpen/fft/tests.rs
@@ -0,0 +1,146 @@
+use super::*;
+use crate::sharpen::tests::{reference, source};
+use crate::{Ctx, image::Image};
+use photocraft_color::{ColorMode, PixelFormat, SampleType};
+
+fn compare(old: &Surface, new: &Surface, area: Rect) {
+    let tolerance = match old.format().sample {
+        SampleType::U8 => 1.0 / 255.0 + 1e-7,
+        SampleType::U16 => 2.0 / 65535.0 + 1e-7,
+        SampleType::F32 => 3e-5,
+    };
+    for (a, b) in old.read_region(area).iter().zip(new.read_region(area)) {
+        let limit = if old.format().sample == SampleType::F32 { tolerance * (1.0 + a.abs()) } else { tolerance };
+        assert!((a - b).abs() <= limit, "{a} != {b}, tolerance {limit}");
+    }
+}
+
+#[test]
+fn fft_preserves_gaussian_quality_at_every_depth_and_model() {
+    let area = Rect::new(-3, 2, 10, 13);
+    for mode in [
+        ColorMode::Bitmap,
+        ColorMode::Grayscale,
+        ColorMode::Duotone,
+        ColorMode::Indexed,
+        ColorMode::Rgb,
+        ColorMode::Cmyk,
+        ColorMode::Lab,
+        ColorMode::Multichannel,
+    ] {
+        for depth in SampleType::ALL {
+            for alpha in [false, true] {
+                let s = source(area, PixelFormat::new(mode, depth, alpha));
+                let ctx = Ctx { bounds: area, mode, alpha };
+                for radius in [3.25, 64.0] {
+                    let src = Image::read_clamped(&s, area.inflate((radius * 3.0_f32).ceil() as i32 + 1), area);
+                    let pixels = reference::unsharp(&src, area, &ctx, 500.0, radius, 0.0);
+                    let mut expected = s.clone();
+                    expected.write_region(area, &pixels);
+                    let actual = run(&s, area, 500.0, radius, None, Some(area), &Interrupt::NONE).unwrap();
+                    compare(&expected, &actual, area);
+                    if alpha {
+                        for (a, b) in s.read_region(area).chunks_exact(s.channels()).zip(actual.read_region(area).chunks_exact(s.channels())) {
+                            assert_eq!(a.last(), b.last());
+                            if a.last() == Some(&0.0) {
+                                assert_eq!(a, b);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn fft_keeps_partial_regions_selections_and_edge_policies() {
+    let extent = Rect::new(-7, -9, 35, 39);
+    let area = Rect::new(-3, 2, 19, 23);
+    let mut sel = Surface::new(PixelFormat::GRAY8);
+    sel.fill_rect(area, &[0.4]);
+    for depth in SampleType::ALL {
+        let s = source(extent, PixelFormat::new(ColorMode::Rgb, depth, true));
+        let p = FilterParams::UnsharpMask { amount: 150.0, radius: 64.0, threshold: 0.0 };
+        for edge in [None, Some(extent)] {
+            let expected = crate::sharpen::tests::apply_reference(&s, &p, area, extent, Some(&sel), edge, 256);
+            let actual = run(&s, area, 150.0, 64.0, Some(&sel), edge, &Interrupt::NONE).unwrap();
+            compare(&expected, &actual, extent);
+        }
+    }
+}
+
+#[test]
+fn fft_falls_back_for_thresholds_and_unstable_samples() {
+    let area = Rect::new(0, 0, 256, 256);
+    let mut s = source(area, PixelFormat::RGBA32F);
+    let p = FilterParams::UnsharpMask { amount: 150.0, radius: 64.0, threshold: 8.0 };
+    assert!(apply(&s, &p, area, None, Some(area), &Interrupt::NONE).is_none());
+    let p = FilterParams::UnsharpMask { amount: 150.0, radius: 64.0, threshold: 0.0 };
+    s.fill_rect(Rect::new(0, 0, 1, 1), &[f32::NAN, 0.5, 0.5, 1.0]);
+    assert!(apply(&s, &p, area, None, Some(area), &Interrupt::NONE).is_none());
+    s.fill_rect(area, &[0.5, 0.5, 0.5, 1e-8]);
+    assert!(apply(&s, &p, area, None, Some(area), &Interrupt::NONE).is_none());
+    s.fill_rect(area, &[0.5, 0.5, 0.5, -0.1]);
+    assert!(apply(&s, &p, area, None, Some(area), &Interrupt::NONE).is_none());
+}
+
+#[test]
+fn fft_cancellation_discards_partial_work_and_bounds_scratch() {
+    let area = Rect::new(0, 0, 256, 256);
+    let s = source(area, PixelFormat::RGBA8);
+    let original = s.to_interleaved(area);
+    let p = FilterParams::UnsharpMask { amount: 150.0, radius: 300.0, threshold: 0.0 };
+    let flag = std::sync::atomic::AtomicBool::new(false);
+    let cancel = || flag.load(Ordering::Relaxed);
+    let progress = |_| flag.store(true, Ordering::Relaxed);
+    assert!(apply(&s, &p, area, None, Some(area), &Interrupt::new(&cancel, &progress)).unwrap().is_none());
+    assert_eq!(s.to_interleaved(area), original);
+    flag.store(false, Ordering::Relaxed);
+    let after_writes = |value| {
+        if value > 0.55 {
+            flag.store(true, Ordering::Relaxed);
+        }
+    };
+    assert!(apply(&s, &p, area, None, Some(area), &Interrupt::new(&cancel, &after_writes)).unwrap().is_none());
+    assert_eq!(s.to_interleaved(area), original);
+    assert_eq!(group_size(MAX_BYTES, 1, 1, 1), None);
+    assert_eq!(group_size(0, usize::MAX, 1, 1), None);
+    assert!(Plan::new(usize::MAX, &[1.0], &mut FftPlanner::new()).is_none());
+    assert!(buffer::<f32>(usize::MAX, 0.0).is_none());
+}
+
+#[test]
+fn positive_threshold_dispatch_retains_exact_pixel_decisions() {
+    let area = Rect::new(-3, 2, 253, 258);
+    for depth in SampleType::ALL {
+        let s = source(area, PixelFormat::new(ColorMode::Rgb, depth, true));
+        let p = FilterParams::UnsharpMask { amount: 500.0, radius: 64.0, threshold: 8.0 };
+        let expected = crate::sharpen::tests::apply_reference(&s, &p, area, area, None, Some(area), 256);
+        let actual = crate::apply_in(&s, &p, area, area, None, area);
+        assert_eq!(expected.to_interleaved(area), actual.to_interleaved(area));
+    }
+}
+
+#[test]
+fn fft_handles_maximum_radius_and_hdr_alpha_channel_pairs() {
+    let area = Rect::new(0, 0, 1, 1);
+    let mut s = Surface::new(PixelFormat::new(ColorMode::Grayscale, SampleType::F32, false));
+    s.fill_rect(area, &[0.5]);
+    let ctx = Ctx { bounds: area, mode: ColorMode::Grayscale, alpha: false };
+    let src = Image::read_clamped(&s, area.inflate(3001), area);
+    let pixels = reference::unsharp(&src, area, &ctx, 500.0, 1000.0, 0.0);
+    let mut expected = s.clone();
+    expected.write_region(area, &pixels);
+    compare(&expected, &run(&s, area, 500.0, 1000.0, None, Some(area), &Interrupt::NONE).unwrap(), area);
+
+    let area = Rect::new(-2, 3, 11, 14);
+    let mut s = Surface::new(PixelFormat::RGBA32F);
+    s.fill_rect(area, &[1e6, -1e5, 1e-4, 0.02]);
+    let ctx = Ctx { bounds: area, mode: ColorMode::Rgb, alpha: true };
+    let src = Image::read_clamped(&s, area.inflate(193), area);
+    let pixels = reference::unsharp(&src, area, &ctx, 500.0, 64.0, 0.0);
+    let mut expected = s.clone();
+    expected.write_region(area, &pixels);
+    compare(&expected, &run(&s, area, 500.0, 64.0, None, Some(area), &Interrupt::NONE).unwrap(), area);
+}
diff --git a/crates/algo/src/sharpen/fft_bench.rs b/crates/algo/src/sharpen/fft_bench.rs
new file mode 100644
index 0000000000..3081ff7cd3
--- /dev/null
+++ b/crates/algo/src/sharpen/fft_bench.rs
@@ -0,0 +1,112 @@
+//! Opt-in benchmark of the adaptive production path against the frozen original.
+use super::tests::{apply_reference, source};
+use crate::FilterParams;
+use photocraft_color::{ColorMode, PixelFormat, SampleType};
+use photocraft_geom::Rect;
+use photocraft_raster::Surface;
+use std::time::Instant;
+#[test]
+#[ignore = "adaptive large-radius full-operation quality and performance; run alone"]
+fn unsharp_fft_performance() {
+    let number = |name: &str, default| std::env::var(name).ok().and_then(|v| v.parse::<i32>().ok()).unwrap_or(default);
+    let (w, h) = (number("PHOTOCRAFT_UNSHARP_WIDTH", 1920), number("PHOTOCRAFT_UNSHARP_HEIGHT", 1080));
+    let reps = number("PHOTOCRAFT_UNSHARP_REPS", 3);
+    assert!((1..=8192).contains(&w) && (1..=8192).contains(&h) && (1..=5).contains(&reps));
+    let depth = match number("PHOTOCRAFT_UNSHARP_DEPTH", 8) {
+        8 => SampleType::U8,
+        16 => SampleType::U16,
+        32 => SampleType::F32,
+        _ => panic!("depth"),
+    };
+    let area = Rect::new(0, 0, w, h);
+    let surface = source(area, PixelFormat::new(ColorMode::Rgb, depth, true));
+    let cases = std::env::var("PHOTOCRAFT_UNSHARP_CASES").unwrap_or_else(|_| "100:150:0,300:150:0,500:150:8".into());
+    for case in cases.split(',') {
+        let v: Vec<f32> = case.split(':').map(|v| v.parse().unwrap()).collect();
+        let (radius, amount, threshold) = (v[0], v[1], v[2]);
+        let params = FilterParams::UnsharpMask { amount, radius, threshold };
+        let baseline = || apply_reference(&surface, &params, area, area, None, Some(area), crate::auto_tile(&params, area));
+        let candidate = || crate::apply_in(&surface, &params, area, area, None, area);
+        for _ in 0..2 {
+            std::hint::black_box(baseline());
+            std::hint::black_box(candidate());
+        }
+        let mut before = Vec::new();
+        let mut after = Vec::new();
+        let mut max_error = 0.0f32;
+        let mut changed = 0usize;
+        let mut sum_error = 0.0f64;
+        for rep in 0..reps {
+            let timed = |f: &dyn Fn() -> Surface| {
+                let t = Instant::now();
+                let output = f();
+                (output, t.elapsed().as_secs_f64() * 1000.0)
+            };
+            let ((old, a), (new, b)) = if rep % 2 == 0 {
+                (timed(&baseline), timed(&candidate))
+            } else {
+                let b = timed(&candidate);
+                (timed(&baseline), b)
+            };
+            before.push(a);
+            after.push(b);
+            for (a, b) in old.read_region(area).iter().zip(new.read_region(area)) {
+                let e = (a - b).abs();
+                let limit = match depth {
+                    SampleType::U8 => 1.0 / 255.0 + 1e-7,
+                    SampleType::U16 => 3.0 / 65535.0 + 1e-7,
+                    SampleType::F32 => 3e-5 * (1.0 + a.abs()),
+                };
+                assert!(e <= limit, "quality regression: {a} != {b} at radius {radius}, threshold {threshold}");
+                max_error = max_error.max(e);
+                if rep == 0 {
+                    sum_error += f64::from(e);
+                    changed += usize::from(a.to_bits() != b.to_bits());
+                }
+            }
+        }
+        let median = |v: &[f64]| {
+            let mut v = v.to_vec();
+            v.sort_by(f64::total_cmp);
+            v[v.len() / 2]
+        };
+        println!(
+            "{}",
+            serde_json::json!({"experiment":"adaptive FFT same Gaussian, changed summation","width":w,"height":h,"depth":number("PHOTOCRAFT_UNSHARP_DEPTH",8),"radius":radius,"amount":amount,"threshold":threshold,"before_ms":before,"after_ms":after,"before_median_ms":median(&before),"after_median_ms":median(&after),"speedup":median(&before)/median(&after),"max_error":max_error,"mean_error":sum_error/(w as f64*h as f64*4.0),"changed_samples":changed})
+        );
+    }
+}
+
+#[test]
+#[ignore = "4K wide-radius cancellation latency; run alone in release"]
+fn unsharp_fft_cancel_latency() {
+    use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+    let area = Rect::new(0, 0, 3840, 2160);
+    let surface = source(area, PixelFormat::RGBA8);
+    let input = surface.to_interleaved(area);
+    let p = FilterParams::UnsharpMask { amount: 150.0, radius: 1000.0, threshold: 0.0 };
+    let mut latencies = Vec::new();
+    for _ in 0..5 {
+        let flag = AtomicBool::new(false);
+        let cancel_at = AtomicU64::new(0);
+        let started = Instant::now();
+        std::thread::scope(|scope| {
+            let timer = scope.spawn(|| {
+                std::thread::sleep(std::time::Duration::from_millis(10));
+                cancel_at.store(started.elapsed().as_micros() as u64, Ordering::Relaxed);
+                flag.store(true, Ordering::Release);
+            });
+            let cancel = || flag.load(Ordering::Acquire);
+            let result = crate::apply_in_with(&surface, &p, area, area, None, area, &photocraft_raster::Interrupt::cancel_only(&cancel));
+            let elapsed = started.elapsed().as_micros() as u64;
+            timer.join().unwrap();
+            assert!(result.is_none());
+            latencies.push(elapsed.saturating_sub(cancel_at.load(Ordering::Relaxed)) as f64 / 1000.0);
+        });
+        assert_eq!(surface.to_interleaved(area), input);
+    }
+    println!(
+        "{}",
+        serde_json::json!({"width":3840,"height":2160,"radius":1000,"cancel_after_ms":10,"cancel_return_latencies_ms":latencies,"scope":"native full-resolution algo dispatch, excludes GUI scheduling/proxy creation"})
+    );
+}
diff --git a/crates/algo/src/sharpen/reference.rs b/crates/algo/src/sharpen/reference.rs
new file mode 100644
index 0000000000..a99665c187
--- /dev/null
+++ b/crates/algo/src/sharpen/reference.rs
@@ -0,0 +1,113 @@
+//! Frozen exact Unsharp Mask from a28d7866, independent of production helpers.
+use crate::Ctx;
+use crate::image::{Image, premultiply, unpremultiply};
+use photocraft_geom::Rect;
+pub(crate) fn gaussian_kernel(sigma: f32) -> Vec<f32> {
+    if sigma < 0.05 {
+        return vec![1.0];
+    }
+    let r = (sigma * 3.0).ceil() as i32;
+    let k: Vec<f32> = (-r..=r).map(|i| (-(i * i) as f32 / (2.0 * sigma * sigma)).exp()).collect();
+    let s: f32 = k.iter().sum();
+    k.into_iter().map(|v| v / s).collect()
+}
+
+/// Separable convolution of `src` (premultiplied internally) for `out`.
+/// `src` must cover `out` grown by the kernel radii.
+pub(crate) fn conv_sep(src: &Image, out: Rect, kx: &[f32], ky: &[f32], alpha: bool) -> Vec<f32> {
+    let n = src.ch;
+    let (rx, ry) = ((kx.len() / 2) as i32, (ky.len() / 2) as i32);
+    let (ow, oh) = (out.width() as usize, out.height() as usize);
+    let th = oh + 2 * ry as usize;
+    // Premultiplied copy of the needed source window.
+    let win = Rect::new(out.x0 - rx, out.y0 - ry, out.x1 + rx, out.y1 + ry);
+    let ww = win.width() as usize;
+    let mut p = vec![0.0f32; ww * win.height() as usize * n];
+    for y in win.y0..win.y1 {
+        for x in win.x0..win.x1 {
+            let o = ((y - win.y0) as usize * ww + (x - win.x0) as usize) * n;
+            for c in 0..n {
+                p[o + c] = src.get(x, y, c);
+            }
+        }
+    }
+    premultiply(&mut p, n, alpha);
+    // Horizontal pass: (ow × th).
+    let mut tmp = vec![0.0f32; ow * th * n];
+    for ty in 0..th {
+        let row = &p[ty * ww * n..(ty + 1) * ww * n];
+        let dst = &mut tmp[ty * ow * n..(ty + 1) * ow * n];
+        match n {
+            1 => conv_row::<1>(row, dst, kx),
+            2 => conv_row::<2>(row, dst, kx),
+            3 => conv_row::<3>(row, dst, kx),
+            4 => conv_row::<4>(row, dst, kx),
+            5 => conv_row::<5>(row, dst, kx),
+            _ => {
+                for ox in 0..ow {
+                    let d = &mut dst[ox * n..(ox + 1) * n];
+                    for (i, kv) in kx.iter().enumerate() {
+                        let s = &row[(ox + i) * n..(ox + i + 1) * n];
+                        for c in 0..n {
+                            d[c] += s[c] * kv;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Vertical pass.
+    let mut res = vec![0.0f32; ow * oh * n];
+    for oy in 0..oh {
+        let d = &mut res[oy * ow * n..(oy + 1) * ow * n];
+        for (i, kv) in ky.iter().enumerate() {
+            let s = &tmp[(oy + i) * ow * n..(oy + i + 1) * ow * n];
+            for (dv, sv) in d.iter_mut().zip(s) {
+                *dv += sv * kv;
+            }
+        }
+    }
+    unpremultiply(&mut res, n, alpha);
+    res
+}
+
+// Fixed channel counts let LLVM keep one pixel's accumulators in registers and vectorize
+// channels. The tap order is unchanged; unusual multichannel images keep the generic path.
+fn conv_row<const N: usize>(src: &[f32], dst: &mut [f32], kernel: &[f32]) {
+    let pixels = src.as_chunks::<N>().0;
+    for (x, out) in dst.as_chunks_mut::<N>().0.iter_mut().enumerate() {
+        let mut acc = [0.0f32; N];
+        for (pixel, weight) in pixels.get(x..).unwrap_or(&[]).iter().zip(kernel) {
+            for c in 0..N {
+                acc[c] += pixel[c] * weight;
+            }
+        }
+        *out = acc;
+    }
+}
+
+fn with_blur(src: &Image, out: Rect, ctx: &Ctx, radius: f32, mut f: impl FnMut(f32, f32) -> f32) -> Vec<f32> {
+    let k = gaussian_kernel(radius);
+    let blurred = conv_sep(src, out, &k, &k, ctx.alpha);
+    let mut res = src.crop(out);
+    let n = src.ch;
+    let cc = if ctx.alpha { n - 1 } else { n };
+    for (px, bl) in res.chunks_exact_mut(n).zip(blurred.chunks_exact(n)) {
+        if ctx.alpha && px[n - 1] <= 0.0 {
+            continue;
+        }
+        for c in 0..cc {
+            px[c] = f(px[c], bl[c]);
+        }
+    }
+    res
+}
+
+pub(crate) fn unsharp(src: &Image, out: Rect, ctx: &Ctx, amount: f32, radius: f32, threshold: f32) -> Vec<f32> {
+    let k = amount / 100.0;
+    let t = threshold / 255.0;
+    with_blur(src, out, ctx, radius, |o, b| {
+        let d = o - b;
+        if d.abs() + 1e-6 >= t { o + k * d } else { o }
+    })
+}
diff --git a/crates/algo/src/sharpen/tests.rs b/crates/algo/src/sharpen/tests.rs
new file mode 100644
index 0000000000..4699bb3a10
--- /dev/null
+++ b/crates/algo/src/sharpen/tests.rs
@@ -0,0 +1,434 @@
+use super::*;
+use photocraft_color::{ColorMode, PixelFormat, SampleType};
+use photocraft_raster::{Interrupt, Surface};
+use std::time::Instant;
+
+#[path = "reference.rs"]
+pub(super) mod reference;
+
+pub(super) fn source(rect: Rect, fmt: PixelFormat) -> Surface {
+    let mut s = Surface::new(fmt);
+    for y in rect.y0..rect.y1 {
+        let data: Vec<f32> = (rect.x0..rect.x1)
+            .flat_map(|x| {
+                (0..fmt.channels()).map(move |c| {
+                    if fmt.alpha && c + 1 == fmt.channels() {
+                        if (x + y).rem_euclid(17) == 0 { 0.0 } else { ((x ^ y).rem_euclid(255) + 1) as f32 / 255.0 }
+                    } else {
+                        let value = ((x * (7 + c as i32) + y * 13).rem_euclid(257)) as f32 / 256.0;
+                        if fmt.sample == SampleType::F32 { 3.0 * value - 0.5 } else { value }
+                    }
+                })
+            })
+            .collect();
+        s.write_region(Rect::new(rect.x0, y, rect.x1, y + 1), &data);
+    }
+    s
+}
+
+// Preserve the surrounding tiled workload as well as the old convolution: halo reads,
+// automatic tiles, grouping, selection mixing, writes and pruning are timed in both paths.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn apply_reference(
+    s: &Surface,
+    p: &crate::FilterParams,
+    area: Rect,
+    bounds: Rect,
+    sel: Option<&Surface>,
+    extent: Option<Rect>,
+    tile: i32,
+) -> Surface {
+    let crate::FilterParams::UnsharpMask { amount, radius, threshold } = *p else { panic!("unsharp params") };
+    let crate::Halo::Radius(halo) = p.halo_for(bounds) else { panic!("radius halo") };
+    let fmt = s.format();
+    let ctx = Ctx { bounds, mode: fmt.mode, alpha: fmt.alpha };
+    let tiles: Vec<_> = (area.y0..area.y1)
+        .step_by(tile as usize)
+        .flat_map(|y| (area.x0..area.x1).step_by(tile as usize).map(move |x| Rect::new(x, y, (x + tile).min(area.x1), (y + tile).min(area.y1))))
+        .collect();
+    let group = (crate::RESULT_BUDGET / ((tile as usize).pow(2) * fmt.channels() * 4)).max(workers()).max(1);
+    let finished = std::sync::atomic::AtomicUsize::new(0);
+    let ctl = Interrupt::NONE;
+    let run = |t: &Rect| {
+        let src = match extent {
+            Some(e) => Image::read_clamped(s, t.inflate(halo), e),
+            None => Image::read(s, t.inflate(halo)),
+        };
+        let mut data = reference::unsharp(&src, *t, &ctx, amount, radius, threshold);
+        if let Some(sel) = sel {
+            crate::mix_selection(&mut data, *t, sel, &src, fmt.alpha);
+        }
+        let done = finished.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
+        ctl.progress(0.98 * done as f32 / tiles.len().max(1) as f32);
+        (*t, data)
+    };
+    let mut out = s.clone();
+    for chunk in tiles.chunks(group) {
+        #[cfg(not(target_arch = "wasm32"))]
+        let results: Vec<_> = {
+            use rayon::prelude::*;
+            chunk.par_iter().map(run).collect()
+        };
+        #[cfg(target_arch = "wasm32")]
+        let results: Vec<_> = chunk.iter().map(run).collect();
+        for (t, data) in results {
+            out.write_region(t, &data);
+        }
+    }
+    out.prune();
+    out
+}
+
+fn workers() -> usize {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        rayon::current_num_threads()
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        1
+    }
+}
+
+#[test]
+fn frozen_reference_matches_current_kernel() {
+    let out = Rect::new(-3, 2, 16, 15);
+    let src = Image { rect: out.inflate(13), ch: 4, data: (0..(out.width() + 26) * (out.height() + 26) * 4).map(|i| (i % 127) as f32 / 126.0).collect() };
+    let ctx = Ctx { bounds: out, mode: ColorMode::Rgb, alpha: true };
+    for radius in [0.1, 0.6, 1.5, 4.0] {
+        assert_eq!(unsharp(&src, out, &ctx, 150.0, radius, 8.0), reference::unsharp(&src, out, &ctx, 150.0, radius, 8.0));
+    }
+}
+
+fn same_bits(a: &[f32], b: &[f32]) {
+    assert_eq!(a.len(), b.len());
+    for (i, (&a, &b)) in a.iter().zip(b).enumerate() {
+        assert!(a.to_bits() == b.to_bits() || a.is_nan() && b.is_nan(), "sample {i}: {a:?} ({:x}) != {b:?} ({:x})", a.to_bits(), b.to_bits());
+    }
+}
+
+#[test]
+fn exact_kernel_across_models_depths_edges_and_thresholds() {
+    let modes = [
+        ColorMode::Bitmap,
+        ColorMode::Grayscale,
+        ColorMode::Duotone,
+        ColorMode::Indexed,
+        ColorMode::Rgb,
+        ColorMode::Cmyk,
+        ColorMode::Lab,
+        ColorMode::Multichannel,
+    ];
+    for mode in modes {
+        for depth in SampleType::ALL {
+            for alpha in [false, true] {
+                let fmt = PixelFormat::new(mode, depth, alpha);
+                let area = Rect::new(-3, 2, 8, 7);
+                let mut surface = source(area, fmt);
+                if depth == SampleType::F32 {
+                    // HDR, negative, signed zero, subnormal and nonfinite samples; colour is
+                    // never clamped by this filter. Transparent hidden colour must survive.
+                    let px: Vec<f32> = (0..fmt.channels()).map(|c| if alpha && c + 1 == fmt.channels() { 0.0 } else { -4.0 }).collect();
+                    surface.fill_rect(Rect::new(0, 3, 1, 4), &px);
+                    for (x, value) in [3.5, -0.0, f32::MIN_POSITIVE, f32::INFINITY, f32::NAN].into_iter().enumerate() {
+                        let mut px = vec![value; fmt.channels()];
+                        if alpha {
+                            *px.last_mut().unwrap() = if x == 2 { 1e-8 } else { 1.0 };
+                        }
+                        surface.fill_rect(Rect::new(x as i32, 5, x as i32 + 1, 6), &px);
+                    }
+                }
+                let ctx = Ctx { bounds: area, mode, alpha };
+                for radius in [0.0, 0.049, 0.1, 0.6, 1.5, 4.0, 17.25] {
+                    let src = Image::read_clamped(&surface, area.inflate((radius * 3.0_f32).ceil() as i32 + 1), area);
+                    for (amount, threshold) in [(0.0, 0.0), (50.0, 0.0), (500.0, 8.0), (300.0, 255.0)] {
+                        same_bits(&unsharp(&src, area, &ctx, amount, radius, threshold), &reference::unsharp(&src, area, &ctx, amount, radius, threshold));
+                    }
+                    // An incomplete halo has zero extension, even with alpha.
+                    let src = Image::read(&surface, area);
+                    let out = Rect::new(-5, 1, 10, 8);
+                    same_bits(&unsharp(&src, out, &ctx, 150.0, radius, 8.0), &reference::unsharp(&src, out, &ctx, 150.0, radius, 8.0));
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn exact_threshold_boundary_and_degenerate_images() {
+    for (w, h, n) in [(1, 1, 1), (1, 7, 2), (9, 1, 3), (7, 5, 4), (2, 3, 5), (5, 2, 7)] {
+        let out = Rect::new(-2, 3, w - 2, h + 3);
+        let ctx = Ctx { bounds: out, mode: ColorMode::Rgb, alpha: n % 2 == 0 };
+        let src = Image { rect: out, ch: n, data: (0..w * h * n as i32).map(|i| if i % 7 == 0 { -0.0 } else { (i % 17) as f32 / 16.0 }).collect() };
+        for radius in [0.0, 0.1, 0.75, 8.5, 64.0] {
+            let k = reference::gaussian_kernel(radius);
+            let blurred = reference::conv_sep(&src, out, &k, &k, ctx.alpha);
+            for (&o, &b) in src.data.iter().zip(&blurred).take(8) {
+                let boundary = ((o - b).abs() + 1e-6) * 255.0;
+                for threshold in [boundary, f32::from_bits(boundary.to_bits().saturating_sub(1)), f32::from_bits(boundary.to_bits() + 1)] {
+                    same_bits(&unsharp(&src, out, &ctx, 500.0, radius, threshold), &reference::unsharp(&src, out, &ctx, 500.0, radius, threshold));
+                }
+            }
+        }
+    }
+    let empty = Image { rect: Rect::EMPTY, ch: 4, data: Vec::new() };
+    let ctx = Ctx { bounds: Rect::EMPTY, mode: ColorMode::Rgb, alpha: true };
+    assert!(unsharp(&empty, Rect::EMPTY, &ctx, 100.0, 1.0, 0.0).is_empty());
+}
+
+#[test]
+fn exact_tiled_selected_outputs_and_cancellation() {
+    let bounds = Rect::new(-13, -7, 281, 271);
+    let area = Rect::new(-3, 5, 273, 265);
+    let mut sel = Surface::new(PixelFormat::GRAY8);
+    sel.fill_rect(area, &[0.4]);
+    sel.fill_rect(Rect::new(250, 250, 270, 265), &[1.0]);
+    for depth in SampleType::ALL {
+        let surface = source(bounds, PixelFormat::new(ColorMode::Rgb, depth, true));
+        for radius in [0.6, 3.0, 10.0] {
+            let p = crate::FilterParams::UnsharpMask { amount: 150.0, radius, threshold: 8.0 };
+            for extent in [None, Some(bounds)] {
+                let expected = apply_reference(&surface, &p, area, bounds, Some(&sel), extent, 256);
+                for tile in [63, 256, 512] {
+                    let actual = crate::apply_tiled(&surface, &p, area, bounds, Some(&sel), tile, extent);
+                    assert_eq!(expected.to_interleaved(bounds), actual.to_interleaved(bounds));
+                }
+            }
+            let cancelled = std::sync::atomic::AtomicBool::new(false);
+            let cancel = || cancelled.load(std::sync::atomic::Ordering::Relaxed);
+            let progress = |_| cancelled.store(true, std::sync::atomic::Ordering::Relaxed);
+            let ctl = Interrupt::new(&cancel, &progress);
+            let input = surface.to_interleaved(bounds);
+            assert!(crate::apply_in_with(&surface, &p, area, bounds, Some(&sel), bounds, &ctl).is_none());
+            assert_eq!(surface.to_interleaved(bounds), input);
+        }
+    }
+}
+
+#[test]
+fn preserve_details_resampling_keeps_the_same_sharpening() {
+    use crate::resample::{Resample, resize_surface};
+    let src = Rect::new(-3, 2, 19, 17);
+    let (sx, sy) = (2.0, 1.5);
+    let dst = crate::resample::scaled_rect(src, sx, sy);
+    for depth in SampleType::ALL {
+        for mode in [ColorMode::Grayscale, ColorMode::Rgb, ColorMode::Cmyk, ColorMode::Lab] {
+            let s = source(src, PixelFormat::new(mode, depth, true));
+            let resized = resize_surface(&s, sx, sy, Resample::Lanczos);
+            let p = crate::FilterParams::UnsharpMask { amount: 30.0, radius: 0.6 * sx.max(sy) as f32, threshold: 0.0 };
+            let area = crate::output_area(&p, resized.content_bounds(), dst, None);
+            let expected = apply_reference(&resized, &p, area, dst, None, None, crate::auto_tile(&p, dst));
+            let actual = resize_surface(&s, sx, sy, Resample::PreserveDetails);
+            assert_eq!(actual.to_interleaved(area), expected.to_interleaved(area));
+        }
+    }
+}
+
+#[test]
+fn flat_fields_and_sharp_edges_keep_exact_halos() {
+    let out = Rect::new(0, 0, 17, 9);
+    for alpha in [false, true] {
+        let ctx = Ctx { bounds: out, mode: ColorMode::Rgb, alpha };
+        for radius in [0.1, 0.6, 3.25, 64.0] {
+            let rect = out.inflate((radius * 3.0_f32).ceil() as i32 + 1);
+            for edge in [false, true] {
+                let n = 3 + usize::from(alpha);
+                let data = (rect.y0..rect.y1)
+                    .flat_map(|_| {
+                        (rect.x0..rect.x1).flat_map(|x| {
+                            (0..n).map(move |c| {
+                                if alpha && c + 1 == n {
+                                    0.7
+                                } else if edge && x >= 8 {
+                                    0.75
+                                } else {
+                                    0.25
+                                }
+                            })
+                        })
+                    })
+                    .collect();
+                let src = Image { rect, ch: n, data };
+                same_bits(&unsharp(&src, out, &ctx, 300.0, radius, 0.0), &reference::unsharp(&src, out, &ctx, 300.0, radius, 0.0));
+            }
+        }
+    }
+}
+
+#[test]
+fn malformed_inputs_and_allocations_stop_gracefully() {
+    let rect = Rect::new(0, 0, 2, 2);
+    let src = Image { rect, ch: 1, data: vec![0.5; 4] };
+    let ctx = Ctx { bounds: rect, mode: ColorMode::Grayscale, alpha: false };
+    for (amount, radius, threshold) in [(f32::NAN, 1.0, 0.0), (100.0, f32::INFINITY, 0.0), (100.0, -1.0, 0.0), (100.0, f32::MAX, 0.0), (100.0, 1.0, f32::NAN)] {
+        assert!(exact::run(&src, rect, &ctx, amount, radius, threshold, &Interrupt::NONE).is_none());
+        let s = source(rect, PixelFormat::GRAY8);
+        let p = crate::FilterParams::UnsharpMask { amount, radius, threshold };
+        assert!(crate::apply_in_with(&s, &p, rect, rect, None, rect, &Interrupt::NONE).is_none());
+        assert_eq!(crate::apply_in(&s, &p, rect, rect, None, rect), s);
+    }
+    for bad in [Image { ch: 0, ..src.clone() }, Image { data: vec![0.0], ..src.clone() }, Image { rect: Rect::new(5, 0, 0, 2), ..src.clone() }] {
+        assert!(exact::run(&bad, rect, &ctx, 100.0, 1.0, 0.0, &Interrupt::NONE).is_none());
+    }
+    for rect in [Rect::new(i32::MIN, 0, i32::MAX, 2), Rect::new(0, 0, 300_000, 300_000), Rect::new(2, 0, 0, 2)] {
+        assert!(exact::run(&src, rect, &ctx, 100.0, 1.0, 0.0, &Interrupt::NONE).is_none());
+    }
+    let s = source(Rect::new(0, 0, 2, 2), PixelFormat::GRAY8);
+    let p = crate::FilterParams::UnsharpMask { amount: 100.0, radius: 1.0, threshold: 0.0 };
+    for tile in [i32::MIN, 0, i32::MAX] {
+        let r = s.content_bounds();
+        assert_eq!(crate::apply_tiled(&s, &p, r, r, None, tile, Some(r)), crate::apply_in(&s, &p, r, r, None, r));
+    }
+    // Allocation/geometry guard prevents a huge halo read before allocating it.
+    let p = crate::FilterParams::UnsharpMask { amount: 100.0, radius: 15_446.0, threshold: 0.0 };
+    assert!(crate::apply_in_with(&s, &p, s.content_bounds(), s.content_bounds(), None, s.content_bounds(), &Interrupt::NONE).is_none());
+}
+
+#[test]
+fn maximum_supported_radius_matches_the_frozen_kernel() {
+    let out = Rect::new(0, 0, 1, 1);
+    let src = Image { rect: out, ch: 1, data: vec![0.75] };
+    let ctx = Ctx { bounds: out, mode: ColorMode::Grayscale, alpha: false };
+    same_bits(&unsharp(&src, out, &ctx, 500.0, 1000.0, 8.0), &reference::unsharp(&src, out, &ctx, 500.0, 1000.0, 8.0));
+}
+
+#[test]
+fn cancellation_stops_inside_a_tile_before_publishing() {
+    let rect = Rect::new(0, 0, 16, 16);
+    let s = source(rect, PixelFormat::RGBA8);
+    let src = Image::read(&s, rect);
+    let ctx = Ctx { bounds: rect, mode: ColorMode::Rgb, alpha: true };
+    let checks = std::sync::atomic::AtomicUsize::new(0);
+    let cancel = || checks.fetch_add(1, std::sync::atomic::Ordering::Relaxed) >= 10;
+    assert!(exact::run(&src, rect, &ctx, 150.0, 30.0, 8.0, &Interrupt::cancel_only(&cancel)).is_none());
+    assert_eq!(src, Image::read(&s, rect));
+}
+
+#[test]
+#[ignore = "release full-operation baseline/candidate comparison; run alone"]
+fn unsharp_performance() {
+    let number = |name: &str, default: i32| std::env::var(name).ok().and_then(|s| s.parse::<i32>().ok()).unwrap_or(default);
+    let (w, h, reps) = (number("PHOTOCRAFT_UNSHARP_WIDTH", 1500), number("PHOTOCRAFT_UNSHARP_HEIGHT", 1000), number("PHOTOCRAFT_UNSHARP_REPS", 5));
+    assert!((1..=8192).contains(&w) && (1..=8192).contains(&h) && (1..=15).contains(&reps));
+    let depth = match number("PHOTOCRAFT_UNSHARP_DEPTH", 8) {
+        8 => SampleType::U8,
+        16 => SampleType::U16,
+        32 => SampleType::F32,
+        _ => panic!("depth"),
+    };
+    let area = Rect::new(0, 0, w, h);
+    let channels = number("PHOTOCRAFT_UNSHARP_CHANNELS", 4);
+    let (mode, alpha) = match channels {
+        1 => (ColorMode::Grayscale, false),
+        2 => (ColorMode::Grayscale, true),
+        3 => (ColorMode::Rgb, false),
+        4 => (ColorMode::Rgb, true),
+        5 => (ColorMode::Cmyk, true),
+        _ => panic!("channels 1..5"),
+    };
+    let surface = source(area, PixelFormat::new(mode, depth, alpha));
+    let measure = std::env::var("PHOTOCRAFT_UNSHARP_MODE").unwrap_or_else(|_| "paired".into());
+    assert!(matches!(measure.as_str(), "paired" | "reference" | "candidate"));
+    let cases = std::env::var("PHOTOCRAFT_UNSHARP_CASES").unwrap_or_else(|_| "0.6:150:0,3:150:8,10:300:16,30:150:0".into());
+    for case in cases.split(',') {
+        let values: Vec<f32> = case.split(':').map(|v| v.parse().unwrap()).collect();
+        let (radius, amount, threshold) = (values[0], values[1], values[2]);
+        let p = crate::FilterParams::UnsharpMask { amount, radius, threshold };
+        let tile = crate::auto_tile(&p, area);
+        let before = || apply_reference(&surface, &p, area, area, None, Some(area), tile);
+        // Isolate the streamed exact path from the new adaptive FFT dispatcher.
+        let after = || crate::apply_tiled_with_impl(&surface, &p, area, area, None, tile, Some(area), &Interrupt::NONE, false).unwrap();
+        if measure != "paired" {
+            let f = if measure == "reference" { &before as &dyn Fn() -> Surface } else { &after as &dyn Fn() -> Surface };
+            let mut times = Vec::new();
+            for rep in 0..reps + 2 {
+                let start = Instant::now();
+                let output = f();
+                let ms = start.elapsed().as_secs_f64() * 1000.0;
+                std::hint::black_box(output);
+                if rep >= 2 {
+                    times.push(ms);
+                }
+            }
+            println!(
+                "{}",
+                serde_json::json!({"mode":measure,"width":w,"height":h,"channels":channels,"depth":number("PHOTOCRAFT_UNSHARP_DEPTH",8),"radius":radius,"amount":amount,"threshold":threshold,"workers":workers(),"runs_ms":times})
+            );
+            continue;
+        }
+        for _ in 0..2 {
+            std::hint::black_box(before());
+            std::hint::black_box(after());
+        }
+        let (mut a, mut b) = (Vec::new(), Vec::new());
+        for rep in 0..reps {
+            let timed = |f: &dyn Fn() -> Surface| {
+                let start = Instant::now();
+                let s = f();
+                (s, start.elapsed().as_secs_f64() * 1000.0)
+            };
+            let ((old, old_ms), (new, new_ms)) = if rep % 2 == 0 {
+                (timed(&before), timed(&after))
+            } else {
+                let b = timed(&after);
+                (timed(&before), b)
+            };
+            assert_eq!(old.to_interleaved(area), new.to_interleaved(area));
+            a.push(old_ms);
+            b.push(new_ms);
+        }
+        let median = |v: &[f64]| {
+            let mut v = v.to_vec();
+            v.sort_by(f64::total_cmp);
+            v[v.len() / 2]
+        };
+        println!(
+            "{}",
+            serde_json::json!({"width":w,"height":h,"channels":channels,"depth":number("PHOTOCRAFT_UNSHARP_DEPTH",8),"radius":radius,"amount":amount,"threshold":threshold,"workers":workers(),"before_ms":a,"after_ms":b,"before_median_ms":median(&a),"after_median_ms":median(&b),"speedup":median(&a)/median(&b),"max_error":0})
+        );
+    }
+}
+
+#[test]
+#[ignore = "unchanged-filter stage profile; run alone in release"]
+fn unsharp_baseline_profile() {
+    let out = Rect::new(0, 0, 256, 256);
+    for radius in [0.6, 3.0, 10.0, 30.0] {
+        let reach = (radius * 3.0_f32).ceil() as i32 + 1;
+        let s = source(out.inflate(reach), PixelFormat::new(ColorMode::Rgb, SampleType::U8, true));
+        let src = Image::read(&s, out.inflate(reach));
+        let ctx = Ctx { bounds: out, mode: ColorMode::Rgb, alpha: true };
+        let k = reference::gaussian_kernel(radius);
+        let mut times = [0.0; 4];
+        for _ in 0..20 {
+            let start = Instant::now();
+            std::hint::black_box(reference::gaussian_kernel(radius));
+            times[0] += start.elapsed().as_secs_f64();
+            let start = Instant::now();
+            let bl = reference::conv_sep(&src, out, &k, &k, true);
+            times[1] += start.elapsed().as_secs_f64();
+            let start = Instant::now();
+            let mut res = src.crop(out);
+            for (px, b) in res.as_chunks_mut::<4>().0.iter_mut().zip(bl.as_chunks::<4>().0) {
+                if px[3] <= 0.0 {
+                    continue;
+                }
+                for c in 0..3 {
+                    let d = px[c] - b[c];
+                    if d.abs() + 1e-6 >= 8.0 / 255.0 {
+                        px[c] += 1.5 * d;
+                    }
+                }
+            }
+            std::hint::black_box(res);
+            times[2] += start.elapsed().as_secs_f64();
+            let start = Instant::now();
+            std::hint::black_box(reference::unsharp(&src, out, &ctx, 150.0, radius, 8.0));
+            times[3] += start.elapsed().as_secs_f64();
+        }
+        println!(
+            "{}",
+            serde_json::json!({"baseline_tile_radius":radius,"kernel_ms":times[0]*50.0,"convolution_ms":times[1]*50.0,"crop_blend_ms":times[2]*50.0,"total_kernel_ms":times[3]*50.0})
+        );
+    }
+}
diff --git a/crates/algo/src/stylize.rs b/crates/algo/src/stylize.rs
index 2a88c6ed6e..53b4c846ce 100644
--- a/crates/algo/src/stylize.rs
+++ b/crates/algo/src/stylize.rs
@@ -5,6 +5,7 @@ use photocraft_geom::Rect;
 use photocraft_raster::{from_rgba, to_rgba};
 
 use crate::Ctx;
+use crate::fxutil::subtractive;
 use crate::image::Image;
 
 fn fmt(ctx: &Ctx) -> PixelFormat {
@@ -23,6 +24,16 @@ fn set_gray(ctx: &Ctx, px: &mut [f32], g: f32) {
     px.copy_from_slice(&v[..px.len()]);
 }
 
+/// Solarize: inverts the highlights. CMYK samples are ink, so there the
+/// channels below 50% ink (the light ones) invert.
+pub(crate) fn solarize(src: &Image, out: Rect, ctx: &Ctx) -> Vec<f32> {
+    if subtractive(ctx) {
+        per_pixel(src, out, ctx, |v| if v < 0.5 { 1.0 - v } else { v })
+    } else {
+        per_pixel(src, out, ctx, |v| if v > 0.5 { 1.0 - v } else { v })
+    }
+}
+
 /// Colour channels through `f` (alpha untouched).
 pub(crate) fn per_pixel(src: &Image, out: Rect, ctx: &Ctx, f: impl Fn(f32) -> f32) -> Vec<f32> {
     let n = src.ch;
@@ -167,10 +178,13 @@ pub(crate) fn emboss(src: &Image, out: Rect, ctx: &Ctx, angle: f32, height: f32,
     res
 }
 
-/// Find Edges: Sobel magnitude per colour channel, dark edges on white.
+/// Find Edges: Sobel magnitude per colour channel, dark edges on white (CMYK samples are ink, so
+/// there the edge strength is the ink itself). At full strength, as Photoshop's: a 60-level step
+/// darkens by 240 (Photoshop 27.11; a quarter of that was 4× too pale).
 pub(crate) fn find_edges(src: &Image, out: Rect, ctx: &Ctx) -> Vec<f32> {
     let n = src.ch;
     let cc = if ctx.alpha { n - 1 } else { n };
+    let sub = subtractive(ctx);
     let mut res = src.crop(out);
     let w = out.width() as usize;
     for (i, px) in res.chunks_exact_mut(n).enumerate() {
@@ -179,7 +193,8 @@ pub(crate) fn find_edges(src: &Image, out: Rect, ctx: &Ctx) -> Vec<f32> {
             let g = |dx: i32, dy: i32| src.get(x + dx, y + dy, c);
             let gx = (g(1, -1) + 2.0 * g(1, 0) + g(1, 1)) - (g(-1, -1) + 2.0 * g(-1, 0) + g(-1, 1));
             let gy = (g(-1, 1) + 2.0 * g(0, 1) + g(1, 1)) - (g(-1, -1) + 2.0 * g(0, -1) + g(1, -1));
-            *v = (1.0 - (gx * gx + gy * gy).sqrt() / 4.0).clamp(0.0, 1.0);
+            let e = (gx * gx + gy * gy).sqrt().clamp(0.0, 1.0);
+            *v = if sub { e } else { 1.0 - e };
         }
     }
     res
diff --git a/crates/algo/src/stylize2/tests.rs b/crates/algo/src/stylize2/tests.rs
index cc44558ea6..3d7f6b5235 100644
--- a/crates/algo/src/stylize2/tests.rs
+++ b/crates/algo/src/stylize2/tests.rs
@@ -167,17 +167,7 @@ fn storage_selection_and_tile_sizes_match_original_kernels() {
                     FilterParams::Wind { method, from_right, seed } => wind_direct(&src, area, &ctx, method, from_right, seed),
                     _ => continue,
                 };
-                let original = s.read_region(area);
-                for (i, px) in raw.chunks_exact_mut(fmt.channels()).enumerate() {
-                    let (x, y) = (area.x0 + (i % area.width() as usize) as i32, area.y0 + (i / area.width() as usize) as i32);
-                    let k = selection.sample_channel(x, y, 0);
-                    if k >= 1.0 {
-                        continue;
-                    }
-                    for (c, v) in px.iter_mut().enumerate() {
-                        *v = original[i * fmt.channels() + c] + (*v - original[i * fmt.channels() + c]) * k;
-                    }
-                }
+                crate::mix_selection(&mut raw, area, &selection, &src, fmt.alpha);
                 let mut want = s.clone();
                 want.write_region(area, &raw);
                 for tile in [1, 7, 17, 256] {
diff --git a/crates/algo/src/tests.rs b/crates/algo/src/tests.rs
index 763cc0bcee..9a90012df9 100644
--- a/crates/algo/src/tests.rs
+++ b/crates/algo/src/tests.rs
@@ -367,6 +367,30 @@ fn stylize_basics() {
     assert!((d[0] - d[1]).abs() < 1e-6 && (d[1] - d[2]).abs() < 1e-6);
 }
 
+/// CMYK samples are ink (1 = full ink): Find Edges leaves flat areas white (no ink, not 100% ink)
+/// and Solarize inverts the channels below 50% ink, as Photoshop does (#4222). Alpha is untouched.
+#[test]
+fn find_edges_and_solarize_treat_cmyk_as_ink() {
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        let f = PixelFormat::new(ColorMode::Cmyk, depth, true);
+        let mut s = Surface::new(f);
+        s.fill_rect(R, &[0.1, 0.1, 0.1, 0.1, 1.0]);
+        let e = run(&s, &FilterParams::FindEdges).pixel(20, 15);
+        assert!(e[..4].iter().all(|v| v.abs() < 1e-6) && (e[4] - 1.0).abs() < 1e-6, "{depth:?} flat CMYK -> white: {e:?}");
+        let mut s = Surface::new(f);
+        s.fill_rect(R, &[0.1, 0.2, 0.8, 0.9, 0.6]);
+        let so = run(&s, &FilterParams::Solarize).pixel(3, 3);
+        let want = [0.9, 0.8, 0.8, 0.9, 0.6];
+        assert!(so.iter().zip(want).all(|(a, b)| (a - b).abs() < 0.01), "{depth:?} solarize CMYK: {so:?}");
+    }
+    // RGB keeps the light-polarity behaviour: flat -> white, channels above 50% invert.
+    let s = flat(SampleType::U8, R, [0.1, 0.2, 0.8, 1.0]);
+    let e = run(&s, &FilterParams::FindEdges).pixel(20, 15);
+    assert!(e[..3].iter().all(|v| (v - 1.0).abs() < 1e-6), "{e:?}");
+    let so = run(&s, &FilterParams::Solarize).pixel(3, 3);
+    assert!(so.iter().zip([0.1, 0.2, 0.2, 1.0]).all(|(a, b)| (a - b).abs() < 0.01), "{so:?}");
+}
+
 #[test]
 fn distortions_are_identity_at_zero() {
     let s = pattern(SampleType::U8, R);
@@ -463,3 +487,87 @@ fn layer_filters_repeat_the_canvas_edge() {
         assert!(faded.pixel(0, 0)[3] < 0.9, "{depth:?}: unclamped path should read transparency");
     }
 }
+
+/// Photoshop 27.11's Polar Coordinates turn counter-clockwise from 12 o'clock: just left of the
+/// top centre, Rectangular to Polar samples the source's left edge (clockwise would take its right).
+#[test]
+fn polar_coordinates_turn_counter_clockwise() {
+    let r = Rect::new(0, 0, 64, 64);
+    let mut s = flat(SampleType::U8, r, [0.0, 0.0, 1.0, 1.0]);
+    s.fill_rect(Rect::new(0, 0, 32, 64), &[1.0, 0.0, 0.0, 1.0]);
+    let p = FilterParams::PolarCoordinates { mode: PolarMode::RectangularToPolar };
+    let out = apply(&s, &p, r, r, None);
+    let left_of_top = out.rgba(28, 12);
+    assert!(left_of_top[0] > 0.9 && left_of_top[2] < 0.1, "{left_of_top:?}");
+    // The corners outside the circle repeat the source's edge instead of going transparent.
+    assert!(out.rgba(0, 0)[3] > 0.99, "{:?}", out.rgba(0, 0));
+}
+
+/// `mix_selection` before #4533, one selection lookup per pixel: the oracle for the per-tile read.
+fn mix_selection_reference(data: &mut [f32], t: Rect, sel: &Surface, orig: &crate::image::Image, alpha: bool) {
+    let w = t.width() as usize;
+    for (i, px) in data.chunks_exact_mut(orig.ch.max(1)).enumerate() {
+        let (x, y) = (t.x0 + (i % w) as i32, t.y0 + (i / w) as i32);
+        let k = sel.pixel(x, y)[0].clamp(0.0, 1.0);
+        if k >= 1.0 {
+            continue;
+        }
+        if k <= 0.0 {
+            for (c, v) in px.iter_mut().enumerate() {
+                *v = orig.get(x, y, c);
+            }
+            continue;
+        }
+        if alpha {
+            let a = px.len() - 1;
+            let original_alpha = orig.get(x, y, a);
+            let filtered_alpha = px[a];
+            if original_alpha != filtered_alpha {
+                let mixed_alpha = original_alpha + (filtered_alpha - original_alpha) * k;
+                let original_weight = original_alpha * (1.0 - k);
+                let filtered_weight = filtered_alpha * k;
+                for (c, v) in px[..a].iter_mut().enumerate() {
+                    *v = if mixed_alpha > 0.0 { (orig.get(x, y, c) * original_weight + *v * filtered_weight) / mixed_alpha } else { 0.0 };
+                }
+                px[a] = mixed_alpha;
+                continue;
+            }
+        }
+        for (c, v) in px.iter_mut().enumerate() {
+            let o = orig.get(x, y, c);
+            *v = o + (*v - o) * k;
+        }
+    }
+}
+
+/// Reading the selection once per tile gives exactly the per-pixel result (#4533): a soft
+/// selection with fully selected, unselected and partial pixels, with and without alpha, on a
+/// tile that crosses the selection's tile boundaries.
+#[test]
+fn mix_selection_reads_the_selection_once_per_tile() {
+    let noise = |seed: u32, n: usize| -> Vec<f32> {
+        (0..n as u32)
+            .map(|i| {
+                let mut h = seed.wrapping_mul(0x9e37_79b9) ^ i.wrapping_mul(0x85eb_ca6b);
+                h ^= h >> 13;
+                h = h.wrapping_mul(0xc2b2_ae35);
+                (h >> 16) as f32 / 65535.0
+            })
+            .collect()
+    };
+    let t = Rect::new(200, 180, 330, 300);
+    let n = (t.width() * t.height()) as usize;
+    let mut sel = Surface::new(PixelFormat::GRAY8);
+    sel.fill_rect(Rect::new(150, 150, 260, 250), &[1.0]);
+    let soft = Rect::new(260, 150, 330, 250);
+    sel.write_region(soft, &noise(5, (soft.width() * soft.height()) as usize));
+    for (alpha, fmt) in [(true, PixelFormat::RGBA8), (false, PixelFormat { alpha: false, ..PixelFormat::RGBA8 })] {
+        let ch = fmt.channels();
+        let orig = crate::image::Image { rect: t, ch, data: noise(1, n * ch) };
+        let filtered = noise(2, n * ch);
+        let (mut a, mut b) = (filtered.clone(), filtered);
+        mix_selection(&mut a, t, &sel, &orig, alpha);
+        mix_selection_reference(&mut b, t, &sel, &orig, alpha);
+        assert!(a.iter().zip(&b).all(|(x, y)| x.to_bits() == y.to_bits()), "alpha {alpha}: results differ");
+    }
+}
diff --git a/crates/algo/src/tests_iris.rs b/crates/algo/src/tests_iris.rs
index 1f930c172d..2d54c8f134 100644
--- a/crates/algo/src/tests_iris.rs
+++ b/crates/algo/src/tests_iris.rs
@@ -170,7 +170,7 @@ fn iris_depths_models_selection_tiles_and_cancellation() {
                             let t = Rect::new(x, y, (x + tile).min(area.x1), (y + tile).min(area.y1));
                             let src = Image::read_clamped(&surface, t.inflate(radius), bounds);
                             let mut data = reference::iris(&src, t, &ctx, &pins);
-                            crate::mix_selection(&mut data, t, &selection, &src);
+                            crate::mix_selection(&mut data, t, &selection, &src, alpha);
                             want.write_region(t, &data);
                         }
                     }
diff --git a/crates/algo/src/tests_selection_mix.rs b/crates/algo/src/tests_selection_mix.rs
new file mode 100644
index 0000000000..f715a8bbc2
--- /dev/null
+++ b/crates/algo/src/tests_selection_mix.rs
@@ -0,0 +1,98 @@
+use super::*;
+use photocraft_color::{PixelFormat, SampleType};
+
+fn selection(coverage: f32) -> Surface {
+    Surface::with_default(PixelFormat::new(ColorMode::Grayscale, SampleType::F32, false), &[coverage])
+}
+
+#[test]
+fn feathered_color_to_alpha_preserves_appearance_over_the_key() {
+    let r = Rect::new(0, 0, 1, 1);
+    let filter = FilterParams::ColorToAlpha { color: [1.0; 4], transparency_threshold: 0.0, opacity_threshold: 1.0 };
+    for sample in SampleType::ALL {
+        for mode in [ColorMode::Rgb, ColorMode::Grayscale] {
+            for alpha in [0.5, 1.0] {
+                let format = PixelFormat::new(mode, sample, true);
+                let mut s = Surface::new(format);
+                let mut p = vec![0.5; format.channels()];
+                *p.last_mut().unwrap() = alpha;
+                s.write_pixel(0, 0, &p);
+                let original = s.pixel(0, 0);
+                let a = format.channels() - 1;
+                for coverage in [0.0, 0.25, 0.5, 0.75, 1.0] {
+                    let out = apply(&s, &filter, r, r, Some(&selection(coverage)));
+                    let actual = out.pixel(0, 0);
+                    let tolerance = if sample == SampleType::U8 { 2.0 / 255.0 } else { 1e-4 };
+                    for c in 0..a {
+                        let before = original[c] * original[a] + 1.0 - original[a];
+                        let after = actual[c] * actual[a] + 1.0 - actual[a];
+                        assert!(
+                            (before - after).abs() < tolerance,
+                            "{sample:?}/{mode:?}, alpha={alpha}, coverage={coverage}: {original:?} -> {actual:?}, over white {before} -> {after}"
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn feathered_offset_ignores_hidden_colour_of_the_original_pixel() {
+    let r = Rect::new(0, 0, 2, 1);
+    let filter = FilterParams::Offset { horizontal: 1, vertical: 0, undefined: UndefinedAreas::Wrap };
+    for sample in SampleType::ALL {
+        let mut s = Surface::new(PixelFormat::new(ColorMode::Rgb, sample, true));
+        s.write_pixel(0, 0, &[1.0, 0.0, 0.0, 0.0]);
+        s.write_pixel(1, 0, &[0.0, 0.0, 1.0, 1.0]);
+        let out = apply(&s, &filter, r, r, Some(&selection(0.5)));
+        let p = out.pixel(0, 0);
+        assert_eq!(&p[..3], &[0.0, 0.0, 1.0], "{sample:?}: hidden red contaminated the selected blue: {p:?}");
+        assert!((p[3] - 0.5).abs() < 1.0 / 255.0);
+    }
+}
+
+#[test]
+fn feathered_blurs_do_not_reintroduce_hidden_colour() {
+    let r = Rect::new(0, 0, 3, 3);
+    let mut s = Surface::new(PixelFormat::RGBA32F);
+    s.fill_rect(r, &[1.0, 0.0, 0.0, 0.0]);
+    s.write_pixel(1, 1, &[0.0, 0.0, 1.0, 1.0]);
+    for filter in [FilterParams::BoxBlur { radius: 1.0 }, FilterParams::MotionBlur { angle: 0.0, distance: 3.0 }] {
+        let full = apply(&s, &filter, r, r, None);
+        let out = apply(&s, &filter, r, r, Some(&selection(0.5)));
+        let p = out.pixel(0, 1);
+        assert!(p[3] > 0.0, "{filter:?}: expected blur to spread coverage");
+        assert!((p[3] - full.pixel(0, 1)[3] * 0.5).abs() < 1e-6, "{filter:?}: selection should halve the new coverage");
+        assert!(p[0].abs() < 1e-6 && (p[2] - 1.0).abs() < 1e-6, "{filter:?}: hidden red reappeared: {p:?}");
+    }
+}
+
+#[test]
+fn selection_mixing_keeps_hdr_range_and_exact_endpoints() {
+    let r = Rect::new(0, 0, 1, 1);
+    let original = Image { rect: r, ch: 4, data: vec![-2.0, 4.0, 0.5, 0.25] };
+    let filtered = vec![8.0, -4.0, 0.75, 1.0];
+    let mut data = filtered.clone();
+    mix_selection(&mut data, r, &selection(0.5), &original, true);
+    for (&actual, expected) in data.iter().zip([6.0, -2.4, 0.7, 0.625]) {
+        assert!((actual - expected).abs() < 1e-6, "{data:?}");
+    }
+    for coverage in [0.0, 1.0] {
+        let mut data = filtered.clone();
+        mix_selection(&mut data, r, &selection(coverage), &original, true);
+        assert_eq!(data, if coverage == 0.0 { &original.data } else { &filtered }.clone());
+    }
+}
+
+#[test]
+fn selection_mixing_without_alpha_keeps_every_channel_independent() {
+    let r = Rect::new(0, 0, 1, 1);
+    // One channel is a mask; three/four channels can be RGB or CMYK without alpha.
+    for ch in [1, 3, 4] {
+        let original = Image { rect: r, ch, data: vec![0.25; ch] };
+        let mut data = vec![0.75; ch];
+        mix_selection(&mut data, r, &selection(0.25), &original, false);
+        assert_eq!(data, vec![0.375; ch]);
+    }
+}
diff --git a/crates/algo/src/tests_tilt_shift.rs b/crates/algo/src/tests_tilt_shift.rs
index 49a6e79bbf..88066ca9d6 100644
--- a/crates/algo/src/tests_tilt_shift.rs
+++ b/crates/algo/src/tests_tilt_shift.rs
@@ -177,7 +177,7 @@ fn tilt_shift_depths_models_selection_and_tile_edges_match_reference() {
                                     None => Image::read(&surface, t.inflate(radius)),
                                 };
                                 let mut data = reference::tilt_shift(&src, t, &ctx, 17.0, (0.3, 0.7), 29.0, 0.07, 0.3);
-                                crate::mix_selection(&mut data, t, &selection, &src);
+                                crate::mix_selection(&mut data, t, &selection, &src, alpha);
                                 want.write_region(t, &data);
                             }
                         }
diff --git a/crates/algo/src/tone.rs b/crates/algo/src/tone.rs
index 2050d8138d..2632d4a29a 100644
--- a/crates/algo/src/tone.rs
+++ b/crates/algo/src/tone.rs
@@ -4,7 +4,8 @@
 //! All work on straight (non-premultiplied) RGBA buffers in 0..=1, row-major `w × h`, so callers
 //! convert any colour model / bit depth to RGBA first (as `Image › Adjustments` does for the
 //! per-pixel adjustments). Formulas are documented approximations of Photoshop's behaviour,
-//! derived from its manual and observation, not from its implementation.
+//! derived from its manual and observation, not from its implementation; Shadows/Highlights is
+//! measured on Photoshop (see [`shadows_highlights`]).
 
 use photocraft_color::convert::{lab_to_srgb, srgb_to_lab};
 use serde::{Deserialize, Serialize};
@@ -17,18 +18,6 @@ fn luma(c: [f32; 3]) -> f32 {
     0.299 * c[0] + 0.587 * c[1] + 0.114 * c[2]
 }
 
-fn smoothstep(e0: f32, e1: f32, x: f32) -> f32 {
-    let t = ((x - e0) / (e1 - e0)).clamp(0.0, 1.0);
-    t * t * (3.0 - 2.0 * t)
-}
-
-/// Blurred luminance (Gaussian, `radius` px ≈ 2σ like Photoshop's radius fields).
-fn blurred_luma(px: &[[f32; 4]], w: usize, h: usize, radius: f32) -> Vec<f32> {
-    let mut l: Vec<f32> = px.iter().map(|p| luma([p[0], p[1], p[2]])).collect();
-    gauss_blur_n(&mut l, w, h, 1, radius.max(0.0) / 2.0);
-    l
-}
-
 /// Image › Adjustments › Shadows/Highlights parameters (Photoshop's dialog, percentages as 0..=100).
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ShadowsHighlights {
@@ -64,102 +53,22 @@ impl Default for ShadowsHighlights {
     }
 }
 
-/// Local tone mapping: a blurred-luminance mask selects shadows (dark neighbourhoods, up to the
-/// tonal width) and highlights; shadows are lifted and highlights pulled down by a gain that
-/// preserves hue, then saturation is corrected where the gain moved tones, midtone contrast is
-/// applied, and the result is stretched by the clip percentages.
-pub fn shadows_highlights(px: &mut [[f32; 4]], w: usize, h: usize, p: &ShadowsHighlights) {
-    if px.is_empty() {
-        return;
-    }
-    let ls = blurred_luma(px, w, h, p.shadow_radius);
-    let lh = if (p.highlight_radius - p.shadow_radius).abs() < 1e-3 { ls.clone() } else { blurred_luma(px, w, h, p.highlight_radius) };
-    let (sa, ha) = (p.shadow_amount / 100.0, p.highlight_amount / 100.0);
-    let (st, ht) = ((p.shadow_tone / 100.0).max(0.01), (p.highlight_tone / 100.0).max(0.01));
-    let color = p.color / 100.0;
-    let mid = p.midtone / 100.0;
-    par_rows(px, w, 1, |y, pxrow| {
-        for (x, q) in pxrow.iter_mut().enumerate() {
-            let i = y * w + x;
-            if q[3] <= 0.0 {
-                continue;
-            }
-            let c = [q[0], q[1], q[2]];
-            // Mask weights: 1 in deep shadows (resp. bright highlights), fading out at the tonal width.
-            let ms = 1.0 - smoothstep(0.0, st, ls[i]);
-            let mh = smoothstep(1.0 - ht, 1.0, lh[i]);
-            let mut out = c;
-            if sa > 0.0 && ms > 0.0 {
-                // Lift: a gamma-like curve on the pixel, stronger for darker neighbourhoods.
-                let g = 1.0 / (1.0 + 2.0 * sa * ms);
-                out = out.map(|v| v.max(0.0).powf(g));
-            }
-            if ha > 0.0 && mh > 0.0 {
-                let g = 1.0 / (1.0 + 2.0 * ha * mh);
-                out = out.map(|v| 1.0 - (1.0 - v.min(1.0)).powf(g));
-            }
-            if mid != 0.0 {
-                let k = 1.0 + mid * (1.0 - ms - mh).clamp(0.0, 1.0);
-                out = out.map(|v| (v - 0.5) * k + 0.5);
-            }
-            let changed = (ms * sa + mh * ha).min(1.0);
-            if color != 0.0 && changed > 0.0 {
-                let l1 = luma(out);
-                let s = 1.0 + color * changed;
-                out = out.map(|v| l1 + (v - l1) * s);
-            }
-            q[0] = out[0].clamp(0.0, 1.0);
-            q[1] = out[1].clamp(0.0, 1.0);
-            q[2] = out[2].clamp(0.0, 1.0);
-        }
-    });
-    clip_stretch(px, p.black_clip, p.white_clip);
-}
-
-/// Stretches levels so `black`% of pixels clip to 0 and `white`% to 1 (luminance histogram).
-fn clip_stretch(px: &mut [[f32; 4]], black: f32, white: f32) {
-    if black <= 0.0 && white <= 0.0 {
-        return;
-    }
-    let mut hist = [0u32; 1024];
-    let mut n = 0u32;
-    for q in px.iter().filter(|q| q[3] > 0.0) {
-        hist[((luma([q[0], q[1], q[2]]).clamp(0.0, 1.0)) * 1023.0).round() as usize] += 1;
-        n += 1;
-    }
-    if n == 0 {
-        return;
-    }
-    let find = |pct: f32, rev: bool| -> f32 {
-        let target = (pct.clamp(0.0, 50.0) / 100.0 * n as f32) as u32;
-        let mut acc = 0;
-        for k in 0..1024 {
-            let i = if rev { 1023 - k } else { k };
-            acc += hist[i];
-            if acc > target {
-                return i as f32 / 1023.0;
-            }
-        }
-        if rev { 0.0 } else { 1.0 }
-    };
-    let lo = find(black, false);
-    let hi = find(white, true);
-    if hi - lo < 1e-3 {
-        return;
-    }
-    for q in px.iter_mut().filter(|q| q[3] > 0.0) {
-        for v in &mut q[..3] {
-            *v = ((*v - lo) / (hi - lo)).clamp(0.0, 1.0);
-        }
-    }
-}
+mod shadows_highlights;
+pub use shadows_highlights::shadows_highlights;
 
 /// Image › Adjustments › Replace Color: Color Range-style selection (fuzziness in 0..=200 levels)
 /// around `color`, then a hue (±180°), saturation and lightness (±100) shift weighted by it.
 /// Returns the selection mask (what the dialog previews).
 pub fn replace_color(px: &mut [[f32; 4]], color: [f32; 3], fuzziness: f32, hue: f32, saturation: f32, lightness: f32) -> Vec<f32> {
     let mask = crate::selection::color_range(px, color, fuzziness);
-    for (q, &k) in px.iter_mut().zip(&mask) {
+    replace_color_masked(px, &mask, hue, saturation, lightness);
+    mask
+}
+
+/// Replace Color's hue, saturation and lightness shift, applied to each pixel as far as `mask`
+/// (`0..=1`, one per pixel: the colour match, localized or not) covers it.
+pub fn replace_color_masked(px: &mut [[f32; 4]], mask: &[f32], hue: f32, saturation: f32, lightness: f32) {
+    for (q, &k) in px.iter_mut().zip(mask) {
         if k <= 0.0 {
             continue;
         }
@@ -172,7 +81,6 @@ pub fn replace_color(px: &mut [[f32; 4]], color: [f32; 3], fuzziness: f32, hue:
             q[i] = (c[i] + (o[i] - c[i]) * k).clamp(0.0, 1.0);
         }
     }
-    mask
 }
 
 /// Lab mean and standard deviation of the opaque pixels, `[L, a, b]` each.
@@ -378,31 +286,6 @@ mod tests {
             .collect()
     }
 
-    #[test]
-    fn shadows_lift_dark_pixels_more_than_bright() {
-        let mut px = ramp(32, 8);
-        let orig = px.clone();
-        shadows_highlights(&mut px, 32, 8, &ShadowsHighlights { black_clip: 0.0, white_clip: 0.0, ..Default::default() });
-        let gain = |i: usize| luma([px[i][0], px[i][1], px[i][2]]) - luma([orig[i][0], orig[i][1], orig[i][2]]);
-        assert!(gain(3) > 0.02, "{}", gain(3));
-        assert!(gain(3) > gain(30), "{} {}", gain(3), gain(30));
-        // Zero amounts and no clipping: identity.
-        let mut px2 = orig.clone();
-        let id = ShadowsHighlights { shadow_amount: 0.0, highlight_amount: 0.0, color: 0.0, black_clip: 0.0, white_clip: 0.0, ..Default::default() };
-        shadows_highlights(&mut px2, 32, 8, &id);
-        assert_eq!(px2, orig);
-    }
-
-    #[test]
-    fn highlights_darken_bright_pixels() {
-        let mut px = ramp(32, 8);
-        let orig = px.clone();
-        let p = ShadowsHighlights { shadow_amount: 0.0, highlight_amount: 80.0, black_clip: 0.0, white_clip: 0.0, ..Default::default() };
-        shadows_highlights(&mut px, 32, 8, &p);
-        assert!(px[30][0] < orig[30][0]);
-        assert!((px[1][0] - orig[1][0]).abs() < 1e-6);
-    }
-
     #[test]
     fn replace_color_only_touches_matching_pixels() {
         let mut px = vec![[1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0]];
diff --git a/crates/algo/src/tone/shadows_highlights.rs b/crates/algo/src/tone/shadows_highlights.rs
new file mode 100644
index 0000000000..0b5feaee2d
--- /dev/null
+++ b/crates/algo/src/tone/shadows_highlights.rs
@@ -0,0 +1,423 @@
+//! Image › Adjustments › Shadows/Highlights, as Photoshop 25.4 does it.
+//!
+//! Measured on Photoshop as a black box (synthetic 16-bit images through the adjustment, results
+//! read back exactly); no Photoshop code was read. The pieces:
+//!
+//! - **Neighbourhood brightness.** Per pixel, the mean of its brightest channel and its Rec. 601
+//!   luma. Its neighbourhood value is an edge-aware average: a Gaussian of σ = 1.14 · Radius whose
+//!   weights fall linearly with the difference from the pixel's own (lightly blurred) brightness,
+//!   so pixels across a strong edge count less and halos stay small. It is quantised to 8 bits.
+//! - **Tonal mask.** Tone sets which neighbourhoods are treated: shadows take the complement of a
+//!   Beta distribution function of the neighbourhood brightness, from Beta(1.95, 23) at Tone 0 to
+//!   1 − L at Tone 95 and over; highlights take the same of 1 − L.
+//! - **Curve.** Amount sets a curve that screens the image with itself: 1 − (1 − v)^q, blended
+//!   between q = 1, 2, 4 and 8 by a strength s = 3 at 100, 2 at 50 and 1 near 15. Shadows lift each
+//!   channel by mask × (curve − v); highlights darken with the mirrored curve.
+//! - **Colour.** Only the luma of that result is kept: the pixel's own colour differences are
+//!   added back, scaled by the Color slider (by exp(h · ΔY / max Y) for positive values, by
+//!   1 + h · ΔY / max Y for negative ones) and shortened where they would leave the gamut.
+//! - **Midtone** is a global S-curve on the luma, k · (Y − ½) · (4Y(1 − Y))^p.
+
+use crate::fxutil::gauss_blur_n;
+use crate::photo_util::par_rows;
+
+use super::ShadowsHighlights;
+
+const W: [f32; 3] = [0.299, 0.587, 0.114];
+
+fn luma(c: [f32; 3]) -> f32 {
+    W[0] * c[0] + W[1] * c[1] + W[2] * c[2]
+}
+
+/// Neighbourhood σ per pixel of Radius.
+const SPATIAL: f32 = 1.1424;
+/// σ of the blur of the pixel's own brightness the edge weights compare with.
+const GUIDE: f32 = 1.3559;
+/// Brightness difference at which a neighbour's weight reaches zero.
+const RANGE: f32 = 1.0152;
+/// Brightness levels of the piecewise-linear edge-aware average.
+const LEVELS: usize = 17;
+
+/// Edge-aware neighbourhood brightness of `lum` (`w × h`) for Photoshop's Radius.
+fn neighbourhood(lum: &[f32], w: usize, h: usize, radius: f32) -> Vec<f32> {
+    let mut guide = lum.to_vec();
+    gauss_blur_n(&mut guide, w, h, 1, GUIDE);
+    let sigma = SPATIAL * radius;
+    if sigma < 0.3 {
+        return guide;
+    }
+    // The average at each of a few brightness levels, interpolated at the pixel's own level
+    // (Durand and Dorsey, "Fast bilateral filtering", 2002). The averages are smooth, so they are
+    // taken on a grid `d` times coarser, with σ ≥ 4 cells there.
+    let d = ((sigma / 4.0).floor() as usize).max(1);
+    let (rw, rh) = (w.div_ceil(d), h.div_ceil(d));
+    let cells = rw * rh;
+    let step = 1.0 / (LEVELS - 1) as f32;
+    let mut avg = vec![0.0f32; LEVELS * cells];
+    let mut buf = vec![0.0f32; 2 * cells];
+    for (k, out) in avg.chunks_exact_mut(cells).enumerate() {
+        let g = k as f32 * step;
+        buf.fill(0.0);
+        for (i, &l) in lum.iter().enumerate() {
+            let wgt = (1.0 - (l - g).abs() / RANGE).max(0.0);
+            let c = 2 * ((i / w) / d * rw + (i % w) / d);
+            buf[c] += wgt * l;
+            buf[c + 1] += wgt;
+        }
+        gauss_blur_n(&mut buf, rw, rh, 2, sigma / d as f32);
+        for (o, b) in out.iter_mut().zip(buf.as_chunks::<2>().0) {
+            *o = if b[1] > 1e-6 { b[0] / b[1] } else { g };
+        }
+    }
+    let mut out = vec![0.0f32; lum.len()];
+    par_rows(&mut out, w, 1, |y, row| {
+        let fy = ((y as f32 + 0.5) / d as f32 - 0.5).clamp(0.0, (rh - 1) as f32);
+        let (y0, ty) = (fy.floor() as usize, fy.fract());
+        let y1 = (y0 + 1).min(rh - 1);
+        for (x, o) in row.iter_mut().enumerate() {
+            let fx = ((x as f32 + 0.5) / d as f32 - 0.5).clamp(0.0, (rw - 1) as f32);
+            let (x0, tx) = (fx.floor() as usize, fx.fract());
+            let x1 = (x0 + 1).min(rw - 1);
+            let at = |k: usize| {
+                let a = &avg[k * cells..(k + 1) * cells];
+                let top = a[y0 * rw + x0] + (a[y0 * rw + x1] - a[y0 * rw + x0]) * tx;
+                let bot = a[y1 * rw + x0] + (a[y1 * rw + x1] - a[y1 * rw + x0]) * tx;
+                top + (bot - top) * ty
+            };
+            let t = (guide[y * w + x].clamp(0.0, 1.0) / step).min((LEVELS - 1) as f32 - 1e-4);
+            let k = t.floor() as usize;
+            let f = t - k as f32;
+            *o = at(k) * (1.0 - f) + at(k + 1) * f;
+        }
+    });
+    out
+}
+
+/// Beta(α, β) parameters of the tonal mask for Tone 0, 5, …, 95 (fitted to Photoshop's masks
+/// within 2/255).
+const MASK_BETA: [(f32, f32); 20] = [
+    (1.9468, 22.9366),
+    (1.7770, 18.3471),
+    (1.6403, 14.7559),
+    (1.5270, 11.9346),
+    (1.4269, 9.6467),
+    (1.3470, 7.8430),
+    (1.2807, 6.4038),
+    (1.2240, 5.2384),
+    (1.1772, 4.2967),
+    (1.1373, 3.5350),
+    (1.1021, 2.9109),
+    (1.0755, 2.4186),
+    (1.0508, 2.0189),
+    (1.0307, 1.7034),
+    (1.0140, 1.4583),
+    (1.0015, 1.2758),
+    (1.0, 1.1403),
+    (1.0, 1.0510),
+    (1.0, 1.0002),
+    (1.0, 1.0),
+];
+
+/// The tonal mask for `tone` (0..=100) at the 256 neighbourhood levels: 1 − I_L(α, β).
+fn tonal_mask(tone: f32) -> [f32; 256] {
+    let t = (tone.clamp(0.0, 95.0)) / 5.0;
+    let i = (t.floor() as usize).min(MASK_BETA.len() - 2);
+    let f = t - i as f32;
+    let (a0, b0) = MASK_BETA[i];
+    let (a1, b1) = MASK_BETA[i + 1];
+    let (a, b) = ((a0 + (a1 - a0) * f) as f64, (b0 + (b1 - b0) * f) as f64);
+    // Midpoint sums of the Beta density, 16 per level.
+    const SUB: usize = 16;
+    let n = 255 * SUB;
+    let dens = |x: f64| ((a - 1.0) * x.ln() + (b - 1.0) * (1.0 - x).ln()).exp();
+    let mut cum = vec![0.0f64; 256];
+    let mut acc = 0.0;
+    for j in 0..n {
+        acc += dens((j as f64 + 0.5) / n as f64);
+        if (j + 1) % SUB == 0 {
+            cum[(j + 1) / SUB] = acc;
+        }
+    }
+    let total = acc.max(f64::MIN_POSITIVE);
+    std::array::from_fn(|k| (1.0 - cum[k] / total) as f32)
+}
+
+/// Curve strength for Amount `a` (0..=100): 0 at 0, 1 near 15, 2 at 50, 3 at 100.
+fn strength(a: f32) -> f32 {
+    let u = (a.clamp(0.0, 100.0) / 100.0).powf(0.6216);
+    if u <= 0.3 { u / 0.3 } else { (1.0 + 20.0 * u) / 7.0 }
+}
+
+/// The full-strength curve of strength `s`: 1 − (1 − v)^q between q = 2^⌊s⌋ and 2^(⌊s⌋+1).
+fn lift(s: f32, v: f32) -> f32 {
+    let n = (s.floor() as i32).clamp(0, 2);
+    let t = (s - n as f32).clamp(0.0, 1.0);
+    let c = (1.0 - v).clamp(0.0, 1.0);
+    let lo = c.powi(1 << n);
+    let hi = lo * lo;
+    1.0 - ((1.0 - t) * lo + t * hi)
+}
+
+/// Linear interpolation in a table of `(x, y)` sorted by `x`.
+fn interp(table: &[(f32, f32)], x: f32) -> f32 {
+    let Some(&(x0, y0)) = table.first() else { return 0.0 };
+    if x <= x0 {
+        return y0;
+    }
+    for p in table.windows(2) {
+        let ((xa, ya), (xb, yb)) = (p[0], p[1]);
+        if x <= xb {
+            return ya + (yb - ya) * (x - xa) / (xb - xa);
+        }
+    }
+    table.last().map_or(0.0, |p| p.1)
+}
+
+/// Color: the h of the colour-difference gain for positive values (exp(h · F))…
+const COLOR_UP: [(f32, f32); 12] = [
+    (0.0, 0.0),
+    (1.0, 0.1566),
+    (2.0, 0.2271),
+    (5.0, 0.3776),
+    (10.0, 0.5653),
+    (20.0, 0.8669),
+    (30.0, 1.1299),
+    (40.0, 1.3748),
+    (50.0, 1.6093),
+    (60.0, 1.8375),
+    (75.0, 2.1721),
+    (100.0, 2.7193),
+];
+/// … and for negative values (1 + h · F), by −Color.
+const COLOR_DOWN: [(f32, f32); 9] =
+    [(0.0, 0.0), (1.0, -0.0145), (5.0, -0.0709), (10.0, -0.1373), (20.0, -0.2570), (30.0, -0.3612), (50.0, -0.5312), (75.0, -0.6866), (100.0, -0.7968)];
+
+/// Midtone: (value, k, p) of k · (Y − ½) · (4Y(1 − Y))^p.
+const MIDTONE: [(f32, f32, f32); 11] = [
+    (-100.0, -0.6955, 2.267),
+    (-75.0, -0.5873, 2.362),
+    (-50.0, -0.4429, 2.492),
+    (-25.0, -0.2514, 2.667),
+    (-10.0, -0.1088, 2.803),
+    (0.0, 0.0, 2.9),
+    (10.0, 0.1206, 3.016),
+    (25.0, 0.3262, 3.216),
+    (50.0, 0.7423, 3.625),
+    (75.0, 1.2635, 4.160),
+    (100.0, 1.9032, 4.850),
+];
+
+fn midtone(m: f32, y: f32) -> f32 {
+    if m == 0.0 {
+        return y;
+    }
+    let ks: Vec<(f32, f32)> = MIDTONE.iter().map(|r| (r.0, r.1)).collect();
+    let ps: Vec<(f32, f32)> = MIDTONE.iter().map(|r| (r.0, r.2)).collect();
+    let (k, p) = (interp(&ks, m), interp(&ps, m));
+    (y + k * (y - 0.5) * (4.0 * y * (1.0 - y)).max(0.0).powf(p)).clamp(0.0, 1.0)
+}
+
+fn level(v: f32) -> usize {
+    (v.clamp(0.0, 1.0) * 255.0).round() as usize
+}
+
+/// Image › Adjustments › Shadows/Highlights on straight RGBA `w × h`.
+pub fn shadows_highlights(px: &mut [[f32; 4]], w: usize, h: usize, p: &ShadowsHighlights) {
+    if px.is_empty() || px.len() != w * h {
+        return;
+    }
+    let (sa, ha) = (p.shadow_amount, p.highlight_amount);
+    let lum: Vec<f32> = px.iter().map(|q| (q[0].max(q[1]).max(q[2]) + luma([q[0], q[1], q[2]])) / 2.0).collect();
+    let ls = (sa > 0.0).then(|| neighbourhood(&lum, w, h, p.shadow_radius));
+    let lh = (ha > 0.0).then(|| match &ls {
+        Some(l) if (p.highlight_radius - p.shadow_radius).abs() < 1e-3 => l.clone(),
+        _ => neighbourhood(&lum, w, h, p.highlight_radius),
+    });
+    let (ms, mh) = (tonal_mask(p.shadow_tone), tonal_mask(p.highlight_tone));
+    let (ss, hs) = (strength(sa), strength(ha));
+    // The new luma of every pixel.
+    let mut y2 = vec![0.0f32; px.len()];
+    par_rows(&mut y2, w, 1, |y, row| {
+        for (x, out) in row.iter_mut().enumerate() {
+            let i = y * w + x;
+            let q = px[i];
+            let mut adj = [q[0], q[1], q[2]];
+            if let Some(l) = &ls {
+                let m = ms[level(l[i])];
+                for v in &mut adj {
+                    *v += m * (lift(ss, *v) - *v);
+                }
+            }
+            if let Some(l) = &lh {
+                let m = mh[255 - level(l[i])];
+                for (v, &o) in adj.iter_mut().zip(&q[..3]) {
+                    *v -= m * (lift(hs, 1.0 - o) - (1.0 - o));
+                }
+            }
+            *out = midtone(p.midtone, luma(adj).clamp(0.0, 1.0));
+        }
+    });
+    clip_levels(&mut y2, px, p.black_clip, p.white_clip);
+    let gain = |f: f32| {
+        if p.color >= 0.0 { (interp(&COLOR_UP, p.color) * f).exp() } else { 1.0 + interp(&COLOR_DOWN, -p.color) * f }
+    };
+    par_rows(px, w, 1, |y, row| {
+        for (x, q) in row.iter_mut().enumerate() {
+            if q[3] <= 0.0 {
+                continue;
+            }
+            let y1 = luma([q[0], q[1], q[2]]);
+            let yn = y2[y * w + x];
+            let f = (yn - y1).abs() / yn.max(y1).max(1e-6);
+            let g = gain(f);
+            let d = [(q[0] - y1) * g, (q[1] - y1) * g, (q[2] - y1) * g];
+            // Shorten the colour difference where it would leave 0..=1.
+            let mut k = 1.0f32;
+            for v in d {
+                if v > 1e-9 {
+                    k = k.min((1.0 - yn) / v);
+                } else if v < -1e-9 {
+                    k = k.min(yn / -v);
+                }
+            }
+            let k = k.clamp(0.0, 1.0);
+            for c in 0..3 {
+                q[c] = (yn + k * d[c]).clamp(0.0, 1.0);
+            }
+        }
+    });
+}
+
+/// Black and White Clip: stretches the new luma so `black`% of pixels reach 0 and `white`% reach 1.
+fn clip_levels(y2: &mut [f32], px: &[[f32; 4]], black: f32, white: f32) {
+    if black <= 0.0 && white <= 0.0 {
+        return;
+    }
+    let mut hist = vec![0u32; 4096];
+    let mut n = 0u32;
+    for (&y, q) in y2.iter().zip(px) {
+        if q[3] > 0.0 {
+            hist[(y.clamp(0.0, 1.0) * 4095.0).round() as usize] += 1;
+            n += 1;
+        }
+    }
+    if n == 0 {
+        return;
+    }
+    let find = |pct: f32, rev: bool| -> f32 {
+        let target = (pct.clamp(0.0, 50.0) / 100.0 * n as f32) as u32;
+        let mut acc = 0;
+        for k in 0..4096 {
+            let i = if rev { 4095 - k } else { k };
+            acc += hist[i];
+            if acc > target {
+                return i as f32 / 4095.0;
+            }
+        }
+        if rev { 0.0 } else { 1.0 }
+    };
+    let (lo, hi) = (if black > 0.0 { find(black, false) } else { 0.0 }, if white > 0.0 { find(white, true) } else { 1.0 });
+    if hi - lo < 1e-3 {
+        return;
+    }
+    for y in y2.iter_mut() {
+        *y = ((*y - lo) / (hi - lo)).clamp(0.0, 1.0);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A flat `w × h` grey or colour image with one different pixel in the middle; returns that
+    /// pixel after Shadows/Highlights.
+    fn probe(bg: [f32; 3], px: [f32; 3], p: &ShadowsHighlights) -> [f32; 3] {
+        let (w, h) = (121, 121);
+        let mut img = vec![[bg[0], bg[1], bg[2], 1.0]; w * h];
+        img[60 * w + 60] = [px[0], px[1], px[2], 1.0];
+        shadows_highlights(&mut img, w, h, p);
+        let q = img[60 * w + 60];
+        [q[0], q[1], q[2]]
+    }
+
+    fn levels(v: [i32; 3]) -> [f32; 3] {
+        v.map(|c| c as f32 / 32768.0)
+    }
+
+    fn off(a: [f32; 3], b: [f32; 3]) -> f32 {
+        a.iter().zip(b).map(|(x, y)| (x - y).abs() * 255.0).fold(0.0, f32::max)
+    }
+
+    /// Photoshop 25.4's results (16-bit levels of 32768) for grey pixels lifted by the default
+    /// Shadows (35 %, Tone 50 %, Radius 30 px; Color 0), in black surroundings and in grey 0.5.
+    #[test]
+    fn grey_matches_photoshop() {
+        let p = ShadowsHighlights { color: 0.0, black_clip: 0.0, white_clip: 0.0, ..Default::default() };
+        for (bg, want) in [(0.0, [11389, 19422, 28451, 31931]), (0.5, [5211, 9909, 18229, 25700])] {
+            for (v, w) in [0.125f32, 0.25, 0.5, 0.749969].into_iter().zip(want) {
+                let got = probe([bg; 3], [v; 3], &p);
+                assert!(off(got, levels([w; 3])) < 2.0, "bg {bg} v {v}: {} vs {}", got[0] * 32768.0, w);
+            }
+        }
+    }
+
+    /// Colour pixels keep their colour differences, scaled by Color (+20 here; Amount 35 %,
+    /// Radius 10 px), in black, 0.15 and 0.3 grey surroundings: Photoshop's results.
+    #[test]
+    fn colour_matches_photoshop() {
+        let p = ShadowsHighlights { shadow_radius: 10.0, black_clip: 0.0, white_clip: 0.0, ..Default::default() };
+        for (bg, px, want) in [
+            (0.0, [3277, 1638, 0], [8235, 5202, 2170]),
+            (0.0, [8192, 6554, 4915], [19350, 16514, 13676]),
+            (4915.0 / 32768.0, [4915, 3277, 1638], [10124, 7424, 4723]),
+            (9830.0 / 32768.0, [11469, 9830, 8192], [16540, 14376, 12214]),
+        ] {
+            let got = probe([bg; 3], levels(px), &p);
+            assert!(off(got, levels(want)) < 2.0, "{px:?} on {bg}: {:?} vs {want:?}", got.map(|c| (c * 32768.0).round()));
+        }
+    }
+
+    /// Across a strong edge the neighbourhood barely leaks (Amount 100 %, Tone 100 %, Radius
+    /// 10 px; 0.1 | 0.9): Photoshop's results 8, 2 and 1 pixels either side.
+    #[test]
+    fn edge_matches_photoshop() {
+        let (w, h) = (200, 24);
+        let (a, b) = (3277.0 / 32768.0, 29491.0 / 32768.0);
+        let mut img: Vec<[f32; 4]> = (0..w * h).map(|i| if i % w < 100 { [a, a, a, 1.0] } else { [b, b, b, 1.0] }).collect();
+        let p = ShadowsHighlights {
+            shadow_amount: 100.0,
+            shadow_tone: 100.0,
+            shadow_radius: 10.0,
+            color: 0.0,
+            black_clip: 0.0,
+            white_clip: 0.0,
+            ..Default::default()
+        };
+        shadows_highlights(&mut img, w, h, &p);
+        let row = &img[12 * w..13 * w];
+        for (x, want) in [(92, 16370), (98, 14439), (99, 12146), (100, 30891), (101, 30403), (102, 30146), (108, 29979)] {
+            let got = row[x][0] * 32768.0;
+            assert!((got - want as f32).abs() / 32768.0 * 255.0 < 6.0, "x {x}: {got} vs {want}");
+        }
+    }
+
+    #[test]
+    fn strength_and_curve_follow_photoshop() {
+        assert!((strength(50.0) - 2.0).abs() < 2e-3 && (strength(100.0) - 3.0).abs() < 1e-4);
+        assert!((strength(15.0) - 1.02).abs() < 0.01 && (strength(1.0) - 0.19).abs() < 0.01);
+        // Amount 50 is the image screened with itself twice: 1 − (1 − v)^4.
+        for v in [0.1f32, 0.3, 0.6] {
+            assert!((lift(2.0, v) - (1.0 - (1.0 - v).powi(4))).abs() < 1e-6);
+        }
+    }
+
+    #[test]
+    fn tonal_mask_spans_photoshop_tones() {
+        let m95 = tonal_mask(95.0);
+        assert!((m95[128] - (1.0 - 128.0 / 255.0)).abs() < 1e-3, "{}", m95[128]);
+        assert_eq!(tonal_mask(100.0), m95);
+        // Tone 0 still reaches about 7 % into the levels (Photoshop: half at level 18).
+        let m0 = tonal_mask(0.0);
+        assert!(m0[0] > 0.999 && (m0[18] - 0.5).abs() < 0.03 && m0[60] < 0.02, "{} {}", m0[18], m0[60]);
+    }
+}
diff --git a/crates/algo/src/transform.rs b/crates/algo/src/transform.rs
index e684f87b96..7d1dd0fe6e 100644
--- a/crates/algo/src/transform.rs
+++ b/crates/algo/src/transform.rs
@@ -3,13 +3,13 @@
 //! A transform is described by where the four corners of a source rectangle land (a quad). Scale,
 //! rotate, skew and flips are affine special cases; Distort and Perspective use the full
 //! homography. Warping is an inverse mapping with premultiplied-alpha sampling (nearest, bilinear
-//! or Catmull-Rom bicubic), processed per destination tile (in parallel on native) so memory stays
+//! or Photoshop's Keys bicubic), processed per destination tile (in parallel on native) so memory stays
 //! bounded by the tile working set. Large reductions are pre-filtered with a proper resize first,
 //! so shrinking a layer doesn't alias.
 
 use photocraft_color::PixelFormat;
 use photocraft_geom::Rect;
-use photocraft_raster::Surface;
+use photocraft_raster::{Interrupt, Surface};
 use serde::{Deserialize, Serialize};
 
 use crate::resample::{Resample, resize_surface};
@@ -43,6 +43,27 @@ impl Homography {
         ((m[0] * x + m[1] * y + m[2]) / w, (m[3] * x + m[4] * y + m[5]) / w)
     }
 
+    /// The homogeneous `w` of `(x, y)`: its sign is the side of the horizon the point maps to
+    /// (0 on the horizon itself).
+    pub fn w(&self, x: f64, y: f64) -> f64 {
+        let m = &self.0;
+        m[6] * x + m[7] * y + m[8]
+    }
+
+    /// The side of the horizon (+1 or −1) that most corners of `r` (`[x0, y0, x1, y1]`) map to,
+    /// the centre's on a tie. A Distort dragged past the horizon maps the rest of the source to the
+    /// far side, where it would show as a mirrored copy wrapped round infinity; drawing keeps to
+    /// this side, as Photoshop's does (#4863).
+    pub fn front_side(&self, r: [f64; 4]) -> f64 {
+        let ahead = [(r[0], r[1]), (r[2], r[1]), (r[2], r[3]), (r[0], r[3])].iter().filter(|(x, y)| self.w(*x, *y) > 0.0).count();
+        match ahead {
+            3 | 4 => 1.0,
+            0 | 1 => -1.0,
+            _ if self.w((r[0] + r[2]) / 2.0, (r[1] + r[3]) / 2.0) >= 0.0 => 1.0,
+            _ => -1.0,
+        }
+    }
+
     pub fn mul(&self, o: &Homography) -> Homography {
         let (a, b) = (&self.0, &o.0);
         let mut r = [0.0; 9];
@@ -133,24 +154,40 @@ impl Interp {
     }
 }
 
-fn catmull_rom(t: f64) -> [f64; 4] {
-    let t2 = t * t;
-    let t3 = t2 * t;
-    [-0.5 * t3 + t2 - 0.5 * t, 1.5 * t3 - 2.5 * t2 + 1.0, -1.5 * t3 + 2.0 * t2 + 0.5 * t, 0.5 * t3 - 0.5 * t2]
+/// Photoshop's Bicubic: the Keys cubic at a = −0.75 (Catmull-Rom is −0.5), the weights of the
+/// four source pixels around a sample `t` (0..1) past the second. Measured on Photoshop 27.11's
+/// Free Transform: a 200 % step edge matches within 0.5 levels; Catmull-Rom was 6 off.
+pub(crate) fn bicubic(t: f64) -> [f64; 4] {
+    const A: f64 = -0.75;
+    let near = |x: f64| (A + 2.0) * x * x * x - (A + 3.0) * x * x + 1.0;
+    let far = |x: f64| A * (x * x * x - 5.0 * x * x + 8.0 * x - 4.0);
+    [far(1.0 + t), near(t), near(1.0 - t), far(2.0 - t)]
 }
 
 /// Warp `src` (its content inside `src_rect`) by `h` (source → destination document space).
 /// The result has the same format as `src`, with alpha added if `src` had none; pixels outside
 /// the warped quad are transparent.
 pub fn warp_surface(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp) -> Result<Surface, photocraft_raster::AllocationError> {
-    warp(src, src_rect, h, interp, None)
+    warp(src, src_rect, h, interp, None, &Interrupt::NONE)
+}
+
+/// [`warp_surface`] reporting progress per destination tile; `Ok(None)` once `ctl` is cancelled.
+pub fn warp_surface_with(
+    src: &Surface,
+    src_rect: Rect,
+    h: &Homography,
+    interp: Interp,
+    ctl: &Interrupt,
+) -> Result<Option<Surface>, photocraft_raster::AllocationError> {
+    let out = warp(src, src_rect, h, interp, None, ctl)?;
+    Ok((!ctl.cancelled()).then_some(out))
 }
 
 /// [`warp_surface`] keeping only the destination pixels inside `clip`. The work is bounded by
 /// `clip` even when part of the source lies at or beyond the map's horizon (a Perspective Crop of a
 /// layer that reaches far past the crop quad), which would make the full warped extent unbounded.
 pub fn warp_surface_clipped(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Rect) -> Result<Surface, photocraft_raster::AllocationError> {
-    warp(src, src_rect, h, interp, Some(clip))
+    warp(src, src_rect, h, interp, Some(clip), &Interrupt::NONE)
 }
 
 /// Is `q` (TL, TR, BR, BL) a usable Perspective Crop quad: finite, strictly convex with every
@@ -192,7 +229,39 @@ pub fn quad_to_rect(q: &[[f64; 2]; 4], w: f64, h: f64) -> Option<Homography> {
     Homography::rect_to_quad([0.0, 0.0, w, h], *q)?.inverse()
 }
 
-fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Option<Rect>) -> Result<Surface, photocraft_raster::AllocationError> {
+/// The destination rectangle [`warp_surface`] fills for `src_rect` under `h`: the warped corners
+/// plus a pixel for filter support, each side clamped to ±2²⁰. `None` when a corner maps to
+/// infinity (the result is then empty). Lets a caller price a warp before allocating it.
+pub fn warp_output_bounds(src_rect: Rect, h: &Homography) -> Option<Rect> {
+    if src_rect.is_empty() || h.inverse().is_none() {
+        return None;
+    }
+    let corners = [(src_rect.x0, src_rect.y0), (src_rect.x1, src_rect.y0), (src_rect.x1, src_rect.y1), (src_rect.x0, src_rect.y1)]
+        .map(|(x, y)| h.apply(x as f64, y as f64));
+    corner_bounds(&corners)
+}
+
+fn corner_bounds(corners: &[(f64, f64); 4]) -> Option<Rect> {
+    if !corners.iter().all(|c| c.0.is_finite() && c.1.is_finite()) {
+        return None;
+    }
+    let lim = (1 << 20) as f64;
+    let bx0 = corners.iter().map(|c| c.0).fold(f64::MAX, f64::min).floor().max(-lim) as i32 - 1;
+    let by0 = corners.iter().map(|c| c.1).fold(f64::MAX, f64::min).floor().max(-lim) as i32 - 1;
+    let bx1 = corners.iter().map(|c| c.0).fold(f64::MIN, f64::max).ceil().min(lim) as i32 + 1;
+    let by1 = corners.iter().map(|c| c.1).fold(f64::MIN, f64::max).ceil().min(lim) as i32 + 1;
+    Some(Rect::new(bx0, by0, bx1, by1))
+}
+
+/// A cancelled `ctl` skips the remaining tiles; the caller discards the result.
+fn warp(
+    src: &Surface,
+    src_rect: Rect,
+    h: &Homography,
+    interp: Interp,
+    clip: Option<Rect>,
+    ctl: &Interrupt,
+) -> Result<Surface, photocraft_raster::AllocationError> {
     let mut fmt = src.format();
     let converted;
     let mut src = if fmt.alpha {
@@ -216,8 +285,12 @@ fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Opt
     };
     let scale = h.local_scale(cx, cy);
     let reduced;
-    if interp != Interp::Nearest && scale < 0.5 && scale > 0.0 {
-        let f = 2f64.powf(scale.log2().ceil()).min(1.0); // remaining scale lands in [0.5, 1)
+    // Photoshop reduces with its Bicubic widened by 1 / scale (as Image Size does), so the source is
+    // brought down by the whole local scale first and the warp samples it at about 1:1; a plain
+    // 4×4 kernel at 50 % aliased (Photoshop 27.11 Free Transform, 50 % of an impulse image).
+    // Bilinear samples the source directly, as Photoshop's does (exact at 50 % without a prefilter).
+    if interp == Interp::Bicubic && scale < 0.999 && scale > 0.0 {
+        let f = scale.max(1.0 / 64.0);
         reduced = resize_surface(src, f, f, Resample::Bicubic);
         src = &reduced;
         h = h.mul(&Homography([1.0 / f, 0.0, 0.0, 0.0, 1.0 / f, 0.0, 0.0, 0.0, 1.0]));
@@ -234,21 +307,17 @@ fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Opt
     let fwd_w = [(sx0, sy0), (sx1, sy0), (sx1, sy1), (sx0, sy1)].map(|(x, y)| h.0[6] * x + h.0[7] * y + h.0[8]);
     let side = [1.0, -1.0].into_iter().find(|&s| fwd_w.iter().all(|&c| s * c > 0.0));
     let w_lo = 1.0 / fwd_w.iter().fold(0.0f64, |m, c| m.max(c.abs()));
-    let finite = corners.iter().all(|c| c.0.is_finite() && c.1.is_finite());
-    let lim = 1 << 20;
-    let bounds = || {
-        let bx0 = corners.iter().map(|c| c.0).fold(f64::MAX, f64::min).floor().max(-(lim as f64)) as i32 - 1;
-        let by0 = corners.iter().map(|c| c.1).fold(f64::MAX, f64::min).floor().max(-(lim as f64)) as i32 - 1;
-        let bx1 = corners.iter().map(|c| c.0).fold(f64::MIN, f64::max).ceil().min(lim as f64) as i32 + 1;
-        let by1 = corners.iter().map(|c| c.1).fold(f64::MIN, f64::max).ceil().min(lim as f64) as i32 + 1;
-        Rect::new(bx0, by0, bx1, by1)
-    };
-    let dst = match clip {
+    // A source straddling the horizon draws only its front side: the inverse w at a pixel has the
+    // sign of the forward w at the source point it samples, and the other side would show as a
+    // mirrored copy wrapped round infinity (#4863).
+    let front = side.is_none().then(|| h.front_side([src_rect.x0 as f64, src_rect.y0 as f64, src_rect.x1 as f64, src_rect.y1 as f64]));
+    let bounds = corner_bounds(&corners);
+    let dst = match (clip, bounds) {
         // The warped corners only bound the result while the whole source is in front of the horizon.
-        Some(c) if finite && side.is_some() => bounds().intersect(&c),
-        Some(c) => c,
-        None if finite => bounds(),
-        None => return Ok(out),
+        (Some(c), Some(b)) if side.is_some() => b.intersect(&c),
+        (Some(c), _) => c,
+        (None, Some(b)) => b,
+        (None, None) => return Ok(out),
     };
     if dst.is_empty() {
         return Ok(out);
@@ -261,7 +330,16 @@ fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Opt
     tiles.try_reserve_exact(tile_count).map_err(|_| photocraft_raster::AllocationError::NotEnoughMemory { bytes: tile_bytes })?;
     tiles.extend(dst.tiles().map(|tc| tc.rect().intersect(&dst)).filter(|r| !r.is_empty()));
     let src_ref: &Surface = src;
+    // Tiles finished so far, for progress reported per tile (from any worker thread).
+    let finished = std::sync::atomic::AtomicUsize::new(0);
+    let total = tiles.len().max(1);
     let work = |t: &Rect| -> Result<Option<(Rect, Vec<f32>)>, photocraft_raster::AllocationError> {
+        if ctl.cancelled() {
+            return Ok(None);
+        }
+        let k = finished.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
+        // The last few percent are the writes.
+        ctl.progress(0.98 * k as f32 / total as f32);
         // Source footprint of this tile (inverse-mapped corners of its sampled part), padded for the filter.
         let tc = [(t.x0, t.y0), (t.x1, t.y0), (t.x1, t.y1), (t.x0, t.y1)].map(|(x, y)| (x as f64, y as f64));
         let wc = tc.map(|(x, y)| inv.0[6] * x + inv.0[7] * y + inv.0[8]);
@@ -324,6 +402,9 @@ fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Opt
         let mut acc = [0.0f64; 8];
         for y in t.y0..t.y1 {
             for x in t.x0..t.x1 {
+                if front.is_some_and(|s| s * inv.w(x as f64 + 0.5, y as f64 + 0.5) <= 0.0) {
+                    continue;
+                }
                 let (u, v) = inv.apply(x as f64 + 0.5, y as f64 + 0.5);
                 let (u, v) = (u - 0.5, v - 0.5);
                 if u < src_rect.x0 as f64 - 1.0 || v < src_rect.y0 as f64 - 1.0 || u > src_rect.x1 as f64 || v > src_rect.y1 as f64 {
@@ -350,7 +431,7 @@ fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Opt
                     }
                     Interp::Bicubic => {
                         let (ix, iy) = (u.floor() as i32, v.floor() as i32);
-                        let (wx, wy) = (catmull_rom(u - ix as f64), catmull_rom(v - iy as f64));
+                        let (wx, wy) = (bicubic(u - ix as f64), bicubic(v - iy as f64));
                         for (j, wyj) in wy.iter().enumerate() {
                             for (i, wxi) in wx.iter().enumerate() {
                                 let k = wxi * wyj;
@@ -368,7 +449,8 @@ fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Opt
                 any = true;
                 let o = ((y - t.y0) as usize * w + (x - t.x0) as usize) * n;
                 for c in 0..a {
-                    outp[o + c] = (acc[c] / al).clamp(0.0, 1.0) as f32;
+                    // Integer storage clips on write; float colours retain their signed/HDR range.
+                    outp[o + c] = (acc[c] / al) as f32;
                 }
                 outp[o + a] = al as f32;
             }
@@ -396,6 +478,9 @@ fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Opt
         }
     }
     let done = done.into_inner().unwrap_or_else(std::sync::PoisonError::into_inner);
+    if ctl.cancelled() {
+        return Ok(out);
+    }
     for (r, v) in done {
         out.try_write_region(r, &v)?;
     }
@@ -407,6 +492,25 @@ fn warp(src: &Surface, src_rect: Rect, h: &Homography, interp: Interp, clip: Opt
 mod tests {
     use super::*;
 
+    #[test]
+    fn the_interruptible_warp_reports_progress_and_stops_when_cancelled() {
+        let mut s = Surface::new(PixelFormat::RGBA8);
+        s.fill_rect(Rect::new(0, 0, 600, 400), &[0.2, 0.4, 0.6, 1.0]);
+        let r = s.content_bounds();
+        let h = Homography::rect_to_quad([0.0, 0.0, 600.0, 400.0], [[10.0, 0.0], [590.0, 20.0], [600.0, 400.0], [0.0, 380.0]]).unwrap();
+        let reported = std::sync::Mutex::new(0.0f32);
+        let progress = |p: f32| {
+            let mut m = reported.lock().unwrap();
+            *m = m.max(p);
+        };
+        let never = || false;
+        let out = warp_surface_with(&s, r, &h, Interp::Bicubic, &Interrupt::new(&never, &progress)).unwrap().expect("not cancelled");
+        assert_eq!(out.read_region(r), warp_surface(&s, r, &h, Interp::Bicubic).unwrap().read_region(r));
+        assert!(*reported.lock().unwrap() > 0.9);
+        let always = || true;
+        assert!(warp_surface_with(&s, r, &h, Interp::Bicubic, &Interrupt::cancel_only(&always)).unwrap().is_none());
+    }
+
     /// Perspective Crop's map lands each quad corner exactly on its rectangle corner; degenerate,
     /// self-crossing, counter-clockwise and non-finite quads have none.
     #[test]
@@ -435,6 +539,24 @@ mod tests {
         Surface::new(PixelFormat::RGBA8)
     }
 
+    /// Photoshop 27.11's Free Transform, Bicubic, 200 % about the centre of a 64 px image whose left
+    /// half is grey 64 and right half grey 192: the row across the edge, columns 26..36.
+    #[test]
+    fn bicubic_upscale_matches_photoshop() {
+        let mut src = rgba();
+        let g = |v: f32| v / 255.0;
+        src.fill_rect(Rect::new(0, 0, 32, 64), &[g(64.0), g(64.0), g(64.0), 1.0]);
+        src.fill_rect(Rect::new(32, 0, 64, 64), &[g(192.0), g(192.0), g(192.0), 1.0]);
+        let q = [[-32.0, -32.0], [96.0, -32.0], [96.0, 96.0], [-32.0, 96.0]];
+        let h = Homography::rect_to_quad([0.0, 0.0, 64.0, 64.0], q).unwrap();
+        let out = warp_surface(&src, Rect::new(0, 0, 64, 64), &h, Interp::Bicubic).unwrap();
+        let photoshop = [64.0, 64.0, 64.0, 60.0, 51.0, 93.0, 163.0, 206.0, 197.0, 192.0];
+        for (i, want) in photoshop.iter().enumerate() {
+            let got = out.pixel(26 + i as i32, 50)[0] * 255.0;
+            assert!((got - want).abs() <= 1.5, "column {}: {got} vs {want}", 26 + i);
+        }
+    }
+
     #[test]
     fn homography_maps_rect_corners_and_inverts() {
         let r = [10.0, 20.0, 110.0, 70.0];
@@ -469,6 +591,44 @@ mod tests {
         }
     }
 
+    /// #4863: a Distort with the bottom corners pulled in and one dragged past the horizon (a
+    /// concave quad) leaves part of the source behind the horizon. That part maps to the far side,
+    /// where it showed as a mirrored copy wrapped round infinity; only the front side is drawn.
+    #[test]
+    fn a_distort_past_the_horizon_draws_only_its_front_side() {
+        let mut s = rgba();
+        s.fill_rect(Rect::new(0, 0, 100, 100), &[0.0, 0.5, 1.0, 1.0]);
+        let r = s.content_bounds();
+        let h = Homography::rect_to_quad([0.0, 0.0, 100.0, 100.0], [[0.0, 0.0], [300.0, 0.0], [60.0, 60.0], [0.0, 300.0]]).unwrap();
+        let corners = [(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)].map(|(x, y)| h.w(x, y));
+        assert!(corners.iter().any(|w| *w > 0.0) && corners.iter().any(|w| *w < 0.0), "the source straddles the horizon: {corners:?}");
+        let front = h.front_side([0.0, 0.0, 100.0, 100.0]);
+        let inv = h.inverse().unwrap();
+        let clip = Rect::new(-400, -400, 700, 700);
+        for interp in [Interp::Nearest, Interp::Bilinear] {
+            let w = warp_surface_clipped(&s, r, &h, interp, clip).unwrap();
+            let px = w.read_region(clip);
+            let (mut drawn, mut behind) = (0, 0);
+            for y in clip.y0..clip.y1 {
+                for x in clip.x0..clip.x1 {
+                    let i = ((y - clip.y0) * clip.width() as i32 + (x - clip.x0)) as usize * 4;
+                    if px[i + 3] > 0.0 {
+                        drawn += 1;
+                        // The source point this pixel samples is on the far side of the horizon.
+                        if front * inv.w(x as f64 + 0.5, y as f64 + 0.5) <= 0.0 {
+                            behind += 1;
+                        }
+                    }
+                }
+            }
+            assert!(drawn > 1000, "{interp:?}: the front side is drawn ({drawn} px)");
+            assert_eq!(behind, 0, "{interp:?}: {behind} pixels come from behind the horizon");
+        }
+        // A quad wholly in front of the horizon is drawn exactly as before.
+        let ok = Homography::rect_to_quad([0.0, 0.0, 100.0, 100.0], [[0.0, 0.0], [300.0, 0.0], [155.0, 155.0], [0.0, 300.0]]).unwrap();
+        assert_eq!(ok.front_side([0.0, 0.0, 100.0, 100.0]), ok.w(50.0, 50.0).signum());
+    }
+
     #[test]
     fn identity_and_translation_are_exact() {
         let mut s = rgba();
@@ -482,6 +642,44 @@ mod tests {
         }
     }
 
+    #[test]
+    fn translation_preserves_colour_range_at_every_depth() {
+        use photocraft_color::{ColorMode, SampleType};
+
+        let h = Homography([1.0, 0.0, 7.0, 0.0, 1.0, -3.0, 0.0, 0.0, 1.0]);
+        for sample in SampleType::ALL {
+            for mode in [ColorMode::Rgb, ColorMode::Grayscale] {
+                for alpha in [false, true] {
+                    let mut s = Surface::new(PixelFormat::new(mode, sample, alpha));
+                    let mut pixel = if mode == ColorMode::Rgb { vec![2.0, -0.25, 0.5] } else { vec![2.0] };
+                    if alpha {
+                        pixel.push(0.5);
+                    }
+                    s.fill_rect(Rect::new(4, 4, 8, 8), &pixel);
+                    let mut expected = s.pixel(5, 5);
+                    if !alpha {
+                        expected.push(1.0);
+                    }
+                    for interp in [Interp::Nearest, Interp::Bilinear, Interp::Bicubic] {
+                        let out = warp_surface(&s, s.content_bounds(), &h, interp).unwrap();
+                        assert_eq!(out.pixel(12, 2), expected, "{sample:?}/{mode:?}/alpha={alpha}/{interp:?}");
+                        assert_eq!(out.pixel(0, 0).last(), Some(&0.0));
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn bilinear_translation_interpolates_signed_hdr_colours() {
+        let mut s = Surface::new(PixelFormat::RGBA32F);
+        s.write_pixel(0, 0, &[2.0, -0.5, 0.25, 0.5]);
+        s.write_pixel(1, 0, &[4.0, -0.25, 0.75, 0.5]);
+        let h = Homography([1.0, 0.0, 0.5, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]);
+        let out = warp_surface(&s, s.content_bounds(), &h, Interp::Bilinear).unwrap();
+        assert_eq!(out.pixel(1, 0), vec![3.0, -0.375, 0.5, 0.5]);
+    }
+
     #[test]
     fn scale_doubles_size_and_rotation_keeps_area() {
         let mut s = rgba();
diff --git a/crates/algo/src/warp.rs b/crates/algo/src/warp.rs
index 36d4a313dc..01c54e7643 100644
--- a/crates/algo/src/warp.rs
+++ b/crates/algo/src/warp.rs
@@ -4,27 +4,26 @@
 //! The source rectangle is subdivided into a fine grid whose vertices are mapped forward; each
 //! cell's two triangles are rasterized in destination space with the source position
 //! interpolated barycentrically, then the source is sampled there (premultiplied, nearest /
-//! bilinear / Catmull-Rom bicubic, like Free Transform). Cells are a few source pixels across, so
+//! bilinear / Photoshop's Keys bicubic, like Free Transform). Cells are a few source pixels across, so
 //! the piecewise-affine inverse is within a small fraction of a pixel of the true one; affine
-//! maps (the identity included) are reproduced exactly. Where the warp folds over itself the
+//! maps (the identity included) are reproduced exactly. Where the warp shrinks the source, each
+//! pixel instead averages a grid of bilinear subsamples over its source footprint (about one per
+//! source pixel), so thin lines don't alias. Where the warp folds over itself the
 //! later (lower-right) cell wins. Work is split per destination tile (parallel on native).
 
 use photocraft_color::PixelFormat;
 use photocraft_geom::Rect;
 use photocraft_raster::Surface;
 
-use crate::transform::Interp;
-
-fn catmull_rom(t: f64) -> [f64; 4] {
-    let t2 = t * t;
-    let t3 = t2 * t;
-    [-0.5 * t3 + t2 - 0.5 * t, 1.5 * t3 - 2.5 * t2 + 1.0, -1.5 * t3 + 2.0 * t2 + 0.5 * t, 0.5 * t3 - 0.5 * t2]
-}
+use crate::transform::{Interp, bicubic};
 
 /// Grid cell size (source px) used to approximate the map.
 const CELL: f64 = 4.0;
 /// Most cells along one axis (bounds memory and time on huge layers).
 const MAX_CELLS: usize = 512;
+/// Most subsamples per axis when a warp shrinks the source; also the longest source step per
+/// destination pixel the filter follows (bounds the footprint each tile reads).
+const MAX_SS: f64 = 8.0;
 
 /// Places a smart object's source image (`src`, its pixels in `src_rect`) in the document:
 /// through `warp` (source space) and then the affine `t` (source → document) in one resampling
@@ -172,14 +171,37 @@ pub fn warp_triangles(src: &Surface, src_rect: Rect, verts: &[([f64; 2], [f64; 2
         }
         let w = t.width() as usize;
         let h = t.height() as usize;
-        // Source position per destination pixel (NaN = not covered).
+        // Subsamples along one destination axis, from the source step `j` it makes: one where
+        // the warp keeps or enlarges the source, else about one per source pixel the output pixel
+        // spans (an area average, as the transform path gets from its pre-reduction; a single
+        // bicubic sample aliases thin lines when shrinking). The subsamples are bilinear: the
+        // box does the filtering, and it is ~4x cheaper than bicubic at no loss.
+        let count = |j: [f64; 2]| if interp == Interp::Nearest { 1 } else { j[0].hypot(j[1]).round().clamp(1.0, MAX_SS) as usize };
+        // Source position per destination pixel (NaN = not covered) and the triangle it came
+        // from. Per triangle: its source step per destination pixel along x and y (`[dx_u, dx_v,
+        // dy_u, dy_v]`, the inverse map's Jacobian, constant over a triangle; zero when
+        // point-sampled) and the subsamples along each.
         let mut uv = vec![[f64::NAN; 2]; w * h];
-        for tri in tris {
+        let mut owner = vec![0u32; w * h];
+        let mut jac: Vec<([f64; 4], usize, usize)> = Vec::with_capacity(tris.len());
+        for (k, tri) in tris.iter().enumerate() {
             let [(p0, s0), (p1, s1), (p2, s2)] = tri.map(|v| verts[v]);
             let det = (p1[0] - p0[0]) * (p2[1] - p0[1]) - (p2[0] - p0[0]) * (p1[1] - p0[1]);
             if det.abs() < 1e-12 {
+                jac.push(([0.0; 4], 1, 1));
                 continue;
             }
+            let (d1, d2) = ([s1[0] - s0[0], s1[1] - s0[1]], [s2[0] - s0[0], s2[1] - s0[1]]);
+            let (l1x, l1y, l2x, l2y) = ((p2[1] - p0[1]) / det, (p0[0] - p2[0]) / det, (p0[1] - p1[1]) / det, (p1[0] - p0[0]) / det);
+            // Capped, so a sliver triangle can't ask for an unbounded footprint.
+            let cap = |j: [f64; 2]| {
+                let l = j[0].hypot(j[1]);
+                if l > MAX_SS { [j[0] * MAX_SS / l, j[1] * MAX_SS / l] } else { j }
+            };
+            let jx = cap([l1x * d1[0] + l2x * d2[0], l1x * d1[1] + l2x * d2[1]]);
+            let jy = cap([l1y * d1[0] + l2y * d2[0], l1y * d1[1] + l2y * d2[1]]);
+            let (nx, ny) = (count(jx), count(jy));
+            jac.push(if nx * ny == 1 { ([0.0; 4], 1, 1) } else { ([jx[0], jx[1], jy[0], jy[1]], nx, ny) });
             let bx0 = (p0[0].min(p1[0]).min(p2[0]) - 0.5).floor().max(f64::from(t.x0)) as i32;
             let by0 = (p0[1].min(p1[1]).min(p2[1]) - 0.5).floor().max(f64::from(t.y0)) as i32;
             let bx1 = (p0[0].max(p1[0]).max(p2[0]) + 0.5).ceil().min(f64::from(t.x1)) as i32;
@@ -197,16 +219,18 @@ pub fn warp_triangles(src: &Surface, src_rect: Rect, verts: &[([f64; 2], [f64; 2
                     }
                     let o = (y - t.y0) as usize * w + (x - t.x0) as usize;
                     uv[o] = [l0 * s0[0] + l1 * s1[0] + l2 * s2[0], l0 * s0[1] + l1 * s1[1] + l2 * s2[1]];
+                    owner[o] = k as u32;
                 }
             }
         }
-        // Source footprint of the covered pixels.
+        // Source footprint of the covered pixels, including the spread of their subsamples.
         let (mut fx0, mut fy0, mut fx1, mut fy1) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
-        for q in uv.iter().filter(|q| !q[0].is_nan()) {
-            fx0 = fx0.min(q[0]);
-            fy0 = fy0.min(q[1]);
-            fx1 = fx1.max(q[0]);
-            fy1 = fy1.max(q[1]);
+        for (q, j) in uv.iter().zip(&owner).filter(|(q, _)| !q[0].is_nan()).map(|(q, &k)| (q, jac[k as usize].0)) {
+            let (ex, ey) = (0.5 * (j[0].abs() + j[2].abs()), 0.5 * (j[1].abs() + j[3].abs()));
+            fx0 = fx0.min(q[0] - ex);
+            fy0 = fy0.min(q[1] - ey);
+            fx1 = fx1.max(q[0] + ex);
+            fy1 = fy1.max(q[1] + ey);
         }
         if fx0 > fx1 {
             return None;
@@ -233,11 +257,9 @@ pub fn warp_triangles(src: &Surface, src_rect: Rect, verts: &[([f64; 2], [f64; 2
         let mut outp = vec![0.0f32; w * h * n];
         let mut any = false;
         let mut acc = [0.0f64; 8];
-        for (o, q) in uv.iter().enumerate() {
-            if q[0].is_nan() {
-                continue;
-            }
-            let (u, v) = (q[0] - 0.5, q[1] - 0.5);
+        let mut one = [0.0f64; 8];
+        // One premultiplied sample at source position (u, v) (pixel centres at integers).
+        let point = |interp: Interp, u: f64, v: f64, acc: &mut [f64; 8]| {
             acc[..n].fill(0.0);
             match interp {
                 Interp::Nearest => {
@@ -262,7 +284,7 @@ pub fn warp_triangles(src: &Surface, src_rect: Rect, verts: &[([f64; 2], [f64; 2
                     let snap = |t: f64| if (t - t.round()).abs() < 1e-7 { t.round() } else { t };
                     let (u, v) = (snap(u), snap(v));
                     let (ix, iy) = (u.floor() as i32, v.floor() as i32);
-                    let (wx, wy) = (catmull_rom(u - f64::from(ix)), catmull_rom(v - f64::from(iy)));
+                    let (wx, wy) = (bicubic(u - f64::from(ix)), bicubic(v - f64::from(iy)));
                     for (j, wyj) in wy.iter().enumerate() {
                         for (i, wxi) in wx.iter().enumerate() {
                             let k = wxi * wyj;
@@ -276,6 +298,31 @@ pub fn warp_triangles(src: &Surface, src_rect: Rect, verts: &[([f64; 2], [f64; 2
                     }
                 }
             }
+        };
+        for (o, (q, &k)) in uv.iter().zip(&owner).enumerate() {
+            if q[0].is_nan() {
+                continue;
+            }
+            let (j, nx, ny) = jac[k as usize];
+            if nx * ny == 1 {
+                point(interp, q[0] - 0.5, q[1] - 0.5, &mut acc);
+            } else {
+                acc[..n].fill(0.0);
+                for sy in 0..ny {
+                    let t = (sy as f64 + 0.5) / ny as f64 - 0.5;
+                    for sx in 0..nx {
+                        let s = (sx as f64 + 0.5) / nx as f64 - 0.5;
+                        point(Interp::Bilinear, q[0] + s * j[0] + t * j[2] - 0.5, q[1] + s * j[1] + t * j[3] - 0.5, &mut one);
+                        for (c, v) in acc.iter_mut().zip(&one).take(n) {
+                            *c += v;
+                        }
+                    }
+                }
+                let k = 1.0 / (nx * ny) as f64;
+                for c in acc.iter_mut().take(n) {
+                    *c *= k;
+                }
+            }
             let al = acc[a].clamp(0.0, 1.0);
             // Float noise (a vertex a hair off the pixel grid) must not leave invisible
             // colour behind in transparent pixels.
@@ -407,6 +454,32 @@ mod tests {
         assert!(c.y0 < r.y0 - 2 && c.x0 < r.x0 && c.x1 > r.x1, "the top rises and spreads past the box: {c:?}");
     }
 
+    #[test]
+    fn a_shrinking_mesh_warp_is_prefiltered() {
+        // A warped smart object placed at ~1/5 size: a grid of 1 px lines every 4 px must come
+        // out its area average (9/16 white) everywhere, not point-sampled moiré (crinkled,
+        // doubled or missing lines), like the affine path's `large_downscale_is_prefiltered`.
+        for s in [SampleType::U8, SampleType::U16, SampleType::F32] {
+            let (w, h) = (400, 320);
+            let mut src = Surface::new(PixelFormat::new(ColorMode::Rgb, s, true));
+            let px: Vec<f32> =
+                (0..h).flat_map(|y| (0..w).map(move |x| if x % 4 == 0 || y % 4 == 0 { 0.0 } else { 1.0 })).flat_map(|v| [v, v, v, 1.0]).collect();
+            let r = Rect::new(0, 0, w, h);
+            src.write_region(r, &px);
+            let warp = Warp::preset(WarpStyle::Arc, 15.0, [0.0, 0.0, f64::from(w), f64::from(h)]);
+            let t = photocraft_geom::Affine { m: [0.2, 0.0, 0.0, 0.2, 7.0, 5.0] };
+            let out = place_source(&src, r, &t, Some(&warp)).unwrap();
+            let b = out.content_bounds();
+            let o = out.read_region(b);
+            let opaque: Vec<f32> = o.as_chunks::<4>().0.iter().filter(|p| p[3] >= 0.999).map(|p| p[0]).collect();
+            assert!(opaque.len() > 2000, "{s:?}: {} opaque pixels", opaque.len());
+            let worst = opaque.iter().map(|v| (v - 0.5625).abs()).fold(0.0f32, f32::max);
+            // An area average over the ~5 px footprint still covers one or two lines per axis
+            // (up to 0.2 off); point sampling lands wholly on or off a line (up to 0.56 off).
+            assert!(worst < 0.25, "{s:?}: worst deviation from the area average {worst}");
+        }
+    }
+
     #[test]
     fn gray_masks_keep_their_default() {
         let mut m = Surface::with_default(PixelFormat::GRAY8, &[1.0]);
diff --git a/crates/algo/tests/retouch_blur_exact.rs b/crates/algo/tests/retouch_blur_exact.rs
new file mode 100644
index 0000000000..871a52b7f4
--- /dev/null
+++ b/crates/algo/tests/retouch_blur_exact.rs
@@ -0,0 +1,90 @@
+//! Frozen scalar convolution from main 5dac5c6, used as an exact-output oracle.
+use photocraft_algo::retouch::local_blur;
+
+#[test]
+fn matches_scalar_blur_bit_for_bit_across_layouts_edges_and_hdr() {
+    for (w, h) in [(1, 1), (3, 7), (37, 29)] {
+        for ch in 1..=5 {
+            for alpha in std::iter::once(None).chain((0..ch).map(Some)) {
+                let data: Vec<f32> = (0..w * h * ch)
+                    .map(|i| if Some(i % ch) == alpha { [0.0, 1e-8, 0.25, 0.75, 1.0][(i / ch) % 5] } else { ((i * 73 + 19) % 113) as f32 / 17.0 - 2.0 })
+                    .collect();
+                for win in [(0, 0, w, h), (w / 2, h / 2, w, h), (0, 0, 1, 1), (0, 0, 0, h)] {
+                    for sigma in [0.0, 0.25, 1.0, 3.0, 4.0, 12.0] {
+                        let expected = scalar_local_blur(&data, w, h, ch, alpha, win, sigma);
+                        let actual = local_blur(&data, w, h, ch, alpha, win, sigma);
+                        assert_eq!(actual.len(), expected.len());
+                        for (i, (a, b)) in actual.iter().zip(&expected).enumerate() {
+                            assert_eq!(a.to_bits(), b.to_bits(), "{w}x{h} ch={ch} alpha={alpha:?} win={win:?} sigma={sigma} sample={i}");
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn empty_channel_layout_remains_empty() {
+    assert!(local_blur(&[], 5, 5, 0, None, (0, 0, 5, 5), 4.0).is_empty());
+}
+
+#[allow(clippy::too_many_arguments)]
+fn scalar_local_blur(data: &[f32], w: usize, h: usize, ch: usize, alpha: Option<usize>, win: (usize, usize, usize, usize), sigma: f32) -> Vec<f32> {
+    let (x0, y0, x1, y1) = win;
+    let (ow, oh) = (x1 - x0, y1 - y0);
+    let r = (sigma * 3.0).ceil().max(1.0) as i32;
+    let k: Vec<f32> = (-r..=r).map(|i| (-((i * i) as f32) / (2.0 * sigma * sigma).max(1e-6)).exp()).collect();
+    let ks: f32 = k.iter().sum();
+    let k: Vec<f32> = k.into_iter().map(|v| v / ks).collect();
+    let get = |x: i32, y: i32, out: &mut [f32]| {
+        let (xx, yy) = (x.clamp(0, w as i32 - 1) as usize, y.clamp(0, h as i32 - 1) as usize);
+        let i = (yy * w + xx) * ch;
+        out.copy_from_slice(&data[i..i + ch]);
+        if let Some(a) = alpha {
+            let av = out[a];
+            for (c, v) in out.iter_mut().enumerate() {
+                if c != a {
+                    *v *= av;
+                }
+            }
+        }
+    };
+    // Horizontal pass over the window rows extended vertically by r.
+    let th = oh + 2 * r as usize;
+    let mut tmp = vec![0.0f32; ow * th * ch];
+    let mut px = vec![0.0f32; ch];
+    for ty in 0..th {
+        let y = y0 as i32 + ty as i32 - r;
+        for ox in 0..ow {
+            let o = (ty * ow + ox) * ch;
+            for (i, kv) in k.iter().enumerate() {
+                get(x0 as i32 + ox as i32 + i as i32 - r, y, &mut px);
+                for c in 0..ch {
+                    tmp[o + c] += px[c] * kv;
+                }
+            }
+        }
+    }
+    let mut out = vec![0.0f32; ow * oh * ch];
+    for oy in 0..oh {
+        for ox in 0..ow {
+            let o = (oy * ow + ox) * ch;
+            for (i, kv) in k.iter().enumerate() {
+                let s = ((oy + i) * ow + ox) * ch;
+                for c in 0..ch {
+                    out[o + c] += tmp[s + c] * kv;
+                }
+            }
+            if let Some(a) = alpha {
+                let av = out[o + a];
+                for c in 0..ch {
+                    if c != a {
+                        out[o + c] = if av > 1e-6 { out[o + c] / av } else { data[((y0 + oy) * w + x0 + ox) * ch + c] };
+                    }
+                }
+            }
+        }
+    }
+    out
+}
diff --git a/crates/automation/src/headless.rs b/crates/automation/src/headless.rs
index 028ca09f14..d6b3c17102 100644
--- a/crates/automation/src/headless.rs
+++ b/crates/automation/src/headless.rs
@@ -96,13 +96,15 @@ impl Headless {
             st.source_read_only = o.source_read_only;
         }
         let d = &self.session.documents()[index];
+        let mut warnings = o.warnings;
+        warnings.extend(photocraft_engine::type_extra_cmds::missing_font_warnings(&d.doc));
         Ok(json!({
             "index": index,
             "name": d.doc.name,
             "width": d.doc.size.width,
             "height": d.doc.size.height,
             "layers": d.doc.layer_count(),
-            "warnings": o.warnings,
+            "warnings": warnings,
         }))
     }
 
@@ -228,9 +230,11 @@ impl Headless {
             (None, Some(p)) => {
                 let own = file_cmds::extension(p);
                 let written = format.map(|f| f.trim_start_matches('.').to_ascii_lowercase()).or_else(|| own.clone());
-                if !file_cmds::saves_in_place(p) || written != own {
+                if !file_cmds::holds_at(&doc, p) || written != own {
+                    let lost = file_cmds::losses_at(&doc, p);
+                    let why = if lost.is_empty() { String::new() } else { format!(" (it can't keep: {})", lost.join("; ")) };
                     return Err(AutomationError::BadRequest(format!(
-                        "pass `path`: without one, only a PSD, PSB or .pcraft file is written back, in its own format, so `{p}` was left unchanged"
+                        "pass `path`: without one, only a PSD, PSB, .pcraft or OpenRaster file that holds the whole document is written back, in its own format, so `{p}` was left unchanged{why}"
                     )));
                 }
                 PathBuf::from(p)
@@ -240,7 +244,7 @@ impl Headless {
             }
         };
         let target_text = target.to_str().ok_or_else(|| AutomationError::BadRequest("automation paths must be valid UTF-8".into()))?;
-        let warnings = match &self.filesystem {
+        let mut warnings = match &self.filesystem {
             Filesystem::Denied => return Err(AutomationError::BadRequest("automation filesystem access is not granted: write authority is absent".into())),
             Filesystem::TrustedLocal => {
                 let writer = self.writers.entry(doc.id.0).or_default();
@@ -252,13 +256,15 @@ impl Headless {
                 warnings
             }
         };
-        // A layered document save (PSD, PSB, OpenRaster or .pcraft) is a full write, not a flattened copy:
-        // record the current revision as saved so the session stops reporting `dirty`, and make
-        // the file the document's path. A flat export (PNG, JPEG, …) is a copy and leaves both
-        // alone (#1547).
+        warnings.extend(photocraft_engine::type_extra_cmds::missing_font_warnings(&doc));
+        // A layered document save (PSD, PSB, OpenRaster or .pcraft) that holds the whole document is a
+        // full write, not a flattened copy: record the current revision as saved so the session
+        // stops reporting `dirty`, and make the file the document's path. A flat export (PNG,
+        // JPEG, …), or an OpenRaster file that drops part of it, is a copy and leaves both alone
+        // (#1547, #3806).
         let ext =
             format.map(|f| f.trim_start_matches('.').to_ascii_lowercase()).or_else(|| target.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()));
-        if ext.as_deref().is_some_and(file_cmds::layered_extension) {
+        if ext.as_deref().is_some_and(|e| file_cmds::holds(&doc, e)) {
             // Saving by index must not retarget the next automation command.
             let previously_active = self.session.active_index();
             self.session.set_active(i);
@@ -317,21 +323,7 @@ impl Headless {
     }
 
     pub fn command_list(&self) -> Value {
-        Value::Array(
-            command_specs()
-                .iter()
-                .map(|c| {
-                    json!({
-                        "id": c.id,
-                        "label": c.label,
-                        "menu": c.menu,
-                        "shortcut": c.shortcut,
-                        "params": c.params,
-                        "enabled": self.session.is_enabled(c.id),
-                    })
-                })
-                .collect(),
-        )
+        Value::Array(command_specs().iter().map(|c| photocraft_engine::commands::list_entry(&self.session, c, self.session.disabled_reason(c.id))).collect())
     }
 
     pub fn command_run(&mut self, id: &str, params: Value) -> Result<Value, AutomationError> {
diff --git a/crates/automation/src/rpc.rs b/crates/automation/src/rpc.rs
index d513bfa889..507010b9c8 100644
--- a/crates/automation/src/rpc.rs
+++ b/crates/automation/src/rpc.rs
@@ -30,7 +30,7 @@ use serde_json::{Value, json};
 use crate::budgets::{BatchReplyBudget, write_reply};
 use crate::security::{
     ConnectionLimiter, LineRead, MAX_BATCH_STEPS, MAX_CONNECTIONS, MAX_REQUEST_BYTES, authentication_reply, configure_stream, discard_rest_of_line,
-    read_bounded_line,
+    read_bounded_line, repeat_auth_reply,
 };
 use crate::{AutomationError, Headless};
 
@@ -60,8 +60,13 @@ fn bad(msg: impl Into<String>) -> AutomationError {
     AutomationError::BadRequest(msg.into())
 }
 
-fn index_of(p: &Value) -> Option<usize> {
-    p.get("index").and_then(Value::as_u64).map(|i| i as usize)
+/// The optional `index` param: missing or null means the active document; anything else must be a
+/// non-negative integer (never silently fall back to the active document, which `doc.close` would close).
+fn index_of(p: &Value) -> Result<Option<usize>, AutomationError> {
+    match p.get("index") {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => v.as_u64().and_then(|i| usize::try_from(i).ok()).map(Some).ok_or_else(|| bad("`index` must be a non-negative integer")),
+    }
 }
 
 fn str_of<'a>(p: &'a Value, k: &str) -> Option<&'a str> {
@@ -109,20 +114,21 @@ impl Headless {
                 let mut opts = p.as_object().cloned().unwrap_or_default();
                 opts.remove("path");
                 opts.remove("index");
-                self.place(index_of(&p), path, &Value::Object(opts))
+                self.place(index_of(&p)?, path, &Value::Object(opts))
             }
             "doc.new" => self.command_run("file.new", p),
             "doc.save" => {
                 let tga_bits = photocraft_engine::file_cmds::tga_bits_param(&p, "doc.save").map_err(|e| bad(e.to_string()))?;
                 let mut opts =
                     photocraft_io::ExportOptions { tiff_layers: p.get("tiffLayers").and_then(Value::as_bool).unwrap_or(false), tga_bits, ..Default::default() };
+                opts.encode.dpx_bits = photocraft_engine::file_cmds::dpx_bits_param(&p, "doc.save").map_err(|e| bad(e.to_string()))?;
                 if let Some(q) = p.get("quality").and_then(Value::as_u64) {
                     opts.encode.jpeg_quality = q.clamp(1, 100) as u8;
                     opts.encode.webp_quality = q.clamp(1, 100) as u8;
                     opts.encode.webp_lossless = false;
                 }
                 let path = str_of(&p, "path").map(PathBuf::from);
-                self.save(index_of(&p), path.as_deref(), str_of(&p, "format"), &opts)
+                self.save(index_of(&p)?, path.as_deref(), str_of(&p, "format"), &opts)
             }
             "doc.exportLayers" | "doc.exportDataSets" => {
                 let dir = str_of(&p, "dir").ok_or_else(|| bad(format!("{method} needs `dir`")))?;
@@ -130,16 +136,16 @@ impl Headless {
                 opts.remove("dir");
                 opts.remove("index");
                 let opts = Value::Object(opts);
-                if method == "doc.exportLayers" { self.export_layers(index_of(&p), dir, &opts) } else { self.export_data_sets(index_of(&p), dir, &opts) }
+                if method == "doc.exportLayers" { self.export_layers(index_of(&p)?, dir, &opts) } else { self.export_data_sets(index_of(&p)?, dir, &opts) }
             }
             "doc.importDataSets" => {
                 let path = str_of(&p, "path").ok_or_else(|| bad("doc.importDataSets needs `path`"))?;
                 let mut opts = p.as_object().cloned().unwrap_or_default();
                 opts.remove("path");
                 opts.remove("index");
-                self.import_data_sets(index_of(&p), path, &Value::Object(opts))
+                self.import_data_sets(index_of(&p)?, path, &Value::Object(opts))
             }
-            "doc.inspect" => self.inspect(index_of(&p)),
+            "doc.inspect" => self.inspect(index_of(&p)?),
             "doc.render" => {
                 let max = match p.get("maxSide") {
                     None => 1024,
@@ -147,7 +153,7 @@ impl Headless {
                         value.as_u64().and_then(|value| u32::try_from(value).ok()).ok_or_else(|| bad("maxSide must be an unsigned 32-bit integer"))?
                     }
                 };
-                let png = self.render_png(index_of(&p), max)?;
+                let png = self.render_png(index_of(&p)?, max)?;
                 match str_of(&p, "path") {
                     Some(path) => {
                         self.write_render(&PathBuf::from(path), &png)?;
@@ -160,10 +166,10 @@ impl Headless {
                 }
             }
             "doc.select" => {
-                let i = index_of(&p).ok_or_else(|| bad("doc.select needs `index`"))?;
+                let i = index_of(&p)?.ok_or_else(|| bad("doc.select needs `index`"))?;
                 self.select(i)
             }
-            "doc.close" => self.close(index_of(&p)),
+            "doc.close" => self.close(index_of(&p)?),
             "batch" => self.batch(&p),
             "methods" => Ok(json!(METHODS)),
             other => Err(bad(format!("unknown method `{other}` (try `methods`)"))),
@@ -288,7 +294,7 @@ fn serve_tcp_connection(h: &Mutex<Headless>, stream: std::net::TcpStream, token:
             LineRead::Line => {}
         }
         let reply = if authenticated {
-            respond(h, &line)
+            repeat_auth_reply(&line).unwrap_or_else(|| respond(h, &line))
         } else {
             let (reply, ok) = authentication_reply(&line, token);
             authenticated = ok;
@@ -357,6 +363,40 @@ mod tests {
         }
     }
 
+    /// Pins the reply shape documented in docs/control-protocol.md › Command list replies
+    /// (#3684): a bare JSON array (not `{"commands": [...]}`), one object per command with
+    /// exactly these keys, from `engine.commands` (filtered or not) and `command.list`.
+    #[test]
+    fn command_list_replies_are_documented_array_of_objects() {
+        let h = session();
+        let mut g = h.lock().unwrap();
+        let all = g.handle("engine.commands", json!({})).unwrap();
+        let filtered = g.handle("engine.commands", json!({"filter": "BLUR"})).unwrap();
+        let engine = g.handle("engine.execute", json!({"command": "command.list"})).unwrap();
+        for (name, reply) in [("engine.commands", &all), ("engine.commands {filter}", &filtered), ("command.list", &engine)] {
+            let items = reply.as_array().unwrap_or_else(|| panic!("{name} must reply with a bare array, got {reply}"));
+            assert!(!items.is_empty(), "{name}");
+            for c in items {
+                let mut keys: Vec<&str> = c.as_object().unwrap().keys().map(String::as_str).collect();
+                keys.sort_unstable();
+                assert_eq!(keys, ["disabledReason", "enabled", "id", "label", "menu", "needsDocument", "params", "shortcut"], "{name}: {c}");
+                assert!(c["id"].is_string() && c["label"].is_string() && c["params"].is_string() && c["enabled"].is_boolean(), "{c}");
+                assert!(c["needsDocument"].is_boolean(), "{c}");
+                assert_eq!(c["disabledReason"].is_null(), c["enabled"] == true, "disabledReason is null exactly when enabled: {c}");
+                assert!(c["menu"].as_array().unwrap().iter().all(Value::is_string), "{c}");
+                assert!(c["shortcut"].is_string() || c["shortcut"].is_null(), "{c}");
+            }
+        }
+        let n_all = all.as_array().unwrap().len();
+        assert_eq!(engine.as_array().unwrap().len(), n_all);
+        let filtered = filtered.as_array().unwrap();
+        assert!(filtered.len() < n_all);
+        assert!(filtered.iter().all(|c| format!("{} {}", c["id"], c["label"]).to_lowercase().contains("blur")));
+        let new = all.as_array().unwrap().iter().find(|c| c["id"] == "file.new").unwrap();
+        assert_eq!((&new["menu"], &new["shortcut"], &new["enabled"]), (&json!(["File"]), &json!("Cmd+N"), &json!(true)), "{new}");
+        assert_eq!((&new["disabledReason"], &new["needsDocument"]), (&Value::Null, &json!(false)), "{new}");
+    }
+
     #[test]
     fn lines_round_trip_and_errors() {
         let h = session();
@@ -780,6 +820,36 @@ mod tests {
         assert!(v["result"].as_array().unwrap().iter().any(|m| m == "batch"));
     }
 
+    #[test]
+    fn tcp_repeat_auth_reports_already_authenticated_and_keeps_serving() {
+        use std::io::{BufReader, Write as _};
+        const TOKEN: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+        let h = Arc::new(Mutex::new(Headless::new()));
+        let (tx, rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || {
+            let _ = serve_tcp("127.0.0.1:0", h, TOKEN.into(), move |a| tx.send(a).unwrap());
+        });
+        let addr = rx.recv().unwrap();
+        let mut s = std::net::TcpStream::connect(addr).unwrap();
+        let mut reader = BufReader::new(s.try_clone().unwrap());
+        let mut line = String::new();
+        for id in ["auth", "again"] {
+            writeln!(s, r#"{{"id":"{id}","method":"auth","params":{{"token":"{TOKEN}"}}}}"#).unwrap();
+            line.clear();
+            reader.read_line(&mut line).unwrap();
+        }
+        let again: Value = serde_json::from_str(&line).unwrap();
+        assert_eq!(again["id"], "again");
+        assert_eq!(again["ok"], false);
+        assert_eq!(again["error"], "already authenticated");
+        writeln!(s, r#"{{"id":"m","method":"methods"}}"#).unwrap();
+        line.clear();
+        reader.read_line(&mut line).unwrap();
+        let v: Value = serde_json::from_str(&line).unwrap();
+        assert_eq!(v["id"], "m");
+        assert_eq!(v["ok"], true);
+    }
+
     #[test]
     fn tcp_rejects_requests_before_authentication() {
         use std::io::{BufReader, Write as _};
@@ -799,4 +869,27 @@ mod tests {
         assert_eq!(v["error"], "authentication required");
         assert!(v.get("result").is_none());
     }
+
+    #[test]
+    fn invalid_document_index_is_rejected_not_the_active_document() {
+        let h = session();
+        for _ in 0..2 {
+            assert_eq!(respond(&h, r#"{"method":"doc.new","params":{"width":8,"height":8}}"#)["ok"], true);
+        }
+        let count = |h: &Mutex<Headless>| h.lock().unwrap().session_list()["documents"].as_array().unwrap().len();
+        for index in [json!("0"), json!(-1), json!(0.5), json!(true)] {
+            for method in ["doc.close", "doc.inspect", "doc.select"] {
+                let reply = respond(&h, &json!({"method": method, "params": {"index": index}}).to_string());
+                assert_eq!(reply["ok"], false, "{method} {index}: {reply}");
+                assert!(reply["error"].as_str().unwrap().contains("`index` must be a non-negative integer"), "{reply}");
+            }
+            assert_eq!(count(&h), 2, "index {index} closed a document");
+        }
+        // Null means "the active document", like a missing `index`.
+        assert_eq!(respond(&h, r#"{"method":"doc.inspect","params":{"index":null}}"#)["ok"], true);
+        // A valid index still closes that document.
+        let reply = respond(&h, r#"{"method":"doc.close","params":{"index":0}}"#);
+        assert_eq!(reply["ok"], true, "{reply}");
+        assert_eq!(count(&h), 1);
+    }
 }
diff --git a/crates/automation/src/security.rs b/crates/automation/src/security.rs
index 075427c03f..4659a3ff17 100644
--- a/crates/automation/src/security.rs
+++ b/crates/automation/src/security.rs
@@ -118,6 +118,18 @@ pub fn authentication_reply(line: &str, expected_token: &str) -> (Value, bool) {
     }
 }
 
+/// Answer a repeat `auth` frame on an already authenticated connection. Returns `None` for any
+/// other frame, which the caller dispatches as usual.
+/// Without this, a second `auth` fell through to the method dispatcher as an unknown method.
+pub fn repeat_auth_reply(line: &str) -> Option<Value> {
+    let req: Value = serde_json::from_str(line).ok()?;
+    if req.get("method").and_then(Value::as_str) != Some(AUTH_METHOD) {
+        return None;
+    }
+    let id = req.get("id").cloned().unwrap_or(Value::Null);
+    Some(json!({"id": id, "ok": false, "error": "already authenticated"}))
+}
+
 fn read_token_file(path: &Path) -> Result<String, AutomationError> {
     let token = std::fs::read_to_string(path).map_err(|e| AutomationError::Io(format!("{}: {e}", path.display())))?;
     let token = token.trim().to_owned();
@@ -294,6 +306,17 @@ mod tests {
         assert_eq!(reply["result"]["authenticated"], true);
     }
 
+    #[test]
+    fn repeat_auth_on_an_authenticated_connection_says_so() {
+        let line = json!({"id": 3, "method": AUTH_METHOD, "params": {"token": "anything"}}).to_string();
+        let reply = repeat_auth_reply(&line).unwrap();
+        assert_eq!(reply["id"], 3);
+        assert_eq!(reply["ok"], false);
+        assert_eq!(reply["error"], "already authenticated");
+        assert!(repeat_auth_reply(r#"{"id":4,"method":"methods"}"#).is_none());
+        assert!(repeat_auth_reply("{not json").is_none());
+    }
+
     #[test]
     fn token_file_round_trips_between_server_and_client() {
         let path = std::env::temp_dir().join(format!("photocraft-control-token-{}-{}.txt", std::process::id(), generate_token().unwrap()));
diff --git a/crates/automation/src/server.rs b/crates/automation/src/server.rs
index 909e221984..b31507b005 100644
--- a/crates/automation/src/server.rs
+++ b/crates/automation/src/server.rs
@@ -167,6 +167,9 @@ pub struct SaveParams {
     /// alpha, 24 none. Unset: 32 with an alpha channel or transparency, else 24.
     #[serde(default, rename = "tgaBits")]
     pub tga_bits: Option<u8>,
+    /// DPX: 8, 10, 12 or 16 bits per sample. Unset: 8 for an 8-bit document, else 16.
+    #[serde(default, rename = "dpxBits")]
+    pub dpx_bits: Option<u8>,
     #[serde(default)]
     pub index: Option<usize>,
 }
@@ -306,7 +309,7 @@ pub struct UiSetParams {
     /// Fields for the control method `ui.set`: tool, panels, dock, dockTabs, dockWidth, colorPanel
     /// ({background: bool} picks which swatch the Color panel edits), maskTarget,
     /// vectorMaskTarget, selectionMode, zoom, center, rotation (view angle in degrees), fit, theme (pro, proMedium, studio,
-    /// studioLight, classic, solarizedDark, adwaita, adwaitaDark, breezeLight, breezeDark), brushSection, brushTab,
+    /// studioLight, classic, solarizedDark, adwaita, adwaitaDark, breezeLight, breezeDark, softLight, softDark), brushSection, brushTab,
     /// brushesView, brushPicker ([x, y] opens the Brush Preset picker there, null closes it),
     /// brushPickerName, brushPickerStroke, brushPickerTip (the picker card's parts, at least one
     /// on), brushPickerScale (the picker footer's card-scale slider, 0.15 to 2, 1 the standard),
@@ -320,7 +323,8 @@ pub struct UiSetParams {
     /// auto_adjust, classic_mode and auto_center_preview), shapeStroke (an object patching width, align, cap, join, miterLimit,
     /// dashes, dashOffset and opacity; null disables the stroke). Shape stroke fields use
     /// `shape.edit` names and units; colour comes from `tools.setColors`. camTransformOnDrop (bool,
-    /// the Content-Aware Move tool's Transform On Drop). Other fields are an error.
+    /// the Content-Aware Move tool's Transform On Drop). tileGrid (bool, a developer overlay of the
+    /// active layer's storage tiles). Other fields are an error.
     pub fields: Value,
 }
 
@@ -792,7 +796,10 @@ impl PhotocraftMcp {
         }
     }
 
-    #[tool(description = "List engine commands: id, label, menu path, shortcut, parameter doc, enabled now.")]
+    #[tool(description = "List engine commands. Returns a JSON array (no wrapper object) of {id, label, menu: [path], \
+        shortcut: string|null, params: doc string, enabled: bool, disabledReason: string|null, needsDocument: bool}. \
+        `disabledReason` says why a command is off (null when enabled); `needsDocument` is true when it is off because no \
+        document is open: create or open one first (doc_new, doc_open).")]
     async fn command_list(&self, Parameters(p): Parameters<ListParams>) -> Result<CallToolResult, McpError> {
         let all = if let Some(r) = self.headless_op(|h| Ok(h.command_list())).await {
             r
@@ -985,6 +992,11 @@ impl PhotocraftMcp {
             Some((_, Some(bits))) => Some(bits),
             Some((b, None)) => return Ok(fail(format!("`tgaBits` must be 24 or 32, got {b}"))),
         };
+        let dpx_bits = match p.dpx_bits.map(|b| (b, photocraft_io::DpxBits::from_bits(u64::from(b)))) {
+            None => None,
+            Some((_, Some(bits))) => Some(bits),
+            Some((b, None)) => return Ok(fail(format!("`dpxBits` must be 8, 10, 12 or 16, got {b}"))),
+        };
         if let Some(b) = self.bridge_client() {
             // The bridge forwards to the running app's `app.save`, which takes only an optional
             // path (without one it writes back to the document's own layered file, as headless
@@ -994,6 +1006,7 @@ impl PhotocraftMcp {
                 p.format.is_some().then_some("format"),
                 p.quality.is_some().then_some("quality"),
                 p.tiff_layers.then_some("tiffLayers"),
+                dpx_bits.is_some().then_some("dpxBits"),
                 p.index.is_some().then_some("index"),
             ]
             .into_iter()
@@ -1014,6 +1027,7 @@ impl PhotocraftMcp {
         let Some(r) = self
             .headless_op(move |h| {
                 let mut opts = photocraft_io::ExportOptions { tiff_layers: p.tiff_layers, tga_bits, ..Default::default() };
+                opts.encode.dpx_bits = dpx_bits;
                 if let Some(q) = p.quality {
                     opts.encode.jpeg_quality = q.clamp(1, 100);
                     opts.encode.webp_quality = q.clamp(1, 100);
diff --git a/crates/automation/src/workspace.rs b/crates/automation/src/workspace.rs
index 76a14c6e34..cde3a3a702 100644
--- a/crates/automation/src/workspace.rs
+++ b/crates/automation/src/workspace.rs
@@ -252,6 +252,7 @@ pub fn authorize_engine_command(id: &str, params: &Value) -> Result<(), Automati
             | "file.fileInfo"
             | "file.automate.fitImage"
             | "file.automate.conditionalModeChange"
+            | "file.automate.cropAndStraightenPhotos"
             | "file.scripts.flattenAllLayerEffects"
             | "file.scripts.flattenAllMasks"
             | "file.scripts.deleteAllEmptyLayers"
@@ -362,12 +363,12 @@ fn preference_uses_ambient_filesystem(path: &str) -> bool {
 
 fn command_uses_ambient_path(id: &str, params: &Value) -> bool {
     match id {
-        "brush.presets.importAbr" | "gradient.presets.importGrd" | "plugin.install" | "swatches.import" => {
+        "actions.load" | "brush.presets.importAbr" | "gradient.presets.importGrd" | "plugin.install" | "swatches.import" => {
             // `data` wins over `path` in these commands; any `path` without it reads the filesystem.
             params.get("data").is_none() && params.get("path").is_some()
         }
         // With a `path` the file is written there; without one the bytes come back as `data`.
-        "swatches.export" => params.get("path").is_some(),
+        "actions.save" | "swatches.export" => params.get("path").is_some(),
         "plugin.reload" => true,
         _ => false,
     }
@@ -695,6 +696,8 @@ mod tests {
             assert!(authorize_engine_command(id, &serde_json::json!({})).is_err());
         }
         assert!(authorize_engine_command("file.new", &serde_json::json!({})).is_ok());
+        assert!(authorize_engine_command("file.automate.cropAndStraightenPhotos", &serde_json::json!({})).is_ok());
+        assert!(authorize_desktop_engine_command("file.automate.cropAndStraightenPhotos", &serde_json::json!({})).is_ok());
         for id in ["layer.smartObjects.editContents", "layer.smartObjects.convertToLayers", "layer.smartObjects.saveContents"] {
             assert!(authorize_desktop_engine_command(id, &serde_json::json!({"layer": 19})).is_ok(), "{id}");
         }
@@ -762,6 +765,8 @@ mod tests {
             ("plugin.install", serde_json::json!({"path": " "})),
             ("swatches.import", serde_json::json!({"path": "/outside/set.aco"})),
             ("swatches.export", serde_json::json!({"path": "/outside/set.ase"})),
+            ("actions.load", serde_json::json!({"path": "/outside/set.atn"})),
+            ("actions.save", serde_json::json!({"path": "/outside/set.atn"})),
         ] {
             assert!(authorize_engine_command(id, &params).is_err(), "{id}: {params}");
         }
@@ -771,6 +776,8 @@ mod tests {
             ("plugin.install", serde_json::json!({"data": "QUJD"})),
             ("swatches.import", serde_json::json!({"data": "QUJD"})),
             ("swatches.export", serde_json::json!({"format": "ase"})),
+            ("actions.load", serde_json::json!({"data": "QUJD"})),
+            ("actions.save", serde_json::json!({"set": "S"})),
         ] {
             assert!(authorize_engine_command(id, &params).is_ok(), "{id}: {params}");
         }
@@ -851,6 +858,8 @@ mod tests {
                 | "path.clippingPath.set"
                 | "path.rename"
                 | "path.stroke"
+                | "type.attachToPath"
+                | "type.detachFromPath"
                 | "select.toWorkPath"
                 | "layer.vectorMask.add"
                 | "layer.vectorMask.edit"
diff --git a/crates/automation/tests/agent_tasks.rs b/crates/automation/tests/agent_tasks.rs
index 8eb6ba725a..271993d2bb 100644
--- a/crates/automation/tests/agent_tasks.rs
+++ b/crates/automation/tests/agent_tasks.rs
@@ -331,6 +331,7 @@ async fn agent_play_refuses_a_recorded_file_open() {
         name: "Open".into(),
         steps: vec![("file.open".into(), json!({"path": "/etc/passwd"})), ("layer.new.layer".into(), json!({}))],
         disabled: Default::default(),
+        ..Default::default()
     });
     let (c, server) = connect_headless(headless).await;
     let played = run(&c, "actions.play", json!({"action": "Open"})).await;
@@ -343,3 +344,102 @@ async fn agent_play_refuses_a_recorded_file_open() {
     shutdown(c, server).await;
     std::fs::remove_dir_all(dir).unwrap();
 }
+
+/// The next ten acceptance tasks (11–20): strokes, inverse fills, duplication, merges,
+/// flattening, adjustments, feathering, expand, renaming/deleting and an export/reopen round
+/// trip — all through MCP tools and checked from outside the engine.
+#[tokio::test(flavor = "multi_thread")]
+async fn agent_completes_ten_more_scripted_tasks() {
+    let dir = tmp("tasks2");
+    let (c, server) = connect(&dir).await;
+
+    // 11. Stroke a selection: a red square with a black outside stroke.
+    tool(&c, "doc_new", json!({"width": 80, "height": 80, "background": "white"})).await;
+    run(&c, "select.rect", json!({"x": 20, "y": 20, "width": 40, "height": 40})).await;
+    run(&c, "edit.fill", json!({"color": "#ff0000"})).await;
+    run(&c, "edit.stroke", json!({"width": 4, "color": "#000000", "location": "outside"})).await;
+    let inside = pixel(&c, 40, 40).await;
+    let edge = pixel(&c, 18, 40).await;
+    let away = pixel(&c, 5, 5).await;
+    assert!(inside[0] > 0.99 && inside[1] < 0.01, "task 11: the centre is red {inside:?}");
+    assert!(edge[0] < 0.1 && edge[1] < 0.1, "task 11: the stroke is black {edge:?}");
+    assert!(away[0] > 0.99 && away[1] > 0.99, "task 11: outside stays white {away:?}");
+    run(&c, "select.deselect", json!({})).await;
+
+    // 12. Inverse the selection: a blue frame around the red square.
+    run(&c, "select.rect", json!({"x": 20, "y": 20, "width": 40, "height": 40})).await;
+    run(&c, "select.inverse", json!({})).await;
+    run(&c, "edit.fill", json!({"color": "#0000ff"})).await;
+    let centre = pixel(&c, 40, 40).await;
+    let frame = pixel(&c, 4, 4).await;
+    assert!(centre[0] > 0.99 && centre[2] < 0.01, "task 12: the centre keeps red {centre:?}");
+    assert!(frame[2] > 0.99 && frame[0] < 0.01, "task 12: the frame is blue {frame:?}");
+    run(&c, "select.deselect", json!({})).await;
+
+    // 13. Paint a green patch on a new layer and duplicate it (offset, as Photoshop's default).
+    run(&c, "layer.new.layer", json!({"name": "Patch"})).await;
+    run(&c, "select.rect", json!({"x": 10, "y": 10, "width": 20, "height": 20})).await;
+    run(&c, "edit.fill", json!({"color": "#00ff00"})).await;
+    run(&c, "select.deselect", json!({})).await;
+    run(&c, "layer.duplicate", json!({})).await;
+    let doc = inspect(&c).await;
+    assert_eq!(doc["layers"].as_array().unwrap().len(), 3, "task 13: {doc}");
+    let patches = doc["layers"].as_array().unwrap().iter().filter(|l| l["name"].as_str().is_some_and(|n| n.starts_with("Patch"))).count();
+    assert_eq!(patches, 2, "task 13: {doc}");
+
+    // 14. Merge the copy down; the two patches become one layer.
+    run(&c, "layer.mergeDown", json!({})).await;
+    assert_eq!(inspect(&c).await["layers"].as_array().unwrap().len(), 2, "task 14");
+
+    // 15. Flatten the image; the patch survives.
+    run(&c, "layer.flattenImage", json!({})).await;
+    let doc = inspect(&c).await;
+    assert_eq!(doc["layers"].as_array().unwrap().len(), 1, "task 15: {doc}");
+    let green = pixel(&c, 20, 20).await;
+    assert!(green[1] > 0.99 && green[0] < 0.01, "task 15: the patch survives {green:?}");
+
+    // 16. A Hue/Saturation adjustment layer turns the red square green without touching pixels.
+    run(&c, "layer.newAdjustmentLayer.hueSaturation", json!({"hue": 120})).await;
+    assert_eq!(top_layer(&inspect(&c).await)["kind"], "Adjustment", "task 16");
+    let shifted = pixel(&c, 40, 40).await;
+    assert!(shifted[1] > 0.5 && shifted[0] < 0.5, "task 16: red turns green {shifted:?}");
+    run(&c, "layer.delete", json!({})).await;
+
+    // 17. Feather the selection and reveal a mask through it: the edge blends.
+    run(&c, "select.rect", json!({"x": 20, "y": 20, "width": 40, "height": 40})).await;
+    run(&c, "select.modify.feather", json!({"radius": 4})).await;
+    run(&c, "layer.layerMask.revealSelection", json!({})).await;
+    let doc = inspect(&c).await;
+    assert_eq!(top_layer(&doc)["hasMask"], true, "task 17");
+    let boundary = pixel(&c, 20, 40).await;
+    assert!(boundary[3] > 0.05 && boundary[3] < 0.95, "task 17: the feathered edge keeps partial alpha {boundary:?}");
+    run(&c, "select.deselect", json!({})).await;
+
+    // 18. Expand a selection and read its bounds back.
+    run(&c, "select.rect", json!({"x": 20, "y": 20, "width": 20, "height": 20})).await;
+    run(&c, "select.modify.expand", json!({"radius": 5})).await;
+    let bounds = inspect(&c).await["selectionBounds"].clone();
+    let b = bounds.as_array().unwrap_or_else(|| panic!("task 18: {bounds}"));
+    let (x, w) = (b[0].as_i64().unwrap(), b[2].as_i64().unwrap());
+    assert!((13..=15).contains(&x) && (30..=32).contains(&w), "task 18: expanded outward {bounds}");
+    run(&c, "select.deselect", json!({})).await;
+
+    // 19. Rename a layer and delete it again.
+    run(&c, "layer.new.layer", json!({"name": "Scratch"})).await;
+    run(&c, "layer.renameLayer", json!({"name": "Delivery"})).await;
+    assert_eq!(top_layer(&inspect(&c).await)["name"], "Delivery", "task 19");
+    run(&c, "layer.delete", json!({})).await;
+    assert_eq!(inspect(&c).await["layers"].as_array().unwrap().len(), 1, "task 19: deleted");
+
+    // 20. Export the final image and reopen the PNG as a flat document.
+    tool(&c, "doc_export", json!({"path": "final.png"})).await;
+    tool(&c, "doc_close", json!({})).await;
+    tool(&c, "doc_open", json!({"path": "final.png"})).await;
+    let doc = inspect(&c).await;
+    assert_eq!((doc["width"].as_u64(), doc["height"].as_u64()), (Some(80), Some(80)), "task 20");
+    assert_eq!(doc["layers"].as_array().unwrap().len(), 1, "task 20: a flat reopen");
+    tool(&c, "doc_close", json!({})).await;
+
+    shutdown(c, server).await;
+    std::fs::remove_dir_all(dir).unwrap();
+}
diff --git a/crates/automation/tests/agent_tasks_more.rs b/crates/automation/tests/agent_tasks_more.rs
new file mode 100644
index 0000000000..3bde075e05
--- /dev/null
+++ b/crates/automation/tests/agent_tasks_more.rs
@@ -0,0 +1,184 @@
+//! M11 acceptance, part three: six rounding-out tasks (31–36) over MCP (roadmap M11 DoD).
+//!
+//! Same contract as the other acceptance files: only MCP tools (`doc_*`, `command_run`), checked
+//! through `doc_inspect`, `document.pixel` and exported/saved files.
+
+use photocraft_automation::{AuthorizedWorkspace, PhotocraftMcp};
+use rmcp::model::{CallToolRequestParams, CallToolResult, ClientConfig};
+use rmcp::service::RunningService;
+use rmcp::{ClientHandler, RoleClient, ServiceExt};
+use serde_json::{Value, json};
+
+#[derive(Clone, Default)]
+struct Client;
+impl ClientHandler for Client {
+    fn get_info(&self) -> ClientConfig {
+        ClientConfig::default()
+    }
+}
+
+type Conn = RunningService<RoleClient, Client>;
+type Server = tokio::task::JoinHandle<()>;
+
+async fn connect(root: &std::path::Path) -> (Conn, Server) {
+    let (s, c) = tokio::io::duplex(1 << 20);
+    let workspace = AuthorizedWorkspace::new(Some(root), Some(root)).expect("test workspace");
+    let server = tokio::spawn(async move {
+        if let Ok(running) = PhotocraftMcp::headless_with_workspace(workspace).serve(s).await {
+            let _ = running.waiting().await;
+        }
+    });
+    (Client.serve(c).await.expect("client init"), server)
+}
+
+async fn shutdown(c: Conn, server: Server) {
+    c.cancel().await.unwrap();
+    server.await.unwrap();
+}
+
+fn text(r: &CallToolResult) -> String {
+    r.content.iter().filter_map(|c| c.as_text()).map(|t| t.text.clone()).collect::<Vec<_>>().join("\n")
+}
+
+async fn tool(c: &Conn, name: &str, args: Value) -> Value {
+    let mut p = CallToolRequestParams::new(name.to_owned());
+    if let Value::Object(m) = args {
+        p = p.with_arguments(m);
+    }
+    let r = c.call_tool(p).await.expect("call_tool transport");
+    assert_ne!(r.is_error, Some(true), "{name} failed: {}", text(&r));
+    serde_json::from_str(&text(&r)).unwrap_or(Value::String(text(&r)))
+}
+
+async fn run(c: &Conn, id: &str, params: Value) -> Value {
+    tool(c, "command_run", json!({"id": id, "params": params})).await
+}
+
+async fn inspect(c: &Conn) -> Value {
+    tool(c, "doc_inspect", json!({})).await
+}
+
+async fn pixel(c: &Conn, x: i32, y: i32) -> Vec<f64> {
+    let v = run(c, "document.pixel", json!({"x": x, "y": y})).await;
+    let arr = if v.is_array() { v } else { v.get("result").cloned().unwrap_or(v) };
+    arr.as_array().unwrap_or_else(|| panic!("pixel: {arr}")).iter().map(|x| x.as_f64().unwrap()).collect()
+}
+
+fn top_layer(doc: &Value) -> &Value {
+    &doc["layers"][0]
+}
+
+fn tmp(name: &str) -> std::path::PathBuf {
+    let d = std::env::temp_dir().join(format!("pc-agent-{}-{name}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).unwrap();
+    d
+}
+
+/// Six more acceptance tasks (31–36): an undo/redo sweep, a painted barcode, a grayscale
+/// conversion with an export check, a native save round trip that preserves type, a layer-style
+/// stroke and inverse fills.
+#[tokio::test(flavor = "multi_thread")]
+async fn agent_completes_six_rounding_out_tasks() {
+    let dir = tmp("tasks4");
+    let (c, server) = connect(&dir).await;
+
+    // 31. Undo/redo sweep: four fills go away and come back.
+    tool(&c, "doc_new", json!({"width": 40, "height": 40, "background": "white"})).await;
+    let h0 = inspect(&c).await["history"].as_array().unwrap().len();
+    let colors = ["#ff0000", "#00ff00", "#0000ff", "#000000"];
+    for (i, color) in colors.iter().enumerate() {
+        let x = 10 * i as i32;
+        run(&c, "select.rect", json!({"x": x, "y": 0, "width": 10, "height": 10})).await;
+        run(&c, "edit.fill", json!({"color": color})).await;
+    }
+    run(&c, "select.deselect", json!({})).await;
+    let steps = inspect(&c).await["history"].as_array().unwrap().len() - h0;
+    assert!(steps >= 4, "at least the four fills are history steps: {steps}");
+    for _ in 0..steps {
+        run(&c, "edit.undo", json!({})).await;
+    }
+    for i in 0..4 {
+        let x = 10 * i + 5;
+        let p = pixel(&c, x, 5).await;
+        assert!(p[0] > 0.99 && p[1] > 0.99 && p[2] > 0.99, "task 31: fill {i} undone {p:?}");
+    }
+    for _ in 0..steps {
+        run(&c, "edit.redo", json!({})).await;
+    }
+    let red = pixel(&c, 5, 5).await;
+    let black = pixel(&c, 35, 5).await;
+    assert!(red[0] > 0.99 && red[1] < 0.01, "task 31: the first fill redid {red:?}");
+    assert!(black[0] < 0.01 && black[1] < 0.01, "task 31: the last fill redid {black:?}");
+
+    // 32. Paint a barcode: five black bars on white.
+    tool(&c, "doc_new", json!({"width": 48, "height": 24, "background": "white"})).await;
+    for i in 0..5 {
+        let x = 4 + 8 * i;
+        run(&c, "select.rect", json!({"x": x, "y": 4, "width": 3, "height": 16})).await;
+        run(&c, "edit.fill", json!({"color": "#000000"})).await;
+    }
+    run(&c, "select.deselect", json!({})).await;
+    for i in 0..5 {
+        let bar = pixel(&c, 5 + 8 * i, 12).await;
+        let gap = pixel(&c, 9 + 8 * i, 12).await;
+        assert!(bar[0] < 0.01, "task 32: bar {i} is black {bar:?}");
+        assert!(gap[0] > 0.99, "task 32: gap {i} is white {gap:?}");
+    }
+
+    // 33. Convert to grayscale: the channels flatten and the export keeps them equal.
+    run(&c, "image.mode.grayscale", json!({})).await;
+    assert_eq!(inspect(&c).await["mode"], "Grayscale", "task 33");
+    let g = pixel(&c, 5, 12).await;
+    assert!((g[0] - g[1]).abs() < 1e-4 && (g[1] - g[2]).abs() < 1e-4, "task 33: the channels agree {g:?}");
+    tool(&c, "doc_export", json!({"path": "bars.png"})).await;
+    let img = photocraft_codecs::decode(&std::fs::read(dir.join("bars.png")).unwrap()).unwrap();
+    let px = img.to_rgba8();
+    let at = |x: usize, y: usize| px[(y * img.width() as usize + x) * 4];
+    assert!(at(5, 12) < 8 && at(9, 12) > 247, "task 33: the grayscale export matches the canvas");
+    tool(&c, "doc_close", json!({})).await;
+
+    // 34. A native save round trip preserves a styled type layer.
+    tool(&c, "doc_new", json!({"width": 160, "height": 80, "background": "white"})).await;
+    run(&c, "type.create", json!({"x": 16, "y": 48, "text": "Round", "size": 24, "color": "#3366cc"})).await;
+    tool(&c, "doc_save", json!({"path": "type.pcraft"})).await;
+    tool(&c, "doc_close", json!({})).await;
+    tool(&c, "doc_open", json!({"path": "type.pcraft"})).await;
+    let doc = inspect(&c).await;
+    assert_eq!(top_layer(&doc)["kind"], "Type", "task 34: {doc}");
+    assert_eq!(top_layer(&doc)["text"]["text"], "Round", "task 34: {doc}");
+    tool(&c, "doc_close", json!({})).await;
+
+    // 35. A layer-style stroke frames a swatch.
+    tool(&c, "doc_new", json!({"width": 48, "height": 48, "background": "white"})).await;
+    run(&c, "layer.new.layer", json!({"name": "Swatch"})).await;
+    run(&c, "select.rect", json!({"x": 12, "y": 12, "width": 24, "height": 24})).await;
+    run(&c, "edit.fill", json!({"color": "#ff0000"})).await;
+    run(&c, "select.deselect", json!({})).await;
+    run(&c, "layer.layerStyle.stroke", json!({"size": 3, "position": "outside", "color": "#0000ff"})).await;
+    let doc = inspect(&c).await;
+    assert_eq!(top_layer(&doc)["effects"]["items"][0]["kind"], "Stroke", "task 35: {doc}");
+    let border = pixel(&c, 11, 24).await;
+    let centre = pixel(&c, 24, 24).await;
+    assert!(border[2] > 0.5 && border[0] < 0.5, "task 35: the stroke is blue {border:?}");
+    assert!(centre[0] > 0.99 && centre[2] < 0.01, "task 35: the centre stays red {centre:?}");
+
+    // 36. Inverse fill: gray around the swatch, then Select All paints everything white.
+    run(&c, "select.rect", json!({"x": 12, "y": 12, "width": 24, "height": 24})).await;
+    run(&c, "select.inverse", json!({})).await;
+    run(&c, "edit.fill", json!({"color": "#808080"})).await;
+    run(&c, "select.deselect", json!({})).await;
+    let corner = pixel(&c, 2, 2).await;
+    let centre = pixel(&c, 24, 24).await;
+    assert!(corner[0] > 0.4 && corner[0] < 0.6 && (corner[0] - corner[1]).abs() < 0.01, "task 36: the inverse fill is gray {corner:?}");
+    assert!(centre[0] > 0.99 && centre[2] < 0.01, "task 36: the swatch stays red {centre:?}");
+    run(&c, "select.all", json!({})).await;
+    run(&c, "edit.fill", json!({"color": "#ffffff"})).await;
+    run(&c, "select.deselect", json!({})).await;
+    let white = pixel(&c, 2, 2).await;
+    assert!(white[0] > 0.99 && white[1] > 0.99 && white[2] > 0.99, "task 36: everything is white {white:?}");
+    tool(&c, "doc_close", json!({})).await;
+
+    shutdown(c, server).await;
+    std::fs::remove_dir_all(dir).unwrap();
+}
diff --git a/crates/automation/tests/krita.rs b/crates/automation/tests/krita.rs
new file mode 100644
index 0000000000..85bde4f5fc
--- /dev/null
+++ b/crates/automation/tests/krita.rs
@@ -0,0 +1,68 @@
+//! Krita documents through the agent surface (`doc.open`, `engine.execute`, `doc.save`, as MCP
+//! and the CLI use it): open a .kra with its layers, edit it, and save it as OpenRaster.
+
+use photocraft_automation::Headless;
+use serde_json::json;
+
+/// A tiled pixel file with one raw 64x64 tile of `bgra` at (0, 0).
+fn tiles(bgra: [u8; 4]) -> Vec<u8> {
+    let n = 64 * 64;
+    let mut out = b"VERSION 2\nTILEWIDTH 64\nTILEHEIGHT 64\nPIXELSIZE 4\nDATA 1\n".to_vec();
+    out.extend(format!("0,0,LZF,{}\n", 1 + n * 4).into_bytes());
+    out.push(0);
+    for b in bgra {
+        out.extend(std::iter::repeat_n(b, n));
+    }
+    out
+}
+
+fn kra() -> Vec<u8> {
+    let maindoc = r#"<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE DOC PUBLIC '-//KDE//DTD krita 2.0//EN' 'http://www.calligra.org/DTD/krita-2.0.dtd'>
+<DOC xmlns="http://www.calligra.org/DTD/krita" syntaxVersion="2.0"><IMAGE name="art" width="32" height="24" colorspacename="RGBA" x-res="72" y-res="72"><layers>
+<layer nodetype="grouplayer" name="Inks" filename="layer1" compositeop="normal" opacity="255" visible="1"><layers>
+  <layer nodetype="paintlayer" name="Line" colorspacename="RGBA" filename="layer2" compositeop="multiply" opacity="204" visible="1"/>
+</layers></layer>
+<layer nodetype="shapelayer" name="Speech bubble" filename="layer3"/>
+<layer nodetype="paintlayer" name="Paper" colorspacename="RGBA" filename="layer4" compositeop="normal" opacity="255" visible="1"/>
+</layers></IMAGE></DOC>"#;
+    let mut z = photocraft_format::zip::ZipWriter::new();
+    z.add("mimetype", b"application/x-krita").unwrap();
+    z.add("maindoc.xml", maindoc.as_bytes()).unwrap();
+    z.add("art/layers/layer2", &tiles([0, 0, 255, 255])).unwrap();
+    z.add("art/layers/layer4", &tiles([255, 255, 255, 255])).unwrap();
+    z.finish().unwrap()
+}
+
+fn exec(h: &mut Headless, command: &str, params: serde_json::Value) -> serde_json::Value {
+    h.handle("engine.execute", json!({"command": command, "params": params})).unwrap()
+}
+
+#[test]
+fn krita_documents_open_with_layers_and_save_as_openraster() {
+    let dir = std::env::temp_dir().join(format!("pc-krita-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("art.kra");
+    std::fs::write(&path, kra()).unwrap();
+    let mut h = Headless::trusted_local();
+    let opened = h.handle("doc.open", json!({"path": path.to_str().unwrap()})).unwrap();
+    let warnings = opened["warnings"].to_string();
+    assert!(warnings.contains("vector layers") && warnings.contains("Speech bubble"), "{opened}");
+    let doc = &h.session.active().unwrap().doc;
+    let names: Vec<&str> = doc.layers.iter().map(|l| l.name.as_str()).collect();
+    assert_eq!(names, ["Paper", "Inks"]);
+    let line = doc.layers[1].children().unwrap()[0].clone();
+    assert_eq!((line.name.as_str(), line.blend), ("Line", photocraft_doc::BlendMode::Multiply));
+    let flat = photocraft_compose::flatten(doc);
+    assert!((flat.px[0][1] - 0.2).abs() < 0.01, "80% red multiplied over white: {:?}", flat.px[0]);
+
+    // Read-only source: the file itself is never overwritten as Krita.
+    assert!(h.handle("doc.save", json!({"path": path.to_str().unwrap()})).is_err());
+    exec(&mut h, "layer.setProps", json!({"layer": line.id.0, "opacity": 0.5}));
+    let ora = dir.join("art.ora");
+    h.handle("doc.save", json!({"path": ora.to_str().unwrap()})).unwrap();
+    let back = photocraft_io::import("art.ora", &std::fs::read(&ora).unwrap()).unwrap().document;
+    assert_eq!(back.layers.len(), 2);
+    assert_eq!(back.layers[1].children().unwrap()[0].opacity, 0.5);
+    let _ = std::fs::remove_dir_all(&dir);
+}
diff --git a/crates/automation/tests/mcp.rs b/crates/automation/tests/mcp.rs
index 3ec39ebcc0..ca34d9f915 100644
--- a/crates/automation/tests/mcp.rs
+++ b/crates/automation/tests/mcp.rs
@@ -170,6 +170,12 @@ async fn command_list_filters() {
     let enabled = json_of(&call(&client, "command_list", json!({"enabled_only": true})).await);
     assert!(enabled.as_array().unwrap().iter().any(|c| c["id"] == "file.new"));
     assert!(!enabled.as_array().unwrap().iter().any(|c| c["id"] == "layer.new.layer"), "needs a document");
+    // The full list says why a document command is off with no document open (#3664).
+    let layer = all.as_array().unwrap().iter().find(|c| c["id"] == "layer.new.layer").unwrap();
+    assert_eq!((layer["enabled"].clone(), layer["needsDocument"].clone()), (json!(false), json!(true)), "{layer}");
+    assert!(layer["disabledReason"].as_str().is_some_and(|r| r.starts_with("no document")), "{layer}");
+    let new = all.as_array().unwrap().iter().find(|c| c["id"] == "file.new").unwrap();
+    assert_eq!((new["needsDocument"].clone(), new["disabledReason"].clone()), (json!(false), Value::Null), "{new}");
     client.cancel().await.unwrap();
 }
 
@@ -1230,11 +1236,16 @@ async fn convention_resources_are_live_json() {
     assert_eq!(read("photocraft://document").await["width"], 8);
     // Edit › Purge › All is enabled while the process-wide effect, mask and stack caches hold
     // anything, and the other tests in this binary fill and purge those caches concurrently, so
-    // its `enabled` flag can flip between the two reads. Every other field must match exactly.
+    // its `enabled` flag and paired `disabledReason` can flip between the two reads. Validate
+    // each availability pair; every stable field and every other command must match exactly.
     let stable = |mut v: Value| {
         for c in v.as_array_mut().into_iter().flatten() {
             if c["id"] == "edit.purge.all" {
-                c.as_object_mut().map(|o| o.remove("enabled"));
+                let reason = if c["enabled"].as_bool().unwrap() { Value::Null } else { json!("nothing to purge") };
+                assert_eq!(c["disabledReason"], reason, "purge availability stays internally consistent");
+                let command = c.as_object_mut().unwrap();
+                command.remove("enabled");
+                command.remove("disabledReason");
             }
         }
         v
diff --git a/crates/automation/tests/missing_font_warnings.rs b/crates/automation/tests/missing_font_warnings.rs
new file mode 100644
index 0000000000..fe66e5c062
--- /dev/null
+++ b/crates/automation/tests/missing_font_warnings.rs
@@ -0,0 +1,57 @@
+//! #3391: `doc.save`, `doc.open`, and type commands emit warnings when text uses a missing font.
+
+use photocraft_automation::Headless;
+use serde_json::json;
+
+fn tmp_dir() -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!(
+        "pc-font-warn-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+    ));
+    std::fs::create_dir_all(&dir).unwrap();
+    dir
+}
+
+#[test]
+fn missing_font_warnings_emitted_in_headless_and_type_commands() {
+    let dir = tmp_dir();
+    let psd_path = dir.join("card.psd");
+    let png_path = dir.join("card.png");
+
+    let mut h = Headless::trusted_local();
+    h.handle("doc.new", json!({"width": 600, "height": 300, "background": "white"})).unwrap();
+
+    // 1. type.create with missing font
+    let created = h
+        .handle("engine.execute", json!({"command": "type.create", "params": {"x": 30, "y": 100, "text": "Headline", "font": "NoSuchFamily123", "size": 40}}))
+        .unwrap();
+    assert_eq!(created["warnings"], json!(["font 'NoSuchFamily123' is not installed; text may render using a fallback face"]));
+
+    // 2. doc.save card.psd
+    let saved_psd = h.handle("doc.save", json!({"path": psd_path.to_str().unwrap()})).unwrap();
+    let warnings = saved_psd["warnings"].as_array().expect("warnings array in doc.save");
+    assert!(
+        warnings.iter().any(|w| w == "font 'NoSuchFamily123' is not installed; text may render using a fallback face"),
+        "doc.save PSD warning: {saved_psd}"
+    );
+
+    // 3. doc.save card.png
+    let saved_png = h.handle("doc.save", json!({"path": png_path.to_str().unwrap()})).unwrap();
+    let warnings = saved_png["warnings"].as_array().expect("warnings array in doc.save");
+    assert!(
+        warnings.iter().any(|w| w == "font 'NoSuchFamily123' is not installed; text may render using a fallback face"),
+        "doc.save PNG warning: {saved_png}"
+    );
+
+    // 4. doc.close then doc.open
+    h.handle("doc.close", json!({})).unwrap();
+    let opened = h.handle("doc.open", json!({"path": psd_path.to_str().unwrap()})).unwrap();
+    let warnings = opened["warnings"].as_array().expect("warnings array in doc.open");
+    assert!(
+        warnings.iter().any(|w| w.as_str().unwrap_or("").contains("is not installed; text may render using a fallback face")),
+        "doc.open warning: {opened}"
+    );
+
+    let _ = std::fs::remove_dir_all(dir);
+}
diff --git a/crates/automation/tests/openraster.rs b/crates/automation/tests/openraster.rs
index fe941c50b4..428ecfffb9 100644
--- a/crates/automation/tests/openraster.rs
+++ b/crates/automation/tests/openraster.rs
@@ -66,3 +66,40 @@ fn a_corrupt_openraster_file_reports_an_error() {
     assert!(err.to_string().contains("OpenRaster"), "{err}");
     std::fs::remove_dir_all(dir).unwrap();
 }
+
+/// #3806: an OpenRaster file holds only what OpenRaster can. Once the document has an adjustment
+/// layer, a pathless save refuses to overwrite the .ora (saying what it would drop), and a save to
+/// an .ora path writes a copy: the document keeps its file and stays unsaved.
+#[test]
+fn an_openraster_file_never_overwrites_what_it_cannot_hold() {
+    let dir = tmp("lossy");
+    let path = dir.join("art.ora");
+    let path_str = path.to_str().unwrap();
+    let mut h = Headless::trusted_local();
+    h.handle("doc.new", json!({"width": 40, "height": 30, "background": "white"})).unwrap();
+    exec(&mut h, "layer.new.layer", json!({}));
+    exec(&mut h, "paint.stroke", json!({"points": [[4, 4], [30, 20]], "size": 6, "hardness": 1.0, "color": "#ff0000"}));
+    h.handle("doc.save", json!({"path": path_str})).unwrap();
+    let original = std::fs::read(&path).unwrap();
+    // A Curves adjustment layer: OpenRaster has no adjustment layers.
+    exec(&mut h, "layer.newAdjustmentLayer.curves", json!({}));
+    assert!(h.session.active().unwrap().is_dirty());
+    let err = h.handle("doc.save", json!({})).unwrap_err().to_string();
+    assert!(err.contains("adjustment layers"), "{err}");
+    assert_eq!(std::fs::read(&path).unwrap(), original, "the original is untouched");
+    assert!(h.session.active().unwrap().is_dirty(), "and the edits are still unsaved");
+    // Saving to an .ora path explicitly writes a copy (with the warnings), not the document's file.
+    let copy = dir.join("copy.ora");
+    let saved = h.handle("doc.save", json!({"path": copy.to_str().unwrap()})).unwrap();
+    assert!(saved["warnings"].as_array().is_some_and(|w| w.iter().any(|w| w.as_str().is_some_and(|w| w.contains("adjustment layers")))), "{saved}");
+    let st = h.session.active().unwrap();
+    assert!(st.is_dirty(), "a copy leaves the edits unsaved");
+    assert_eq!(st.path.as_deref(), Some(path_str), "the document keeps its file");
+    // As PSD it holds everything, so that becomes the document's file.
+    let psd = dir.join("art.psd");
+    h.handle("doc.save", json!({"path": psd.to_str().unwrap()})).unwrap();
+    let st = h.session.active().unwrap();
+    assert!(!st.is_dirty());
+    assert_eq!(st.path.as_deref(), psd.to_str());
+    std::fs::remove_dir_all(dir).unwrap();
+}
diff --git a/crates/cms/src/builtin.rs b/crates/cms/src/builtin.rs
index b102562f4a..9d42fef3f6 100644
--- a/crates/cms/src/builtin.rs
+++ b/crates/cms/src/builtin.rs
@@ -32,6 +32,10 @@ pub enum Builtin {
     GrayGamma22,
     /// Gray with the sRGB transfer function (sGray): gray `v` looks like RGB `(v, v, v)` in sRGB.
     SGray,
+    /// Gray matching Photoshop's default working gray (Dot Gain 20 %) with our own curve: a pure
+    /// gamma of 1.732, fitted on Photoshop 27.11's RGB → Grayscale (sRGB 64 / 128 / 192 and pure red
+    /// become 46 / 105 / 177 / 107, all within 1 level). Not Adobe's profile.
+    DotGain20Compat,
     /// CIE L*a*b* D50 identity (device Lab = PCS Lab, ICC v4 encoding).
     LabD50,
     /// Synthetic coated-offset CMYK (300 % total ink, medium GCR); see [`crate::synth`].
@@ -39,7 +43,7 @@ pub enum Builtin {
 }
 
 impl Builtin {
-    pub const ALL: [Builtin; 10] = [
+    pub const ALL: [Builtin; 11] = [
         Builtin::Srgb,
         Builtin::DisplayP3,
         Builtin::AdobeRgbCompat,
@@ -48,6 +52,7 @@ impl Builtin {
         Builtin::Rec2020,
         Builtin::GrayGamma22,
         Builtin::SGray,
+        Builtin::DotGain20Compat,
         Builtin::LabD50,
         Builtin::CoatedCmyk,
     ];
@@ -63,6 +68,7 @@ impl Builtin {
             Builtin::Rec2020 => "rec2020",
             Builtin::GrayGamma22 => "gray-gamma-2.2",
             Builtin::SGray => "sgray",
+            Builtin::DotGain20Compat => "dot-gain-20-compat",
             Builtin::LabD50 => "lab-d50",
             Builtin::CoatedCmyk => "coated-cmyk",
         }
@@ -79,6 +85,7 @@ impl Builtin {
             Builtin::Rec2020 => "Rec. ITU-R BT.2020 (Photocraft)",
             Builtin::GrayGamma22 => "Gray Gamma 2.2 (Photocraft)",
             Builtin::SGray => "sGray (sRGB tone curve, Photocraft)",
+            Builtin::DotGain20Compat => "Dot Gain 20%-compatible (gamma 1.732, Photocraft)",
             Builtin::LabD50 => "Lab D50 identity (Photocraft)",
             Builtin::CoatedCmyk => crate::synth::DESCRIPTION,
         }
@@ -96,6 +103,7 @@ impl Builtin {
             "rec2020" | "bt2020" => Some(Builtin::Rec2020),
             "gray" | "graygamma22" | "gamma22" => Some(Builtin::GrayGamma22),
             "sgray" | "graysrgb" => Some(Builtin::SGray),
+            "dotgain20" | "dotgain20compat" | "dotgain" => Some(Builtin::DotGain20Compat),
             "lab" | "labd50" | "cielab" => Some(Builtin::LabD50),
             "cmyk" | "coatedcmyk" | "defaultcmyk" | "photocraftcoatedcmyk" => Some(Builtin::CoatedCmyk),
             _ => None,
@@ -105,18 +113,19 @@ impl Builtin {
 
     /// The profile (built once per process).
     pub fn profile(self) -> &'static Profile {
-        static CELLS: [OnceLock<Profile>; 10] = [const { OnceLock::new() }; 10];
+        static CELLS: [OnceLock<Profile>; 11] = [const { OnceLock::new() }; 11];
         // `ALL` lists the variants in declaration order (checked by `all_in_declaration_order`),
         // so the discriminant is the cell index.
         CELLS[self as usize].get_or_init(|| build(self))
     }
 }
 
-/// The default profile for a colour space: sRGB, sGray, the coated CMYK profile, Lab D50.
+/// The default profile for a colour space: sRGB, Dot Gain 20 %-compatible gray (Photoshop's default
+/// working gray), the coated CMYK profile, Lab D50.
 pub fn default_for(cs: ColorSpace) -> Option<&'static Profile> {
     Some(match cs {
         ColorSpace::Rgb => Builtin::Srgb.profile(),
-        ColorSpace::Gray => Builtin::SGray.profile(),
+        ColorSpace::Gray => Builtin::DotGain20Compat.profile(),
         ColorSpace::Cmyk => Builtin::CoatedCmyk.profile(),
         ColorSpace::Lab => Builtin::LabD50.profile(),
         _ => return None,
@@ -268,6 +277,7 @@ fn build(b: Builtin) -> Profile {
         }
         Builtin::GrayGamma22 => gray(b.description(), Curve::Gamma(2.2)),
         Builtin::SGray => gray(b.description(), srgb_trc()),
+        Builtin::DotGain20Compat => gray(b.description(), Curve::Gamma(1.732)),
         Builtin::LabD50 => lab(),
         // The shipped bytes are `synth::coated_cmyk()` (checked by the `regen` test); rebuild
         // them rather than crash if they ever fail to parse.
diff --git a/crates/cms/src/profile.rs b/crates/cms/src/profile.rs
index 6d646cc1e1..99f5710e5d 100644
--- a/crates/cms/src/profile.rs
+++ b/crates/cms/src/profile.rs
@@ -296,6 +296,13 @@ impl Profile {
         self.a2b.iter().all(Option::is_none) && (self.matrix.is_some() && self.trc.is_some() || self.gray_trc.is_some())
     }
 
+    /// Whether colours can be converted into this profile for every intent. Input profiles with
+    /// only AToB tables (Apple's Wide Color Sharing Profile on iPhone photos) can't: they
+    /// describe a source but have no PCS → device path.
+    pub fn can_be_destination(&self) -> bool {
+        [Intent::Perceptual, Intent::RelativeColorimetric, Intent::Saturation].into_iter().all(|i| self.pcs_to_device(i).is_ok())
+    }
+
     fn lut_for(luts: &[Option<Lut>; 3], intent: Intent) -> Option<&Lut> {
         let i = match intent {
             Intent::Perceptual => 0,
diff --git a/crates/cms/tests/cms.rs b/crates/cms/tests/cms.rs
index ba3f008fb4..f390a390da 100644
--- a/crates/cms/tests/cms.rs
+++ b/crates/cms/tests/cms.rs
@@ -450,6 +450,73 @@ fn malformed_profiles_are_rejected_without_panicking() {
     }
 }
 
+// A press's full-K lightness depends on its ink and paper (newsprint can exceed L* 40).
+// Keep the relative paper-white check and require finite endpoints with darker, bounded ink.
+fn cmyk_endpoints_valid(paper: [f64; 3], black: [f64; 3]) -> bool {
+    // Allow only float rounding at the physical L* limits, not a different printing condition.
+    let lightness = -1e-4..=100.0 + 1e-4;
+    paper.iter().chain(&black).all(|v| v.is_finite())
+        && lightness.contains(&paper[0])
+        && lightness.contains(&black[0])
+        && paper[0] > 90.0
+        && black[0] < paper[0]
+}
+
+#[test]
+fn a_light_black_cmyk_lut_has_the_known_relative_ramp() {
+    use photocraft_cms::Curve;
+    use photocraft_cms::pipeline::Stage;
+    use photocraft_cms::profile::{Lut, LutKind};
+
+    let mut p = cmyk().clone();
+    // Independent linear test model: L* = 100 - 52 K, neutral a*/b*. Exercise A2B1 only;
+    // the inherited coated profile's inverse is not an inverse of this generated model.
+    p.a2b = [None, None, None];
+    p.b2a = [None, None, None];
+    p.a2b[1] = Some(Lut {
+        kind: LutKind::Ab,
+        inputs: 4,
+        outputs: 3,
+        stages: vec![
+            Stage::Curves(vec![Curve::Identity; 4]),
+            Stage::Clut(Clut::sample(vec![2; 4], 3, |ink, out| {
+                out.copy_from_slice(&enc([100.0 - 52.0 * f64::from(ink[3]), 0.0, 0.0]));
+            })),
+            Stage::Curves(vec![Curve::Identity; 3]),
+        ],
+    });
+    let p = Profile::parse(&p.with_encoded_bytes().to_bytes()).unwrap();
+    let paper = to_lab(&p, &[0.0; 4], Intent::RelativeColorimetric);
+    let black = to_lab(&p, &[0.0, 0.0, 0.0, 1.0], Intent::RelativeColorimetric);
+    assert!(cmyk_endpoints_valid(paper, black), "{paper:?} {black:?}");
+    // Explicit expected values, not the validation predicate: also catch wrong channels,
+    // intent selection, constant output and incorrect LUT encoding/interpolation.
+    for (k, expected) in [(0.0, 100.0), (0.25, 87.0), (0.5, 74.0), (0.75, 61.0), (1.0, 48.0)] {
+        let actual = to_lab(&p, &[0.0, 0.0, 0.0, k], Intent::RelativeColorimetric);
+        // The writer quantizes the CLUT to 16 bits: at most 0.000763 L* error.
+        assert!((actual[0] - expected).abs() < 0.001 && actual[1].abs() < 1e-4 && actual[2].abs() < 1e-4, "K={k}: {actual:?}");
+    }
+}
+
+#[test]
+fn cmyk_endpoints_reject_invalid_values() {
+    let paper = [100.0, 0.0, 0.0];
+    let black = [48.0, 0.0, 0.0];
+    for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+        for channel in 0..3 {
+            let mut p = paper;
+            let mut k = black;
+            p[channel] = bad;
+            k[channel] = bad;
+            assert!(!cmyk_endpoints_valid(p, black));
+            assert!(!cmyk_endpoints_valid(paper, k));
+        }
+    }
+    for (p, k) in [(90.0, 48.0), (100.01, 48.0), (100.0, -0.01), (100.0, 100.01), (100.0, 100.0), (99.0, 100.0)] {
+        assert!(!cmyk_endpoints_valid([p, 0.0, 0.0], [k, 0.0, 0.0]), "L*: paper {p}, black {k}");
+    }
+}
+
 /// Parses every profile the OS ships (macOS ColorSync; read-only, nothing is copied) and
 /// converts through each.
 #[test]
@@ -500,7 +567,7 @@ fn system_profiles() {
                 // Real CMYK profile: paper lighter than 100 % K.
                 let w = to_lab(&p, &[0.0; 4], Intent::RelativeColorimetric);
                 let k = to_lab(&p, &[0.0, 0.0, 0.0, 1.0], Intent::RelativeColorimetric);
-                assert!(w[0] > 90.0 && k[0] < 40.0, "{}: {w:?} {k:?}", path.display());
+                assert!(cmyk_endpoints_valid(w, k), "{}: {w:?} {k:?}", path.display());
                 // And it round-trips through its own BToA.
                 if p.b2a[1].is_some() {
                     let to = Transform::new(lab(), &p, Intent::RelativeColorimetric, false).unwrap();
diff --git a/crates/codecs/Cargo.toml b/crates/codecs/Cargo.toml
index a55dcf1213..25f3f09be0 100644
--- a/crates/codecs/Cargo.toml
+++ b/crates/codecs/Cargo.toml
@@ -22,7 +22,7 @@ heif = ["dep:photocraft-heif"]
 thiserror.workspace = true
 image = { workspace = true, features = ["gif", "bmp", "tga", "ico", "qoi", "hdr"] }
 png = "0.18"
-tiff = { version = "0.11", default-features = false, features = ["deflate", "lzw"] }
+tiff = { version = "0.11", default-features = false, features = ["deflate", "fax", "jpeg", "lzw"] }
 exr = { version = "1.73", default-features = false }
 half = "2"
 serde_json.workspace = true
@@ -36,6 +36,8 @@ photocraft-heif = { path = "../heif", optional = true }
 # Orientation is applied a band of rows per task on native; wasm stays single-threaded.
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rayon.workspace = true
+# EXR block (de)compression runs on the rayon pool natively; wasm stays single-threaded.
+exr = { version = "1.73", default-features = false, features = ["rayon"] }
 
 [dev-dependencies]
 proptest.workspace = true
diff --git a/crates/codecs/README.md b/crates/codecs/README.md
index ee639bcb17..7486d46504 100644
--- a/crates/codecs/README.md
+++ b/crates/codecs/README.md
@@ -40,11 +40,13 @@ let out = encode(&img, Format::Tiff, &EncodeOptions::default())?;
 | BMP | yes | yes | U8 | RGB, RGBA | yes | no | no | no | no | no | no | `image` |
 | TGA | yes | yes | U8 | Gray, GrayA, RGB, RGBA | yes | no | no | no | no | no | no | `image` |
 | ICO | yes | yes | U8 | RGBA (at most 256×256) | yes | no | no | no | no | no | no | `image` |
+| DDS | yes | **no** | U8 | Gray, GrayA, RGB, RGBA | yes | no | no | no | no | no | n/a | built in |
 | Netpbm (PBM/PGM/PPM/PAM/PFM) | yes | yes | U8, U16, F32 (float: PFM gray/RGB only) | all six (PAM `CMYK`/`CMYK_ALPHA`) | yes (PAM) | no | no | no | no | no | no | built in |
 | QOI | yes | yes | U8 | RGB, RGBA | yes | no | no | no | no | no | no | `image` |
 | OpenEXR | yes | yes | F16, F32 | Y, YA, RGB, RGBA | yes | no | no | no | no | no | no | `exr` |
 | Radiance HDR | yes | yes | F32 | RGB | no | no | no | no | no | no | yes (RGBE) | `image` |
 | FITS | yes | yes | U8, U16, F32 | Gray, RGB | no | no | no | no | no | yes (header cards) | no | built in |
+| DPX | yes | yes | U8, U16 (10/12-bit code values read and written exactly through U16) | Gray, RGB, RGBA | yes | no | no | no | no | DPX header fields only (creator, project, copyright, creation time, transfer, colorimetric, frame position, frame rate, time code) | no | built in |
 | AVIF | **no** | only with feature `avif` | U8 | RGB, RGBA | yes | no | no | no | no | no | yes | `image` + `ravif` |
 | HEIF/HEIC | with feature `heif` | **no** | U8, U16 (10/12-bit decodes to U16) | RGB, RGBA | yes (auxiliary alpha) | yes (`colr` prof) | yes | yes | no | no | n/a | `heic-rs` |
 
@@ -61,8 +63,17 @@ the encode plan, and `fidelity_warnings` reports the conversion when it loses in
 `Image::convert` applies the same ICC rule: it keeps the profile only when the colour model stays
 the same.
 
+Palette BMP and PNG pixels decode as RGB(A) in `Image`; `bmp_palette` and `png_palette` expose the
+embedded table (and a PNG's transparent entry) so `photocraft-io` can open them in Indexed Color mode.
+
 ## Documented asymmetries and limitations
 
+* **DDS.** The top mip level of a 2D texture: uncompressed pixels described by channel masks
+  (8, 16, 24 or 32 bits, RGB or luminance, with or without alpha) or BC1/BC2/BC3 (DXT1/DXT3/DXT5),
+  with the legacy header or the DX10 one. Everything opens as U8; the other mip levels are
+  ignored. Cubemaps, texture arrays, volume textures, premultiplied DXT2/DXT4 and other formats
+  (BC4–BC7, float) are refused with `CodecError::Unsupported`. Writing is not provided.
+
 * **FITS.** The image in the primary HDU, or the first `IMAGE` extension, is read; `NAXIS3 = 3`
   opens as RGB and any other plane count opens the first plane with `DecodeWarning::MorePages`.
   Rows follow `ROWORDER` (bottom-up by default, as Siril and DS9 do). Physical values that fit
@@ -71,6 +82,19 @@ the same.
   kept as text (`HIERARCH` for long names). Tile-compressed (fpack) files are refused with
   `CodecError::Unsupported`; Bayer mosaics open undebayered.
 
+* **DPX.** SMPTE 268M frames in either byte order (`SDPX`, `XPDS`): the first image element,
+  descriptor 6 (luma), 50 (RGB) or 51 (RGBA), unsigned and unencoded, at 8, 10, 12 or 16 bits.
+  10-bit data may be packed (0) or filled three to a word (1, method A; 2, method B), 12-bit data
+  packed (0) or one to a 16-bit word (1, method A). 10- and 12-bit code values open as U16
+  `round(c × 65535 / (2^b − 1))`, so a frame written back at its depth keeps them exactly. No
+  colour transform is applied: `DecodeWarning::DpxEncoding` names the transfer characteristic and
+  colorimetric specification, so a log frame is reported as log. More elements than the first
+  give `DecodeWarning::MoreElements`; the image orientation is applied on import. Writing is
+  big-endian, one unencoded element, at `EncodeOptions::dpx_bits` (8/10/12/16; by default 8 for
+  U8 and 16 otherwise), packing 1 for 10 and 12 bits; gray with alpha is written as luma.
+  Other descriptors, signed or run-length-encoded data and other bit depths return
+  `CodecError::Unsupported` naming the field. Cineon (`.cin`) is not supported.
+
 * **Camera raw files** (DNG, CR2, NEF, ARW… which are TIFF-structured) are recognised and refused
   with `CodecError::Unsupported`: they are sensor data, not flat images. `photocraft-raw` decodes
   and develops them, and `photocraft-io` routes them there.
diff --git a/crates/codecs/fuzz/Cargo.toml b/crates/codecs/fuzz/Cargo.toml
index 9cbb3d9815..62ec96c523 100644
--- a/crates/codecs/fuzz/Cargo.toml
+++ b/crates/codecs/fuzz/Cargo.toml
@@ -16,7 +16,7 @@ cargo-fuzz = true
 libfuzzer-sys = "0.4"
 photocraft-codecs = { path = "..", features = ["heif"] }
 # Called directly too: the codec turns its panics into errors (see decode_heif.rs).
-heic-rs = "=0.1.1"
+heic-rs = "=0.1.4"
 
 [profile.release]
 debug = 1
diff --git a/crates/codecs/src/codecs/dds.rs b/crates/codecs/src/codecs/dds.rs
new file mode 100644
index 0000000000..efe93c7f2e
--- /dev/null
+++ b/crates/codecs/src/codecs/dds.rs
@@ -0,0 +1,284 @@
+//! DirectDraw Surface (DDS) reader: the top mip level of a 2D texture, either uncompressed
+//! (8 to 32 bits per pixel described by channel masks, RGB or luminance) or block-compressed
+//! BC1/BC2/BC3 (DXT1/DXT3/DXT5), with or without the DX10 header. Read-only. Cubemaps,
+//! texture arrays and volume textures are refused rather than flattened to one face or slice.
+
+use crate::SampleType;
+use crate::error::CodecError;
+use crate::format::Format;
+use crate::image::{ChannelLayout, Image};
+use crate::options::Limits;
+
+/// `DDS ` plus the 124-byte DDS_HEADER.
+const HEADER: usize = 128;
+/// DDS_HEADER_DXT10, present when the FourCC is `DX10`.
+const DX10_HEADER: usize = 20;
+
+const DDSD_DEPTH: u32 = 0x80_0000;
+const DDPF_ALPHAPIXELS: u32 = 0x1;
+const DDPF_FOURCC: u32 = 0x4;
+const DDPF_RGB: u32 = 0x40;
+const DDPF_LUMINANCE: u32 = 0x2_0000;
+const DDSCAPS2_CUBEMAP: u32 = 0x200;
+const DDSCAPS2_VOLUME: u32 = 0x20_0000;
+const DIMENSION_TEXTURE2D: u32 = 3;
+const MISC_TEXTURECUBE: u32 = 0x4;
+
+fn bad(reason: impl std::fmt::Display) -> CodecError {
+    CodecError::malformed(Format::Dds, reason)
+}
+fn unsupported(reason: impl Into<String>) -> CodecError {
+    CodecError::unsupported(Format::Dds, reason)
+}
+fn le32(b: &[u8], at: usize) -> Result<u32, CodecError> {
+    let bytes = b.get(at..at + 4).and_then(|s| <[u8; 4]>::try_from(s).ok()).ok_or_else(|| bad("truncated header"))?;
+    Ok(u32::from_le_bytes(bytes))
+}
+
+/// A FourCC as text when it is printable, else as the number legacy writers store there.
+fn fourcc_name(fourcc: u32) -> String {
+    let bytes = fourcc.to_le_bytes();
+    if bytes.iter().all(|c| c.is_ascii_graphic() || *c == b' ') { bytes.iter().map(|&c| char::from(c)).collect() } else { fourcc.to_string() }
+}
+
+/// One channel of an uncompressed pixel: where it sits and its largest value.
+#[derive(Clone, Copy)]
+struct Field {
+    shift: u32,
+    max: u32,
+}
+
+impl Field {
+    /// `None` for an empty mask; an error for one with gaps or wider than the pixel.
+    fn new(mask: u32, bits: u32) -> Result<Option<Field>, CodecError> {
+        if mask == 0 {
+            return Ok(None);
+        }
+        let shift = mask.trailing_zeros();
+        let max = mask >> shift;
+        if max & max.wrapping_add(1) != 0 || (bits < 32 && mask >> bits != 0) {
+            return Err(bad(format!("channel mask {mask:#x} is not a contiguous field of a {bits}-bit pixel")));
+        }
+        Ok(Some(Field { shift, max }))
+    }
+
+    fn get(self, pixel: u32) -> u8 {
+        let v = u64::from((pixel >> self.shift) & self.max);
+        let max = u64::from(self.max);
+        ((v * 255 + max / 2) / max) as u8
+    }
+}
+
+enum Encoding {
+    /// Uncompressed: bytes per pixel, then red (or luminance), green, blue and alpha.
+    Masks {
+        bytes: usize,
+        gray: bool,
+        fields: [Option<Field>; 4],
+    },
+    Bc1,
+    Bc2,
+    Bc3,
+}
+
+impl Encoding {
+    fn masks(bits: u32, masks: [u32; 4], gray: bool) -> Result<Encoding, CodecError> {
+        if !matches!(bits, 8 | 16 | 24 | 32) {
+            return Err(bad(format!("{bits} bits per pixel is not 8, 16, 24 or 32")));
+        }
+        let mut fields = [None; 4];
+        for (field, mask) in fields.iter_mut().zip(masks) {
+            *field = Field::new(mask, bits)?;
+        }
+        let colour = if gray { fields[0].is_some() } else { fields[..3].iter().any(Option::is_some) };
+        if !colour {
+            return Err(bad("the pixel format has no colour channel masks"));
+        }
+        Ok(Encoding::Masks { bytes: bits as usize / 8, gray, fields })
+    }
+
+    fn layout(&self) -> ChannelLayout {
+        match self {
+            Encoding::Masks { gray: true, fields, .. } if fields[3].is_some() => ChannelLayout::GrayA,
+            Encoding::Masks { gray: true, .. } => ChannelLayout::Gray,
+            Encoding::Masks { fields, .. } if fields[3].is_none() => ChannelLayout::Rgb,
+            _ => ChannelLayout::Rgba,
+        }
+    }
+
+    /// Bytes of the top mip level.
+    fn level_size(&self, width: u32, height: u32) -> Option<usize> {
+        let (w, h) = (usize::try_from(width).ok()?, usize::try_from(height).ok()?);
+        let block = match self {
+            Encoding::Masks { bytes, .. } => return w.checked_mul(*bytes)?.checked_mul(h),
+            Encoding::Bc1 => 8,
+            Encoding::Bc2 | Encoding::Bc3 => 16,
+        };
+        w.div_ceil(4).checked_mul(h.div_ceil(4))?.checked_mul(block)
+    }
+}
+
+/// The legacy pixel format: a FourCC, or channel masks.
+fn legacy_encoding(b: &[u8]) -> Result<Encoding, CodecError> {
+    let (flags, fourcc, bits) = (le32(b, 80)?, le32(b, 84)?, le32(b, 88)?);
+    let alpha = if flags & DDPF_ALPHAPIXELS != 0 { le32(b, 104)? } else { 0 };
+    if flags & DDPF_FOURCC != 0 {
+        return match &fourcc.to_le_bytes() {
+            b"DXT1" => Ok(Encoding::Bc1),
+            b"DXT3" => Ok(Encoding::Bc2),
+            b"DXT5" => Ok(Encoding::Bc3),
+            b"DXT2" | b"DXT4" => Err(unsupported("premultiplied-alpha DXT2/DXT4 textures are not supported")),
+            _ => Err(unsupported(format!("compression `{}` is not supported (DXT1, DXT3 and DXT5 are)", fourcc_name(fourcc)))),
+        };
+    }
+    if flags & DDPF_RGB != 0 {
+        return Encoding::masks(bits, [le32(b, 92)?, le32(b, 96)?, le32(b, 100)?, alpha], false);
+    }
+    if flags & DDPF_LUMINANCE != 0 {
+        return Encoding::masks(bits, [le32(b, 92)?, 0, 0, alpha], true);
+    }
+    Err(unsupported(format!("pixel format flags {flags:#x} are not RGB, luminance or a supported compression")))
+}
+
+/// The DX10 header's DXGI format, refusing anything but a single 2D texture.
+fn dx10_encoding(b: &[u8]) -> Result<Encoding, CodecError> {
+    let (dxgi, dimension, misc, array) = (le32(b, HEADER)?, le32(b, HEADER + 4)?, le32(b, HEADER + 8)?, le32(b, HEADER + 12)?);
+    if misc & MISC_TEXTURECUBE != 0 {
+        return Err(unsupported("cubemaps are not supported"));
+    }
+    if dimension != DIMENSION_TEXTURE2D {
+        return Err(unsupported(format!("only 2D textures are supported (resource dimension {dimension})")));
+    }
+    if array > 1 {
+        return Err(unsupported(format!("texture arrays are not supported ({array} textures)")));
+    }
+    const RGBA: [u32; 4] = [0xff, 0xff00, 0xff_0000, 0xff00_0000];
+    const BGRA: [u32; 4] = [0xff_0000, 0xff00, 0xff, 0xff00_0000];
+    const BGRX: [u32; 4] = [0xff_0000, 0xff00, 0xff, 0];
+    match dxgi {
+        27..=29 => Encoding::masks(32, RGBA, false),
+        87 | 90 | 91 => Encoding::masks(32, BGRA, false),
+        88 | 92 | 93 => Encoding::masks(32, BGRX, false),
+        70..=72 => Ok(Encoding::Bc1),
+        73..=75 => Ok(Encoding::Bc2),
+        76..=78 => Ok(Encoding::Bc3),
+        _ => Err(unsupported(format!("DXGI format {dxgi} is not supported (BC1, BC2, BC3 and 8-bit RGBA or BGRA are)"))),
+    }
+}
+
+pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
+    if !b.starts_with(b"DDS ") {
+        return Err(bad("missing the `DDS ` signature"));
+    }
+    if le32(b, 4)? != 124 {
+        return Err(bad("header size is not 124"));
+    }
+    let (flags, height, width, depth, caps2) = (le32(b, 8)?, le32(b, 12)?, le32(b, 16)?, le32(b, 24)?, le32(b, 112)?);
+    if caps2 & DDSCAPS2_CUBEMAP != 0 {
+        return Err(unsupported("cubemaps are not supported"));
+    }
+    if caps2 & DDSCAPS2_VOLUME != 0 || (flags & DDSD_DEPTH != 0 && depth > 1) {
+        return Err(unsupported("volume textures are not supported"));
+    }
+    let dx10 = le32(b, 80)? & DDPF_FOURCC != 0 && &le32(b, 84)?.to_le_bytes() == b"DX10";
+    let (encoding, start) = if dx10 { (dx10_encoding(b)?, HEADER + DX10_HEADER) } else { (legacy_encoding(b)?, HEADER) };
+    let layout = encoding.layout();
+    limits.check(width, height, layout, SampleType::U8)?;
+    let size = encoding.level_size(width, height).ok_or_else(|| bad("pixel data size overflow"))?;
+    let data = b.get(start..).and_then(|d| d.get(..size)).ok_or_else(|| bad(format!("truncated pixel data: {size} bytes needed")))?;
+    let (w, h) = (width as usize, height as usize);
+    let channels = layout.channels();
+    let total = w.checked_mul(h).and_then(|n| n.checked_mul(channels)).ok_or_else(|| bad("pixel size overflow"))?;
+    let mut pixels = vec![0u8; total];
+    match encoding {
+        Encoding::Masks { bytes, gray, fields } => {
+            for (src, dst) in data.chunks_exact(bytes).zip(pixels.chunks_exact_mut(channels)) {
+                let pixel = src.iter().rev().fold(0u32, |v, &byte| v << 8 | u32::from(byte));
+                let channel = |i: usize| fields[i].map_or(0, |f| f.get(pixel));
+                let values = if gray { [channel(0), channel(3), 0, 0] } else { [channel(0), channel(1), channel(2), channel(3)] };
+                dst.copy_from_slice(&values[..channels]);
+            }
+        }
+        Encoding::Bc1 | Encoding::Bc2 | Encoding::Bc3 => {
+            let block_size = if matches!(encoding, Encoding::Bc1) { 8 } else { 16 };
+            let blocks_x = w.div_ceil(4);
+            for (i, block) in data.chunks_exact(block_size).enumerate() {
+                let texels = match encoding {
+                    Encoding::Bc1 => bc1(block, true),
+                    Encoding::Bc2 => with_alpha(bc1(block.get(8..).unwrap_or_default(), false), bc2_alpha(block)),
+                    _ => with_alpha(bc1(block.get(8..).unwrap_or_default(), false), bc3_alpha(block)),
+                };
+                let (bx, by) = ((i % blocks_x) * 4, (i / blocks_x) * 4);
+                for (t, texel) in texels.iter().enumerate() {
+                    let (x, y) = (bx + t % 4, by + t / 4);
+                    if x < w && y < h {
+                        let at = (y * w + x) * 4;
+                        if let Some(dst) = pixels.get_mut(at..at + 4) {
+                            dst.copy_from_slice(texel);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Image::from_u8(width, height, layout, pixels)
+}
+
+fn rgb565(c: u16) -> [u8; 3] {
+    let scale = |v: u16, max: u16| ((u32::from(v) * 255 + u32::from(max) / 2) / u32::from(max)) as u8;
+    [scale(c >> 11, 31), scale((c >> 5) & 63, 63), scale(c & 31, 31)]
+}
+
+/// A BC1 colour block. BC2 and BC3 colour blocks always have four colours; only BC1's
+/// `c0 <= c1` order selects three colours and transparent black.
+fn bc1(block: &[u8], one_bit_alpha: bool) -> [[u8; 4]; 16] {
+    let byte = |i: usize| block.get(i).copied().unwrap_or(0);
+    let (c0, c1) = (u16::from_le_bytes([byte(0), byte(1)]), u16::from_le_bytes([byte(2), byte(3)]));
+    let (a, b) = (rgb565(c0), rgb565(c1));
+    let mix = |wa: u32, wb: u32| {
+        let d = wa + wb;
+        let at = |i: usize| ((wa * u32::from(a[i]) + wb * u32::from(b[i]) + d / 2) / d) as u8;
+        [at(0), at(1), at(2), 255]
+    };
+    let palette = if c0 > c1 || !one_bit_alpha {
+        [[a[0], a[1], a[2], 255], [b[0], b[1], b[2], 255], mix(2, 1), mix(1, 2)]
+    } else {
+        [[a[0], a[1], a[2], 255], [b[0], b[1], b[2], 255], mix(1, 1), [0; 4]]
+    };
+    let indices = u32::from_le_bytes([byte(4), byte(5), byte(6), byte(7)]);
+    std::array::from_fn(|t| palette[(indices >> (2 * t)) as usize & 3])
+}
+
+/// BC2: four explicit bits of alpha per texel.
+fn bc2_alpha(block: &[u8]) -> [u8; 16] {
+    let bits = u64::from_le_bytes(std::array::from_fn(|i| block.get(i).copied().unwrap_or(0)));
+    std::array::from_fn(|t| ((bits >> (4 * t)) & 0xf) as u8 * 17)
+}
+
+/// BC3: two alpha endpoints and a 3-bit index per texel into eight values, or into six plus
+/// 0 and 255 when `a0 <= a1`.
+fn bc3_alpha(block: &[u8]) -> [u8; 16] {
+    let byte = |i: usize| block.get(i).copied().unwrap_or(0);
+    let (a0, a1) = (u32::from(byte(0)), u32::from(byte(1)));
+    let mut palette = [a0, a1, 0, 0, 0, 0, 0, 255];
+    if a0 > a1 {
+        for (k, v) in palette.iter_mut().enumerate().skip(2) {
+            let k = k as u32;
+            *v = ((8 - k) * a0 + (k - 1) * a1 + 3) / 7;
+        }
+    } else {
+        for (k, v) in palette.iter_mut().enumerate().take(6).skip(2) {
+            let k = k as u32;
+            *v = ((6 - k) * a0 + (k - 1) * a1 + 2) / 5;
+        }
+    }
+    let bits = u64::from_le_bytes([byte(2), byte(3), byte(4), byte(5), byte(6), byte(7), 0, 0]);
+    std::array::from_fn(|t| palette[((bits >> (3 * t)) & 7) as usize] as u8)
+}
+
+fn with_alpha(mut texels: [[u8; 4]; 16], alpha: [u8; 16]) -> [[u8; 4]; 16] {
+    for (texel, a) in texels.iter_mut().zip(alpha) {
+        texel[3] = a;
+    }
+    texels
+}
diff --git a/crates/codecs/src/codecs/deep_exr.rs b/crates/codecs/src/codecs/deep_exr.rs
index 574e13c40a..0726228be5 100644
--- a/crates/codecs/src/codecs/deep_exr.rs
+++ b/crates/codecs/src/codecs/deep_exr.rs
@@ -227,6 +227,27 @@ pub(crate) fn decode_deep(meta: &MetaData, bytes: &[u8], limits: &Limits) -> Res
     let npixels = w.checked_mul(h).ok_or_else(|| err("the data window is too large"))?;
     limits.check_bytes(w as u32, h as u32, (header.channels.list.len().max(1) as u64) * 4)?;
 
+    // The display window is the full stage the renderer composed onto (a render pass's data
+    // window is often its crop). Open on the stage when it plausibly holds the data region:
+    // sane size for the limits, and the data region inside it. Otherwise fall back to the
+    // data window alone, as before.
+    let display = header.shared_attributes.display_window;
+    let display_size = (display.size.0.max(1) as u32, display.size.1.max(1) as u32);
+    let (stage, origin) = match display_size {
+        (sw, sh)
+            if sw <= 1 << 15
+                && sh <= 1 << 15
+                && limits.check_bytes(sw, sh, 4).is_ok()
+                && dw.position.0 >= display.position.0
+                && dw.position.1 >= display.position.1
+                && dw.position.0.saturating_add(w as i32) <= display.position.0.saturating_add(sw as i32)
+                && dw.position.1.saturating_add(h as i32) <= display.position.1.saturating_add(sh as i32) =>
+        {
+            (Some((sw, sh)), (dw.position.0 - display.position.0, dw.position.1 - display.position.1))
+        }
+        _ => (None, (0, 0)),
+    };
+
     let exr_types: Vec<ExrSample> = header.channels.list.iter().map(|c| c.sample_type).collect();
     let bytes_per_sample: usize = exr_types.iter().map(|t| sample_bytes(*t)).sum();
     let multipart = meta.requirements.has_multiple_layers;
@@ -440,7 +461,7 @@ pub(crate) fn decode_deep(meta: &MetaData, bytes: &[u8], limits: &Limits) -> Res
         }
     }
 
-    Ok(DeepImage { width: w as u32, height: h as u32, channels, counts: deep_counts })
+    Ok(DeepImage { width: w as u32, height: h as u32, stage, origin, channels, counts: deep_counts })
 }
 
 /// Where the headers end and the offset tables begin. [`MetaData::read_from_buffered`]
@@ -565,7 +586,28 @@ pub(crate) fn flatten(deep: &DeepImage) -> Result<Image, CodecError> {
             }
         }
     }
-    let mut img = Image::from_f32(deep.width, deep.height, layout, &out)?;
+    // Open on the full display-window stage when the file declares one: the renderer's data
+    // window is its crop, and the composition lives on the whole stage. The composed region
+    // pads to the stage at its offset, transparent elsewhere (limits validated the size).
+    let mut img = match deep.stage {
+        Some((sw, sh)) => {
+            let mut padded = vec![0f32; sw as usize * sh as usize * nc];
+            let row_len = deep.width as usize * nc;
+            let dx = deep.origin.0.max(0) as usize;
+            for row in 0..deep.height as usize {
+                let src = row * row_len;
+                let dst = (row + deep.origin.1.max(0) as usize) * sw as usize + dx;
+                if let (Some(d), Some(r)) = (padded.get_mut(dst * nc..dst * nc + row_len), out.get(src..src + row_len)) {
+                    d.copy_from_slice(r);
+                }
+            }
+            Image::from_f32(sw, sh, layout, &padded)?
+        }
+        None => Image::from_f32(deep.width, deep.height, layout, &out)?,
+    };
+    if let Some((sw, sh)) = deep.stage {
+        img.warnings.push(DecodeWarning::DisplayWindowStage { stage: (sw, sh), origin: deep.origin });
+    }
     img.warnings.push(DecodeWarning::DeepFlattened { format: F, max_samples_per_pixel: max_samples });
     Ok(img)
 }
diff --git a/crates/codecs/src/codecs/dpx.rs b/crates/codecs/src/codecs/dpx.rs
new file mode 100644
index 0000000000..8b772707cc
--- /dev/null
+++ b/crates/codecs/src/codecs/dpx.rs
@@ -0,0 +1,656 @@
+//! DPX (SMPTE 268M Digital Picture Exchange), implemented here from the published layout: the
+//! 1664-byte generic header (file and image information, image source), the 384-byte industry
+//! header (film and television), then the image data of each element.
+//!
+//! Reading:
+//!
+//! * Both byte orders: `SDPX` (big-endian) and `XPDS` (little-endian).
+//! * The first image element, descriptor 6 (luma), 50 (RGB) or 51 (RGBA), unsigned, without
+//!   run-length encoding, at 8, 10, 12 or 16 bits. 10-bit samples are packed into 32-bit words
+//!   (packing 0), or three to a word with the padding bits at the bottom (1, method A) or the
+//!   top (2, method B); 12-bit samples are packed (0) or one to a 16-bit word in its top bits
+//!   (1, method A). Lines start on a 32-bit word boundary.
+//! * 8- and 16-bit code values become U8 and U16 samples unchanged; 10- and 12-bit ones become U16
+//!   as `round(c × 65535 / (2^b − 1))`, so they come back exactly when written at their depth.
+//! * No colour transform: the transfer characteristic and colorimetric specification are reported
+//!   ([`DecodeWarning::DpxEncoding`]), so a log frame is labelled log, not shown as display-referred.
+//! * The image orientation is applied on import (the caller turns the image upright).
+//! * Header fields a pipeline relies on travel as text metadata under the [`KEYS`] names, and a
+//!   DPX export writes them back.
+//!
+//! Writing: one element, big-endian, unencoded, descriptor 6, 50 or 51; 8 and 16 bits with
+//! packing 0, 10 and 12 bits with packing 1 (method A). The bit depth follows the image
+//! (8 → 8, 16 → 16) unless [`EncodeOptions::dpx_bits`] picks one.
+
+use crate::Format;
+use crate::error::CodecError;
+use crate::fidelity::Plan;
+use crate::image::{ChannelLayout, DecodeWarning, Image, SampleType};
+use crate::options::{DpxBits, EncodeOptions, Limits};
+
+const F: Format = Format::Dpx;
+/// Generic plus industry header: where our image data starts.
+const HEADER_LEN: usize = 2048;
+const GENERIC_LEN: u32 = 1664;
+const INDUSTRY_LEN: u32 = 384;
+/// "Undefined" for 32-bit fields (also the bit pattern of an undefined float).
+const UNDEF32: u32 = u32::MAX;
+const UNDEF8: u8 = u8::MAX;
+/// Offset of the first image element and the size of one.
+const ELEMENT0: usize = 780;
+const ELEMENT_LEN: usize = 72;
+const MAX_ELEMENTS: u16 = 8;
+
+// Header field offsets (generic file header, image information, film and TV headers).
+const CREATION_TIME: (usize, usize) = (136, 24);
+const CREATOR: (usize, usize) = (160, 100);
+const PROJECT: (usize, usize) = (260, 200);
+const COPYRIGHT: (usize, usize) = (460, 200);
+const ORIENTATION: usize = 768;
+const FRAME_POSITION: usize = 1712;
+const FRAME_RATE: usize = 1724;
+const TIME_CODE: usize = 1920;
+
+/// Text metadata keys of the header fields kept through a DPX → document → DPX round trip.
+pub(crate) const KEY_CREATOR: &str = "DPX:Creator";
+pub(crate) const KEY_PROJECT: &str = "DPX:Project";
+pub(crate) const KEY_COPYRIGHT: &str = "DPX:Copyright";
+pub(crate) const KEY_CREATION_TIME: &str = "DPX:CreationTime";
+pub(crate) const KEY_TRANSFER: &str = "DPX:Transfer";
+pub(crate) const KEY_COLORIMETRIC: &str = "DPX:Colorimetric";
+pub(crate) const KEY_FRAME_POSITION: &str = "DPX:FramePosition";
+pub(crate) const KEY_FRAME_RATE: &str = "DPX:FrameRate";
+pub(crate) const KEY_TIME_CODE: &str = "DPX:TimeCode";
+pub(crate) const KEYS: [&str; 9] =
+    [KEY_CREATOR, KEY_PROJECT, KEY_COPYRIGHT, KEY_CREATION_TIME, KEY_TRANSFER, KEY_COLORIMETRIC, KEY_FRAME_POSITION, KEY_FRAME_RATE, KEY_TIME_CODE];
+
+fn err(msg: impl std::fmt::Display) -> CodecError {
+    CodecError::malformed(F, msg)
+}
+
+fn unsupported(msg: impl Into<String>) -> CodecError {
+    CodecError::unsupported(F, msg)
+}
+
+/// The file's byte order.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Order {
+    Big,
+    Little,
+}
+
+impl Order {
+    fn bytes<const N: usize>(b: &[u8], at: usize) -> Option<[u8; N]> {
+        b.get(at..at.checked_add(N)?)?.try_into().ok()
+    }
+
+    fn u16(self, b: &[u8], at: usize) -> Option<u16> {
+        let s = Self::bytes::<2>(b, at)?;
+        Some(if self == Order::Big { u16::from_be_bytes(s) } else { u16::from_le_bytes(s) })
+    }
+
+    fn u32(self, b: &[u8], at: usize) -> Option<u32> {
+        let s = Self::bytes::<4>(b, at)?;
+        Some(if self == Order::Big { u32::from_be_bytes(s) } else { u32::from_le_bytes(s) })
+    }
+
+    /// A 32-bit field that may be undefined (all ones).
+    fn defined_u32(self, b: &[u8], at: usize) -> Option<u32> {
+        self.u32(b, at).filter(|&v| v != UNDEF32)
+    }
+
+    fn f32(self, b: &[u8], at: usize) -> Option<f32> {
+        self.defined_u32(b, at).map(f32::from_bits).filter(|v| v.is_finite())
+    }
+}
+
+/// The byte order from the magic number, `None` when it is not DPX.
+fn order(b: &[u8]) -> Option<Order> {
+    match b.get(..4)? {
+        b"SDPX" => Some(Order::Big),
+        b"XPDS" => Some(Order::Little),
+        _ => None,
+    }
+}
+
+/// An ASCII header string: up to the first NUL, printable characters only, trimmed. `None` when
+/// empty or undefined (all ones).
+fn string(b: &[u8], (at, len): (usize, usize)) -> Option<String> {
+    let raw = b.get(at..at.checked_add(len)?)?;
+    let end = raw.iter().position(|&c| c == 0).unwrap_or(raw.len());
+    let s: String = raw.get(..end)?.iter().filter(|c| (32..=126).contains(*c)).map(|&c| c as char).collect();
+    Some(s.trim().to_string()).filter(|s| !s.is_empty())
+}
+
+/// The descriptive fields of image element 0 that decoding needs.
+#[derive(Debug, Clone, Copy)]
+struct Element {
+    signed: bool,
+    descriptor: u8,
+    transfer: u8,
+    colorimetric: u8,
+    bits: u8,
+    packing: u16,
+    encoding: u16,
+    data_offset: usize,
+    eol_padding: usize,
+}
+
+struct Header {
+    order: Order,
+    width: u32,
+    height: u32,
+    elements: u16,
+    element: Element,
+}
+
+fn parse(b: &[u8]) -> Result<Header, CodecError> {
+    let o = order(b).ok_or_else(|| err("missing SDPX/XPDS magic number"))?;
+    let missing = |what: &str| err(format!("the header ends before {what}"));
+    let image_offset = o.u32(b, 4).ok_or_else(|| missing("the image data offset"))?;
+    o.u16(b, ORIENTATION).ok_or_else(|| missing("the orientation"))?;
+    let elements = o.u16(b, ORIENTATION + 2).ok_or_else(|| missing("the element count"))?;
+    if !(1..=MAX_ELEMENTS).contains(&elements) {
+        return Err(err(format!("invalid number of image elements {elements}")));
+    }
+    let width = o.u32(b, 772).ok_or_else(|| missing("the line length"))?;
+    let height = o.u32(b, 776).ok_or_else(|| missing("the line count"))?;
+    let e = ELEMENT0;
+    let field = |at: usize| o.u32(b, e + at).ok_or_else(|| missing("image element 1"));
+    let byte = |at: usize| b.get(e + at).copied().ok_or_else(|| missing("image element 1"));
+    let half = |at: usize| o.u16(b, e + at).ok_or_else(|| missing("image element 1"));
+    let data_offset = match field(28)? {
+        0 | UNDEF32 => image_offset,
+        v => v,
+    };
+    let eol_padding = match field(32)? {
+        UNDEF32 => 0,
+        v => v,
+    };
+    let element = Element {
+        signed: field(0)? == 1,
+        descriptor: byte(20)?,
+        transfer: byte(21)?,
+        colorimetric: byte(22)?,
+        bits: byte(23)?,
+        packing: half(24)?,
+        encoding: half(26)?,
+        data_offset: usize::try_from(data_offset).map_err(|_| err("image data offset out of range"))?,
+        eol_padding: usize::try_from(eol_padding).map_err(|_| err("line padding out of range"))?,
+    };
+    Ok(Header { order: o, width, height, elements, element })
+}
+
+/// The EXIF orientation (1–8) that turns the stored lines upright: the DPX orientation codes 0–7
+/// in SMPTE 268M order (left-to-right top-to-bottom, mirrored, flipped, rotated, transposed…).
+/// Anything else, undefined included, is taken as the default (1).
+pub(crate) fn orientation(b: &[u8]) -> u16 {
+    let Some(o) = order(b).and_then(|o| o.u16(b, ORIENTATION)) else { return 1 };
+    match o {
+        1 => 2,
+        2 => 4,
+        3 => 3,
+        4 => 5,
+        5 => 6,
+        6 => 8,
+        7 => 7,
+        _ => 1,
+    }
+}
+
+/// Bytes in one stored line of `samples` samples, padded to a 32-bit word.
+fn line_bytes(samples: usize, bits: u8, packing: u16) -> Option<usize> {
+    let words = match (bits, packing) {
+        // Three samples to a word, or one to a 16-bit half word.
+        (10, 1 | 2) => samples.div_ceil(3),
+        (12, 1 | 2) => samples.div_ceil(2),
+        _ => samples.checked_mul(usize::from(bits))?.div_ceil(32),
+    };
+    words.checked_mul(4)
+}
+
+/// Code values of one stored line.
+fn unpack_line(line: &[u8], o: Order, bits: u8, packing: u16, out: &mut [u16]) -> Result<(), CodecError> {
+    let short = || err("truncated image data");
+    match (bits, packing) {
+        (8, _) => {
+            let src = line.get(..out.len()).ok_or_else(short)?;
+            for (v, &c) in out.iter_mut().zip(src) {
+                *v = u16::from(c);
+            }
+        }
+        (16, _) => {
+            for (i, v) in out.iter_mut().enumerate() {
+                *v = o.u16(line, i * 2).ok_or_else(short)?;
+            }
+        }
+        (10, 1 | 2) => {
+            let base = if packing == 1 { 22 } else { 20 };
+            for (i, v) in out.iter_mut().enumerate() {
+                let word = o.u32(line, i / 3 * 4).ok_or_else(short)?;
+                *v = ((word >> (base - 10 * (i % 3) as u32)) & 0x3FF) as u16;
+            }
+        }
+        (12, 1 | 2) => {
+            let shift = if packing == 1 { 4 } else { 0 };
+            for (i, v) in out.iter_mut().enumerate() {
+                *v = (o.u16(line, i * 2).ok_or_else(short)? >> shift) & 0xFFF;
+            }
+        }
+        // Packing 0: one bit stream through the line's 32-bit words, high bits first.
+        _ => {
+            let mask = (1u64 << bits) - 1;
+            let (mut acc, mut have, mut word) = (0u64, 0u32, 0usize);
+            for v in out.iter_mut() {
+                while have < u32::from(bits) {
+                    acc = (acc << 32) | u64::from(o.u32(line, word * 4).ok_or_else(short)?);
+                    word += 1;
+                    have += 32;
+                }
+                have -= u32::from(bits);
+                *v = ((acc >> have) & mask) as u16;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// A 10- or 12-bit code value as a 16-bit sample: `round(c × 65535 / max)`.
+fn widen(c: u16, max: u64) -> u16 {
+    ((u64::from(c) * 2 * 65535 + max) / (2 * max)).min(65535) as u16
+}
+
+/// The inverse of [`widen`]: `round(v × max / 65535)`.
+fn narrow(v: u16, max: u64) -> u16 {
+    ((u64::from(v) * 2 * max + 65535) / (2 * 65535)) as u16
+}
+
+pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
+    let h = parse(bytes)?;
+    let e = h.element;
+    let layout = match e.descriptor {
+        6 => ChannelLayout::Gray,
+        50 => ChannelLayout::Rgb,
+        51 => ChannelLayout::Rgba,
+        d => return Err(unsupported(format!("descriptor {d} is not supported (only 6 luma, 50 RGB and 51 RGBA)"))),
+    };
+    if e.signed {
+        return Err(unsupported("data sign 1 (signed samples) is not supported"));
+    }
+    if e.encoding != 0 {
+        return Err(unsupported(format!("encoding {} (run-length encoded data) is not supported", e.encoding)));
+    }
+    let packing_ok = match e.bits {
+        8 | 16 => e.packing == 0,
+        10 => e.packing <= 2,
+        12 => e.packing <= 1,
+        b => return Err(unsupported(format!("bit size {b} is not supported (only 8, 10, 12 and 16)"))),
+    };
+    if !packing_ok {
+        return Err(unsupported(format!("packing {} is not supported at {} bits", e.packing, e.bits)));
+    }
+    let sample = if e.bits == 8 { SampleType::U8 } else { SampleType::U16 };
+    limits.check(h.width, h.height, layout, sample)?;
+
+    let nc = layout.channels();
+    let per_line = (h.width as usize).checked_mul(nc).ok_or_else(|| CodecError::LimitExceeded("line too long".into()))?;
+    let height = h.height as usize;
+    let data = bytes.get(e.data_offset..).ok_or_else(|| err("the image data offset is past the end of the file"))?;
+    let too_large = || CodecError::LimitExceeded("image too large".into());
+    let mut line_len = line_bytes(per_line, e.bits, e.packing).ok_or_else(too_large)?;
+    let mut stride = line_len.checked_add(e.eol_padding).ok_or_else(too_large)?;
+    // Lines run `stride` apart; the last one needs no padding after it.
+    let span = |stride: usize, line_len: usize| stride.checked_mul(height - 1)?.checked_add(line_len);
+    // Some writers pack 8- and 16-bit lines without padding them to a word; take that layout
+    // when the file is too short for padded lines but holds the unpadded ones.
+    let tight = per_line * usize::from(e.bits / 8);
+    if matches!(e.bits, 8 | 16) && e.eol_padding == 0 && line_len != tight && span(stride, line_len).is_none_or(|need| data.len() < need) {
+        (line_len, stride) = (tight, tight);
+    }
+    if span(stride, line_len).ok_or_else(too_large)? > data.len() {
+        return Err(err("truncated image data"));
+    }
+
+    let mut codes = vec![0u16; per_line.checked_mul(height).ok_or_else(too_large)?];
+    for (y, row) in codes.chunks_exact_mut(per_line.max(1)).enumerate() {
+        let start = y * stride;
+        let line = data.get(start..).ok_or_else(|| err("truncated image data"))?;
+        unpack_line(line, h.order, e.bits, e.packing, row)?;
+    }
+
+    let mut img = match e.bits {
+        8 => Image::from_u8(h.width, h.height, layout, codes.iter().map(|&c| c as u8).collect())?,
+        16 => Image::from_u16(h.width, h.height, layout, &codes)?,
+        b => {
+            let max = (1u64 << b) - 1;
+            let wide: Vec<u16> = codes.iter().map(|&c| widen(c, max)).collect();
+            Image::from_u16(h.width, h.height, layout, &wide)?
+        }
+    };
+    if h.elements > 1 {
+        img.warnings.push(DecodeWarning::MoreElements { total: u32::from(h.elements) });
+    }
+    if e.transfer != UNDEF8 || e.colorimetric != UNDEF8 {
+        img.warnings.push(DecodeWarning::DpxEncoding { transfer: e.transfer, colorimetric: e.colorimetric });
+    }
+    img.meta.text = header_text(bytes, h.order, e);
+    Ok(img)
+}
+
+/// The kept header fields as text metadata, in [`KEYS`] order; undefined ones are left out.
+fn header_text(b: &[u8], o: Order, e: Element) -> Vec<(String, String)> {
+    let mut text = Vec::new();
+    let mut put = |k: &str, v: Option<String>| {
+        if let Some(v) = v {
+            text.push((k.to_string(), v));
+        }
+    };
+    put(KEY_CREATOR, string(b, CREATOR));
+    put(KEY_PROJECT, string(b, PROJECT));
+    put(KEY_COPYRIGHT, string(b, COPYRIGHT));
+    put(KEY_CREATION_TIME, string(b, CREATION_TIME));
+    put(KEY_TRANSFER, (e.transfer != UNDEF8).then(|| e.transfer.to_string()));
+    put(KEY_COLORIMETRIC, (e.colorimetric != UNDEF8).then(|| e.colorimetric.to_string()));
+    // The industry header is there when the generic header says so and the file holds it.
+    let industry = o.u32(b, 28).is_some_and(|l| l != 0 && l != UNDEF32) && b.len() >= HEADER_LEN;
+    if industry {
+        put(KEY_FRAME_POSITION, o.defined_u32(b, FRAME_POSITION).map(|v| v.to_string()));
+        put(KEY_FRAME_RATE, o.f32(b, FRAME_RATE).map(|v| v.to_string()));
+        put(KEY_TIME_CODE, o.defined_u32(b, TIME_CODE).map(format_time_code));
+    }
+    text
+}
+
+/// A SMPTE time code (BCD `HHMMSSFF`) as `HH:MM:SS:FF`, or `0x…` when it is not valid BCD.
+fn format_time_code(v: u32) -> String {
+    let d: [u32; 8] = std::array::from_fn(|i| (v >> ((7 - i) * 4)) & 0xF);
+    if d.iter().all(|&d| d <= 9) { format!("{}{}:{}{}:{}{}:{}{}", d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7]) } else { format!("{v:#010x}") }
+}
+
+/// The inverse of [`format_time_code`]; `None` for anything else.
+fn parse_time_code(s: &str) -> Option<u32> {
+    if let Some(hex) = s.strip_prefix("0x") {
+        return u32::from_str_radix(hex, 16).ok();
+    }
+    let parts: Vec<&str> = s.split(':').collect();
+    if parts.len() != 4 || parts.iter().any(|p| p.len() != 2 || !p.bytes().all(|c| c.is_ascii_digit())) {
+        return None;
+    }
+    parts.iter().flat_map(|p| p.bytes()).try_fold(0u32, |acc, c| Some((acc << 4) | u32::from(c - b'0')))
+}
+
+/// Bits written for `sample` when the options pick none: 8 for U8, 16 otherwise.
+pub(crate) fn bits_for(opt: Option<DpxBits>, sample: SampleType) -> u8 {
+    match opt {
+        Some(b) => b.bits(),
+        None if sample == SampleType::U8 => 8,
+        None => 16,
+    }
+}
+
+/// The plan's sample type for the chosen bits: U8 for 8 bits, U16 for 10, 12 and 16.
+pub(crate) fn plan_sample(opt: Option<DpxBits>, src: SampleType) -> SampleType {
+    match opt {
+        Some(DpxBits::Bits8) => SampleType::U8,
+        Some(_) => SampleType::U16,
+        None if src == SampleType::U8 => SampleType::U8,
+        None => SampleType::U16,
+    }
+}
+
+struct Writer {
+    h: Vec<u8>,
+}
+
+impl Writer {
+    fn u8(&mut self, at: usize, v: u8) {
+        if let Some(b) = self.h.get_mut(at) {
+            *b = v;
+        }
+    }
+
+    fn u16(&mut self, at: usize, v: u16) {
+        if let Some(s) = self.h.get_mut(at..at + 2) {
+            s.copy_from_slice(&v.to_be_bytes());
+        }
+    }
+
+    fn u32(&mut self, at: usize, v: u32) {
+        if let Some(s) = self.h.get_mut(at..at + 4) {
+            s.copy_from_slice(&v.to_be_bytes());
+        }
+    }
+
+    /// Marks a run of numeric fields undefined (all ones).
+    fn undefined(&mut self, from: usize, to: usize) {
+        if let Some(s) = self.h.get_mut(from..to) {
+            s.fill(0xFF);
+        }
+    }
+
+    /// An ASCII string field, cut to leave room for a terminating NUL.
+    fn string(&mut self, (at, len): (usize, usize), v: &str) {
+        let ascii: Vec<u8> = v.chars().map(|c| if (' '..='~').contains(&c) { c as u8 } else { b'?' }).take(len.saturating_sub(1)).collect();
+        if let Some(s) = self.h.get_mut(at..at + ascii.len()) {
+            s.copy_from_slice(&ascii);
+        }
+    }
+}
+
+fn text<'a>(img: &'a Image, key: &str) -> Option<&'a str> {
+    img.meta.text.iter().find(|(k, _)| k == key).map(|(_, v)| v.trim()).filter(|v| !v.is_empty())
+}
+
+/// Appends one line's code values, padded to a 32-bit word.
+fn pack_line(out: &mut Vec<u8>, codes: &[u16], bits: u8) {
+    let start = out.len();
+    match bits {
+        8 => out.extend(codes.iter().map(|&c| c as u8)),
+        10 => {
+            for chunk in codes.chunks(3) {
+                let word = chunk.iter().enumerate().fold(0u32, |w, (i, &c)| w | (u32::from(c & 0x3FF) << (22 - 10 * i as u32)));
+                out.extend_from_slice(&word.to_be_bytes());
+            }
+        }
+        12 => out.extend(codes.iter().flat_map(|&c| ((c & 0xFFF) << 4).to_be_bytes())),
+        _ => out.extend(codes.iter().flat_map(|&c| c.to_be_bytes())),
+    }
+    let written = out.len() - start;
+    out.resize(start + written.div_ceil(4) * 4, 0);
+}
+
+pub(crate) fn encode(src: &Image, plan: Plan, opts: &EncodeOptions) -> Result<Vec<u8>, CodecError> {
+    let img = src.converted(plan.layout, plan.sample);
+    let (w, h) = img.dimensions();
+    let (descriptor, layout) = match img.layout() {
+        ChannelLayout::Gray => (6u8, ChannelLayout::Gray),
+        ChannelLayout::Rgb => (50, ChannelLayout::Rgb),
+        ChannelLayout::Rgba => (51, ChannelLayout::Rgba),
+        l => return Err(CodecError::encode(F, format!("DPX cannot store {l:?}"))),
+    };
+    let bits = bits_for(opts.dpx_bits, img.sample_type());
+    let codes: Vec<u16> = match (img.sample_type(), bits) {
+        (SampleType::U8, 8) => img.data().iter().map(|&v| u16::from(v)).collect(),
+        (SampleType::U16, 16) => img.to_u16_samples().unwrap_or_default(),
+        (SampleType::U16, 10 | 12) => {
+            let max = (1u64 << bits) - 1;
+            img.to_u16_samples().unwrap_or_default().into_iter().map(|v| narrow(v, max)).collect()
+        }
+        (s, b) => return Err(CodecError::encode(F, format!("cannot write {s:?} samples at {b} bits"))),
+    };
+    let per_line = w as usize * layout.channels();
+    if codes.len() != per_line * h as usize {
+        return Err(CodecError::encode(F, "the image has the wrong number of samples"));
+    }
+    let data_len = line_bytes(per_line, bits, if matches!(bits, 10 | 12) { 1 } else { 0 })
+        .and_then(|l| l.checked_mul(h as usize))
+        .ok_or_else(|| CodecError::encode(F, "image too large"))?;
+    let total = u32::try_from(HEADER_LEN + data_len).map_err(|_| CodecError::encode(F, "image too large for a DPX file (4 GiB)"))?;
+
+    let mut wr = Writer { h: vec![0; HEADER_LEN] };
+    // Generic file header.
+    wr.h[..4].copy_from_slice(b"SDPX");
+    wr.u32(4, HEADER_LEN as u32);
+    wr.string((8, 8), "V2.0");
+    wr.u32(16, total);
+    wr.u32(20, 1);
+    wr.u32(24, GENERIC_LEN);
+    wr.u32(28, INDUSTRY_LEN);
+    wr.u32(32, 0);
+    let keep = |key| if opts.embed_metadata { text(&img, key) } else { None };
+    wr.string(CREATION_TIME, keep(KEY_CREATION_TIME).unwrap_or(""));
+    wr.string(CREATOR, keep(KEY_CREATOR).unwrap_or("PhotoCraft"));
+    wr.string(PROJECT, keep(KEY_PROJECT).unwrap_or(""));
+    wr.string(COPYRIGHT, keep(KEY_COPYRIGHT).unwrap_or(""));
+    wr.u32(660, UNDEF32);
+    // Image information: default orientation, one element.
+    wr.u16(ORIENTATION, 0);
+    wr.u16(ORIENTATION + 2, 1);
+    wr.u32(772, w);
+    wr.u32(776, h);
+    let e = ELEMENT0;
+    wr.u32(e, 0);
+    wr.u32(e + 4, 0);
+    wr.u32(e + 8, UNDEF32);
+    wr.u32(e + 12, ((1u32 << bits) - 1).min(65535));
+    wr.u32(e + 16, UNDEF32);
+    wr.u8(e + 20, descriptor);
+    // No claim about the encoding unless the document came with one.
+    let code = |key| keep(key).and_then(|v| v.parse::<u8>().ok()).unwrap_or(UNDEF8);
+    wr.u8(e + 21, code(KEY_TRANSFER));
+    wr.u8(e + 22, code(KEY_COLORIMETRIC));
+    wr.u8(e + 23, bits);
+    wr.u16(e + 24, if matches!(bits, 10 | 12) { 1 } else { 0 });
+    wr.u16(e + 26, 0);
+    wr.u32(e + 28, HEADER_LEN as u32);
+    wr.u32(e + 32, 0);
+    wr.u32(e + 36, 0);
+    // The seven unused elements, the image source header's numbers and the industry header's
+    // numbers are undefined; their strings stay empty.
+    wr.undefined(e + ELEMENT_LEN, e + ELEMENT_LEN * usize::from(MAX_ELEMENTS));
+    wr.undefined(1408, 1432);
+    wr.undefined(1620, 1644);
+    wr.undefined(FRAME_POSITION, 1732);
+    wr.undefined(TIME_CODE, 1972);
+    if let Some(v) = keep(KEY_FRAME_POSITION).and_then(|v| v.parse::<u32>().ok()) {
+        wr.u32(FRAME_POSITION, v);
+    }
+    if let Some(v) = keep(KEY_FRAME_RATE).and_then(|v| v.parse::<f32>().ok()).filter(|v| v.is_finite()) {
+        wr.u32(FRAME_RATE, v.to_bits());
+    }
+    if let Some(v) = keep(KEY_TIME_CODE).and_then(parse_time_code) {
+        wr.u32(TIME_CODE, v);
+    }
+
+    let mut out = wr.h;
+    out.try_reserve_exact(data_len).map_err(|_| CodecError::encode(F, "out of memory"))?;
+    for row in codes.chunks_exact(per_line.max(1)) {
+        pack_line(&mut out, row, bits);
+    }
+    Ok(out)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A minimal header for `w`×`h` with element 0 set; image data at 2048.
+    fn header(o: Order, w: u32, h: u32, descriptor: u8, bits: u8, packing: u16) -> Vec<u8> {
+        let mut b = vec![0u8; HEADER_LEN];
+        let put32 = |b: &mut Vec<u8>, at: usize, v: u32| b[at..at + 4].copy_from_slice(&if o == Order::Big { v.to_be_bytes() } else { v.to_le_bytes() });
+        let put16 = |b: &mut Vec<u8>, at: usize, v: u16| b[at..at + 2].copy_from_slice(&if o == Order::Big { v.to_be_bytes() } else { v.to_le_bytes() });
+        b[..4].copy_from_slice(if o == Order::Big { b"SDPX" } else { b"XPDS" });
+        put32(&mut b, 4, HEADER_LEN as u32);
+        put32(&mut b, 28, INDUSTRY_LEN);
+        put16(&mut b, ORIENTATION, 0);
+        put16(&mut b, ORIENTATION + 2, 1);
+        put32(&mut b, 772, w);
+        put32(&mut b, 776, h);
+        b[ELEMENT0 + 20] = descriptor;
+        b[ELEMENT0 + 21] = UNDEF8;
+        b[ELEMENT0 + 22] = UNDEF8;
+        b[ELEMENT0 + 23] = bits;
+        put16(&mut b, ELEMENT0 + 24, packing);
+        put32(&mut b, ELEMENT0 + 28, HEADER_LEN as u32);
+        b[FRAME_POSITION..1732].fill(0xFF);
+        b[TIME_CODE..1972].fill(0xFF);
+        b
+    }
+
+    fn words(o: Order, ws: &[u32]) -> Vec<u8> {
+        ws.iter().flat_map(|w| if o == Order::Big { w.to_be_bytes() } else { w.to_le_bytes() }).collect()
+    }
+
+    #[test]
+    fn ten_bit_method_a_and_b_unpack_three_to_a_word() {
+        for o in [Order::Big, Order::Little] {
+            for (packing, base) in [(1u16, 22u32), (2, 20)] {
+                let mut b = header(o, 1, 1, 50, 10, packing);
+                b.extend(words(o, &[(1023 << base) | (512 << (base - 10)) | (1 << (base - 20))]));
+                let img = decode(&b, &Limits::default()).unwrap();
+                assert_eq!(img.to_u16_samples().unwrap(), vec![65535, widen(512, 1023), widen(1, 1023)], "{o:?} packing {packing}");
+            }
+        }
+    }
+
+    #[test]
+    fn ten_bit_packing_0_is_one_bit_stream_per_line() {
+        // Four luma samples: 40 bits over two words, the line padded to the second word.
+        let samples = [1u64, 2, 1022, 1023];
+        let stream = samples.iter().fold(0u64, |acc, &s| (acc << 10) | s) << 24;
+        for o in [Order::Big, Order::Little] {
+            let mut b = header(o, 4, 2, 6, 10, 0);
+            let line = words(o, &[(stream >> 32) as u32, stream as u32]);
+            b.extend(&line);
+            b.extend(&line);
+            let img = decode(&b, &Limits::default()).unwrap();
+            let want: Vec<u16> = samples.iter().map(|&s| widen(s as u16, 1023)).collect();
+            assert_eq!(img.to_u16_samples().unwrap(), [want.clone(), want].concat(), "{o:?}");
+        }
+    }
+
+    #[test]
+    fn twelve_bit_method_a_keeps_the_top_bits() {
+        let mut b = header(Order::Big, 2, 1, 6, 12, 1);
+        b.extend_from_slice(&[0xFF, 0xF0, 0x00, 0x10]);
+        let img = decode(&b, &Limits::default()).unwrap();
+        assert_eq!(img.to_u16_samples().unwrap(), vec![65535, widen(1, 4095)]);
+    }
+
+    #[test]
+    fn widen_and_narrow_round_trip_every_code() {
+        for bits in [10u8, 12] {
+            let max = (1u64 << bits) - 1;
+            for c in 0..=max as u16 {
+                assert_eq!(narrow(widen(c, max), max), c, "{bits}-bit {c}");
+            }
+        }
+        assert_eq!(widen(512, 1023), ((512.0f64 * 65535.0 / 1023.0).round()) as u16);
+    }
+
+    #[test]
+    fn orientation_codes_map_to_exif() {
+        let mut b = header(Order::Big, 1, 1, 6, 8, 0);
+        for (dpx, exif) in [(0u16, 1u16), (1, 2), (2, 4), (3, 3), (4, 5), (5, 6), (6, 8), (7, 7), (0xFFFF, 1)] {
+            b[ORIENTATION..ORIENTATION + 2].copy_from_slice(&dpx.to_be_bytes());
+            assert_eq!(orientation(&b), exif, "DPX {dpx}");
+        }
+    }
+
+    #[test]
+    fn time_codes_round_trip() {
+        assert_eq!(format_time_code(0x0102_0304), "01:02:03:04");
+        assert_eq!(parse_time_code("01:02:03:04"), Some(0x0102_0304));
+        assert_eq!(parse_time_code(&format_time_code(0xABCD_0000)), Some(0xABCD_0000));
+        assert_eq!(parse_time_code("1:2:3:4"), None);
+    }
+
+    #[test]
+    fn eight_bit_lines_without_word_padding_still_open() {
+        // 1 × 2 RGB: 3 bytes a line, 6 in all; padded lines would need 8.
+        let mut b = header(Order::Big, 1, 2, 50, 8, 0);
+        b.extend_from_slice(&[1, 2, 3, 4, 5, 6]);
+        let img = decode(&b, &Limits::default()).unwrap();
+        assert_eq!(img.data(), &[1, 2, 3, 4, 5, 6]);
+    }
+}
diff --git a/crates/codecs/src/codecs/exr.rs b/crates/codecs/src/codecs/exr.rs
index a4014db0b3..2506dd062b 100644
--- a/crates/codecs/src/codecs/exr.rs
+++ b/crates/codecs/src/codecs/exr.rs
@@ -35,7 +35,7 @@ fn map_exr(e: exr::error::Error) -> CodecError {
 
 /// Read the headers without the `exr` crate's validation (it rejects deep parts outright),
 /// after checking every part's declared size against the limits, before any pixel allocation.
-fn read_meta(bytes: &[u8], limits: &Limits) -> Result<MetaData, CodecError> {
+pub(super) fn read_meta(bytes: &[u8], limits: &Limits) -> Result<MetaData, CodecError> {
     let meta = MetaData::read_from_buffered(Cursor::new(bytes), false).map_err(err)?;
     // Flat decoding reads every part at once, so the parts' sizes are also capped together.
     let mut total: u64 = 0;
@@ -93,12 +93,31 @@ fn pick_part(meta: &MetaData) -> usize {
     best
 }
 
-/// Decode the flat layers via the `exr` crate (it handles every flat compression) and
-/// return the requested part's layer.
-fn read_layer(bytes: &[u8], index: usize) -> Result<Layer<AnyChannels<FlatSamples>>, CodecError> {
-    let image =
-        read().no_deep_data().largest_resolution_level().all_channels().all_layers().all_attributes().from_buffered(Cursor::new(bytes)).map_err(map_exr)?;
-    image.layer_data.into_iter().nth(index).ok_or_else(|| err(format!("part {index} is missing from the file")))
+/// Selects one part for the `exr` crate's first-valid-layer reader: `create_channels_reader`
+/// is asked about the headers in file order and the first `Ok` wins, so every header before
+/// `index` (and, harmlessly, those after it) is declined. Only the chosen part's chunks are
+/// then decompressed and only its planes allocated; the other parts are skipped unread.
+struct OnlyPart<C> {
+    inner: C,
+    index: usize,
+    seen: std::cell::Cell<usize>,
+}
+
+impl<'s, C: ReadChannels<'s>> ReadChannels<'s> for OnlyPart<C> {
+    type Reader = C::Reader;
+
+    fn create_channels_reader(&'s self, header: &exr::meta::header::Header) -> exr::error::Result<Self::Reader> {
+        let position = self.seen.get();
+        self.seen.set(position.saturating_add(1));
+        if position == self.index { self.inner.create_channels_reader(header) } else { Err(exr::error::Error::Invalid("part not requested".into())) }
+    }
+}
+
+/// Decode one part's flat layer via the `exr` crate (it handles every flat compression).
+/// Other parts are not decompressed, so an AOV file costs one part per request, not the file.
+pub(super) fn read_layer(bytes: &[u8], index: usize) -> Result<Layer<AnyChannels<FlatSamples>>, CodecError> {
+    let only = OnlyPart { inner: read().no_deep_data().largest_resolution_level().all_channels(), index, seen: std::cell::Cell::new(0) };
+    only.first_valid_layer().all_attributes().from_buffered(Cursor::new(bytes)).map(|image| image.layer_data).map_err(map_exr)
 }
 
 fn layer_to_image(layer: &Layer<AnyChannels<FlatSamples>>) -> Result<Image, CodecError> {
diff --git a/crates/codecs/src/codecs/exr_cryptomatte.rs b/crates/codecs/src/codecs/exr_cryptomatte.rs
index f28c57ab47..5f13f98621 100644
--- a/crates/codecs/src/codecs/exr_cryptomatte.rs
+++ b/crates/codecs/src/codecs/exr_cryptomatte.rs
@@ -1,7 +1,8 @@
 //! Cryptomatte (specification 1.2): per-pixel object/material IDs with coverage in EXR
 //! channels, as written by Arnold, V-Ray, Redshift, Mantra/Karma and Cycles. Layers are
 //! announced by `cryptomatte/<key>/name|hash|conversion|manifest` header attributes; the
-//! samples live in `<name>NN.red` (ID) / `<name>NN.green` (coverage) channel pairs.
+//! samples live in `<name>NN` RGBA channel sets, each holding two (ID, coverage) ranks:
+//! `.red`/`.green` (rank 2·NN) and `.blue`/`.alpha` (rank 2·NN+1).
 //!
 //! IDs are the float *values*: MurmurHash3 x86-32 (seed 0) of the object name, its
 //! exponent fixed away from 0/255 so no ID is denormal, infinite or NaN, read as an f32
@@ -11,7 +12,6 @@ use std::io::Cursor;
 
 use exr::meta::MetaData;
 use exr::meta::attribute::AttributeValue;
-use exr::prelude::{ReadChannels, ReadLayers, read};
 
 use crate::Format;
 use crate::error::CodecError;
@@ -21,21 +21,26 @@ use crate::options::Limits;
 const F: Format = Format::OpenExr;
 
 /// A Cryptomatte stream channel (`crypto_asset00.red`) splits into its stream name
-/// (`crypto_asset00`), the layer prefix without digits (`crypto_asset`), the stream index,
-/// and whether it is the coverage (green) channel instead of the ID (red).
+/// (`crypto_asset00`), the stream index, whether it is a coverage channel (green/alpha)
+/// instead of an ID (red/blue), and its rank within the set (0 for red/green, 1 for
+/// blue/alpha).
 pub(crate) struct StreamChannel {
     pub stream: String,
     pub index: u32,
     pub coverage: bool,
+    pub rank: usize,
 }
 
 /// `<name>NN` where NN is one or more digits (the reference readers match `\d+`), with a
-/// `.red`/`.r` (ID) or `.green`/`.g` (coverage) suffix.
+/// `.red`/`.r` or `.blue`/`.b` (ID) or `.green`/`.g` or `.alpha`/`.a` (coverage) suffix,
+/// in any case (Blender writes `.R`/`.G`/`.B`/`.A`).
 pub(crate) fn split_stream(channel: &str) -> Option<StreamChannel> {
     let (stream, suffix) = channel.rsplit_once('.')?;
-    let coverage = match suffix {
-        "red" | "r" => false,
-        "green" | "g" => true,
+    let (coverage, rank) = match suffix.to_ascii_lowercase().as_str() {
+        "red" | "r" => (false, 0),
+        "green" | "g" => (true, 0),
+        "blue" | "b" => (false, 1),
+        "alpha" | "a" => (true, 1),
         _ => return None,
     };
     let digits = stream.chars().rev().take_while(|c| c.is_ascii_digit()).count();
@@ -44,7 +49,7 @@ pub(crate) fn split_stream(channel: &str) -> Option<StreamChannel> {
     }
     let split = stream.len() - digits;
     let index = stream[split..].parse().ok()?;
-    Some(StreamChannel { stream: stream.to_string(), index, coverage })
+    Some(StreamChannel { stream: stream.to_string(), index, coverage, rank })
 }
 
 /// MurmurHash3, x86-32 bit variant, seed 0 (public-domain algorithm, Austin Appleby).
@@ -200,7 +205,8 @@ pub(crate) fn decode(bytes: &[u8], layer_name: &str, limits: &Limits) -> Result<
         .iter()
         .find(|l| l.name.eq_ignore_ascii_case(layer_name))
         .ok_or_else(|| CodecError::unsupported(F, format!("no Cryptomatte layer named {layer_name}")))?;
-    let meta = MetaData::read_from_buffered(Cursor::new(bytes), false).map_err(|e| CodecError::malformed(F, e))?;
+    // Also caps all parts' declared sizes together, like every other flat decode.
+    let meta = super::exr::read_meta(bytes, limits)?;
     if meta.requirements.has_deep_data {
         return Err(CodecError::unsupported(F, "this file has deep parts; Cryptomatte decoding stays with flat files"));
     }
@@ -210,20 +216,17 @@ pub(crate) fn decode(bytes: &[u8], layer_name: &str, limits: &Limits) -> Result<
     let npx = w.checked_mul(h).ok_or_else(|| CodecError::malformed(F, "the layer is too large"))?;
     let too_large = || CodecError::malformed(F, "the layer is too large");
     let (w32, h32) = (u32::try_from(w).map_err(|_| too_large())?, u32::try_from(h).map_err(|_| too_large())?);
-    // Each pixel also gets a pair list, so count its header with the channel samples.
-    let per_pixel = (layer.channels.len().max(1) as u64).saturating_mul(8).saturating_add(std::mem::size_of::<Vec<(f32, f32)>>() as u64);
+    // Each pixel also gets a pair list, so count its header with the channel samples (four
+    // f32 channels per set: two ranks of ID and coverage).
+    let per_pixel = (layer.channels.len().max(1) as u64).saturating_mul(16).saturating_add(std::mem::size_of::<Vec<(f32, f32)>>() as u64);
     limits.check_bytes(w32, h32, per_pixel)?;
 
-    let image = read().no_deep_data().largest_resolution_level().all_channels().all_layers().all_attributes().from_buffered(Cursor::new(bytes)).map_err(
-        |e| match e {
-            exr::error::Error::NotSupported(m) => CodecError::unsupported(F, format!("not supported: {m}")),
-            e => CodecError::malformed(F, e),
-        },
-    )?;
-    let ex_layer = image.layer_data.get(layer.part).ok_or_else(|| CodecError::malformed(F, "the Cryptomatte part is missing"))?;
+    let ex_layer = super::exr::read_layer(bytes, layer.part)?;
 
-    let mut ids: Vec<Vec<f32>> = vec![Vec::new(); layer.channels.len()];
-    let mut coverages: Vec<Vec<f32>> = vec![Vec::new(); layer.channels.len()];
+    // Two (ID, coverage) ranks per set: rank `slot * 2 + stream.rank`.
+    let ranks = layer.channels.len().saturating_mul(2);
+    let mut ids: Vec<Vec<f32>> = vec![Vec::new(); ranks];
+    let mut coverages: Vec<Vec<f32>> = vec![Vec::new(); ranks];
     for c in &ex_layer.channel_data.list {
         let Some(stream) = split_stream(&c.name.to_string()) else { continue };
         let Some(slot) = layer.channels.iter().position(|s| *s == stream.stream) else { continue };
@@ -232,7 +235,8 @@ pub(crate) fn decode(bytes: &[u8], layer_name: &str, limits: &Limits) -> Result<
             return Err(CodecError::malformed(F, "a Cryptomatte channel is smaller than its layer"));
         }
         let bucket = if stream.coverage { &mut coverages } else { &mut ids };
-        bucket[slot] = values;
+        let Some(dst) = slot.checked_mul(2).and_then(|r| r.checked_add(stream.rank)).and_then(|r| bucket.get_mut(r)) else { continue };
+        *dst = values;
     }
 
     let mut pixels = vec![Vec::new(); npx];
diff --git a/crates/codecs/src/codecs/fits.rs b/crates/codecs/src/codecs/fits.rs
index 8da3849207..3aa769fb01 100644
--- a/crates/codecs/src/codecs/fits.rs
+++ b/crates/codecs/src/codecs/fits.rs
@@ -14,10 +14,12 @@
 //!   65535 when they fit in it (DeepSkyStacker, most stackers) and by the maximum otherwise. NaN
 //!   and blank pixels read as 0.
 //! * The other header cards are kept as text: `KEY` → value (strings unquoted), `COMMENT` and
-//!   `HISTORY` by their text, `HIERARCH` keywords by their long name.
+//!   `HISTORY` by their text, `HIERARCH` keywords by their long name. Long strings continued
+//!   on `CONTINUE` cards are joined.
 //!
 //! Writing: gray or RGB, U8 (`BITPIX = 8`), U16 (`BITPIX = 16`, `BZERO = 32768`) or F32
-//! (`BITPIX = -32`, 0..1), bottom-to-top with `ROWORDER = 'BOTTOM-UP'`, plus the text cards.
+//! (`BITPIX = -32`, 0..1), bottom-to-top with `ROWORDER = 'BOTTOM-UP'`, plus the text cards
+//! (strings longer than one card on `CONTINUE` cards).
 //! Tile-compressed files (fpack `ZIMAGE` tables) are recognised and refused.
 
 use crate::Format;
@@ -149,7 +151,20 @@ fn parse_header(b: &[u8], start: usize) -> Result<Header, CodecError> {
         if raw.starts_with(b"END") && raw.get(3..).is_some_and(|r| r.iter().all(|&c| c == b' ')) {
             break;
         }
-        cards.push(parse_card(raw));
+        let card = parse_card(raw);
+        // Long strings (FITS 4.0 section 4.2.1.2): a string ending in '&' goes on in the next
+        // `CONTINUE` record. An orphaned `CONTINUE` stays a card of its own (commentary).
+        if let Some(Card { value: Some(Value::Str(s)), .. }) = cards.last_mut()
+            && s.ends_with('&')
+            && card.key == "CONTINUE"
+            && card.text.starts_with("  ")
+            && let Value::Str(more) = parse_value(&card.text)
+        {
+            s.pop();
+            s.push_str(&more);
+            continue;
+        }
+        cards.push(card);
     }
     let data_start = pos.div_ceil(BLOCK).checked_mul(BLOCK).ok_or_else(|| err("header too long"))?;
     Ok(Header { cards, data_start })
@@ -390,9 +405,22 @@ impl Writer {
     fn value(&mut self, key: &str, v: &str) {
         if literal(v) {
             self.card(&format!("{key:<8}= {v:>20}"));
-        } else {
-            self.card(&format!("{key:<8}= {}", quoted(v, CARD - 10)));
+            return;
         }
+        // A string too long for one card goes on in `CONTINUE` cards, every piece but the last
+        // ending in '&' (FITS 4.0 section 4.2.1.2). A doubled quote is never split, and trailing
+        // blanks (not significant) are dropped so none are kept before an '&'.
+        let escaped = ascii(v).trim_end().replace('\'', "''");
+        let mut rest = escaped.as_str();
+        let mut head = format!("{key:<8}= ");
+        while rest.len() > CARD - 12 {
+            let cut = CARD - 13 - rest.get(..CARD - 13).unwrap_or("").bytes().rev().take_while(|&b| b == b'\'').count() % 2;
+            let (piece, tail) = rest.split_at_checked(cut).unwrap_or((rest, ""));
+            self.card(&format!("{head}'{piece}&'"));
+            head = "CONTINUE  ".to_string();
+            rest = tail;
+        }
+        self.card(&format!("{head}'{rest:<8}'"));
     }
 
     fn commentary(&mut self, key: &str, text: &str) {
@@ -410,7 +438,8 @@ impl Writer {
         if matches!(upper.as_str(), "COMMENT" | "HISTORY") {
             self.commentary(&upper, v);
         } else if standard_key(key) {
-            if !STRUCTURAL.contains(&key) && !is_naxis(key) {
+            // `CONTINUE` only ever carries a string's continuation, written by `value`.
+            if !STRUCTURAL.contains(&key) && !is_naxis(key) && key != "CONTINUE" {
                 self.value(key, v);
             }
         } else {
@@ -526,6 +555,40 @@ mod tests {
         out
     }
 
+    #[test]
+    fn continue_strings_decode() {
+        let mut b = header(&[
+            "SIMPLE  = T",
+            "BITPIX  = 8",
+            "NAXIS   = 2",
+            "NAXIS1  = 1",
+            "NAXIS2  = 1",
+            "OBJECT  = 'aaa&'",
+            "CONTINUE  'bbb&' / a comment",
+            "CONTINUE  '&'",
+            "CONTINUE  ''",
+            "OBSERVER= 'R&'",
+            "COMMENT hi",
+            "CONTINUE  'orphan'",
+        ]);
+        b.push(0);
+        let img = decode(&b, &Limits::default()).unwrap();
+        let text = [("OBJECT", "aaabbb"), ("OBSERVER", "R&"), ("COMMENT", "hi"), ("CONTINUE", "'orphan'")];
+        assert_eq!(img.meta.text, text.map(|(k, v)| (k.to_string(), v.to_string())));
+    }
+
+    #[test]
+    fn continue_strings_round_trip() {
+        for value in ["a".repeat(100), format!("{}' {}", "a".repeat(65), "b".repeat(100)), "'".repeat(100), "a".repeat(68)] {
+            let mut img = Image::from_u8(1, 1, ChannelLayout::Gray, vec![0]).unwrap();
+            img.meta.text = vec![("OBJECT".into(), value.clone()), ("CONTINUE".into(), "orphan".into())];
+            let b = crate::encode(&img, F, &EncodeOptions::default()).unwrap();
+            assert!(!b.chunks(CARD).any(|c| c.starts_with(b"CONTINUE=")));
+            let decoded = decode(&b, &Limits::default()).unwrap();
+            assert_eq!(decoded.meta.text, vec![("OBJECT".into(), value)]);
+        }
+    }
+
     #[test]
     fn camera_u16_with_bzero_reads_exactly_and_bottom_up() {
         let mut b = header(&[
diff --git a/crates/codecs/src/codecs/mod.rs b/crates/codecs/src/codecs/mod.rs
index ea70ccc2b8..afb7f96791 100644
--- a/crates/codecs/src/codecs/mod.rs
+++ b/crates/codecs/src/codecs/mod.rs
@@ -1,14 +1,19 @@
+pub(crate) mod dds;
 pub(crate) mod deep_exr;
+pub(crate) mod dpx;
 pub(crate) mod exr;
 pub(crate) mod exr_cryptomatte;
 pub(crate) mod fits;
 pub(crate) mod gif_frames;
 pub(crate) mod heif;
 pub(crate) mod jpeg;
+pub(crate) mod pcx;
 pub(crate) mod png;
 pub(crate) mod pnm;
 pub(crate) mod tiff;
+pub(crate) mod tiff_exif;
 pub(crate) mod tiff_ifd;
 pub(crate) mod via_image;
 pub(crate) mod vp8;
 pub(crate) mod webp;
+pub(crate) mod xpm;
diff --git a/crates/codecs/src/codecs/pcx.rs b/crates/codecs/src/codecs/pcx.rs
new file mode 100644
index 0000000000..43a3e97302
--- /dev/null
+++ b/crates/codecs/src/codecs/pcx.rs
@@ -0,0 +1,118 @@
+//! ZSoft PCX (Paintbrush) reader: strictly bounded scanline RLE, 16/256-colour
+//! palettes and 8-bit three-plane RGB. Read-only: modern saves should use PNG.
+
+use crate::SampleType;
+use crate::error::CodecError;
+use crate::format::Format;
+use crate::image::{ChannelLayout, Image};
+use crate::options::Limits;
+
+const HEADER: usize = 128;
+
+fn bad(reason: impl std::fmt::Display) -> CodecError {
+    CodecError::malformed(Format::Pcx, reason)
+}
+fn le16(b: &[u8], i: usize) -> u16 {
+    u16::from_le_bytes([b[i], b[i + 1]])
+}
+
+/// PCX lacks a strong magic number. Require plausible complete header fields before
+/// identifying it, rather than classifying every file starting with 0x0a as PCX.
+pub(crate) fn looks_like_pcx(b: &[u8]) -> bool {
+    if b.len() < HEADER || b[0] != 0x0a || !matches!(b[1], 0 | 2 | 3 | 5) || b[2] != 1 {
+        return false;
+    }
+    let bits = b[3];
+    let planes = b[65];
+    let stride = u32::from(le16(b, 66));
+    let (x0, y0, x1, y1) = (le16(b, 4), le16(b, 6), le16(b, 8), le16(b, 10));
+    if x1 < x0 || y1 < y0 || !matches!(bits, 1 | 2 | 4 | 8) || !(1..=4).contains(&planes) {
+        return false;
+    }
+    let width = u32::from(x1 - x0) + 1;
+    let min_stride = (width * u32::from(bits)).div_ceil(8);
+    stride >= min_stride && stride > 0 && (bits != 8 || matches!(planes, 1 | 3)) && (bits == 8 || u32::from(bits) * u32::from(planes) <= 4)
+}
+
+/// Read one compressed plane's row. RLE packets never cross a scanline.
+fn read_row(b: &[u8], pos: &mut usize, out: &mut [u8]) -> Result<(), CodecError> {
+    let mut n = 0;
+    while n < out.len() {
+        let code = *b.get(*pos).ok_or_else(|| bad("truncated pixel RLE"))?;
+        *pos += 1;
+        let (count, value) = if code >= 0xc0 {
+            let count = usize::from(code & 0x3f);
+            let value = *b.get(*pos).ok_or_else(|| bad("truncated RLE packet"))?;
+            *pos += 1;
+            (count, value)
+        } else {
+            (1, code)
+        };
+        if count == 0 || count > out.len() - n {
+            return Err(bad("RLE packet crosses a scanline or has zero length"));
+        }
+        out[n..n + count].fill(value);
+        n += count;
+    }
+    Ok(())
+}
+
+pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
+    if !looks_like_pcx(b) {
+        return Err(bad("invalid PCX header or unsupported pixel layout"));
+    }
+    let (w, h) = (u32::from(le16(b, 8) - le16(b, 4)) + 1, u32::from(le16(b, 10) - le16(b, 6)) + 1);
+    limits.check(w, h, ChannelLayout::Rgb, SampleType::U8)?;
+    let (bits, planes, stride) = (usize::from(b[3]), usize::from(b[65]), usize::from(le16(b, 66)));
+    let row_len = stride.checked_mul(planes).ok_or_else(|| bad("row size overflow"))?;
+    let total = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(3)).ok_or_else(|| bad("pixel size overflow"))?;
+    // The last 769 bytes are the optional VGA palette for 8-bit indexed images.
+    let vga = bits == 8 && planes == 1 && b.len() >= HEADER + 769 && b[b.len() - 769] == 0x0c;
+    if bits == 8 && planes == 1 && !vga && le16(b, 68) != 2 {
+        return Err(bad("8-bit indexed PCX has no 256-colour palette"));
+    }
+    let image_end = if vga { b.len() - 769 } else { b.len() };
+    let mut row = vec![0u8; row_len];
+    let mut pixels = vec![0u8; total];
+    let mut p = HEADER;
+    let width = w as usize;
+    for y in 0..h as usize {
+        for plane in row.chunks_mut(stride) {
+            read_row(&b[..image_end], &mut p, plane)?;
+        }
+        for x in 0..width {
+            let rgb = if bits == 8 && planes == 3 {
+                [row[x], row[stride + x], row[2 * stride + x]]
+            } else {
+                let index = if bits == 8 {
+                    usize::from(row[x])
+                } else {
+                    let bit = x * bits;
+                    let shift = 8 - bits - (bit % 8);
+                    let mask = (1usize << bits) - 1;
+                    (0..planes).fold(0usize, |v, plane| {
+                        let sample = (usize::from(row[plane * stride + bit / 8]) >> shift) & mask;
+                        v | sample << (plane * bits)
+                    })
+                };
+                if vga {
+                    let o = image_end + 1 + index * 3;
+                    [b[o], b[o + 1], b[o + 2]]
+                } else if bits == 8 {
+                    let g = index as u8;
+                    [g, g, g] // palette-info 2: gray scale
+                } else {
+                    let o = 16 + index * 3;
+                    [b[o], b[o + 1], b[o + 2]]
+                }
+            };
+            pixels[(y * width + x) * 3..(y * width + x + 1) * 3].copy_from_slice(&rgb);
+        }
+    }
+    let mut image = Image::from_u8(w, h, ChannelLayout::Rgb, pixels)?;
+    let (xdpi, ydpi) = (le16(b, 12), le16(b, 14));
+    if xdpi > 0 && ydpi > 0 {
+        image.meta.dpi = Some((f32::from(xdpi), f32::from(ydpi)));
+    }
+    Ok(image)
+}
diff --git a/crates/codecs/src/codecs/png.rs b/crates/codecs/src/codecs/png.rs
index 636238a7bf..7c1a633d17 100644
--- a/crates/codecs/src/codecs/png.rs
+++ b/crates/codecs/src/codecs/png.rs
@@ -7,7 +7,7 @@ use crate::Format;
 use crate::error::CodecError;
 use crate::fidelity::Plan;
 use crate::image::{ChannelLayout, DecodeWarning, Image, Metadata, SampleType};
-use crate::options::{EncodeOptions, Limits, PngCompression};
+use crate::options::{EncodeOptions, Limits, PngCompression, alloc_zeroed};
 
 const F: Format = Format::Png;
 pub(crate) const XMP_KEYWORD: &str = "XML:com.adobe.xmp";
@@ -17,6 +17,15 @@ fn err(e: impl std::fmt::Display) -> CodecError {
     CodecError::malformed(F, e)
 }
 
+/// Pixels per inch for `pHYs` pixels per metre. A whole number of ppi is stored rounded to whole
+/// pixels per metre (300 ppi = 11811), so reading it back gives 299.9994: the whole number that
+/// rounds to the stored value is the resolution that was meant, as Photoshop reads it.
+pub(crate) fn dpi_of_ppm(ppm: u32) -> f32 {
+    let dpi = f64::from(ppm) * f64::from(METERS_PER_INCH);
+    let whole = dpi.round();
+    if (whole / f64::from(METERS_PER_INCH)).round() == f64::from(ppm) { whole as f32 } else { dpi as f32 }
+}
+
 pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
     let mut input = Cursor::new(bytes);
     let mut decoder = png::Decoder::new_with_limits(&mut input, png::Limits { bytes: limits.alloc_usize() });
@@ -29,6 +38,10 @@ pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError>
         let (w, h) = info.size();
         // Worst case output: 4 channels x 16 bit.
         limits.check_bytes(w, h, 8)?;
+        // zlib never beats 1032:1; refuse a file too small for the declared image before the
+        // output buffer exists. Measured on the stored samples (before palette/bit expansion).
+        let stored = u64::from(w).saturating_mul(u64::from(h)).saturating_mul(info.bits_per_pixel() as u64).div_ceil(8);
+        Limits::check_plausible(stored, bytes.len(), 1100)?;
     }
     let mut reader = decoder.read_info().map_err(map_png_err)?;
     // APNG: the IDAT image is the first frame, or an extra default image when no fcTL precedes it.
@@ -47,7 +60,7 @@ pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError>
         d => return Err(err(format!("unexpected output bit depth {d:?}"))),
     };
     let size = reader.output_buffer_size().ok_or_else(|| err("image too large"))?;
-    let mut buf = vec![0u8; size];
+    let mut buf = alloc_zeroed::<u8>(size)?;
     let out = reader.next_frame(&mut buf).map_err(map_png_err)?;
     buf.truncate(out.buffer_size());
     // Collect ancillary chunks after IDAT. Tolerate malformed tails once pixels
@@ -70,7 +83,7 @@ pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError>
         && d.xppu > 0
         && d.yppu > 0
     {
-        meta.dpi = Some((d.xppu as f32 * METERS_PER_INCH, d.yppu as f32 * METERS_PER_INCH));
+        meta.dpi = Some((dpi_of_ppm(d.xppu), dpi_of_ppm(d.yppu)));
     }
     drop(reader);
     let end = usize::try_from(input.position()).map_err(|_| err("invalid PNG reader position"))?;
@@ -83,6 +96,37 @@ pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError>
     Ok(img)
 }
 
+/// The colour table of a palette PNG (`PLTE`) and the one entry its `tRNS` makes transparent.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PngPalette {
+    pub colors: Vec<[u8; 3]>,
+    pub transparent: Option<u8>,
+}
+
+/// The colour table of a palette PNG (colour type 3), read from the headers without decoding
+/// pixels. `None` for other colour types, and for a `tRNS` with partial alpha or several
+/// transparent entries: an Indexed Color document holds one transparent entry.
+pub fn palette(bytes: &[u8]) -> Result<Option<PngPalette>, CodecError> {
+    let mut decoder = png::Decoder::new_with_limits(Cursor::new(bytes), png::Limits::default());
+    decoder.set_ignore_text_chunk(true);
+    let reader = decoder.read_info().map_err(map_png_err)?;
+    let info = reader.info();
+    if info.color_type != png::ColorType::Indexed {
+        return Ok(None);
+    }
+    let Some(plte) = info.palette.as_deref() else { return Ok(None) };
+    let colors = plte.as_chunks::<3>().0.to_vec();
+    let mut transparent = None;
+    for (i, &a) in info.trns.as_deref().unwrap_or_default().iter().enumerate() {
+        match a {
+            255 => {}
+            0 if transparent.is_none() && i < colors.len() => transparent = u8::try_from(i).ok(),
+            _ => return Ok(None),
+        }
+    }
+    Ok(Some(PngPalette { colors, transparent }))
+}
+
 fn map_png_err(e: png::DecodingError) -> CodecError {
     match e {
         png::DecodingError::LimitsExceeded => CodecError::LimitExceeded("PNG decoder memory limit".into()),
@@ -582,6 +626,33 @@ mod indexed_tests {
         assert!(encode_indexed(3, 2, &[9; 6], &pal, None, None).is_err());
         assert!(encode_indexed(3, 3, &idx, &pal, None, None).is_err());
     }
+
+    fn png(color: png::ColorType, trns: Option<&[u8]>) -> Vec<u8> {
+        let mut out = Vec::new();
+        let mut e = png::Encoder::new(&mut out, 2, 1);
+        e.set_color(color);
+        e.set_depth(png::BitDepth::Eight);
+        e.set_palette(vec![1, 2, 3, 4, 5, 6]);
+        if let Some(t) = trns {
+            e.set_trns(t.to_vec());
+        }
+        let data = if color == png::ColorType::Rgb { vec![0; 6] } else { vec![0, 1] };
+        e.write_header().unwrap().write_image_data(&data).unwrap();
+        out
+    }
+
+    #[test]
+    fn palette_reads_the_table_and_its_one_transparent_entry() {
+        let bytes = encode_indexed(2, 1, &[0, 1], &[[1, 2, 3], [4, 5, 6]], Some(1), None).unwrap();
+        let colors = vec![[1, 2, 3], [4, 5, 6]];
+        assert_eq!(palette(&bytes).unwrap(), Some(PngPalette { colors: colors.clone(), transparent: Some(1) }));
+        assert_eq!(palette(&png(png::ColorType::Indexed, None)).unwrap(), Some(PngPalette { colors, transparent: None }));
+        // A truecolour PNG's suggested palette is not a colour table.
+        assert_eq!(palette(&png(png::ColorType::Rgb, None)).unwrap(), None);
+        // Partial alpha or two transparent entries don't fit one transparent index.
+        assert_eq!(palette(&png(png::ColorType::Indexed, Some(&[255, 128]))).unwrap(), None);
+        assert_eq!(palette(&png(png::ColorType::Indexed, Some(&[0, 0]))).unwrap(), None);
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/codecs/src/codecs/tiff.rs b/crates/codecs/src/codecs/tiff.rs
index b2b315e263..5e09a68ece 100644
--- a/crates/codecs/src/codecs/tiff.rs
+++ b/crates/codecs/src/codecs/tiff.rs
@@ -35,6 +35,7 @@ use tiff::encoder::colortype::{self, ColorType as TiffColorType};
 use tiff::encoder::{Rational, TiffEncoder, TiffKind, TiffKindBig, TiffKindStandard, TiffValue};
 use tiff::tags::{PhotometricInterpretation, ResolutionUnit, SampleFormat, Tag, Type};
 
+use super::tiff_exif::{self, ExifDirs};
 use super::tiff_ifd::{self as ifd, File, Ifd};
 use crate::Format;
 use crate::error::CodecError;
@@ -297,6 +298,13 @@ fn metadata(f: &File<'_>, dir: &Ifd, icc: &mut Option<Vec<u8>>) -> Metadata {
         if dir.at == f.first_ifd { photoshop_tags(f.b) } else { (f.tag_bytes(dir, TAG_PHOTOSHOP), f.tag_bytes(dir, TAG_IMAGE_SOURCE_DATA)) };
     meta.photoshop_resources = resources.map(<[u8]>::to_vec);
     meta.photoshop_layers = layers.map(<[u8]>::to_vec);
+    // EXIF: the Exif and GPS directories IFD0 points to, with IFD0's descriptive tags, as an
+    // EXIF block (the other pages are reduced copies or layers of the same image).
+    if dir.at == f.first_ifd
+        && let Some(e) = tiff_exif::read(f.b).filter(ExifDirs::has_directories)
+    {
+        meta.exif = Some(tiff_exif::block(&e));
+    }
     meta
 }
 
@@ -1016,6 +1024,8 @@ custom_colortype!(CmykA32F, f32, PI::CMYK, &[32; 5], &[SampleFormat::IEEEFP; 5],
 
 struct TagSet<'a> {
     icc: Option<&'a [u8]>,
+    /// The EXIF block's directories and IFD0 tags, written as the TIFF's own.
+    exif: Option<ExifDirs>,
     xmp: Option<&'a [u8]>,
     dpi: Option<(f32, f32)>,
     text: Vec<(Tag, &'a str)>,
@@ -1032,6 +1042,16 @@ where
     [C::Inner]: TiffValue,
     K: TiffKind,
 {
+    // The Exif and GPS directories go before the image, outside its chain; IFD0 points to them.
+    let mut sub = |e: &ExifDirs, fields: &[tiff_exif::Field]| (!fields.is_empty()).then(|| tiff_exif::write_directory(enc, fields, e.le)).transpose();
+    let exif_at = match &tags.exif {
+        Some(e) => sub(e, &e.exif)?,
+        None => None,
+    };
+    let gps_at = match &tags.exif {
+        Some(e) => sub(e, &e.gps)?,
+        None => None,
+    };
     let mut im = enc.new_image::<C>(w, h)?;
     if let Some((x, y)) = tags.dpi {
         im.resolution_unit(ResolutionUnit::Inch);
@@ -1052,6 +1072,17 @@ where
     for (tag, s) in &tags.text {
         d.write_tag(*tag, *s)?;
     }
+    if let Some(e) = &tags.exif {
+        // The EXIF block's descriptive IFD0 tags, unless the text metadata already wrote them.
+        let ifd0: Vec<tiff_exif::Field> = e.ifd0.iter().filter(|f| !tags.text.iter().any(|(t, _)| t.to_u16() == f.tag)).cloned().collect();
+        tiff_exif::write_fields(d, &ifd0, e.le)?;
+    }
+    if let Some(at) = exif_at {
+        d.write_tag(Tag::Unknown(tiff_exif::TAG_EXIF_IFD), at)?;
+    }
+    if let Some(at) = gps_at {
+        d.write_tag(Tag::Unknown(tiff_exif::TAG_GPS_IFD), at)?;
+    }
     if let Some(r) = tags.photoshop_resources {
         d.write_tag(Tag::Unknown(TAG_PHOTOSHOP), r)?;
     }
@@ -1099,7 +1130,8 @@ const CLASSIC_LIMIT: u64 = u32::MAX as u64;
 /// room for the directory and strip tables.
 fn estimated_size(img: &Image, tags: &TagSet<'_>) -> u64 {
     let payloads = [tags.icc, tags.xmp, tags.photoshop_resources, tags.photoshop_layers].iter().flatten().map(|p| p.len() as u64).sum::<u64>();
-    let text = tags.text.iter().map(|(_, s)| s.len() as u64).sum::<u64>();
+    let text = tags.text.iter().map(|(_, s)| s.len() as u64).sum::<u64>()
+        + tags.exif.iter().flat_map(|e| e.ifd0.iter().chain(&e.exif).chain(&e.gps)).map(|f| f.value.len() as u64 + 12).sum::<u64>();
     // Strip tables: one offset and one count per strip of about 1 MB.
     let tables = (img.data().len() as u64 / (1 << 20) + 1) * 16;
     (img.data().len() as u64).saturating_add(payloads).saturating_add(text).saturating_add(tables).saturating_add(1 << 20)
@@ -1132,6 +1164,7 @@ pub(crate) fn encode(src: &Image, plan: Plan, opts: &EncodeOptions) -> Result<Ve
     let xmp = if opts.embed_metadata { img.meta.xmp.as_deref().map(|x| crate::resolution::export_xmp(x, img.meta.dpi)) } else { None };
     let tags = TagSet {
         icc: if opts.embed_icc { img.icc.as_deref() } else { None },
+        exif: if opts.embed_metadata { img.meta.exif.as_deref().and_then(|e| tiff_exif::read(crate::orientation::tiff_body(e))) } else { None },
         xmp: xmp.as_deref().map(str::as_bytes),
         dpi: if opts.embed_metadata { img.meta.dpi.filter(|d| d.0 > 0.0 && d.1 > 0.0) } else { None },
         text,
diff --git a/crates/codecs/src/codecs/tiff_exif.rs b/crates/codecs/src/codecs/tiff_exif.rs
new file mode 100644
index 0000000000..d07f555f30
--- /dev/null
+++ b/crates/codecs/src/codecs/tiff_exif.rs
@@ -0,0 +1,195 @@
+//! EXIF in a TIFF file: the Exif (34665) and GPS (34853) directories that IFD0 points to, plus
+//! IFD0's descriptive tags (make, model, software, artist, …), the way cameras and Photoshop
+//! write them.
+//!
+//! An EXIF block (`Metadata::exif`) is itself a small TIFF stream, so both directions go through
+//! the same reader ([`super::tiff_ifd::File`]): reading a TIFF builds a block from the file's own
+//! directories, writing one copies the block's directories into the file. Values are copied as
+//! bytes (re-ordered when the byte orders differ), so tags PhotoCraft doesn't know survive.
+//! Classic TIFF only on the reading side: an EXIF block has 4-byte offsets.
+
+use tiff::encoder::{DirectoryEncoder, TiffEncoder, TiffKind};
+use tiff::tags::{Tag, Type};
+use tiff::{Directory, TiffResult};
+
+use super::tiff_ifd::{File, Ifd};
+
+/// IFD0's pointer to the Exif directory.
+pub(crate) const TAG_EXIF_IFD: u16 = 34665;
+/// IFD0's pointer to the GPS directory.
+pub(crate) const TAG_GPS_IFD: u16 = 34853;
+/// The Exif directory's pointer to the Interoperability directory (not carried: it holds only
+/// the interoperability index, and a copied pointer would point nowhere).
+const TAG_INTEROP_IFD: u16 = 40965;
+/// IFD0 tags an EXIF block carries next to its directories: ImageDescription, Make, Model,
+/// Software, DateTime, Artist, Copyright. Structure, resolution and orientation belong to the
+/// image and are written from it.
+const IFD0_TAGS: [u16; 7] = [270, 271, 272, 305, 306, 315, 33432];
+/// At most this many entries are copied from one directory.
+const MAX_FIELDS: usize = 1024;
+
+/// One entry with its value bytes in the byte order of the stream it came from.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct Field {
+    pub tag: u16,
+    pub ty: u16,
+    pub count: u32,
+    pub value: Vec<u8>,
+}
+
+/// The EXIF parts of a TIFF stream, in its byte order (`le`).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub(crate) struct ExifDirs {
+    pub le: bool,
+    pub ifd0: Vec<Field>,
+    pub exif: Vec<Field>,
+    pub gps: Vec<Field>,
+}
+
+impl ExifDirs {
+    /// Whether there is an Exif or GPS directory (IFD0's descriptive tags alone are not EXIF).
+    pub fn has_directories(&self) -> bool {
+        !self.exif.is_empty() || !self.gps.is_empty()
+    }
+}
+
+fn fields(f: &File<'_>, ifd: &Ifd, keep: impl Fn(u16) -> bool) -> Vec<Field> {
+    ifd.entries
+        .iter()
+        .filter(|e| keep(e.tag) && !matches!(e.tag, TAG_EXIF_IFD | TAG_GPS_IFD | TAG_INTEROP_IFD))
+        .filter_map(|e| Some(Field { tag: e.tag, ty: e.ty, count: u32::try_from(e.count).ok()?, value: f.data(e)?.to_vec() }))
+        .take(MAX_FIELDS)
+        .collect()
+}
+
+fn sub(f: &File<'_>, ifd: &Ifd, tag: u16) -> Option<Ifd> {
+    let at = f.tag_uint(ifd, tag)?;
+    (at != ifd.at).then(|| f.ifd(at)).flatten()
+}
+
+/// The EXIF parts of the classic TIFF stream `b` (a TIFF file, or an EXIF block without its
+/// `Exif\0\0` prefix): IFD0's descriptive tags and the Exif and GPS directories.
+pub(crate) fn read(b: &[u8]) -> Option<ExifDirs> {
+    let f = File::parse(b)?;
+    if f.big {
+        return None;
+    }
+    let ifd0 = f.ifd(f.first_ifd)?;
+    let dir = |tag: u16| sub(&f, &ifd0, tag).map(|d| fields(&f, &d, |_| true)).unwrap_or_default();
+    Some(ExifDirs { le: f.le, ifd0: fields(&f, &ifd0, |t| IFD0_TAGS.contains(&t)), exif: dir(TAG_EXIF_IFD), gps: dir(TAG_GPS_IFD) })
+}
+
+/// Bytes per element whose order a byte-order change reverses: a RATIONAL is two LONGs.
+fn element(ty: u16) -> usize {
+    match ty {
+        3 | 8 => 2,
+        4 | 5 | 9 | 10 | 11 | 13 => 4,
+        12 | 16 | 17 | 18 => 8,
+        _ => 1,
+    }
+}
+
+/// `value` of type `ty` in byte order `to_le`, from `from_le`.
+pub(crate) fn reorder(ty: u16, value: &[u8], from_le: bool, to_le: bool) -> Vec<u8> {
+    let n = element(ty);
+    if from_le == to_le || n == 1 {
+        return value.to_vec();
+    }
+    value.chunks(n).flat_map(|c| c.iter().rev().copied()).collect()
+}
+
+/// An EXIF block: a classic TIFF stream in `dirs.le` order whose IFD0 holds `dirs.ifd0` and
+/// points to the Exif and GPS directories.
+pub(crate) fn block(dirs: &ExifDirs) -> Vec<u8> {
+    let le = dirs.le;
+    let u16b = |v: u16| if le { v.to_le_bytes() } else { v.to_be_bytes() };
+    let u32b = |v: u32| if le { v.to_le_bytes() } else { v.to_be_bytes() };
+    let mut ifd0: Vec<Field> = dirs.ifd0.clone();
+    // Placeholders for the pointers; their offsets are known once the layout is.
+    let pointer = |tag: u16| Field { tag, ty: 4, count: 1, value: vec![0; 4] };
+    if !dirs.exif.is_empty() {
+        ifd0.push(pointer(TAG_EXIF_IFD));
+    }
+    if !dirs.gps.is_empty() {
+        ifd0.push(pointer(TAG_GPS_IFD));
+    }
+    // Layout: header, then each directory followed by its out-of-line values.
+    let size = |fs: &[Field]| 2 + 12 * fs.len() + 4 + fs.iter().filter(|f| f.value.len() > 4).map(|f| f.value.len().next_multiple_of(2)).sum::<usize>();
+    let at0 = 8;
+    let at_exif = at0 + size(&ifd0);
+    let at_gps = at_exif + if dirs.exif.is_empty() { 0 } else { size(&dirs.exif) };
+    for f in &mut ifd0 {
+        match f.tag {
+            TAG_EXIF_IFD => f.value = u32b(at_exif as u32).to_vec(),
+            TAG_GPS_IFD => f.value = u32b(at_gps as u32).to_vec(),
+            _ => {}
+        }
+    }
+    let mut out = Vec::new();
+    out.extend_from_slice(if le { b"II" } else { b"MM" });
+    out.extend_from_slice(&u16b(42));
+    out.extend_from_slice(&u32b(at0 as u32));
+    let write_dir = |out: &mut Vec<u8>, fs: &[Field]| {
+        let mut fs = fs.to_vec();
+        fs.sort_by_key(|f| f.tag);
+        let start = out.len();
+        let mut extra = start + 2 + 12 * fs.len() + 4;
+        let mut values = Vec::new();
+        out.extend_from_slice(&u16b(fs.len() as u16));
+        for f in &fs {
+            out.extend_from_slice(&u16b(f.tag));
+            out.extend_from_slice(&u16b(f.ty));
+            out.extend_from_slice(&u32b(f.count));
+            if f.value.len() <= 4 {
+                let mut inline = f.value.clone();
+                inline.resize(4, 0);
+                out.extend_from_slice(&inline);
+            } else {
+                out.extend_from_slice(&u32b(extra as u32));
+                values.extend_from_slice(&f.value);
+                if f.value.len() % 2 == 1 {
+                    values.push(0);
+                }
+                extra += f.value.len().next_multiple_of(2);
+            }
+        }
+        out.extend_from_slice(&u32b(0));
+        out.extend_from_slice(&values);
+    };
+    write_dir(&mut out, &ifd0);
+    if !dirs.exif.is_empty() {
+        write_dir(&mut out, &dirs.exif);
+    }
+    if !dirs.gps.is_empty() {
+        write_dir(&mut out, &dirs.gps);
+    }
+    out
+}
+
+/// Writes `fields` (in byte order `from_le`) into a directory of `enc` that is not part of the
+/// page chain, and returns its offset for the pointer tag.
+pub(crate) fn write_directory<W: std::io::Write + std::io::Seek, K: TiffKind>(
+    enc: &mut TiffEncoder<W, K>,
+    fields: &[Field],
+    from_le: bool,
+) -> TiffResult<K::OffsetType> {
+    let mut sub = enc.extra_directory()?;
+    write_fields(&mut sub, fields, from_le)?;
+    Ok(sub.finish_with_offsets()?.offset)
+}
+
+/// Adds `fields` (in byte order `from_le`) to directory `d`, in the file's (native) byte order.
+pub(crate) fn write_fields<W: std::io::Write + std::io::Seek, K: TiffKind>(
+    d: &mut DirectoryEncoder<'_, W, K>,
+    fields: &[Field],
+    from_le: bool,
+) -> TiffResult<()> {
+    let mut dir = Directory::empty();
+    for f in fields {
+        let Some(ty) = Type::from_u16(f.ty) else { continue };
+        let entry = d.write_entry_bytes(ty, &reorder(f.ty, &f.value, from_le, cfg!(target_endian = "little")))?;
+        dir.extend([(Tag::from_u16_exhaustive(f.tag), entry)]);
+    }
+    d.extend_from(&dir);
+    Ok(())
+}
diff --git a/crates/codecs/src/codecs/tiff_ifd.rs b/crates/codecs/src/codecs/tiff_ifd.rs
index 45fe9ee753..199d44ecc7 100644
--- a/crates/codecs/src/codecs/tiff_ifd.rs
+++ b/crates/codecs/src/codecs/tiff_ifd.rs
@@ -145,6 +145,14 @@ impl<'a> File<'a> {
         Some(if self.le { u64::from_le_bytes(s) } else { u64::from_be_bytes(s) })
     }
 
+    /// The declared entry count of the directory at `at`, before its table is parsed.
+    pub fn entry_count(&self, at: u64) -> Option<u64> {
+        if at < self.header_len() {
+            return None;
+        }
+        if self.big { self.u64_at(at) } else { self.u16_at(at).map(u64::from) }
+    }
+
     /// The directory at `at`: its whole table, up to and including the next-IFD pointer, must
     /// be inside the file and after the header.
     pub fn ifd(&self, at: u64) -> Option<Ifd> {
@@ -355,6 +363,10 @@ struct Walk<'a, 'f> {
     seen: HashSet<u64>,
     pages: Vec<TiffPage>,
     complete: bool,
+    /// Directory entries that may still be parsed. Real directory tables are disjoint, so their
+    /// total size is bounded by the file; overlapping tables (a hostile file) would otherwise
+    /// make every one of thousands of directories cost a full 65,535-entry parse.
+    entry_budget: u64,
 }
 
 impl Walk<'_, '_> {
@@ -366,6 +378,15 @@ impl Walk<'_, '_> {
                 self.complete = false;
                 return;
             }
+            let Some(n) = self.f.entry_count(at) else {
+                self.complete = false;
+                return;
+            };
+            if n > self.entry_budget {
+                self.complete = false;
+                return;
+            }
+            self.entry_budget -= n;
             let Some(ifd) = self.f.ifd(at) else {
                 self.complete = false;
                 return;
@@ -391,10 +412,37 @@ pub fn tiff_info(bytes: &[u8]) -> Result<TiffInfo, CodecError> {
 }
 
 pub(crate) fn info_of(f: &File<'_>) -> Result<TiffInfo, CodecError> {
-    let mut w = Walk { f, seen: HashSet::new(), pages: Vec::new(), complete: true };
+    let mut w = Walk { f, seen: HashSet::new(), pages: Vec::new(), complete: true, entry_budget: (f.b.len() as u64) / 12 + 64 };
     w.chain(f.first_ifd, None, 0);
     if w.pages.is_empty() {
         return Err(CodecError::malformed(Format::Tiff, "the first image directory is missing or cut off"));
     }
     Ok(TiffInfo { big_tiff: f.big, little_endian: f.le, pages: w.pages, complete: w.complete })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// 10,000 directories 4 bytes apart, each declaring 65,535 overlapping entries: the walk must
+    /// stop after the file-size entry budget instead of parsing ~6.5e8 entries.
+    #[test]
+    fn overlapping_directory_tables_exhaust_the_entry_budget() {
+        let first = 8usize;
+        let table = 2 + 65_535 * 12 + 4;
+        let mut b = vec![0u8; first + table + 4 * 10_000];
+        b[..8].copy_from_slice(&[b'I', b'I', 42, 0, first as u8, 0, 0, 0]);
+        for i in 0..10_000usize {
+            let at = first + 4 * i;
+            b[at..at + 2].copy_from_slice(&u16::MAX.to_le_bytes());
+            let next_cell = at + 2 + 65_535 * 12;
+            let next = (first + 4 * (i + 1)) as u32;
+            if let Some(cell) = b.get_mut(next_cell..next_cell + 4) {
+                cell.copy_from_slice(&next.to_le_bytes());
+            }
+        }
+        let info = tiff_info(&b).expect("the first directory is readable");
+        assert!(!info.complete);
+        assert!(info.pages.len() < 200, "{} directories parsed", info.pages.len());
+    }
+}
diff --git a/crates/codecs/src/codecs/via_image.rs b/crates/codecs/src/codecs/via_image.rs
index eca2fbb748..c91be5baf7 100644
--- a/crates/codecs/src/codecs/via_image.rs
+++ b/crates/codecs/src/codecs/via_image.rs
@@ -32,6 +32,11 @@ fn map_err(f: Format, e: image::ImageError) -> CodecError {
     }
 }
 
+pub(crate) fn bmp_palette(bytes: &[u8]) -> Result<Option<Vec<[u8; 3]>>, CodecError> {
+    let decoder = image::codecs::bmp::BmpDecoder::new(Cursor::new(bytes)).map_err(|e| map_err(Format::Bmp, e))?;
+    Ok(decoder.get_palette().map(|palette| palette.to_vec()))
+}
+
 pub(crate) fn decode(f: Format, bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
     let fmt = image_format(f).ok_or_else(|| CodecError::unsupported(f, "not handled by image backend"))?;
     let mut reader = image::ImageReader::with_format(Cursor::new(bytes), fmt);
diff --git a/crates/codecs/src/codecs/webp.rs b/crates/codecs/src/codecs/webp.rs
index c26c10c8cd..36473041dd 100644
--- a/crates/codecs/src/codecs/webp.rs
+++ b/crates/codecs/src/codecs/webp.rs
@@ -9,7 +9,7 @@ use crate::Format;
 use crate::error::CodecError;
 use crate::fidelity::Plan;
 use crate::image::{ChannelLayout, DecodeWarning, Image, Metadata, SampleType};
-use crate::options::{EncodeOptions, Limits};
+use crate::options::{EncodeOptions, Limits, alloc_zeroed};
 
 const F: Format = Format::WebP;
 
@@ -23,8 +23,11 @@ pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError>
     let (w, h) = dec.dimensions();
     let layout = if dec.has_alpha() { ChannelLayout::Rgba } else { ChannelLayout::Rgb };
     limits.check(w, h, layout, SampleType::U8)?;
+    // VP8L back-references and VP8 skipped macroblocks compress flat areas extremely well, so the
+    // ratio is generous; it still stops a header-only file from asking for a gigabyte.
+    Limits::check_plausible(u64::from(w) * u64::from(h) * layout.channels() as u64, bytes.len(), 1 << 16)?;
     let size = dec.output_buffer_size().ok_or_else(|| err("image too large"))?;
-    let mut buf = vec![0u8; size];
+    let mut buf = alloc_zeroed::<u8>(size)?;
     dec.read_image(&mut buf).map_err(err)?;
     let icc = dec.icc_profile().ok().flatten();
     let exif = dec.exif_metadata().ok().flatten();
diff --git a/crates/codecs/src/codecs/xpm.rs b/crates/codecs/src/codecs/xpm.rs
new file mode 100644
index 0000000000..82543d8867
--- /dev/null
+++ b/crates/codecs/src/codecs/xpm.rs
@@ -0,0 +1,221 @@
+//! X PixMap reader for XPM2 plain-text icons and XPM3 C-source icon arrays.
+//! Supports transparency (None), RGB hex at 4/8/16 bits per channel and
+//! common X11 colour names. Does not execute C code.
+
+use std::collections::HashMap;
+
+mod x11_colors;
+
+use crate::SampleType;
+use crate::error::CodecError;
+use crate::format::Format;
+use crate::image::{ChannelLayout, Image};
+use crate::options::Limits;
+
+const MAX_SOURCE: usize = 256 << 20;
+const MAX_COLOURS: usize = 65_536;
+const MAX_CPP: usize = 8;
+
+fn bad(msg: impl std::fmt::Display) -> CodecError {
+    CodecError::malformed(Format::Xpm, msg)
+}
+
+/// Extract C string literals without treating quoted text or // in a string as a comment.
+/// XPM uses one literal for the header, each palette entry and each row.
+fn c_strings(bytes: &[u8]) -> Result<Vec<Vec<u8>>, CodecError> {
+    let mut lines = Vec::new();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        if bytes[i..].starts_with(b"/*") {
+            let tail = &bytes[i + 2..];
+            let Some(end) = tail.windows(2).position(|p| p == b"*/") else { return Err(bad("unterminated C comment")) };
+            i += end + 4;
+        } else if bytes[i..].starts_with(b"//") {
+            i += bytes[i..].iter().position(|&c| c == b'\n').unwrap_or(bytes.len() - i);
+        } else if bytes[i] == b'"' {
+            i += 1;
+            let mut s = Vec::new();
+            let mut closed = false;
+            while i < bytes.len() {
+                let c = bytes[i];
+                i += 1;
+                match c {
+                    b'"' => {
+                        closed = true;
+                        break;
+                    }
+                    b'\\' => {
+                        let next = *bytes.get(i).ok_or_else(|| bad("truncated C escape"))?;
+                        i += 1;
+                        s.push(match next {
+                            b'n' => b'\n',
+                            b'r' => b'\r',
+                            b't' => b'\t',
+                            b'0' => 0,
+                            _ => next, // quoted backslash or quote
+                        });
+                    }
+                    _ => s.push(c),
+                }
+            }
+            if !closed {
+                return Err(bad("unterminated XPM string"));
+            }
+            lines.push(s);
+        } else {
+            i += 1;
+        }
+    }
+    Ok(lines)
+}
+
+/// Extract XPM2's plain-text lines without trimming pixel rows: leading and
+/// trailing spaces can be palette keys, and physical CRLF is not image data.
+fn xpm2_lines(bytes: &[u8]) -> Result<Vec<Vec<u8>>, CodecError> {
+    let mut input = bytes.split(|&b| b == b'\n');
+    let header = input.next().ok_or_else(|| bad("missing XPM2 marker"))?;
+    if header.strip_suffix(b"\r").unwrap_or(header) != b"! XPM2" {
+        return Err(bad("not an XPM2 image"));
+    }
+    let mut lines = Vec::new();
+    for raw in input {
+        let line = raw.strip_suffix(b"\r").unwrap_or(raw);
+        // The header may be preceded by comments and blank lines. After the
+        // header, a leading '!' is allowed as a palette key or pixel value.
+        if lines.is_empty() && (line.is_empty() || line.starts_with(b"!")) {
+            continue;
+        }
+        lines.push(line.to_vec());
+    }
+    Ok(lines)
+}
+
+fn channel(hex: &str) -> Option<u8> {
+    let v = u32::from_str_radix(hex, 16).ok()?;
+    let max = (1u32 << (hex.len() * 4)) - 1;
+    Some(((v * 255 + max / 2) / max) as u8)
+}
+
+fn named(name: &str) -> Option<[u8; 3]> {
+    let s = name.to_ascii_lowercase().replace([' ', '-', '_'], "");
+    // XPM imports X11 names, whose RGB values differ from CSS for names
+    // such as gray, maroon and purple. Keep these exact rather than guessing.
+    if let Ok(index) = x11_colors::X11_COLORS.binary_search_by_key(&s.as_str(), |(name, _)| *name) {
+        return Some(x11_colors::X11_COLORS[index].1);
+    }
+    // Retain useful web color aliases not present in the X11 database.
+    Some(match s.as_str() {
+        "silver" => [192, 192, 192],
+        "olive" => [128, 128, 0],
+        "teal" => [0, 128, 128],
+        "fuchsia" => [255, 0, 255],
+        "navyblue" => [0, 0, 128],
+        _ => return None,
+    })
+}
+
+fn color(name: &str) -> Option<[u8; 4]> {
+    if name.eq_ignore_ascii_case("none") {
+        return Some([0, 0, 0, 0]);
+    }
+    let rgb = if let Some(hex) = name.strip_prefix('#') {
+        // UTF-8 byte lengths can match a supported hex width while slicing would panic.
+        // `from_str_radix` would also take a leading `+`: accept hex digits only.
+        if !hex.bytes().all(|b| b.is_ascii_hexdigit()) {
+            return None;
+        }
+        let digits = match hex.len() {
+            3 => 1,
+            6 => 2,
+            12 => 4,
+            _ => return None,
+        };
+        let rgb = (0..3).map(|i| channel(&hex[i * digits..(i + 1) * digits])).collect::<Option<Vec<_>>>()?;
+        [rgb[0], rgb[1], rgb[2]]
+    } else {
+        named(name)?
+    };
+    Some([rgb[0], rgb[1], rgb[2], 255])
+}
+
+pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
+    if bytes.len() > MAX_SOURCE {
+        return Err(CodecError::LimitExceeded("XPM source exceeds 256 MiB".into()));
+    }
+    let lines = if bytes.starts_with(b"/* XPM */") {
+        c_strings(bytes)?
+    } else if bytes.starts_with(b"! XPM2\n") || bytes.starts_with(b"! XPM2\r\n") {
+        xpm2_lines(bytes)?
+    } else {
+        return Err(bad("not an XPM2/XPM3 image"));
+    };
+    decode_lines(&lines, limits)
+}
+
+fn decode_lines(lines: &[Vec<u8>], limits: &Limits) -> Result<Image, CodecError> {
+    let header = lines.first().ok_or_else(|| bad("missing image header"))?;
+    let parts = std::str::from_utf8(header).map_err(|_| bad("non-UTF-8 XPM header"))?;
+    let mut parts = parts.split_ascii_whitespace();
+    let number = |key: &str, s: Option<&str>| -> Result<usize, CodecError> {
+        s.ok_or_else(|| bad(format!("missing {key}")))?.parse::<usize>().map_err(|_| bad(format!("invalid {key}")))
+    };
+    let width = number("width", parts.next())?;
+    let height = number("height", parts.next())?;
+    let colours = number("palette size", parts.next())?;
+    let cpp = number("chars per pixel", parts.next())?;
+    if width == 0 || height == 0 || colours == 0 || colours > MAX_COLOURS || !(1..=MAX_CPP).contains(&cpp) {
+        return Err(bad("invalid XPM dimensions, palette size or chars per pixel"));
+    }
+    let (w, h) = (u32::try_from(width).map_err(|_| bad("width overflow"))?, u32::try_from(height).map_err(|_| bad("height overflow"))?);
+    limits.check(w, h, ChannelLayout::Rgba, SampleType::U8)?;
+    let required = 1usize.checked_add(colours).and_then(|n| n.checked_add(height)).ok_or_else(|| bad("row count overflow"))?;
+    if lines.len() < required {
+        return Err(bad("truncated palette or image rows"));
+    }
+    let mut palette = HashMap::<Vec<u8>, [u8; 4]>::with_capacity(colours);
+    for line in &lines[1..1 + colours] {
+        if line.len() < cpp {
+            return Err(bad("truncated colour key"));
+        }
+        let fields = std::str::from_utf8(&line[cpp..]).map_err(|_| bad("invalid colour name"))?;
+        // XPM priority is colour, gray, four-level gray, then monochrome,
+        // regardless of the order of keys in the palette entry.
+        let terms: Vec<&str> = fields.split_ascii_whitespace().collect();
+        let mut picked: Option<(u8, String)> = None;
+        let mut i = 0;
+        while i < terms.len() {
+            let priority = match terms[i] {
+                "c" => 4,
+                "g" => 3,
+                "g4" => 2,
+                "m" => 1,
+                _ => 0, // Symbolic names ('s') are not colour values.
+            };
+            let start = i + 1;
+            i = start;
+            while i < terms.len() && !matches!(terms[i], "c" | "g" | "g4" | "m" | "s") {
+                i += 1;
+            }
+            if priority > 0 && i > start && picked.as_ref().is_none_or(|(current, _)| priority > *current) {
+                picked = Some((priority, terms[start..i].join(" ")));
+            }
+        }
+        let value = picked.as_ref().and_then(|(_, name)| color(name)).ok_or_else(|| bad("unsupported or missing XPM colour"))?;
+        if palette.insert(line[..cpp].to_vec(), value).is_some() {
+            return Err(bad("duplicate XPM palette key"));
+        }
+    }
+    let row_len = width.checked_mul(cpp).ok_or_else(|| bad("row byte count overflow"))?;
+    let mut pixels = vec![0u8; width.checked_mul(height).and_then(|n| n.checked_mul(4)).ok_or_else(|| bad("pixel size overflow"))?];
+    for (y, line) in lines[1 + colours..required].iter().enumerate() {
+        if line.len() != row_len {
+            return Err(bad("XPM row has the wrong width"));
+        }
+        for x in 0..width {
+            let key = &line[x * cpp..(x + 1) * cpp];
+            let rgba = palette.get(key).ok_or_else(|| bad("unknown palette key"))?;
+            pixels[(y * width + x) * 4..(y * width + x + 1) * 4].copy_from_slice(rgba);
+        }
+    }
+    Image::from_u8(w, h, ChannelLayout::Rgba, pixels)
+}
diff --git a/crates/codecs/src/codecs/xpm/x11_colors.rs b/crates/codecs/src/codecs/xpm/x11_colors.rs
new file mode 100644
index 0000000000..1d47b37061
--- /dev/null
+++ b/crates/codecs/src/codecs/xpm/x11_colors.rs
@@ -0,0 +1,666 @@
+//! X11 color-name database (X.Org rgb.txt) normalized to lowercase without
+//! spaces, underscores, or hyphens. RGB values are *X11* values, not CSS values.
+//! Source: https://cgit.freedesktop.org/xorg/app/rgb/tree/rgb.txt
+//! License: MIT (X.Org Foundation), see the upstream app/rgb COPYING file.
+//! Aliases differing only in case or spaces have been collapsed.
+//! Keep sorted: decoder uses binary search without allocation per candidate.
+
+pub(super) const X11_COLORS: &[(&str, [u8; 3])] = &[
+    ("aliceblue", [240, 248, 255]),
+    ("antiquewhite", [250, 235, 215]),
+    ("antiquewhite1", [255, 239, 219]),
+    ("antiquewhite2", [238, 223, 204]),
+    ("antiquewhite3", [205, 192, 176]),
+    ("antiquewhite4", [139, 131, 120]),
+    ("aquamarine", [127, 255, 212]),
+    ("aquamarine1", [127, 255, 212]),
+    ("aquamarine2", [118, 238, 198]),
+    ("aquamarine3", [102, 205, 170]),
+    ("aquamarine4", [69, 139, 116]),
+    ("azure", [240, 255, 255]),
+    ("azure1", [240, 255, 255]),
+    ("azure2", [224, 238, 238]),
+    ("azure3", [193, 205, 205]),
+    ("azure4", [131, 139, 139]),
+    ("beige", [245, 245, 220]),
+    ("bisque", [255, 228, 196]),
+    ("bisque1", [255, 228, 196]),
+    ("bisque2", [238, 213, 183]),
+    ("bisque3", [205, 183, 158]),
+    ("bisque4", [139, 125, 107]),
+    ("black", [0, 0, 0]),
+    ("blanchedalmond", [255, 235, 205]),
+    ("blue", [0, 0, 255]),
+    ("blue1", [0, 0, 255]),
+    ("blue2", [0, 0, 238]),
+    ("blue3", [0, 0, 205]),
+    ("blue4", [0, 0, 139]),
+    ("blueviolet", [138, 43, 226]),
+    ("brown", [165, 42, 42]),
+    ("brown1", [255, 64, 64]),
+    ("brown2", [238, 59, 59]),
+    ("brown3", [205, 51, 51]),
+    ("brown4", [139, 35, 35]),
+    ("burlywood", [222, 184, 135]),
+    ("burlywood1", [255, 211, 155]),
+    ("burlywood2", [238, 197, 145]),
+    ("burlywood3", [205, 170, 125]),
+    ("burlywood4", [139, 115, 85]),
+    ("cadetblue", [95, 158, 160]),
+    ("cadetblue1", [152, 245, 255]),
+    ("cadetblue2", [142, 229, 238]),
+    ("cadetblue3", [122, 197, 205]),
+    ("cadetblue4", [83, 134, 139]),
+    ("chartreuse", [127, 255, 0]),
+    ("chartreuse1", [127, 255, 0]),
+    ("chartreuse2", [118, 238, 0]),
+    ("chartreuse3", [102, 205, 0]),
+    ("chartreuse4", [69, 139, 0]),
+    ("chocolate", [210, 105, 30]),
+    ("chocolate1", [255, 127, 36]),
+    ("chocolate2", [238, 118, 33]),
+    ("chocolate3", [205, 102, 29]),
+    ("chocolate4", [139, 69, 19]),
+    ("coral", [255, 127, 80]),
+    ("coral1", [255, 114, 86]),
+    ("coral2", [238, 106, 80]),
+    ("coral3", [205, 91, 69]),
+    ("coral4", [139, 62, 47]),
+    ("cornflowerblue", [100, 149, 237]),
+    ("cornsilk", [255, 248, 220]),
+    ("cornsilk1", [255, 248, 220]),
+    ("cornsilk2", [238, 232, 205]),
+    ("cornsilk3", [205, 200, 177]),
+    ("cornsilk4", [139, 136, 120]),
+    ("cyan", [0, 255, 255]),
+    ("cyan1", [0, 255, 255]),
+    ("cyan2", [0, 238, 238]),
+    ("cyan3", [0, 205, 205]),
+    ("cyan4", [0, 139, 139]),
+    ("darkblue", [0, 0, 139]),
+    ("darkcyan", [0, 139, 139]),
+    ("darkgoldenrod", [184, 134, 11]),
+    ("darkgoldenrod1", [255, 185, 15]),
+    ("darkgoldenrod2", [238, 173, 14]),
+    ("darkgoldenrod3", [205, 149, 12]),
+    ("darkgoldenrod4", [139, 101, 8]),
+    ("darkgray", [169, 169, 169]),
+    ("darkgreen", [0, 100, 0]),
+    ("darkgrey", [169, 169, 169]),
+    ("darkkhaki", [189, 183, 107]),
+    ("darkmagenta", [139, 0, 139]),
+    ("darkolivegreen", [85, 107, 47]),
+    ("darkolivegreen1", [202, 255, 112]),
+    ("darkolivegreen2", [188, 238, 104]),
+    ("darkolivegreen3", [162, 205, 90]),
+    ("darkolivegreen4", [110, 139, 61]),
+    ("darkorange", [255, 140, 0]),
+    ("darkorange1", [255, 127, 0]),
+    ("darkorange2", [238, 118, 0]),
+    ("darkorange3", [205, 102, 0]),
+    ("darkorange4", [139, 69, 0]),
+    ("darkorchid", [153, 50, 204]),
+    ("darkorchid1", [191, 62, 255]),
+    ("darkorchid2", [178, 58, 238]),
+    ("darkorchid3", [154, 50, 205]),
+    ("darkorchid4", [104, 34, 139]),
+    ("darkred", [139, 0, 0]),
+    ("darksalmon", [233, 150, 122]),
+    ("darkseagreen", [143, 188, 143]),
+    ("darkseagreen1", [193, 255, 193]),
+    ("darkseagreen2", [180, 238, 180]),
+    ("darkseagreen3", [155, 205, 155]),
+    ("darkseagreen4", [105, 139, 105]),
+    ("darkslateblue", [72, 61, 139]),
+    ("darkslategray", [47, 79, 79]),
+    ("darkslategray1", [151, 255, 255]),
+    ("darkslategray2", [141, 238, 238]),
+    ("darkslategray3", [121, 205, 205]),
+    ("darkslategray4", [82, 139, 139]),
+    ("darkslategrey", [47, 79, 79]),
+    ("darkturquoise", [0, 206, 209]),
+    ("darkviolet", [148, 0, 211]),
+    ("deeppink", [255, 20, 147]),
+    ("deeppink1", [255, 20, 147]),
+    ("deeppink2", [238, 18, 137]),
+    ("deeppink3", [205, 16, 118]),
+    ("deeppink4", [139, 10, 80]),
+    ("deepskyblue", [0, 191, 255]),
+    ("deepskyblue1", [0, 191, 255]),
+    ("deepskyblue2", [0, 178, 238]),
+    ("deepskyblue3", [0, 154, 205]),
+    ("deepskyblue4", [0, 104, 139]),
+    ("dimgray", [105, 105, 105]),
+    ("dimgrey", [105, 105, 105]),
+    ("dodgerblue", [30, 144, 255]),
+    ("dodgerblue1", [30, 144, 255]),
+    ("dodgerblue2", [28, 134, 238]),
+    ("dodgerblue3", [24, 116, 205]),
+    ("dodgerblue4", [16, 78, 139]),
+    ("firebrick", [178, 34, 34]),
+    ("firebrick1", [255, 48, 48]),
+    ("firebrick2", [238, 44, 44]),
+    ("firebrick3", [205, 38, 38]),
+    ("firebrick4", [139, 26, 26]),
+    ("floralwhite", [255, 250, 240]),
+    ("forestgreen", [34, 139, 34]),
+    ("gainsboro", [220, 220, 220]),
+    ("ghostwhite", [248, 248, 255]),
+    ("gold", [255, 215, 0]),
+    ("gold1", [255, 215, 0]),
+    ("gold2", [238, 201, 0]),
+    ("gold3", [205, 173, 0]),
+    ("gold4", [139, 117, 0]),
+    ("goldenrod", [218, 165, 32]),
+    ("goldenrod1", [255, 193, 37]),
+    ("goldenrod2", [238, 180, 34]),
+    ("goldenrod3", [205, 155, 29]),
+    ("goldenrod4", [139, 105, 20]),
+    ("gray", [190, 190, 190]),
+    ("gray0", [0, 0, 0]),
+    ("gray1", [3, 3, 3]),
+    ("gray10", [26, 26, 26]),
+    ("gray100", [255, 255, 255]),
+    ("gray11", [28, 28, 28]),
+    ("gray12", [31, 31, 31]),
+    ("gray13", [33, 33, 33]),
+    ("gray14", [36, 36, 36]),
+    ("gray15", [38, 38, 38]),
+    ("gray16", [41, 41, 41]),
+    ("gray17", [43, 43, 43]),
+    ("gray18", [46, 46, 46]),
+    ("gray19", [48, 48, 48]),
+    ("gray2", [5, 5, 5]),
+    ("gray20", [51, 51, 51]),
+    ("gray21", [54, 54, 54]),
+    ("gray22", [56, 56, 56]),
+    ("gray23", [59, 59, 59]),
+    ("gray24", [61, 61, 61]),
+    ("gray25", [64, 64, 64]),
+    ("gray26", [66, 66, 66]),
+    ("gray27", [69, 69, 69]),
+    ("gray28", [71, 71, 71]),
+    ("gray29", [74, 74, 74]),
+    ("gray3", [8, 8, 8]),
+    ("gray30", [77, 77, 77]),
+    ("gray31", [79, 79, 79]),
+    ("gray32", [82, 82, 82]),
+    ("gray33", [84, 84, 84]),
+    ("gray34", [87, 87, 87]),
+    ("gray35", [89, 89, 89]),
+    ("gray36", [92, 92, 92]),
+    ("gray37", [94, 94, 94]),
+    ("gray38", [97, 97, 97]),
+    ("gray39", [99, 99, 99]),
+    ("gray4", [10, 10, 10]),
+    ("gray40", [102, 102, 102]),
+    ("gray41", [105, 105, 105]),
+    ("gray42", [107, 107, 107]),
+    ("gray43", [110, 110, 110]),
+    ("gray44", [112, 112, 112]),
+    ("gray45", [115, 115, 115]),
+    ("gray46", [117, 117, 117]),
+    ("gray47", [120, 120, 120]),
+    ("gray48", [122, 122, 122]),
+    ("gray49", [125, 125, 125]),
+    ("gray5", [13, 13, 13]),
+    ("gray50", [127, 127, 127]),
+    ("gray51", [130, 130, 130]),
+    ("gray52", [133, 133, 133]),
+    ("gray53", [135, 135, 135]),
+    ("gray54", [138, 138, 138]),
+    ("gray55", [140, 140, 140]),
+    ("gray56", [143, 143, 143]),
+    ("gray57", [145, 145, 145]),
+    ("gray58", [148, 148, 148]),
+    ("gray59", [150, 150, 150]),
+    ("gray6", [15, 15, 15]),
+    ("gray60", [153, 153, 153]),
+    ("gray61", [156, 156, 156]),
+    ("gray62", [158, 158, 158]),
+    ("gray63", [161, 161, 161]),
+    ("gray64", [163, 163, 163]),
+    ("gray65", [166, 166, 166]),
+    ("gray66", [168, 168, 168]),
+    ("gray67", [171, 171, 171]),
+    ("gray68", [173, 173, 173]),
+    ("gray69", [176, 176, 176]),
+    ("gray7", [18, 18, 18]),
+    ("gray70", [179, 179, 179]),
+    ("gray71", [181, 181, 181]),
+    ("gray72", [184, 184, 184]),
+    ("gray73", [186, 186, 186]),
+    ("gray74", [189, 189, 189]),
+    ("gray75", [191, 191, 191]),
+    ("gray76", [194, 194, 194]),
+    ("gray77", [196, 196, 196]),
+    ("gray78", [199, 199, 199]),
+    ("gray79", [201, 201, 201]),
+    ("gray8", [20, 20, 20]),
+    ("gray80", [204, 204, 204]),
+    ("gray81", [207, 207, 207]),
+    ("gray82", [209, 209, 209]),
+    ("gray83", [212, 212, 212]),
+    ("gray84", [214, 214, 214]),
+    ("gray85", [217, 217, 217]),
+    ("gray86", [219, 219, 219]),
+    ("gray87", [222, 222, 222]),
+    ("gray88", [224, 224, 224]),
+    ("gray89", [227, 227, 227]),
+    ("gray9", [23, 23, 23]),
+    ("gray90", [229, 229, 229]),
+    ("gray91", [232, 232, 232]),
+    ("gray92", [235, 235, 235]),
+    ("gray93", [237, 237, 237]),
+    ("gray94", [240, 240, 240]),
+    ("gray95", [242, 242, 242]),
+    ("gray96", [245, 245, 245]),
+    ("gray97", [247, 247, 247]),
+    ("gray98", [250, 250, 250]),
+    ("gray99", [252, 252, 252]),
+    ("green", [0, 255, 0]),
+    ("green1", [0, 255, 0]),
+    ("green2", [0, 238, 0]),
+    ("green3", [0, 205, 0]),
+    ("green4", [0, 139, 0]),
+    ("greenyellow", [173, 255, 47]),
+    ("grey", [190, 190, 190]),
+    ("grey0", [0, 0, 0]),
+    ("grey1", [3, 3, 3]),
+    ("grey10", [26, 26, 26]),
+    ("grey100", [255, 255, 255]),
+    ("grey11", [28, 28, 28]),
+    ("grey12", [31, 31, 31]),
+    ("grey13", [33, 33, 33]),
+    ("grey14", [36, 36, 36]),
+    ("grey15", [38, 38, 38]),
+    ("grey16", [41, 41, 41]),
+    ("grey17", [43, 43, 43]),
+    ("grey18", [46, 46, 46]),
+    ("grey19", [48, 48, 48]),
+    ("grey2", [5, 5, 5]),
+    ("grey20", [51, 51, 51]),
+    ("grey21", [54, 54, 54]),
+    ("grey22", [56, 56, 56]),
+    ("grey23", [59, 59, 59]),
+    ("grey24", [61, 61, 61]),
+    ("grey25", [64, 64, 64]),
+    ("grey26", [66, 66, 66]),
+    ("grey27", [69, 69, 69]),
+    ("grey28", [71, 71, 71]),
+    ("grey29", [74, 74, 74]),
+    ("grey3", [8, 8, 8]),
+    ("grey30", [77, 77, 77]),
+    ("grey31", [79, 79, 79]),
+    ("grey32", [82, 82, 82]),
+    ("grey33", [84, 84, 84]),
+    ("grey34", [87, 87, 87]),
+    ("grey35", [89, 89, 89]),
+    ("grey36", [92, 92, 92]),
+    ("grey37", [94, 94, 94]),
+    ("grey38", [97, 97, 97]),
+    ("grey39", [99, 99, 99]),
+    ("grey4", [10, 10, 10]),
+    ("grey40", [102, 102, 102]),
+    ("grey41", [105, 105, 105]),
+    ("grey42", [107, 107, 107]),
+    ("grey43", [110, 110, 110]),
+    ("grey44", [112, 112, 112]),
+    ("grey45", [115, 115, 115]),
+    ("grey46", [117, 117, 117]),
+    ("grey47", [120, 120, 120]),
+    ("grey48", [122, 122, 122]),
+    ("grey49", [125, 125, 125]),
+    ("grey5", [13, 13, 13]),
+    ("grey50", [127, 127, 127]),
+    ("grey51", [130, 130, 130]),
+    ("grey52", [133, 133, 133]),
+    ("grey53", [135, 135, 135]),
+    ("grey54", [138, 138, 138]),
+    ("grey55", [140, 140, 140]),
+    ("grey56", [143, 143, 143]),
+    ("grey57", [145, 145, 145]),
+    ("grey58", [148, 148, 148]),
+    ("grey59", [150, 150, 150]),
+    ("grey6", [15, 15, 15]),
+    ("grey60", [153, 153, 153]),
+    ("grey61", [156, 156, 156]),
+    ("grey62", [158, 158, 158]),
+    ("grey63", [161, 161, 161]),
+    ("grey64", [163, 163, 163]),
+    ("grey65", [166, 166, 166]),
+    ("grey66", [168, 168, 168]),
+    ("grey67", [171, 171, 171]),
+    ("grey68", [173, 173, 173]),
+    ("grey69", [176, 176, 176]),
+    ("grey7", [18, 18, 18]),
+    ("grey70", [179, 179, 179]),
+    ("grey71", [181, 181, 181]),
+    ("grey72", [184, 184, 184]),
+    ("grey73", [186, 186, 186]),
+    ("grey74", [189, 189, 189]),
+    ("grey75", [191, 191, 191]),
+    ("grey76", [194, 194, 194]),
+    ("grey77", [196, 196, 196]),
+    ("grey78", [199, 199, 199]),
+    ("grey79", [201, 201, 201]),
+    ("grey8", [20, 20, 20]),
+    ("grey80", [204, 204, 204]),
+    ("grey81", [207, 207, 207]),
+    ("grey82", [209, 209, 209]),
+    ("grey83", [212, 212, 212]),
+    ("grey84", [214, 214, 214]),
+    ("grey85", [217, 217, 217]),
+    ("grey86", [219, 219, 219]),
+    ("grey87", [222, 222, 222]),
+    ("grey88", [224, 224, 224]),
+    ("grey89", [227, 227, 227]),
+    ("grey9", [23, 23, 23]),
+    ("grey90", [229, 229, 229]),
+    ("grey91", [232, 232, 232]),
+    ("grey92", [235, 235, 235]),
+    ("grey93", [237, 237, 237]),
+    ("grey94", [240, 240, 240]),
+    ("grey95", [242, 242, 242]),
+    ("grey96", [245, 245, 245]),
+    ("grey97", [247, 247, 247]),
+    ("grey98", [250, 250, 250]),
+    ("grey99", [252, 252, 252]),
+    ("honeydew", [240, 255, 240]),
+    ("honeydew1", [240, 255, 240]),
+    ("honeydew2", [224, 238, 224]),
+    ("honeydew3", [193, 205, 193]),
+    ("honeydew4", [131, 139, 131]),
+    ("hotpink", [255, 105, 180]),
+    ("hotpink1", [255, 110, 180]),
+    ("hotpink2", [238, 106, 167]),
+    ("hotpink3", [205, 96, 144]),
+    ("hotpink4", [139, 58, 98]),
+    ("indianred", [205, 92, 92]),
+    ("indianred1", [255, 106, 106]),
+    ("indianred2", [238, 99, 99]),
+    ("indianred3", [205, 85, 85]),
+    ("indianred4", [139, 58, 58]),
+    ("ivory", [255, 255, 240]),
+    ("ivory1", [255, 255, 240]),
+    ("ivory2", [238, 238, 224]),
+    ("ivory3", [205, 205, 193]),
+    ("ivory4", [139, 139, 131]),
+    ("khaki", [240, 230, 140]),
+    ("khaki1", [255, 246, 143]),
+    ("khaki2", [238, 230, 133]),
+    ("khaki3", [205, 198, 115]),
+    ("khaki4", [139, 134, 78]),
+    ("lavender", [230, 230, 250]),
+    ("lavenderblush", [255, 240, 245]),
+    ("lavenderblush1", [255, 240, 245]),
+    ("lavenderblush2", [238, 224, 229]),
+    ("lavenderblush3", [205, 193, 197]),
+    ("lavenderblush4", [139, 131, 134]),
+    ("lawngreen", [124, 252, 0]),
+    ("lemonchiffon", [255, 250, 205]),
+    ("lemonchiffon1", [255, 250, 205]),
+    ("lemonchiffon2", [238, 233, 191]),
+    ("lemonchiffon3", [205, 201, 165]),
+    ("lemonchiffon4", [139, 137, 112]),
+    ("lightblue", [173, 216, 230]),
+    ("lightblue1", [191, 239, 255]),
+    ("lightblue2", [178, 223, 238]),
+    ("lightblue3", [154, 192, 205]),
+    ("lightblue4", [104, 131, 139]),
+    ("lightcoral", [240, 128, 128]),
+    ("lightcyan", [224, 255, 255]),
+    ("lightcyan1", [224, 255, 255]),
+    ("lightcyan2", [209, 238, 238]),
+    ("lightcyan3", [180, 205, 205]),
+    ("lightcyan4", [122, 139, 139]),
+    ("lightgoldenrod", [238, 221, 130]),
+    ("lightgoldenrod1", [255, 236, 139]),
+    ("lightgoldenrod2", [238, 220, 130]),
+    ("lightgoldenrod3", [205, 190, 112]),
+    ("lightgoldenrod4", [139, 129, 76]),
+    ("lightgoldenrodyellow", [250, 250, 210]),
+    ("lightgray", [211, 211, 211]),
+    ("lightgreen", [144, 238, 144]),
+    ("lightgrey", [211, 211, 211]),
+    ("lightpink", [255, 182, 193]),
+    ("lightpink1", [255, 174, 185]),
+    ("lightpink2", [238, 162, 173]),
+    ("lightpink3", [205, 140, 149]),
+    ("lightpink4", [139, 95, 101]),
+    ("lightsalmon", [255, 160, 122]),
+    ("lightsalmon1", [255, 160, 122]),
+    ("lightsalmon2", [238, 149, 114]),
+    ("lightsalmon3", [205, 129, 98]),
+    ("lightsalmon4", [139, 87, 66]),
+    ("lightseagreen", [32, 178, 170]),
+    ("lightskyblue", [135, 206, 250]),
+    ("lightskyblue1", [176, 226, 255]),
+    ("lightskyblue2", [164, 211, 238]),
+    ("lightskyblue3", [141, 182, 205]),
+    ("lightskyblue4", [96, 123, 139]),
+    ("lightslateblue", [132, 112, 255]),
+    ("lightslategray", [119, 136, 153]),
+    ("lightslategrey", [119, 136, 153]),
+    ("lightsteelblue", [176, 196, 222]),
+    ("lightsteelblue1", [202, 225, 255]),
+    ("lightsteelblue2", [188, 210, 238]),
+    ("lightsteelblue3", [162, 181, 205]),
+    ("lightsteelblue4", [110, 123, 139]),
+    ("lightyellow", [255, 255, 224]),
+    ("lightyellow1", [255, 255, 224]),
+    ("lightyellow2", [238, 238, 209]),
+    ("lightyellow3", [205, 205, 180]),
+    ("lightyellow4", [139, 139, 122]),
+    ("limegreen", [50, 205, 50]),
+    ("linen", [250, 240, 230]),
+    ("magenta", [255, 0, 255]),
+    ("magenta1", [255, 0, 255]),
+    ("magenta2", [238, 0, 238]),
+    ("magenta3", [205, 0, 205]),
+    ("magenta4", [139, 0, 139]),
+    ("maroon", [176, 48, 96]),
+    ("maroon1", [255, 52, 179]),
+    ("maroon2", [238, 48, 167]),
+    ("maroon3", [205, 41, 144]),
+    ("maroon4", [139, 28, 98]),
+    ("mediumaquamarine", [102, 205, 170]),
+    ("mediumblue", [0, 0, 205]),
+    ("mediumorchid", [186, 85, 211]),
+    ("mediumorchid1", [224, 102, 255]),
+    ("mediumorchid2", [209, 95, 238]),
+    ("mediumorchid3", [180, 82, 205]),
+    ("mediumorchid4", [122, 55, 139]),
+    ("mediumpurple", [147, 112, 219]),
+    ("mediumpurple1", [171, 130, 255]),
+    ("mediumpurple2", [159, 121, 238]),
+    ("mediumpurple3", [137, 104, 205]),
+    ("mediumpurple4", [93, 71, 139]),
+    ("mediumseagreen", [60, 179, 113]),
+    ("mediumslateblue", [123, 104, 238]),
+    ("mediumspringgreen", [0, 250, 154]),
+    ("mediumturquoise", [72, 209, 204]),
+    ("mediumvioletred", [199, 21, 133]),
+    ("midnightblue", [25, 25, 112]),
+    ("mintcream", [245, 255, 250]),
+    ("mistyrose", [255, 228, 225]),
+    ("mistyrose1", [255, 228, 225]),
+    ("mistyrose2", [238, 213, 210]),
+    ("mistyrose3", [205, 183, 181]),
+    ("mistyrose4", [139, 125, 123]),
+    ("moccasin", [255, 228, 181]),
+    ("navajowhite", [255, 222, 173]),
+    ("navajowhite1", [255, 222, 173]),
+    ("navajowhite2", [238, 207, 161]),
+    ("navajowhite3", [205, 179, 139]),
+    ("navajowhite4", [139, 121, 94]),
+    ("navy", [0, 0, 128]),
+    ("navyblue", [0, 0, 128]),
+    ("oldlace", [253, 245, 230]),
+    ("olivedrab", [107, 142, 35]),
+    ("olivedrab1", [192, 255, 62]),
+    ("olivedrab2", [179, 238, 58]),
+    ("olivedrab3", [154, 205, 50]),
+    ("olivedrab4", [105, 139, 34]),
+    ("orange", [255, 165, 0]),
+    ("orange1", [255, 165, 0]),
+    ("orange2", [238, 154, 0]),
+    ("orange3", [205, 133, 0]),
+    ("orange4", [139, 90, 0]),
+    ("orangered", [255, 69, 0]),
+    ("orangered1", [255, 69, 0]),
+    ("orangered2", [238, 64, 0]),
+    ("orangered3", [205, 55, 0]),
+    ("orangered4", [139, 37, 0]),
+    ("orchid", [218, 112, 214]),
+    ("orchid1", [255, 131, 250]),
+    ("orchid2", [238, 122, 233]),
+    ("orchid3", [205, 105, 201]),
+    ("orchid4", [139, 71, 137]),
+    ("palegoldenrod", [238, 232, 170]),
+    ("palegreen", [152, 251, 152]),
+    ("palegreen1", [154, 255, 154]),
+    ("palegreen2", [144, 238, 144]),
+    ("palegreen3", [124, 205, 124]),
+    ("palegreen4", [84, 139, 84]),
+    ("paleturquoise", [175, 238, 238]),
+    ("paleturquoise1", [187, 255, 255]),
+    ("paleturquoise2", [174, 238, 238]),
+    ("paleturquoise3", [150, 205, 205]),
+    ("paleturquoise4", [102, 139, 139]),
+    ("palevioletred", [219, 112, 147]),
+    ("palevioletred1", [255, 130, 171]),
+    ("palevioletred2", [238, 121, 159]),
+    ("palevioletred3", [205, 104, 137]),
+    ("palevioletred4", [139, 71, 93]),
+    ("papayawhip", [255, 239, 213]),
+    ("peachpuff", [255, 218, 185]),
+    ("peachpuff1", [255, 218, 185]),
+    ("peachpuff2", [238, 203, 173]),
+    ("peachpuff3", [205, 175, 149]),
+    ("peachpuff4", [139, 119, 101]),
+    ("peru", [205, 133, 63]),
+    ("pink", [255, 192, 203]),
+    ("pink1", [255, 181, 197]),
+    ("pink2", [238, 169, 184]),
+    ("pink3", [205, 145, 158]),
+    ("pink4", [139, 99, 108]),
+    ("plum", [221, 160, 221]),
+    ("plum1", [255, 187, 255]),
+    ("plum2", [238, 174, 238]),
+    ("plum3", [205, 150, 205]),
+    ("plum4", [139, 102, 139]),
+    ("powderblue", [176, 224, 230]),
+    ("purple", [160, 32, 240]),
+    ("purple1", [155, 48, 255]),
+    ("purple2", [145, 44, 238]),
+    ("purple3", [125, 38, 205]),
+    ("purple4", [85, 26, 139]),
+    ("red", [255, 0, 0]),
+    ("red1", [255, 0, 0]),
+    ("red2", [238, 0, 0]),
+    ("red3", [205, 0, 0]),
+    ("red4", [139, 0, 0]),
+    ("rosybrown", [188, 143, 143]),
+    ("rosybrown1", [255, 193, 193]),
+    ("rosybrown2", [238, 180, 180]),
+    ("rosybrown3", [205, 155, 155]),
+    ("rosybrown4", [139, 105, 105]),
+    ("royalblue", [65, 105, 225]),
+    ("royalblue1", [72, 118, 255]),
+    ("royalblue2", [67, 110, 238]),
+    ("royalblue3", [58, 95, 205]),
+    ("royalblue4", [39, 64, 139]),
+    ("saddlebrown", [139, 69, 19]),
+    ("salmon", [250, 128, 114]),
+    ("salmon1", [255, 140, 105]),
+    ("salmon2", [238, 130, 98]),
+    ("salmon3", [205, 112, 84]),
+    ("salmon4", [139, 76, 57]),
+    ("sandybrown", [244, 164, 96]),
+    ("seagreen", [46, 139, 87]),
+    ("seagreen1", [84, 255, 159]),
+    ("seagreen2", [78, 238, 148]),
+    ("seagreen3", [67, 205, 128]),
+    ("seagreen4", [46, 139, 87]),
+    ("seashell", [255, 245, 238]),
+    ("seashell1", [255, 245, 238]),
+    ("seashell2", [238, 229, 222]),
+    ("seashell3", [205, 197, 191]),
+    ("seashell4", [139, 134, 130]),
+    ("sienna", [160, 82, 45]),
+    ("sienna1", [255, 130, 71]),
+    ("sienna2", [238, 121, 66]),
+    ("sienna3", [205, 104, 57]),
+    ("sienna4", [139, 71, 38]),
+    ("skyblue", [135, 206, 235]),
+    ("skyblue1", [135, 206, 255]),
+    ("skyblue2", [126, 192, 238]),
+    ("skyblue3", [108, 166, 205]),
+    ("skyblue4", [74, 112, 139]),
+    ("slateblue", [106, 90, 205]),
+    ("slateblue1", [131, 111, 255]),
+    ("slateblue2", [122, 103, 238]),
+    ("slateblue3", [105, 89, 205]),
+    ("slateblue4", [71, 60, 139]),
+    ("slategray", [112, 128, 144]),
+    ("slategray1", [198, 226, 255]),
+    ("slategray2", [185, 211, 238]),
+    ("slategray3", [159, 182, 205]),
+    ("slategray4", [108, 123, 139]),
+    ("slategrey", [112, 128, 144]),
+    ("snow", [255, 250, 250]),
+    ("snow1", [255, 250, 250]),
+    ("snow2", [238, 233, 233]),
+    ("snow3", [205, 201, 201]),
+    ("snow4", [139, 137, 137]),
+    ("springgreen", [0, 255, 127]),
+    ("springgreen1", [0, 255, 127]),
+    ("springgreen2", [0, 238, 118]),
+    ("springgreen3", [0, 205, 102]),
+    ("springgreen4", [0, 139, 69]),
+    ("steelblue", [70, 130, 180]),
+    ("steelblue1", [99, 184, 255]),
+    ("steelblue2", [92, 172, 238]),
+    ("steelblue3", [79, 148, 205]),
+    ("steelblue4", [54, 100, 139]),
+    ("tan", [210, 180, 140]),
+    ("tan1", [255, 165, 79]),
+    ("tan2", [238, 154, 73]),
+    ("tan3", [205, 133, 63]),
+    ("tan4", [139, 90, 43]),
+    ("thistle", [216, 191, 216]),
+    ("thistle1", [255, 225, 255]),
+    ("thistle2", [238, 210, 238]),
+    ("thistle3", [205, 181, 205]),
+    ("thistle4", [139, 123, 139]),
+    ("tomato", [255, 99, 71]),
+    ("tomato1", [255, 99, 71]),
+    ("tomato2", [238, 92, 66]),
+    ("tomato3", [205, 79, 57]),
+    ("tomato4", [139, 54, 38]),
+    ("turquoise", [64, 224, 208]),
+    ("turquoise1", [0, 245, 255]),
+    ("turquoise2", [0, 229, 238]),
+    ("turquoise3", [0, 197, 205]),
+    ("turquoise4", [0, 134, 139]),
+    ("violet", [238, 130, 238]),
+    ("violetred", [208, 32, 144]),
+    ("violetred1", [255, 62, 150]),
+    ("violetred2", [238, 58, 140]),
+    ("violetred3", [205, 50, 120]),
+    ("violetred4", [139, 34, 82]),
+    ("wheat", [245, 222, 179]),
+    ("wheat1", [255, 231, 186]),
+    ("wheat2", [238, 216, 174]),
+    ("wheat3", [205, 186, 150]),
+    ("wheat4", [139, 126, 102]),
+    ("white", [255, 255, 255]),
+    ("whitesmoke", [245, 245, 245]),
+    ("yellow", [255, 255, 0]),
+    ("yellow1", [255, 255, 0]),
+    ("yellow2", [238, 238, 0]),
+    ("yellow3", [205, 205, 0]),
+    ("yellow4", [139, 139, 0]),
+    ("yellowgreen", [154, 205, 50]),
+];
diff --git a/crates/codecs/src/fidelity.rs b/crates/codecs/src/fidelity.rs
index 720f9421a2..d5654d27a0 100644
--- a/crates/codecs/src/fidelity.rs
+++ b/crates/codecs/src/fidelity.rs
@@ -145,13 +145,19 @@ fn pick_layout(src: ChannelLayout, layouts: &[ChannelLayout], alpha: bool) -> Ch
     layouts[0]
 }
 
-pub(crate) fn plan(image: &Image, format: Format, _opts: &EncodeOptions) -> Plan {
+pub(crate) fn plan(image: &Image, format: Format, opts: &EncodeOptions) -> Plan {
     let c = caps(format);
     let (layout, sample) = (image.layout(), image.sample_type());
     match format {
         // PNM: integer data can use any layout (PAM); float goes to PFM
         // which only has gray and RGB.
         Format::Pnm if sample.is_float() => Plan { layout: pick_layout(layout, &[ChannelLayout::Gray, ChannelLayout::Rgb], false), sample: SampleType::F32 },
+        // DPX has no luma + alpha descriptor: gray with alpha is written as luma, alpha dropped.
+        // The sample type follows the chosen bits (U8 for 8, U16 for 10, 12 and 16).
+        Format::Dpx => Plan {
+            layout: if layout == ChannelLayout::GrayA { ChannelLayout::Gray } else { pick_layout(layout, c.layouts, c.alpha) },
+            sample: crate::codecs::dpx::plan_sample(opts.dpx_bits, sample),
+        },
         _ => Plan { layout: pick_layout(layout, c.layouts, c.alpha), sample: pick_sample(sample, c.depths) },
     }
 }
@@ -237,7 +243,9 @@ pub fn fidelity_warnings_with(image: &Image, format: Format, opts: &EncodeOption
         if m.dpi.is_some() && !c.dpi {
             w.push(W::DpiDropped);
         }
-        if !m.text.is_empty() && !c.text {
+        // DPX keeps its own header fields, not free-form text.
+        let text_kept = |k: &str| c.text && (format != Format::Dpx || crate::codecs::dpx::KEYS.contains(&k));
+        if m.text.iter().any(|(k, _)| !text_kept(k)) {
             w.push(W::TextDropped);
         }
     }
diff --git a/crates/codecs/src/format.rs b/crates/codecs/src/format.rs
index 3d3fa5426e..d3730c08fb 100644
--- a/crates/codecs/src/format.rs
+++ b/crates/codecs/src/format.rs
@@ -15,6 +15,12 @@ pub enum Format {
     Ico,
     /// Netpbm family: PBM/PGM/PPM (P1–P6), PAM (P7) and PFM (`PF`/`Pf`).
     Pnm,
+    /// ZSoft Paintbrush: 1/2/4-bit planar palettes, 8-bit indexed and 24-bit RGB.
+    Pcx,
+    /// X PixMap icons (XPM2 plain text and XPM3 C-string arrays).
+    Xpm,
+    /// DirectDraw Surface: the top mip level of a 2D texture, uncompressed or BC1–BC3.
+    Dds,
     Qoi,
     OpenExr,
     /// Radiance RGBE.
@@ -25,6 +31,8 @@ pub enum Format {
     Heif,
     /// FITS (Flexible Image Transport System), the astronomy format: gray or RGB image data.
     Fits,
+    /// DPX (SMPTE 268M Digital Picture Exchange): luma, RGB or RGBA film and video frames.
+    Dpx,
 }
 
 /// What a format can hold **and** what this crate reads/writes for it.
@@ -56,6 +64,15 @@ pub struct FormatCaps {
 /// Formats that are enabled but intentionally not symmetric, with the reason.
 /// The test-suite asserts that every other enabled format is read+write.
 pub const ASYMMETRIC_EXCEPTIONS: &[(Format, &str)] = &[
+    (Format::Xpm, "XPM is a legacy Unix icon interchange format. Reading existing XPM icons is supported; writing modern image assets should use PNG instead."),
+    (
+        Format::Pcx,
+        "PCX is supported for opening legacy paint and clipart assets. New files should use PNG; writing obsolete indexed and planar variants is intentionally not provided.",
+    ),
+    (
+        Format::Dds,
+        "DDS is supported for opening game and 3D textures. Writing one well means choosing a block compression and generating mip levels, which belongs in a texture export, not Save As.",
+    ),
     (
         Format::Avif,
         "AVIF encode uses ravif (pure Rust) but decoding requires dav1d (C); read stays unsupported \
@@ -78,7 +95,7 @@ const ALL_LAYOUTS: &[ChannelLayout] = &[L::Gray, L::GrayA, L::Rgb, L::Rgba, L::C
 
 impl Format {
     /// Every format known to the crate (enabled or not).
-    pub const ALL: [Format; 15] = [
+    pub const ALL: [Format; 19] = [
         Format::Png,
         Format::Jpeg,
         Format::Tiff,
@@ -88,12 +105,16 @@ impl Format {
         Format::Tga,
         Format::Ico,
         Format::Pnm,
+        Format::Pcx,
+        Format::Xpm,
+        Format::Dds,
         Format::Qoi,
         Format::OpenExr,
         Format::Hdr,
         Format::Avif,
         Format::Heif,
         Format::Fits,
+        Format::Dpx,
     ];
 
     pub fn caps(self) -> FormatCaps {
@@ -117,12 +138,16 @@ impl Format {
             Format::Tga => "TGA",
             Format::Ico => "ICO",
             Format::Pnm => "Netpbm",
+            Format::Pcx => "PCX",
+            Format::Xpm => "XPM",
+            Format::Dds => "DDS",
             Format::Qoi => "QOI",
             Format::OpenExr => "OpenEXR",
             Format::Hdr => "Radiance HDR",
             Format::Avif => "AVIF",
             Format::Heif => "HEIF",
             Format::Fits => "FITS",
+            Format::Dpx => "DPX",
         }
     }
 
@@ -139,12 +164,16 @@ impl Format {
             Format::Tga => &["tga", "icb", "vda", "vst"],
             Format::Ico => &["ico"],
             Format::Pnm => &["pnm", "pbm", "pgm", "ppm", "pam", "pfm"],
+            Format::Pcx => &["pcx"],
+            Format::Xpm => &["xpm"],
+            Format::Dds => &["dds"],
             Format::Qoi => &["qoi"],
             Format::OpenExr => &["exr"],
             Format::Hdr => &["hdr"],
             Format::Avif => &["avif"],
             Format::Heif => &["heic", "heif", "hif"],
             Format::Fits => &["fits", "fit", "fts"],
+            Format::Dpx => &["dpx"],
         }
     }
 
@@ -159,12 +188,16 @@ impl Format {
             Format::Tga => "image/x-tga",
             Format::Ico => "image/x-icon",
             Format::Pnm => "image/x-portable-anymap",
+            Format::Pcx => "image/x-pcx",
+            Format::Xpm => "image/x-xpixmap",
+            Format::Dds => "image/vnd-ms.dds",
             Format::Qoi => "image/qoi",
             Format::OpenExr => "image/x-exr",
             Format::Hdr => "image/vnd.radiance",
             Format::Avif => "image/avif",
             Format::Heif => "image/heif",
             Format::Fits => "image/fits",
+            Format::Dpx => "image/x-dpx",
         }
     }
 
@@ -200,13 +233,16 @@ pub fn caps(format: Format) -> FormatCaps {
             FormatCaps { depths: &[S::U8, S::U16], layouts: RGB_GRAY, icc: true, exif: true, xmp: true, dpi: true, text: true, animation: true, ..base }
         }
         Format::Jpeg => FormatCaps { layouts: &[L::Gray, L::Rgb, L::Cmyk], alpha: false, icc: true, exif: true, xmp: true, dpi: true, lossy: true, ..base },
-        Format::Tiff => FormatCaps { depths: &[S::U8, S::U16, S::F32], layouts: ALL_LAYOUTS, icc: true, xmp: true, dpi: true, text: true, ..base },
+        Format::Tiff => FormatCaps { depths: &[S::U8, S::U16, S::F32], layouts: ALL_LAYOUTS, icc: true, exif: true, xmp: true, dpi: true, text: true, ..base },
         Format::WebP => FormatCaps { icc: true, exif: true, xmp: true, animation: true, ..base },
         Format::Gif => FormatCaps { layouts: &[L::Rgba], animation: true, lossy: true, ..base },
         Format::Bmp => base,
         Format::Tga => FormatCaps { layouts: RGB_GRAY, ..base },
         Format::Ico => FormatCaps { layouts: &[L::Rgba], ..base },
         Format::Pnm => FormatCaps { depths: &[S::U8, S::U16, S::F32], layouts: ALL_LAYOUTS, ..base },
+        Format::Pcx => FormatCaps { read: true, write: false, layouts: &[L::Rgb], alpha: false, ..base },
+        Format::Xpm => FormatCaps { read: true, write: false, layouts: &[L::Rgba], ..base },
+        Format::Dds => FormatCaps { read: true, write: false, layouts: RGB_GRAY, ..base },
         Format::Qoi => base,
         Format::OpenExr => FormatCaps { depths: &[S::F16, S::F32], layouts: RGB_GRAY, ..base },
         Format::Hdr => FormatCaps { depths: &[S::F32], layouts: &[L::Rgb], alpha: false, lossy: true, ..base },
@@ -215,6 +251,8 @@ pub fn caps(format: Format) -> FormatCaps {
             FormatCaps { read: cfg!(feature = "heif"), write: false, depths: &[S::U8, S::U16], icc: true, exif: true, xmp: true, lossy: true, ..base }
         }
         Format::Fits => FormatCaps { depths: &[S::U8, S::U16, S::F32], layouts: &[L::Gray, L::Rgb], alpha: false, text: true, ..base },
+        // `text`: the DPX header fields only (see `fidelity_warnings_with`).
+        Format::Dpx => FormatCaps { depths: &[S::U8, S::U16], layouts: &[L::Gray, L::Rgb, L::Rgba], text: true, ..base },
     }
 }
 
@@ -240,6 +278,9 @@ pub fn detect(bytes: &[u8]) -> Option<Format> {
     if b.starts_with(b"qoif") {
         return Some(Format::Qoi);
     }
+    if b.starts_with(b"DDS ") {
+        return Some(Format::Dds);
+    }
     if b.starts_with(&[0x76, 0x2F, 0x31, 0x01]) {
         return Some(Format::OpenExr);
     }
@@ -263,9 +304,18 @@ pub fn detect(bytes: &[u8]) -> Option<Format> {
     if b.len() >= 3 && b[0] == b'P' && matches!(b[1], b'1'..=b'7' | b'F' | b'f') && b[2].is_ascii_whitespace() {
         return Some(Format::Pnm);
     }
+    if b.starts_with(b"SDPX") || b.starts_with(b"XPDS") {
+        return Some(Format::Dpx);
+    }
     if b.starts_with(b"SIMPLE  =") {
         return Some(Format::Fits);
     }
+    if b.starts_with(b"/* XPM */") || b.starts_with(b"! XPM2\n") || b.starts_with(b"! XPM2\r\n") {
+        return Some(Format::Xpm);
+    }
+    if crate::codecs::pcx::looks_like_pcx(b) {
+        return Some(Format::Pcx);
+    }
     if looks_like_tga(b) {
         return Some(Format::Tga);
     }
diff --git a/crates/codecs/src/image.rs b/crates/codecs/src/image.rs
index 01f5d4cad0..db59d4fa6b 100644
--- a/crates/codecs/src/image.rs
+++ b/crates/codecs/src/image.rs
@@ -150,12 +150,40 @@ pub enum DecodeWarning {
     MorePages { total: Option<u32> },
     /// Only one part of a multi-part file was decoded; `total` counts every part when known.
     MoreParts { total: Option<u32> },
+    /// The image opened on the full `display_window` stage; the data region sits at `origin`.
+    DisplayWindowStage { stage: (u32, u32), origin: (i32, i32) },
     /// The image data ends early (truncated or damaged file); the decoder filled in the rest
     /// (a baseline JPEG's missing rows come out grey).
     Truncated { format: Format },
     /// Deep image data (per-pixel sample lists) was composited into the flat image; the samples
     /// themselves (Z and other deep channels) are not part of the flat result.
     DeepFlattened { format: Format, max_samples_per_pixel: u32 },
+    /// Only the first image element of a DPX file was decoded; `total` counts them all.
+    MoreElements { total: u32 },
+    /// A DPX element's transfer characteristic and colorimetric specification (SMPTE 268M codes,
+    /// 255 when undefined). The code values are imported as stored, without a colour transform.
+    DpxEncoding { transfer: u8, colorimetric: u8 },
+}
+
+/// The SMPTE 268M name of a transfer characteristic or colorimetric code.
+fn dpx_code_name(code: u8) -> &'static str {
+    match code {
+        0 => "user-defined",
+        1 => "printing density",
+        2 => "linear",
+        3 => "logarithmic",
+        4 => "unspecified video",
+        5 => "SMPTE 274M",
+        6 => "ITU-R BT.709",
+        7 => "ITU-R BT.601 625-line",
+        8 => "ITU-R BT.601 525-line",
+        9 => "NTSC composite video",
+        10 => "PAL composite video",
+        11 => "Z linear",
+        12 => "Z homogeneous",
+        255 => "undefined",
+        _ => "unknown",
+    }
 }
 
 impl fmt::Display for DecodeWarning {
@@ -167,6 +195,9 @@ impl fmt::Display for DecodeWarning {
             DecodeWarning::MorePages { total: None } => write!(f, "only the first page of the file was imported"),
             DecodeWarning::MoreParts { total: Some(n) } => write!(f, "only one of {n} EXR parts was imported"),
             DecodeWarning::MoreParts { total: None } => write!(f, "only one EXR part of the file was imported"),
+            DecodeWarning::DisplayWindowStage { stage, origin } => {
+                write!(f, "opened on the full display window stage ({}x{}); the data sits at ({}, {})", stage.0, stage.1, origin.0, origin.1)
+            }
             DecodeWarning::Truncated { format } => {
                 write!(f, "{} data ends early (the file is truncated or damaged); part of the image is missing", format.name())
             }
@@ -175,6 +206,13 @@ impl fmt::Display for DecodeWarning {
                 "{format} deep data was composited into a flat image (up to {max_samples_per_pixel} samples per pixel); per-pixel depth is not kept",
                 format = format.name()
             ),
+            DecodeWarning::MoreElements { total } => write!(f, "only the first of {total} image elements was imported"),
+            DecodeWarning::DpxEncoding { transfer, colorimetric } => write!(
+                f,
+                "DPX transfer characteristic: {} ({transfer}), colorimetric: {} ({colorimetric}); the code values were imported as stored, without a colour transform",
+                dpx_code_name(*transfer),
+                dpx_code_name(*colorimetric)
+            ),
         }
     }
 }
@@ -199,6 +237,13 @@ pub struct DeepChannel {
 pub struct DeepImage {
     pub width: u32,
     pub height: u32,
+    /// The full stage the image opens on: the EXR `display_window` size, when the file declares
+    /// one the data region fits into and the limits allow. `None` when absent, absurd or not
+    /// containing the data region — then the image opens on the data window alone, as before.
+    pub stage: Option<(u32, u32)>,
+    /// Where this image's (0, 0) sits on the stage: `data_window.position - display_window.position`.
+    /// `(0, 0)` when [`Self::stage`] is `None`.
+    pub origin: (i32, i32),
     /// The sample channels in file order.
     pub channels: Vec<DeepChannel>,
     /// Cumulative sample counts, `len == width as usize * height as usize + 1`: pixel `i`
@@ -512,6 +557,8 @@ impl Image {
                 out.extend_from_slice(&one);
             }
             out
+        } else if let Some(fast) = self.convert_int_direct(layout, sample) {
+            fast
         } else if layout == self.layout {
             quantize(&self.to_normalized(), sample)
         } else {
@@ -531,6 +578,55 @@ impl Image {
         }
     }
 
+    /// Integer fast path of [`Image::convert`] for U8/U16 sources and targets whose result is
+    /// a pure channel copy: same colour model (alpha added as opaque, or dropped) or gray to
+    /// RGB. Bit-identical to the generic f32 route (see the equivalence tests) but without
+    /// the two intermediate f32 buffers. Returns `None` for everything else.
+    fn convert_int_direct(&self, layout: ChannelLayout, sample: SampleType) -> Option<Vec<u8>> {
+        let int = |s: SampleType| matches!(s, SampleType::U8 | SampleType::U16);
+        if !int(self.sample) || !int(sample) {
+            return None;
+        }
+        let gray_to_rgb = self.layout.is_gray() && layout.is_rgb();
+        if !gray_to_rgb && !layout.same_model(self.layout) {
+            return None;
+        }
+        let one: &[u8] = match sample {
+            SampleType::U8 => &[u8::MAX],
+            _ => &u16::MAX.to_ne_bytes(),
+        };
+        let (fc, tc) = (self.layout.channels(), layout.channels());
+        let (sb, db) = (self.sample.bytes(), sample.bytes());
+        let (src_color, dst_color) = (self.layout.color_channels(), layout.color_channels());
+        let n = self.data.len() / (fc * sb);
+        let mut out = Vec::with_capacity(n.checked_mul(tc)?.checked_mul(db)?);
+        macro_rules! run {
+            ($conv:expr) => {{
+                let conv = $conv;
+                for px in self.data.chunks_exact(fc * sb) {
+                    for j in 0..dst_color {
+                        let c = if src_color == 1 { 0 } else { j };
+                        conv(&px[c * sb..(c + 1) * sb], &mut out);
+                    }
+                    if layout.has_alpha() {
+                        if self.layout.has_alpha() {
+                            conv(&px[src_color * sb..(src_color + 1) * sb], &mut out);
+                        } else {
+                            out.extend_from_slice(one);
+                        }
+                    }
+                }
+            }};
+        }
+        match (self.sample, sample) {
+            (SampleType::U8, SampleType::U8) => run!(|s: &[u8], o: &mut Vec<u8>| o.push(s[0])),
+            (SampleType::U16, SampleType::U16) => run!(|s: &[u8], o: &mut Vec<u8>| o.extend_from_slice(s)),
+            (SampleType::U8, SampleType::U16) => run!(|s: &[u8], o: &mut Vec<u8>| o.extend_from_slice(&(u16::from(s[0]) * 257).to_ne_bytes())),
+            _ => run!(|s: &[u8], o: &mut Vec<u8>| o.push(((u32::from(u16::from_ne_bytes([s[0], s[1]])) + 128) / 257) as u8)),
+        }
+        Some(out)
+    }
+
     /// [`Image::convert`], borrowing `self` when it already has that layout and sample type
     /// (encoders use it so a full-size image isn't copied for nothing).
     pub fn converted(&self, layout: ChannelLayout, sample: SampleType) -> std::borrow::Cow<'_, Image> {
@@ -661,6 +757,66 @@ mod tests {
 
     use super::*;
 
+    /// The generic f32 route `convert` used before the integer fast paths (the reference).
+    fn convert_via_f32(img: &Image, layout: ChannelLayout, sample: SampleType) -> Vec<u8> {
+        quantize(&convert_layout(&img.to_normalized(), img.layout, layout), sample)
+    }
+
+    #[test]
+    fn int_fast_path_matches_f32_route_for_every_value() {
+        // Every U8 and every U16 value through every depth pair (alpha goes through the same per-sample conversion; covered by the layout test).
+        let all8: Vec<u8> = (0..=255).collect();
+        let all16: Vec<u16> = (0..=65535).collect();
+        for (src, to) in
+            [(SampleType::U8, SampleType::U8), (SampleType::U8, SampleType::U16), (SampleType::U16, SampleType::U8), (SampleType::U16, SampleType::U16)]
+        {
+            let img = if src == SampleType::U8 {
+                Image::from_u8(256, 1, ChannelLayout::Gray, all8.clone()).unwrap()
+            } else {
+                Image::from_u16(65536, 1, ChannelLayout::Gray, &all16).unwrap()
+            };
+            for layout in [ChannelLayout::Gray, ChannelLayout::Rgb] {
+                assert_eq!(img.convert(layout, to).data(), &convert_via_f32(&img, layout, to)[..], "{src:?}->{to:?} {layout:?}");
+            }
+        }
+    }
+
+    #[test]
+    fn int_fast_path_matches_f32_route_for_every_layout() {
+        let mut seed = 0x9e3779b97f4a7c15u64;
+        let mut next = || {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            seed
+        };
+        for from_s in [SampleType::U8, SampleType::U16] {
+            for from_l in ChannelLayout::ALL {
+                let n = 64 * from_l.channels();
+                let mut vals = Vec::new();
+                for i in 0..n {
+                    // Edge values (0, 1, max-1, max, mid) mixed with random ones.
+                    let r = next();
+                    let v = match i % 7 {
+                        0 => 0.0,
+                        1 => 1.0,
+                        2 => 1.0 / 255.0,
+                        3 => 254.0 / 255.0,
+                        _ => (r % 65536) as f32 / 65535.0,
+                    };
+                    vals.push(v);
+                }
+                let img = Image::from_normalized(64, 1, from_l, from_s, &vals).unwrap();
+                for to_l in ChannelLayout::ALL {
+                    for to_s in SampleType::ALL {
+                        let got = img.convert(to_l, to_s);
+                        assert_eq!(got.data(), &convert_via_f32(&img, to_l, to_s)[..], "{from_l:?}/{from_s:?} -> {to_l:?}/{to_s:?}");
+                    }
+                }
+            }
+        }
+    }
+
     #[test]
     fn u8_u16_roundtrip_exact() {
         let v: Vec<u8> = (0..=255).collect();
diff --git a/crates/codecs/src/lib.rs b/crates/codecs/src/lib.rs
index f107732555..438e1857e4 100644
--- a/crates/codecs/src/lib.rs
+++ b/crates/codecs/src/lib.rs
@@ -22,11 +22,12 @@ mod image;
 mod options;
 pub mod orientation;
 pub mod resolution;
+pub mod source_settings;
 pub mod web;
 
 pub use crate::codecs::exr_cryptomatte::{cryptomatte_id, cryptomatte_key, cryptomatte_preview_color};
 pub use crate::codecs::gif_frames::{AnimationFrame, MAX_GIF_FRAMES};
-pub use crate::codecs::png::encode_indexed as encode_png_indexed;
+pub use crate::codecs::png::{PngPalette, encode_indexed as encode_png_indexed, palette as png_palette};
 pub use crate::codecs::tiff::{PhotoshopTags as TiffPhotoshopTags, photoshop_tags as tiff_photoshop_tags, writes_little_endian as tiff_writes_little_endian};
 pub use crate::codecs::tiff_ifd::{TiffInfo, TiffPage, TiffPageKind};
 pub use crate::error::CodecError;
@@ -36,12 +37,13 @@ pub use crate::format::{ASYMMETRIC_EXCEPTIONS, Format, FormatCaps, caps, detect,
 pub use crate::image::{
     ChannelLayout, CryptomatteBuffer, CryptomatteLayer, DecodeWarning, DeepChannel, DeepImage, ExrChannelInfo, ExrPartInfo, Image, Metadata, SampleType,
 };
-pub use crate::options::{DecodeOptions, EncodeOptions, ExrCompression, Limits, PngCompression, TiffCompression};
+pub use crate::options::{DecodeOptions, DpxBits, EncodeOptions, ExrCompression, Limits, PngCompression, TiffCompression};
 pub use crate::orientation::{exif_orientation, upright_exif, upright_xmp};
 pub use crate::resolution::{exif_resolution, export_exif, export_xmp, photoshop_resolution, xmp_resolution};
+pub use crate::source_settings::{WebpEncoding, jpeg_quality, webp_encoding};
 pub use half::f16;
 
-use crate::codecs::{exr, fits, heif, jpeg, png, pnm, tiff, via_image, webp};
+use crate::codecs::{dds, dpx, exr, fits, heif, jpeg, pcx, png, pnm, tiff, via_image, webp, xpm};
 
 /// Detect the format and decode with default [`Limits`].
 pub fn decode(bytes: &[u8]) -> Result<Image, CodecError> {
@@ -72,7 +74,11 @@ pub fn decode_as_with(format: Format, bytes: &[u8], opts: &DecodeOptions) -> Res
         Format::Tiff => tiff::decode(bytes, l),
         Format::WebP => webp::decode(bytes, l),
         Format::Pnm => pnm::decode(bytes, l),
+        Format::Pcx => pcx::decode(bytes, l),
+        Format::Xpm => xpm::decode(bytes, l),
+        Format::Dds => dds::decode(bytes, l),
         Format::Fits => fits::decode(bytes, l),
+        Format::Dpx => dpx::decode(bytes, l),
         Format::OpenExr => exr::decode(bytes, l),
         Format::Heif => heif::decode(bytes, l, opts.keep_orientation),
         Format::Gif | Format::Bmp | Format::Tga | Format::Ico | Format::Qoi | Format::Hdr | Format::Avif => via_image::decode(format, bytes, l),
@@ -90,11 +96,17 @@ pub fn decode_as_with(format: Format, bytes: &[u8], opts: &DecodeOptions) -> Res
     let o = match format {
         Format::Tiff => tiff::orientation(bytes, None),
         Format::Heif => 1,
+        Format::Dpx => dpx::orientation(bytes),
         _ => img.meta.exif.as_deref().map_or(1, exif_orientation),
     };
     finish_decode(img, o, opts)
 }
 
+/// Returns the embedded colour table for an indexed BMP, if it has one.
+pub fn bmp_palette(bytes: &[u8]) -> Result<Option<Vec<[u8; 3]>>, CodecError> {
+    via_image::bmp_palette(bytes)
+}
+
 /// Lists the pages (image directories) of a TIFF or BigTIFF file without decoding pixels: the
 /// main IFD chain and its SubIFDs, each with its size, kind (page, reduced-resolution copy or
 /// mask) and storage. [`TiffInfo::default_page`] is the page [`decode`] opens.
@@ -214,7 +226,11 @@ pub fn encode(image: &Image, format: Format, opts: &EncodeOptions) -> Result<Vec
         Format::Tiff => tiff::encode(image, plan, opts),
         Format::WebP => webp::encode(image, plan, opts),
         Format::Pnm => pnm::encode(image, plan, opts),
+        Format::Pcx => Err(CodecError::unsupported(format, "PCX is import-only; save as PNG instead")),
+        Format::Xpm => Err(CodecError::unsupported(format, "XPM is import-only; save as PNG instead")),
+        Format::Dds => Err(CodecError::unsupported(format, "DDS is import-only; save as PNG instead")),
         Format::Fits => fits::encode(image, plan, opts),
+        Format::Dpx => dpx::encode(image, plan, opts),
         Format::OpenExr => exr::encode(image, plan, opts),
         Format::Heif => Err(CodecError::unsupported(format, "encoding is not available in this build")),
         Format::Gif | Format::Bmp | Format::Tga | Format::Ico | Format::Qoi | Format::Hdr | Format::Avif => via_image::encode(format, image, plan, opts),
diff --git a/crates/codecs/src/options.rs b/crates/codecs/src/options.rs
index 79b288f34c..eee5b38c0a 100644
--- a/crates/codecs/src/options.rs
+++ b/crates/codecs/src/options.rs
@@ -21,8 +21,10 @@ pub struct Limits {
 impl Default for Limits {
     fn default() -> Self {
         // 2^30 pixels (e.g. 32768²) and, on 64-bit targets, 8 GiB: enough for the large
-        // documents Photoshop users open (a 20000² RGBA 16-bit image is 3.2 GB).
-        let max_alloc = if cfg!(target_pointer_width = "64") { 8 << 30 } else { 2 << 30 };
+        // documents Photoshop users open (a 20000² RGBA 16-bit image is 3.2 GB). On 32-bit
+        // targets (wasm32 has a 4 GiB address space shared with the document, history and
+        // the decoder's own buffers) 1 GiB is the most one buffer can safely ask for.
+        let max_alloc = if cfg!(target_pointer_width = "64") { 8 << 30 } else { 1 << 30 };
         Limits { max_width: 1 << 18, max_height: 1 << 18, max_pixels: 1 << 30, max_alloc }
     }
 }
@@ -60,6 +62,19 @@ impl Limits {
         Ok(())
     }
 
+    /// Decompression-bomb guard for formats that compress: refuse a file too small to hold
+    /// `declared_bytes` of (stored, pre-expansion) image data, given that the compression
+    /// never beats `max_ratio`:1. Called before the output buffer is allocated, so a
+    /// header-only hostile file cannot make the decoder reserve gigabytes. A fixed 1 MiB of
+    /// slack keeps tiny images and headers with large metadata unaffected.
+    pub(crate) fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> {
+        let capacity = (file_len as u64).saturating_mul(max_ratio).saturating_add(1 << 20);
+        if declared_bytes > capacity {
+            return Err(CodecError::LimitExceeded(format!("a {file_len} byte file cannot hold {declared_bytes} bytes of image data")));
+        }
+        Ok(())
+    }
+
     pub(crate) fn alloc_usize(&self) -> usize {
         usize::try_from(self.max_alloc).unwrap_or(usize::MAX)
     }
@@ -85,12 +100,13 @@ pub enum PngCompression {
     Best,
 }
 
-/// TIFF strip compression.
+/// TIFF strip compression. The default is none, as in Photoshop: uncompressed strips are the
+/// only kind every TIFF reader opens (Deflate and the predictor are not baseline TIFF, #4484).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum TiffCompression {
+    #[default]
     None,
     Lzw,
-    #[default]
     Deflate,
     PackBits,
 }
@@ -106,6 +122,38 @@ pub enum ExrCompression {
     Piz,
 }
 
+/// Bits per sample of a DPX file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DpxBits {
+    Bits8,
+    Bits10,
+    Bits12,
+    Bits16,
+}
+
+impl DpxBits {
+    /// `8`, `10`, `12` or `16` as [`DpxBits`]; any other number is `None`.
+    pub fn from_bits(bits: u64) -> Option<Self> {
+        match bits {
+            8 => Some(DpxBits::Bits8),
+            10 => Some(DpxBits::Bits10),
+            12 => Some(DpxBits::Bits12),
+            16 => Some(DpxBits::Bits16),
+            _ => None,
+        }
+    }
+
+    /// The bits per sample.
+    pub fn bits(self) -> u8 {
+        match self {
+            DpxBits::Bits8 => 8,
+            DpxBits::Bits10 => 10,
+            DpxBits::Bits12 => 12,
+            DpxBits::Bits16 => 16,
+        }
+    }
+}
+
 /// Options for [`crate::encode`].
 #[derive(Debug, Clone)]
 pub struct EncodeOptions {
@@ -126,6 +174,8 @@ pub struct EncodeOptions {
     /// only when it could pass the 4 GiB a classic TIFF can address.
     pub tiff_bigtiff: bool,
     pub exr_compression: ExrCompression,
+    /// DPX bits per sample. `None` follows the image: 8 for 8-bit, 16 otherwise.
+    pub dpx_bits: Option<DpxBits>,
     /// Embed the ICC profile when the format supports it.
     pub embed_icc: bool,
     /// Embed EXIF/XMP/DPI/text when the format supports it.
@@ -141,11 +191,22 @@ impl Default for EncodeOptions {
             png_interlaced: false,
             webp_lossless: true,
             webp_quality: 80,
-            tiff_compression: TiffCompression::Deflate,
+            tiff_compression: TiffCompression::None,
             tiff_bigtiff: false,
             exr_compression: ExrCompression::Zip16,
+            dpx_bits: None,
             embed_icc: true,
             embed_metadata: true,
         }
     }
 }
+
+/// A zero-filled buffer of `len` elements, allocated fallibly: an allocation failure becomes
+/// [`CodecError::LimitExceeded`] instead of aborting the process (which `catch_unwind` cannot
+/// stop).
+pub(crate) fn alloc_zeroed<T: Copy + Default>(len: usize) -> Result<Vec<T>, CodecError> {
+    let mut v = Vec::new();
+    v.try_reserve_exact(len).map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {len} elements for the image")))?;
+    v.resize(len, T::default());
+    Ok(v)
+}
diff --git a/crates/codecs/src/source_settings.rs b/crates/codecs/src/source_settings.rs
new file mode 100644
index 0000000000..ebd0421c39
--- /dev/null
+++ b/crates/codecs/src/source_settings.rs
@@ -0,0 +1,355 @@
+//! The encoder settings a lossy file was written with, read back from its own data, so a save
+//! can write it again the way it came (File › Save keeps a JPEG's quality and a WebP's lossy or
+//! lossless encoding).
+//!
+//! * **JPEG**: the quality is estimated from the quantisation tables (DQT). Most encoders scale
+//!   the example tables of ITU-T T.81 Annex K (K.1 luminance, K.2 chrominance) by the
+//!   Independent JPEG Group's quality curve, so the quality whose scaled tables match the file's
+//!   best is the one it was saved at (exact for such tables; the closest fit for others).
+//! * **WebP**: a `VP8L` image is lossless; a `VP8 ` image is lossy, and its base quantiser index
+//!   (RFC 6386 §9.6) maps back to a quality on the scale our encoder uses.
+//!
+//! Everything here reads hostile bytes: every index is checked and a malformed file gives `None`.
+
+use crate::codecs::vp8;
+
+/// ITU-T T.81 Annex K.1, the example luminance quantisation table, in natural (row) order.
+const ANNEX_K_LUMA: [u16; 64] = [
+    16, 11, 10, 16, 24, 40, 51, 61, //
+    12, 12, 14, 19, 26, 58, 60, 55, //
+    14, 13, 16, 24, 40, 57, 69, 56, //
+    14, 17, 22, 29, 51, 87, 80, 62, //
+    18, 22, 37, 56, 68, 109, 103, 77, //
+    24, 35, 55, 64, 81, 104, 113, 92, //
+    49, 64, 78, 87, 103, 121, 120, 101, //
+    72, 92, 95, 98, 112, 100, 103, 99,
+];
+
+/// ITU-T T.81 Annex K.2, the example chrominance quantisation table, in natural order.
+const ANNEX_K_CHROMA: [u16; 64] = [
+    17, 18, 24, 47, 99, 99, 99, 99, //
+    18, 21, 26, 66, 99, 99, 99, 99, //
+    24, 26, 56, 99, 99, 99, 99, 99, //
+    47, 66, 99, 99, 99, 99, 99, 99, //
+    99, 99, 99, 99, 99, 99, 99, 99, //
+    99, 99, 99, 99, 99, 99, 99, 99, //
+    99, 99, 99, 99, 99, 99, 99, 99, //
+    99, 99, 99, 99, 99, 99, 99, 99,
+];
+
+/// The natural-order index of the k-th coefficient in zig-zag order (T.81 Figure A.6): DQT
+/// stores its 64 values in this order.
+const ZIGZAG: [usize; 64] = [
+    0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29,
+    22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
+];
+
+/// One quantisation table from a DQT segment, in natural order, with its precision.
+#[derive(Debug, Clone, Copy)]
+struct Table {
+    values: [u16; 64],
+    /// 16-bit entries (Pq = 1) rather than 8-bit.
+    wide: bool,
+}
+
+/// The quality (1–100, the Independent JPEG Group's scale that Save As and Export As use) a
+/// JPEG was most likely saved at, from its quantisation tables; `None` when it has no usable
+/// luminance table (or isn't a JPEG).
+pub fn jpeg_quality(bytes: &[u8]) -> Option<u8> {
+    let tables = jpeg_tables(bytes);
+    let [luma, chroma, ..] = tables;
+    let luma = luma?;
+    let mut best: Option<(u64, u8)> = None;
+    for q in 1..=100u8 {
+        let mut err = table_error(&luma, &ANNEX_K_LUMA, q);
+        if let Some(c) = chroma {
+            err = err.saturating_add(table_error(&c, &ANNEX_K_CHROMA, q));
+        }
+        if best.is_none_or(|(e, _)| err < e) {
+            best = Some((err, q));
+        }
+    }
+    best.map(|(_, q)| q)
+}
+
+/// The Independent JPEG Group's quality scaling of `base` (libjpeg's `jpeg_quality_scaling` and
+/// `jpeg_add_quant_table`, as published with its source): a percentage scale of 5000 / q below
+/// quality 50 and 200 − 2q from it, rounded, and kept within 1..=255 (8-bit) or 1..=32767.
+fn scaled(base: u16, q: u8, wide: bool) -> u32 {
+    let q = u32::from(q.clamp(1, 100));
+    let scale = if q < 50 { 5000 / q } else { 200 - 2 * q };
+    let v = (u32::from(base) * scale + 50) / 100;
+    v.clamp(1, if wide { 32767 } else { 255 })
+}
+
+/// How far `t` is from `base` scaled to quality `q`: the summed absolute difference.
+fn table_error(t: &Table, base: &[u16; 64], q: u8) -> u64 {
+    t.values.iter().zip(base).map(|(&v, &b)| u64::from(u32::from(v).abs_diff(scaled(b, q, t.wide)))).sum()
+}
+
+/// The quantisation tables 0..=3 defined before the first scan (a later definition of the same
+/// slot replaces an earlier one).
+fn jpeg_tables(b: &[u8]) -> [Option<Table>; 4] {
+    let mut tables = [None; 4];
+    if b.get(..2) != Some(&[0xFF, 0xD8]) {
+        return tables;
+    }
+    let mut i = 2usize;
+    while let (Some(&0xFF), Some(&marker)) = (b.get(i), b.get(i.saturating_add(1))) {
+        if marker == 0xFF {
+            i = i.saturating_add(1);
+            continue;
+        }
+        if marker == 0xD8 || (0xD0..=0xD7).contains(&marker) || marker == 0x01 {
+            i = i.saturating_add(2);
+            continue;
+        }
+        if marker == 0xDA || marker == 0xD9 {
+            break;
+        }
+        let Some(len) = b.get(i + 2..i + 4).map(|l| usize::from(u16::from_be_bytes([l[0], l[1]]))) else { break };
+        let Some(seg) = len.checked_sub(2).and_then(|n| b.get(i + 4..i + 4 + n)) else { break };
+        if marker == 0xDB {
+            read_dqt(seg, &mut tables);
+        }
+        i = i.saturating_add(2).saturating_add(len);
+    }
+    tables
+}
+
+/// The tables of one DQT segment; a truncated or malformed table ends the segment.
+fn read_dqt(mut seg: &[u8], tables: &mut [Option<Table>; 4]) {
+    while let Some((&pq_tq, rest)) = seg.split_first() {
+        let wide = pq_tq >> 4 == 1;
+        if pq_tq >> 4 > 1 {
+            return;
+        }
+        let slot = usize::from(pq_tq & 0x0F);
+        let n = if wide { 128 } else { 64 };
+        let Some(data) = rest.get(..n) else { return };
+        let mut values = [0u16; 64];
+        for (k, &natural) in ZIGZAG.iter().enumerate() {
+            let v = if wide { data.get(2 * k..2 * k + 2).map_or(0, |p| u16::from_be_bytes([p[0], p[1]])) } else { data.get(k).map_or(0, |&p| u16::from(p)) };
+            if let Some(dst) = values.get_mut(natural) {
+                *dst = v;
+            }
+        }
+        if let Some(dst) = tables.get_mut(slot) {
+            *dst = Some(Table { values, wide });
+        }
+        seg = rest.get(n..).unwrap_or(&[]);
+    }
+}
+
+/// How a WebP file's image is compressed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WebpEncoding {
+    /// VP8L.
+    Lossless,
+    /// VP8, with the quality (0–100, our encoder's scale) its quantiser maps back to, when the
+    /// frame header could be read.
+    Lossy { quality: Option<u8> },
+}
+
+/// The compression of a WebP file's (first) image, or `None` when it isn't a WebP or holds no
+/// image chunk.
+pub fn webp_encoding(bytes: &[u8]) -> Option<WebpEncoding> {
+    if bytes.get(..4) != Some(b"RIFF") || bytes.get(8..12) != Some(b"WEBP") {
+        return None;
+    }
+    find_image_chunk(bytes.get(12..)?, 0)
+}
+
+/// The first `VP8 ` or `VP8L` chunk among `chunks`, looking inside animation frames.
+fn find_image_chunk(mut chunks: &[u8], depth: u8) -> Option<WebpEncoding> {
+    while let Some(head) = chunks.get(..8) {
+        let fourcc = head.get(..4)?;
+        let size = usize::try_from(u32::from_le_bytes([head[4], head[5], head[6], head[7]])).ok()?;
+        let end = 8usize.checked_add(size)?;
+        // A truncated last chunk still holds its header.
+        let payload = chunks.get(8..end.min(chunks.len()))?;
+        match fourcc {
+            b"VP8L" => return Some(WebpEncoding::Lossless),
+            b"VP8 " => return Some(WebpEncoding::Lossy { quality: vp8_quality(payload) }),
+            // An animation frame: a 16-byte header, then the frame's own chunks.
+            b"ANMF" if depth == 0 => {
+                if let Some(found) = payload.get(16..).and_then(|c| find_image_chunk(c, 1)) {
+                    return Some(found);
+                }
+            }
+            _ => {}
+        }
+        chunks = chunks.get(end.checked_add(size % 2)?..).unwrap_or(&[]);
+    }
+    None
+}
+
+/// The quality a VP8 key frame's base quantiser index maps back to on our encoder's scale (the
+/// quality whose index is nearest; the middle one when several share it).
+fn vp8_quality(frame: &[u8]) -> Option<u8> {
+    let qi = vp8_base_quantizer(frame)?;
+    let distance = |q: u8| vp8::quantizer_index(q).abs_diff(qi);
+    let best = (0..=100u8).map(distance).min()?;
+    let matches: Vec<u8> = (0..=100u8).filter(|&q| distance(q) == best).collect();
+    let mid = matches.get(matches.len() / 2)?;
+    Some(*mid)
+}
+
+/// The base quantiser index of a VP8 key frame: `y_ac_qi` from its frame header (RFC 6386
+/// §9.2–9.6, §19.2), averaged over the segments when segmentation sets absolute quantisers or
+/// adjusted by their mean delta otherwise.
+fn vp8_base_quantizer(frame: &[u8]) -> Option<u8> {
+    let tag = frame.get(..3)?;
+    // Bit 0 clear: a key frame, which carries the start code and dimensions.
+    if tag[0] & 1 != 0 || frame.get(3..6)? != [0x9D, 0x01, 0x2A] {
+        return None;
+    }
+    let mut d = BoolDecoder::new(frame.get(10..)?);
+    d.literal(1); // color_space
+    d.literal(1); // clamping_type
+    let mut segments: Option<(bool, [i32; 4])> = None;
+    if d.flag() {
+        let update_map = d.flag();
+        if d.flag() {
+            let absolute = d.flag();
+            let mut q = [0i32; 4];
+            for v in &mut q {
+                *v = if d.flag() { d.signed(7) } else { 0 };
+            }
+            for _ in 0..4 {
+                if d.flag() {
+                    d.signed(6);
+                }
+            }
+            segments = Some((absolute, q));
+        }
+        if update_map {
+            for _ in 0..3 {
+                if d.flag() {
+                    d.literal(8);
+                }
+            }
+        }
+    }
+    d.literal(1); // filter_type
+    d.literal(6); // loop_filter_level
+    d.literal(3); // sharpness_level
+    if d.flag() && d.flag() {
+        // loop_filter_adj_enable, mode_ref_lf_delta_update: 4 reference and 4 mode deltas.
+        for _ in 0..8 {
+            if d.flag() {
+                d.signed(6);
+            }
+        }
+    }
+    d.literal(2); // log2_nbr_of_dct_partitions
+    if d.exhausted() {
+        return None;
+    }
+    let base = d.literal(7) as i32;
+    let qi = match segments {
+        Some((true, q)) => q.iter().sum::<i32>() / 4,
+        Some((false, q)) => base + q.iter().sum::<i32>() / 4,
+        None => base,
+    };
+    u8::try_from(qi.clamp(0, 127)).ok()
+}
+
+/// RFC 6386 §7's boolean decoder, reading zeros past the end of its data.
+struct BoolDecoder<'a> {
+    data: &'a [u8],
+    pos: usize,
+    value: u32,
+    range: u32,
+    bit_count: u32,
+    /// Bytes read past the end of the data.
+    overrun: usize,
+}
+
+impl<'a> BoolDecoder<'a> {
+    fn new(data: &'a [u8]) -> Self {
+        let mut d = BoolDecoder { data, pos: 0, value: 0, range: 255, bit_count: 0, overrun: 0 };
+        d.value = (d.next_byte() << 8) | d.next_byte();
+        d
+    }
+
+    fn next_byte(&mut self) -> u32 {
+        match self.data.get(self.pos) {
+            Some(&b) => {
+                self.pos += 1;
+                u32::from(b)
+            }
+            None => {
+                self.overrun = self.overrun.saturating_add(1);
+                0
+            }
+        }
+    }
+
+    /// The header was read from beyond the end of the data (a couple of bytes of look-ahead
+    /// are normal).
+    fn exhausted(&self) -> bool {
+        self.overrun > 2
+    }
+
+    fn bool(&mut self, prob: u32) -> bool {
+        let split = 1 + (((self.range - 1) * prob) >> 8);
+        let big_split = split << 8;
+        let bit = if self.value >= big_split {
+            self.range -= split;
+            self.value -= big_split;
+            true
+        } else {
+            self.range = split;
+            false
+        };
+        while self.range < 128 {
+            self.value <<= 1;
+            self.range <<= 1;
+            self.bit_count += 1;
+            if self.bit_count == 8 {
+                self.bit_count = 0;
+                self.value |= self.next_byte();
+            }
+        }
+        bit
+    }
+
+    fn flag(&mut self) -> bool {
+        self.bool(128)
+    }
+
+    fn literal(&mut self, bits: u32) -> u32 {
+        (0..bits).fold(0, |v, _| (v << 1) | u32::from(self.flag()))
+    }
+
+    /// A magnitude of `bits` bits followed by a sign bit.
+    fn signed(&mut self, bits: u32) -> i32 {
+        let v = self.literal(bits) as i32;
+        if self.flag() { -v } else { v }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn scaling_matches_the_published_curve() {
+        // Quality 50 is the Annex K table itself; 100 is all ones; 75 halves it.
+        assert_eq!(scaled(16, 50, false), 16);
+        assert_eq!(scaled(121, 100, false), 1);
+        assert_eq!(scaled(16, 75, false), 8);
+        assert_eq!(scaled(121, 1, false), 255);
+        assert_eq!(scaled(121, 1, true), 6050);
+    }
+
+    #[test]
+    fn zigzag_is_a_permutation() {
+        let mut seen = [false; 64];
+        for &n in &ZIGZAG {
+            seen[n] = true;
+        }
+        assert!(seen.iter().all(|&s| s));
+    }
+}
diff --git a/crates/codecs/src/web.rs b/crates/codecs/src/web.rs
index f48de8634d..584ceb9d6e 100644
--- a/crates/codecs/src/web.rs
+++ b/crates/codecs/src/web.rs
@@ -307,7 +307,9 @@ pub fn encode_jpeg_rgb8(
     }
     let mut out = Vec::new();
     let mut enc = jpeg_encoder::Encoder::new(&mut out, quality.clamp(1, 100));
-    let subsampled = quality < 90;
+    // Like Photoshop's Save for Web: 4:2:0 chroma up to quality 50, 4:4:4 from 51 (measured on
+    // Photoshop 2025's output; its Save As keeps 4:2:0 at every quality).
+    let subsampled = quality <= 50;
     enc.set_progressive(progressive);
     // jpeg-encoder 0.6 writes corrupt baseline scans when optimised Huffman tables meet 4:2:0
     // (both zune-jpeg and image-rs decode them green); progressive output is fine.
@@ -345,6 +347,24 @@ mod tests {
         (0..w * h).map(|i| (((i % w) * 7 + (i / w) * 13 + (i * i) % 5) % n) as u8).collect()
     }
 
+    /// The luma sampling factors (h, v) of a baseline or progressive JPEG.
+    fn luma_sampling(bytes: &[u8]) -> Option<(u8, u8)> {
+        let i = bytes.windows(2).position(|w| w[0] == 0xFF && matches!(w[1], 0xC0..=0xC2))?;
+        let f = *bytes.get(i + 11)?;
+        Some((f >> 4, f & 15))
+    }
+
+    #[test]
+    fn jpeg_chroma_is_full_above_quality_50() {
+        let rgb: Vec<u8> = (0..16 * 16 * 3).map(|i| (i * 37 % 256) as u8).collect();
+        for (q, want) in [(1, (2, 2)), (50, (2, 2)), (51, (1, 1)), (60, (1, 1)), (89, (1, 1)), (100, (1, 1))] {
+            for progressive in [false, true] {
+                let bytes = encode_jpeg_rgb8(16, 16, &rgb, q, progressive, false, None, None, None).unwrap();
+                assert_eq!(luma_sampling(&bytes), Some(want), "quality {q} progressive {progressive}");
+            }
+        }
+    }
+
     #[test]
     fn gif_roundtrips_through_the_decoder() {
         let pal: Vec<[u8; 3]> = (0..200).map(|i| [i as u8, (255 - i) as u8, (i * 3 % 256) as u8]).collect();
diff --git a/crates/codecs/tests/dds.rs b/crates/codecs/tests/dds.rs
new file mode 100644
index 0000000000..766555f6e5
--- /dev/null
+++ b/crates/codecs/tests/dds.rs
@@ -0,0 +1,268 @@
+use photocraft_codecs::{
+    ChannelLayout, CodecError, DecodeOptions, Format, Limits, SampleType, caps, decode, decode_as, decode_as_with, detect, encode, from_extension,
+};
+
+const DDPF_ALPHAPIXELS: u32 = 0x1;
+const DDPF_FOURCC: u32 = 0x4;
+const DDPF_RGB: u32 = 0x40;
+const DDPF_LUMINANCE: u32 = 0x2_0000;
+
+/// A DDS_HEADER for a single-level 2D texture, after the `DDS ` signature.
+fn header(width: u32, height: u32, pf_flags: u32, fourcc: &[u8; 4], bits: u32, masks: [u32; 4]) -> Vec<u8> {
+    let mut b = vec![0u8; 128];
+    b[0..4].copy_from_slice(b"DDS ");
+    let mut put = |at: usize, v: u32| b[at..at + 4].copy_from_slice(&v.to_le_bytes());
+    put(4, 124);
+    put(8, 0x1007); // CAPS | HEIGHT | WIDTH | PIXELFORMAT
+    put(12, height);
+    put(16, width);
+    put(76, 32);
+    put(80, pf_flags);
+    put(88, bits);
+    for (i, m) in masks.into_iter().enumerate() {
+        put(92 + 4 * i, m);
+    }
+    put(108, 0x1000); // DDSCAPS_TEXTURE
+    b[84..88].copy_from_slice(fourcc);
+    b
+}
+
+fn compressed(width: u32, height: u32, fourcc: &[u8; 4]) -> Vec<u8> {
+    header(width, height, DDPF_FOURCC, fourcc, 0, [0; 4])
+}
+
+/// The DX10 extension header after a `DX10` FourCC: format, dimension, misc flags, array size.
+fn dx10(width: u32, height: u32, dxgi: u32, dimension: u32, misc: u32, array: u32) -> Vec<u8> {
+    let mut b = compressed(width, height, b"DX10");
+    for v in [dxgi, dimension, misc, array, 0] {
+        b.extend(v.to_le_bytes());
+    }
+    b
+}
+
+/// BC1 colour endpoints as RGB565, then one 2-bit index per pixel, row by row.
+fn bc1_block(c0: u16, c1: u16, rows: [u8; 4]) -> Vec<u8> {
+    let mut b = Vec::new();
+    b.extend(c0.to_le_bytes());
+    b.extend(c1.to_le_bytes());
+    b.extend(rows);
+    b
+}
+
+const RED: u16 = 0xf800;
+const GREEN: u16 = 0x07e0;
+const BLUE: u16 = 0x001f;
+const BLACK: u16 = 0x0000;
+const WHITE: u16 = 0xffff;
+
+/// Indices 0, 1 on the top row and 2, 3 below them, for the top-left 2x2 pixels.
+const INDICES_0123: [u8; 4] = [0x04, 0x0e, 0, 0];
+
+#[test]
+fn dds_is_readable_but_not_writable() {
+    assert_eq!(from_extension("texture.DDS"), Some(Format::Dds));
+    assert!(caps(Format::Dds).read && !caps(Format::Dds).write);
+    let img = photocraft_codecs::Image::from_u8(1, 1, ChannelLayout::Rgba, vec![0, 0, 0, 0]).unwrap();
+    assert!(matches!(encode(&img, Format::Dds, &Default::default()), Err(CodecError::Unsupported { .. })));
+}
+
+#[test]
+fn decodes_bc1_four_colour_blocks() {
+    // c0 > c1: four opaque colours, the two in between at thirds.
+    let mut b = compressed(2, 2, b"DXT1");
+    b.extend(bc1_block(RED, BLUE, INDICES_0123));
+    assert_eq!(detect(&b), Some(Format::Dds));
+    let im = decode(&b).unwrap();
+    assert_eq!((im.dimensions(), im.layout(), im.sample_type()), ((2, 2), ChannelLayout::Rgba, SampleType::U8));
+    assert_eq!(im.data(), &[255, 0, 0, 255, 0, 0, 255, 255, 170, 0, 85, 255, 85, 0, 170, 255]);
+}
+
+#[test]
+fn decodes_bc1_one_bit_alpha_blocks() {
+    // c0 <= c1: three colours (the third halfway) and index 3 is transparent black.
+    let mut b = compressed(2, 2, b"DXT1");
+    b.extend(bc1_block(BLUE, RED, INDICES_0123));
+    assert_eq!(decode(&b).unwrap().data(), &[0, 0, 255, 255, 255, 0, 0, 255, 128, 0, 128, 255, 0, 0, 0, 0]);
+}
+
+#[test]
+fn decodes_bc2_explicit_alpha_with_four_colour_blocks() {
+    let mut b = compressed(2, 2, b"DXT3");
+    // Four bits of alpha per pixel: 15, 0 on the top row, 8, 1 below.
+    b.extend([0x0f, 0x00, 0x18, 0x00, 0, 0, 0, 0]);
+    // c0 < c1 would mean transparency in BC1; BC2 colour blocks always have four colours.
+    b.extend(bc1_block(BLACK, WHITE, [0x04, 0x0b, 0, 0]));
+    let im = decode(&b).unwrap();
+    assert_eq!(im.layout(), ChannelLayout::Rgba);
+    assert_eq!(im.data(), &[0, 0, 0, 255, 255, 255, 255, 0, 170, 170, 170, 136, 85, 85, 85, 17]);
+}
+
+#[test]
+fn decodes_bc3_interpolated_alpha() {
+    // a0 > a1: eight alpha values, six interpolated at sevenths. Indices 0, 1 / 2, 7.
+    let mut b = compressed(2, 2, b"DXT5");
+    b.extend([255, 0, 0x08, 0xa0, 0x03, 0, 0, 0]);
+    b.extend(bc1_block(BLACK, WHITE, [0x04, 0x0b, 0, 0]));
+    assert_eq!(decode(&b).unwrap().data(), &[0, 0, 0, 255, 255, 255, 255, 0, 170, 170, 170, 219, 85, 85, 85, 36]);
+
+    // a0 <= a1: six values, four interpolated at fifths, then 0 and 255. Indices 2, 5 / 6, 7.
+    let mut b = compressed(2, 2, b"DXT5");
+    let bits: u64 = 2 | 5 << 3 | 6 << 12 | 7 << 15;
+    b.extend([0, 255]);
+    b.extend(&bits.to_le_bytes()[..6]);
+    b.extend(bc1_block(GREEN, GREEN, [0; 4]));
+    assert_eq!(decode(&b).unwrap().data(), &[0, 255, 0, 51, 0, 255, 0, 204, 0, 255, 0, 0, 0, 255, 0, 255]);
+}
+
+#[test]
+fn bc_textures_need_not_be_a_multiple_of_four() {
+    // 5x3 is two blocks wide and one high; the right block's first column is x = 4.
+    let mut b = compressed(5, 3, b"DXT1");
+    b.extend(bc1_block(RED, RED, [0; 4]));
+    b.extend(bc1_block(BLUE, BLUE, [0; 4]));
+    let im = decode(&b).unwrap();
+    assert_eq!(im.dimensions(), (5, 3));
+    let px = |x: usize, y: usize| &im.data()[(y * 5 + x) * 4..(y * 5 + x + 1) * 4];
+    assert_eq!((px(3, 2), px(4, 0), px(4, 2)), (&[255, 0, 0, 255][..], &[0, 0, 255, 255][..], &[0, 0, 255, 255][..]));
+}
+
+#[test]
+fn decodes_uncompressed_rgba_and_bgra_masks() {
+    let rgba = [0xff, 0xff00, 0xff_0000, 0xff00_0000];
+    let mut b = header(2, 1, DDPF_RGB | DDPF_ALPHAPIXELS, &[0; 4], 32, rgba);
+    b.extend([1, 2, 3, 4, 250, 251, 252, 253]);
+    let im = decode(&b).unwrap();
+    assert_eq!(im.layout(), ChannelLayout::Rgba);
+    assert_eq!(im.data(), &[1, 2, 3, 4, 250, 251, 252, 253]);
+
+    let bgra = [0xff_0000, 0xff00, 0xff, 0xff00_0000];
+    let mut b = header(2, 1, DDPF_RGB | DDPF_ALPHAPIXELS, &[0; 4], 32, bgra);
+    b.extend([3, 2, 1, 4, 252, 251, 250, 253]);
+    assert_eq!(decode(&b).unwrap().data(), &[1, 2, 3, 4, 250, 251, 252, 253]);
+
+    // An alpha mask without DDPF_ALPHAPIXELS is not alpha: X8R8G8B8 opens as RGB.
+    let mut b = header(1, 1, DDPF_RGB, &[0; 4], 32, bgra);
+    b.extend([3, 2, 1, 0]);
+    let im = decode(&b).unwrap();
+    assert_eq!((im.layout(), im.data()), (ChannelLayout::Rgb, &[1u8, 2, 3][..]));
+}
+
+#[test]
+fn decodes_packed_masks_and_luminance() {
+    // R5G6B5: each field scaled to 0..255; 3 of 31 is 25.
+    let mut b = header(4, 1, DDPF_RGB, &[0; 4], 16, [0xf800, 0x07e0, 0x001f, 0]);
+    for v in [RED, GREEN, BLUE, 3 << 11] {
+        b.extend(v.to_le_bytes());
+    }
+    let im = decode(&b).unwrap();
+    assert_eq!(im.layout(), ChannelLayout::Rgb);
+    assert_eq!(im.data(), &[255, 0, 0, 0, 255, 0, 0, 0, 255, 25, 0, 0]);
+
+    // 24-bit rows are packed three bytes a pixel, without padding.
+    let mut b = header(2, 2, DDPF_RGB, &[0; 4], 24, [0xff_0000, 0xff00, 0xff, 0]);
+    b.extend([3, 2, 1, 6, 5, 4, 9, 8, 7, 12, 11, 10]);
+    assert_eq!(decode(&b).unwrap().data(), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+
+    let mut b = header(2, 1, DDPF_LUMINANCE | DDPF_ALPHAPIXELS, &[0; 4], 16, [0xff, 0, 0, 0xff00]);
+    b.extend([10, 20, 30, 40]);
+    let im = decode(&b).unwrap();
+    assert_eq!((im.layout(), im.data()), (ChannelLayout::GrayA, &[10u8, 20, 30, 40][..]));
+}
+
+#[test]
+fn decodes_dx10_headers() {
+    let mut b = dx10(1, 1, 28, 3, 0, 1); // R8G8B8A8_UNORM
+    b.extend([1, 2, 3, 4]);
+    assert_eq!(decode(&b).unwrap().data(), &[1, 2, 3, 4]);
+
+    let mut b = dx10(1, 1, 91, 3, 0, 1); // B8G8R8A8_UNORM_SRGB
+    b.extend([3, 2, 1, 4]);
+    assert_eq!(decode(&b).unwrap().data(), &[1, 2, 3, 4]);
+
+    let mut b = dx10(2, 2, 71, 3, 0, 1); // BC1_UNORM
+    b.extend(bc1_block(BLUE, RED, INDICES_0123));
+    assert_eq!(decode(&b).unwrap().data(), &[0, 0, 255, 255, 255, 0, 0, 255, 128, 0, 128, 255, 0, 0, 0, 0]);
+}
+
+#[test]
+fn only_the_top_mip_level_is_read() {
+    let mut b = compressed(4, 4, b"DXT1");
+    b[28..32].copy_from_slice(&3u32.to_le_bytes());
+    b.extend(bc1_block(RED, RED, [0; 4]));
+    b.extend(bc1_block(BLUE, BLUE, [0; 4]));
+    b.extend(bc1_block(GREEN, GREEN, [0; 4]));
+    let im = decode(&b).unwrap();
+    assert_eq!(im.dimensions(), (4, 4));
+    assert!(im.data().chunks(4).all(|p| p == [255, 0, 0, 255]));
+}
+
+#[test]
+fn refuses_cubemaps_arrays_and_volumes() {
+    let unsupported = |b: &[u8], what: &str| match decode_as(Format::Dds, b) {
+        Err(CodecError::Unsupported { reason, .. }) => assert!(reason.contains(what), "{reason}"),
+        other => panic!("{what}: {other:?}"),
+    };
+    let mut cube = compressed(4, 4, b"DXT1");
+    cube[112..116].copy_from_slice(&0xfe00u32.to_le_bytes()); // DDSCAPS2_CUBEMAP and all faces
+    cube.extend([0; 8 * 6]);
+    unsupported(&cube, "cubemap");
+    let mut volume = compressed(4, 4, b"DXT1");
+    volume[8..12].copy_from_slice(&(0x1007u32 | 0x80_0000).to_le_bytes()); // DDSD_DEPTH
+    volume[24..28].copy_from_slice(&4u32.to_le_bytes());
+    volume[112..116].copy_from_slice(&0x20_0000u32.to_le_bytes()); // DDSCAPS2_VOLUME
+    volume.extend([0; 8 * 4]);
+    unsupported(&volume, "volume");
+    unsupported(&dx10(4, 4, 71, 3, 0x4, 1), "cubemap");
+    unsupported(&dx10(4, 4, 71, 3, 0, 6), "array");
+    unsupported(&dx10(4, 4, 71, 4, 0, 1), "2D");
+    unsupported(&dx10(4, 4, 98, 3, 0, 1), "98"); // BC7_UNORM
+    unsupported(&compressed(4, 4, b"ATI2"), "ATI2");
+    unsupported(&compressed(4, 4, b"DXT2"), "premultiplied");
+}
+
+#[test]
+fn rejects_truncated_files_at_every_length_without_panicking() {
+    let mut b = dx10(5, 3, 77, 3, 0, 1); // BC3_UNORM: two 16-byte blocks
+    b.extend([0x5a; 32]);
+    assert!(decode(&b).is_ok());
+    for n in 0..b.len() {
+        assert!(decode_as(Format::Dds, &b[..n]).is_err(), "decoded {n} of {} bytes", b.len());
+    }
+    let mut b = header(3, 2, DDPF_RGB, &[0; 4], 24, [0xff_0000, 0xff00, 0xff, 0]);
+    b.extend([7; 18]);
+    assert!(decode(&b).is_ok());
+    assert!(decode_as(Format::Dds, &b[..b.len() - 1]).is_err(), "one byte short");
+}
+
+#[test]
+fn rejects_bogus_sizes_and_pixel_formats() {
+    // Huge dimensions are refused before anything is allocated.
+    let mut huge = compressed(u32::MAX, u32::MAX, b"DXT1");
+    huge.extend([0; 8]);
+    assert!(matches!(decode_as(Format::Dds, &huge), Err(CodecError::LimitExceeded(_))));
+    let opts = DecodeOptions { limits: Limits { max_alloc: 1024, ..Default::default() }, ..Default::default() };
+    let mut tight = header(64, 64, DDPF_RGB, &[0; 4], 32, [0xff, 0xff00, 0xff_0000, 0]);
+    tight.extend(vec![0; 64 * 64 * 4]);
+    assert!(matches!(decode_as_with(Format::Dds, &tight, &opts), Err(CodecError::LimitExceeded(_))));
+    assert!(decode_as(Format::Dds, &compressed(0, 4, b"DXT1")).is_err(), "zero width");
+
+    let mut bad_size = compressed(4, 4, b"DXT1");
+    bad_size[4..8].copy_from_slice(&100u32.to_le_bytes());
+    bad_size.extend([0; 8]);
+    assert!(matches!(decode_as(Format::Dds, &bad_size), Err(CodecError::Malformed { .. })), "header size must be 124");
+
+    for (bits, masks) in [
+        (12, [0xf00, 0xf0, 0xf, 0]),        // not a whole number of bytes
+        (16, [0xff_0000, 0xff00, 0xff, 0]), // a mask wider than the pixel
+        (32, [0xf0f, 0xf0f0, 0xf_0000, 0]), // a mask with a gap
+        (32, [0, 0, 0, 0]),                 // no colour at all
+        (0, [0xff, 0xff00, 0xff_0000, 0]),  // zero bits per pixel
+    ] {
+        let mut b = header(1, 1, DDPF_RGB, &[0; 4], bits, masks);
+        b.extend([0; 4]);
+        assert!(decode_as(Format::Dds, &b).is_err(), "{bits} bits, masks {masks:x?}");
+    }
+    let mut no_format = header(1, 1, 0, &[0; 4], 32, [0xff, 0xff00, 0xff_0000, 0]);
+    no_format.extend([0; 4]);
+    assert!(matches!(decode_as(Format::Dds, &no_format), Err(CodecError::Unsupported { .. })));
+}
diff --git a/crates/codecs/tests/deep_exr.rs b/crates/codecs/tests/deep_exr.rs
index 001cfab7e9..5a6d6ae75e 100644
--- a/crates/codecs/tests/deep_exr.rs
+++ b/crates/codecs/tests/deep_exr.rs
@@ -254,6 +254,9 @@ fn gen_deep(
     out
 }
 
+/// RGBA float channels in chlist (alphabetical) order, no Z (everything composites).
+const RGBA_NO_Z: [Chan; 4] = [Chan { name: "A", ty: 2 }, Chan { name: "B", ty: 2 }, Chan { name: "G", ty: 2 }, Chan { name: "R", ty: 2 }];
+
 /// RGBA(Z) float channels in chlist (alphabetical) order.
 const RGBAZ: [Chan; 5] =
     [Chan { name: "A", ty: 2 }, Chan { name: "B", ty: 2 }, Chan { name: "G", ty: 2 }, Chan { name: "R", ty: 2 }, Chan { name: "Z", ty: 2 }];
@@ -709,3 +712,131 @@ fn real_deep_files_decode() {
         assert!(img.warnings.iter().any(|w| matches!(w, photocraft_codecs::DecodeWarning::DeepFlattened { .. })), "{name}");
     }
 }
+
+/// `gen_deep` for a cropped render: the data window sits at `(dwx, dwy)` inside a larger
+/// display window of `sw × sh` (the stage the renderer composed onto). Scanline chunk Y
+/// coordinates are absolute display rows, so they carry the data-window offset.
+#[allow(clippy::too_many_arguments)]
+fn gen_deep_cropped(
+    w: usize,
+    h: usize,
+    dwx: i32,
+    dwy: i32,
+    sw: usize,
+    sh: usize,
+    channels: &[Chan],
+    counts: &[u32],
+    sample: &dyn Fn(usize, usize) -> Vec<f32>,
+) -> Vec<u8> {
+    let mut out = Vec::new();
+    out.extend_from_slice(&0x0131_2f76u32.to_le_bytes());
+    out.extend_from_slice(&(2u32 | 0x800).to_le_bytes());
+
+    let mut chlist = Vec::new();
+    for c in channels {
+        chlist.extend_from_slice(c.name.as_bytes());
+        chlist.push(0);
+        chlist.extend_from_slice(&c.ty.to_le_bytes());
+        chlist.push(0);
+        chlist.extend_from_slice(&[0u8; 3]);
+        chlist.extend_from_slice(&1i32.to_le_bytes());
+        chlist.extend_from_slice(&1i32.to_le_bytes());
+    }
+    chlist.push(0);
+    attr(&mut out, "channels", "chlist", &chlist);
+    attr(&mut out, "compression", "compression", &[0u8]);
+    // box2i is inclusive: the windows end at position + size - 1.
+    let dw: Vec<u8> = [dwx, dwy, dwx + w as i32 - 1, dwy + h as i32 - 1].iter().flat_map(|v| v.to_le_bytes()).collect();
+    attr(&mut out, "dataWindow", "box2i", &dw);
+    let disp: Vec<u8> = [0i32, 0, sw as i32 - 1, sh as i32 - 1].iter().flat_map(|v| v.to_le_bytes()).collect();
+    attr(&mut out, "displayWindow", "box2i", &disp);
+    attr(&mut out, "lineOrder", "lineOrder", &[0]);
+    attr(&mut out, "pixelAspectRatio", "float", &1f32.to_le_bytes());
+    attr(&mut out, "screenWindowCenter", "v2f", &[0f32.to_le_bytes(), 0f32.to_le_bytes()].concat());
+    attr(&mut out, "screenWindowWidth", "float", &1f32.to_le_bytes());
+    attr(&mut out, "type", "string", b"deepscanline");
+    attr(&mut out, "version", "int", &1i32.to_le_bytes());
+    out.push(0);
+
+    // One scanline block per data row; the pixel indexing stays data-relative.
+    let mut chunks: Vec<Vec<u8>> = Vec::new();
+    for y in 0..h {
+        let pixels: Vec<usize> = (y * w..y * w + w).collect();
+        let mut c = Vec::new();
+        c.extend_from_slice(&(dwy + y as i32).to_le_bytes());
+        let mut table = Vec::with_capacity(pixels.len() * 4);
+        let mut acc = 0u32;
+        for &p in &pixels {
+            acc += counts[p];
+            table.extend_from_slice(&acc.to_le_bytes());
+        }
+        let mut data = Vec::new();
+        for (ci, _) in channels.iter().enumerate() {
+            for &p in &pixels {
+                for v in sample(p, ci) {
+                    data.extend_from_slice(&v.to_le_bytes());
+                }
+            }
+        }
+        c.extend_from_slice(&(table.len() as u64).to_le_bytes());
+        c.extend_from_slice(&(data.len() as u64).to_le_bytes());
+        c.extend_from_slice(&(data.len() as u64).to_le_bytes());
+        c.extend_from_slice(&table);
+        c.extend_from_slice(&data);
+        chunks.push(c);
+    }
+    let mut pos = out.len() + chunks.len() * 8;
+    let mut table = Vec::new();
+    for c in &chunks {
+        table.extend_from_slice(&(pos as u64).to_le_bytes());
+        pos += c.len();
+    }
+    out.extend_from_slice(&table);
+    for c in chunks {
+        out.extend_from_slice(&c);
+    }
+    out
+}
+
+/// A cropped render opens on the full display-window stage: MY27-style renders carry a
+/// `display_window` of the full frame (e.g. 4000×3000) while the deep data window is the
+/// render pass's crop inside it. The image must open at stage size with the data at its
+/// crop offset, transparent elsewhere — not cropped to the data window.
+#[test]
+fn cropped_deep_data_opens_on_the_display_stage() {
+    let (w, h, dwx, dwy, sw, sh) = (24usize, 16usize, 8i32, 6i32, 48usize, 32usize);
+    let counts = vec![1u32; w * h];
+    let sample = |p: usize, ci: usize| -> Vec<f32> {
+        // chlist order (RGBA_NO_Z): A, B, G, R.
+        let x = p % w;
+        let y = p / w;
+        match ci {
+            0 => vec![1.0],                 // A
+            1 => vec![0.5],                 // B
+            2 => vec![y as f32 / h as f32], // G
+            _ => vec![x as f32 / w as f32], // R
+        }
+    };
+    let bytes = gen_deep_cropped(w, h, dwx, dwy, sw, sh, &RGBA_NO_Z, &counts, &sample);
+    let img = decode(&bytes).expect("cropped deep EXR decodes");
+    assert_eq!((img.width(), img.height()), (sw as u32, sh as u32), "opens on the display window stage");
+    assert!(img.warnings.iter().any(|w| matches!(w, photocraft_codecs::DecodeWarning::DisplayWindowStage { origin, .. } if *origin == (dwx, dwy))));
+
+    // The data sits at its crop offset: the first data pixel's green channel carries its
+    // data-row fraction, everything outside the data region stays transparent black.
+    let s = img.to_f32_samples().expect("f32");
+    let nc = s.len() / (sw * sh);
+    let px = |x: usize, y: usize| -> Vec<f32> { s[y * sw * nc + x * nc..y * sw * nc + x * nc + nc].to_vec() };
+    let first = px(dwx as usize, dwy as usize);
+    assert!(
+        (first[0] - 0.0).abs() < 1e-5 && (first[1] - 0.0).abs() < 1e-5 && (first[2] - 0.5).abs() < 1e-5 && (first[3] - 1.0).abs() < 1e-5,
+        "first data pixel at the offset: {first:?}"
+    );
+    let last = px(dwx as usize + w - 1, dwy as usize + h - 1);
+    assert!(
+        (last[0] - (w - 1) as f32 / w as f32).abs() < 1e-5 && (last[1] - (h - 1) as f32 / h as f32).abs() < 1e-5,
+        "last data pixel keeps its coordinates: {last:?}"
+    );
+    let outside = px(0, 0);
+    assert_eq!(outside, vec![0.0, 0.0, 0.0, 0.0], "outside the data region: transparent");
+}
diff --git a/crates/codecs/tests/detect_caps.rs b/crates/codecs/tests/detect_caps.rs
index 367a8bd813..22bf227eb8 100644
--- a/crates/codecs/tests/detect_caps.rs
+++ b/crates/codecs/tests/detect_caps.rs
@@ -59,6 +59,7 @@ fn default_build_formats_all_symmetric() {
         Format::OpenExr,
         Format::Hdr,
         Format::Fits,
+        Format::Dpx,
     ];
     for f in expected {
         assert!(caps(f).read && caps(f).write, "{f:?}");
diff --git a/crates/codecs/tests/dpx.rs b/crates/codecs/tests/dpx.rs
new file mode 100644
index 0000000000..8fdeb398c3
--- /dev/null
+++ b/crates/codecs/tests/dpx.rs
@@ -0,0 +1,386 @@
+//! DPX (SMPTE 268M) read and write, against fixtures packed here independently of the codec:
+//! every descriptor, bit depth and packing it reads, both byte orders, the header fields kept
+//! through a round trip, the bit-depth choice on export and the files it refuses (#1049).
+
+use photocraft_codecs::*;
+
+const HEADER: usize = 2048;
+const ELEMENT0: usize = 780;
+
+/// A DPX file built field by field.
+#[derive(Clone)]
+struct Fixture {
+    big: bool,
+    width: u32,
+    height: u32,
+    descriptor: u8,
+    bits: u8,
+    packing: u16,
+    encoding: u16,
+    signed: bool,
+    transfer: u8,
+    colorimetric: u8,
+    orientation: u16,
+    elements: u16,
+    strings: Vec<((usize, usize), &'static str)>,
+    frame_position: u32,
+    frame_rate: f32,
+    time_code: u32,
+    /// Code values, interleaved, top line first.
+    codes: Vec<u16>,
+}
+
+impl Fixture {
+    fn new(descriptor: u8, bits: u8, packing: u16, width: u32, height: u32) -> Self {
+        let channels = channels(descriptor);
+        let max = (1u32 << bits) - 1;
+        // Spread over the whole range, ends included.
+        let n = (width * height) as usize * channels;
+        let codes = (0..n)
+            .map(|i| {
+                if i == 0 {
+                    0
+                } else if i == 1 {
+                    max as u16
+                } else {
+                    ((i as u64 * 2654435761) % (u64::from(max) + 1)) as u16
+                }
+            })
+            .collect();
+        Fixture {
+            big: true,
+            width,
+            height,
+            descriptor,
+            bits,
+            packing,
+            encoding: 0,
+            signed: false,
+            transfer: 255,
+            colorimetric: 255,
+            orientation: 0,
+            elements: 1,
+            strings: Vec::new(),
+            frame_position: u32::MAX,
+            frame_rate: f32::from_bits(u32::MAX),
+            time_code: u32::MAX,
+            codes,
+        }
+    }
+
+    fn u16(&self, v: u16) -> [u8; 2] {
+        if self.big { v.to_be_bytes() } else { v.to_le_bytes() }
+    }
+
+    fn u32(&self, v: u32) -> [u8; 4] {
+        if self.big { v.to_be_bytes() } else { v.to_le_bytes() }
+    }
+
+    fn line(&self, codes: &[u16]) -> Vec<u8> {
+        let mut out = Vec::new();
+        match (self.bits, self.packing) {
+            (8, _) => out.extend(codes.iter().map(|&c| c as u8)),
+            (16, _) => out.extend(codes.iter().flat_map(|&c| self.u16(c))),
+            (10, 1 | 2) => {
+                let base = if self.packing == 1 { 22 } else { 20 };
+                for chunk in codes.chunks(3) {
+                    let w = chunk.iter().enumerate().fold(0u32, |w, (i, &c)| w | (u32::from(c) << (base - 10 * i as u32)));
+                    out.extend(self.u32(w));
+                }
+            }
+            (12, 1) => out.extend(codes.iter().flat_map(|&c| self.u16(c << 4))),
+            _ => {
+                // One bit stream, high bits first, cut into 32-bit words.
+                let mut bits: Vec<bool> = codes.iter().flat_map(|&c| (0..self.bits).rev().map(move |b| (c >> b) & 1 == 1)).collect();
+                bits.resize(bits.len().div_ceil(32) * 32, false);
+                for word in bits.chunks(32) {
+                    out.extend(self.u32(word.iter().fold(0u32, |w, &b| (w << 1) | u32::from(b))));
+                }
+            }
+        }
+        out.resize(out.len().div_ceil(4) * 4, 0);
+        out
+    }
+
+    fn bytes(&self) -> Vec<u8> {
+        let mut b = vec![0u8; HEADER];
+        let mut put = |at: usize, v: &[u8]| b[at..at + v.len()].copy_from_slice(v);
+        put(0, if self.big { b"SDPX" } else { b"XPDS" });
+        put(4, &self.u32(HEADER as u32));
+        put(8, b"V2.0");
+        put(24, &self.u32(1664));
+        put(28, &self.u32(384));
+        put(768, &self.u16(self.orientation));
+        put(770, &self.u16(self.elements));
+        put(772, &self.u32(self.width));
+        put(776, &self.u32(self.height));
+        for el in 0..usize::from(self.elements.min(8)) {
+            let e = ELEMENT0 + el * 72;
+            put(e, &self.u32(u32::from(self.signed)));
+            put(e + 20, &[self.descriptor, self.transfer, self.colorimetric, self.bits]);
+            put(e + 24, &self.u16(self.packing));
+            put(e + 26, &self.u16(self.encoding));
+            put(e + 28, &self.u32(HEADER as u32));
+        }
+        for &((at, len), s) in &self.strings {
+            assert!(s.len() < len);
+            put(at, s.as_bytes());
+        }
+        put(1712, &self.u32(self.frame_position));
+        put(1724, &self.u32(self.frame_rate.to_bits()));
+        put(1920, &self.u32(self.time_code));
+        let per_line = self.width as usize * channels(self.descriptor);
+        for line in self.codes.chunks(per_line) {
+            b.extend(self.line(line));
+        }
+        b
+    }
+}
+
+fn channels(descriptor: u8) -> usize {
+    match descriptor {
+        6 => 1,
+        50 => 3,
+        _ => 4,
+    }
+}
+
+fn layout(descriptor: u8) -> ChannelLayout {
+    match descriptor {
+        6 => ChannelLayout::Gray,
+        50 => ChannelLayout::Rgb,
+        _ => ChannelLayout::Rgba,
+    }
+}
+
+/// The 16-bit sample a code value opens as: `round(c × 65535 / (2^b − 1))`.
+fn expected(c: u16, bits: u8) -> u16 {
+    (f64::from(c) * 65535.0 / f64::from((1u32 << bits) - 1)).round() as u16
+}
+
+/// Reads the code values of a big-endian file we wrote (packing 0 at 8/16 bits, 1 at 10/12).
+fn written_codes(b: &[u8]) -> (u8, u16, Vec<u16>) {
+    let be16 = |at: usize| u16::from_be_bytes([b[at], b[at + 1]]);
+    let be32 = |at: usize| u32::from_be_bytes([b[at], b[at + 1], b[at + 2], b[at + 3]]);
+    let (w, h) = (be32(772) as usize, be32(776) as usize);
+    let nc = channels(b[ELEMENT0 + 20]);
+    let (bits, packing) = (b[ELEMENT0 + 23], be16(ELEMENT0 + 24));
+    let off = be32(ELEMENT0 + 28) as usize;
+    let per_line = w * nc;
+    let stride = match bits {
+        10 => per_line.div_ceil(3) * 4,
+        _ => (per_line * if bits == 8 { 1 } else { 2 }).div_ceil(4) * 4,
+    };
+    let mut codes = Vec::new();
+    for y in 0..h {
+        let line = &b[off + y * stride..];
+        for i in 0..per_line {
+            codes.push(match bits {
+                8 => u16::from(line[i]),
+                10 => ((be32_at(line, i / 3 * 4) >> (22 - 10 * (i % 3) as u32)) & 0x3FF) as u16,
+                12 => u16::from_be_bytes([line[i * 2], line[i * 2 + 1]]) >> 4,
+                _ => u16::from_be_bytes([line[i * 2], line[i * 2 + 1]]),
+            });
+        }
+    }
+    (bits, packing, codes)
+}
+
+fn be32_at(b: &[u8], at: usize) -> u32 {
+    u32::from_be_bytes([b[at], b[at + 1], b[at + 2], b[at + 3]])
+}
+
+fn opts(bits: Option<DpxBits>) -> EncodeOptions {
+    EncodeOptions { dpx_bits: bits, ..EncodeOptions::default() }
+}
+
+const COMBOS: [(u8, u16); 7] = [(8, 0), (10, 0), (10, 1), (10, 2), (12, 0), (12, 1), (16, 0)];
+
+#[test]
+fn every_descriptor_depth_and_packing_opens_with_its_model_and_values() {
+    for descriptor in [6, 50, 51] {
+        for (bits, packing) in COMBOS {
+            // Widths that leave partly filled words at the end of a line.
+            let fx = Fixture::new(descriptor, bits, packing, 5, 3);
+            let img = decode(&fx.bytes()).unwrap_or_else(|e| panic!("{descriptor} {bits}/{packing}: {e}"));
+            let what = format!("descriptor {descriptor}, {bits} bits, packing {packing}");
+            assert_eq!(detect(&fx.bytes()), Some(Format::Dpx));
+            assert_eq!((img.width(), img.height()), (5, 3), "{what}");
+            assert_eq!(img.layout(), layout(descriptor), "{what}");
+            assert_eq!(img.layout().has_alpha(), descriptor == 51, "{what}");
+            match bits {
+                8 => assert_eq!(img.as_u8().unwrap(), fx.codes.iter().map(|&c| c as u8).collect::<Vec<_>>(), "{what}"),
+                16 => assert_eq!(img.to_u16_samples().unwrap(), fx.codes, "{what}"),
+                _ => assert_eq!(img.to_u16_samples().unwrap(), fx.codes.iter().map(|&c| expected(c, bits)).collect::<Vec<_>>(), "{what}"),
+            }
+        }
+    }
+}
+
+#[test]
+fn big_and_little_endian_files_open_identically() {
+    for (bits, packing) in COMBOS {
+        let be = Fixture::new(50, bits, packing, 4, 2);
+        let le = Fixture { big: false, ..be.clone() };
+        assert_eq!(&le.bytes()[..4], b"XPDS");
+        assert_eq!(decode(&be.bytes()).unwrap(), decode(&le.bytes()).unwrap(), "{bits} bits, packing {packing}");
+    }
+}
+
+#[test]
+fn ten_bit_code_value_opens_as_the_rounded_16_bit_value() {
+    let mut fx = Fixture::new(6, 10, 1, 1, 1);
+    fx.codes = vec![512];
+    assert_eq!(decode(&fx.bytes()).unwrap().to_u16_samples().unwrap(), vec![(512.0f64 * 65535.0 / 1023.0).round() as u16]);
+}
+
+#[test]
+fn ten_and_twelve_bit_frames_written_back_at_their_depth_keep_their_code_values() {
+    for (bits, choice) in [(10, DpxBits::Bits10), (12, DpxBits::Bits12)] {
+        for packing in [0, 1] {
+            let fx = Fixture::new(50, bits, packing, 7, 3);
+            let out = encode(&decode(&fx.bytes()).unwrap(), Format::Dpx, &opts(Some(choice))).unwrap();
+            let (wbits, wpacking, codes) = written_codes(&out);
+            assert_eq!((wbits, wpacking), (bits, 1));
+            assert_eq!(codes, fx.codes, "{bits} bits, packing {packing}");
+        }
+    }
+}
+
+#[test]
+fn sixteen_bit_frames_round_trip_losslessly_and_files_start_with_sdpx() {
+    let fx = Fixture { big: false, ..Fixture::new(51, 16, 0, 6, 4) };
+    let img = decode(&fx.bytes()).unwrap();
+    let out = encode(&img, Format::Dpx, &EncodeOptions::default()).unwrap();
+    assert_eq!(&out[..4], b"SDPX");
+    let (bits, packing, codes) = written_codes(&out);
+    assert_eq!((bits, packing, codes), (16, 0, fx.codes));
+    assert_eq!(decode(&out).unwrap().to_u16_samples(), img.to_u16_samples());
+}
+
+#[test]
+fn log_frames_report_their_encoding_and_keep_the_plain_mapping() {
+    let mut fx = Fixture::new(50, 10, 1, 3, 2);
+    (fx.transfer, fx.colorimetric) = (3, 1);
+    let img = decode(&fx.bytes()).unwrap();
+    assert_eq!(img.warnings, vec![DecodeWarning::DpxEncoding { transfer: 3, colorimetric: 1 }]);
+    let note = img.warnings[0].to_string();
+    assert!(note.contains("logarithmic (3)") && note.contains("printing density (1)"), "{note}");
+    assert_eq!(img.to_u16_samples().unwrap(), fx.codes.iter().map(|&c| expected(c, 10)).collect::<Vec<_>>());
+}
+
+#[test]
+fn only_the_first_of_several_image_elements_is_imported() {
+    let mut fx = Fixture::new(6, 8, 0, 2, 2);
+    fx.elements = 2;
+    let img = decode(&fx.bytes()).unwrap();
+    assert_eq!(img.warnings.iter().map(ToString::to_string).collect::<Vec<_>>(), ["only the first of 2 image elements was imported"]);
+}
+
+#[test]
+fn listed_header_fields_survive_a_round_trip() {
+    let mut fx = Fixture::new(50, 10, 1, 2, 2);
+    fx.strings = vec![((160, 100), "Resolve 20.1"), ((260, 200), "Reel 7"), ((460, 200), "(c) 2026 Studio"), ((136, 24), "2026:10:12:09:30:00UTC")];
+    (fx.transfer, fx.colorimetric, fx.frame_position, fx.frame_rate, fx.time_code) = (3, 1, 86400, 23.976, 0x0102_0304);
+    let img = decode(&fx.bytes()).unwrap();
+    for (k, v) in [
+        ("DPX:Creator", "Resolve 20.1"),
+        ("DPX:Project", "Reel 7"),
+        ("DPX:Copyright", "(c) 2026 Studio"),
+        ("DPX:CreationTime", "2026:10:12:09:30:00UTC"),
+        ("DPX:Transfer", "3"),
+        ("DPX:Colorimetric", "1"),
+        ("DPX:FramePosition", "86400"),
+        ("DPX:FrameRate", "23.976"),
+        ("DPX:TimeCode", "01:02:03:04"),
+    ] {
+        assert!(img.meta.text.contains(&(k.into(), v.into())), "{k} = {v} in {:?}", img.meta.text);
+    }
+    let out = encode(&img, Format::Dpx, &opts(Some(DpxBits::Bits10))).unwrap();
+    let src = fx.bytes();
+    // Field by field: the strings, the element's encoding codes, film and TV fields.
+    for (at, len) in [(160, 100), (260, 200), (460, 200), (136, 24), (ELEMENT0 + 21, 2), (1712, 4), (1724, 4), (1920, 4)] {
+        assert_eq!(out[at..at + len], src[at..at + len], "field at {at}");
+    }
+    assert_eq!(decode(&out).unwrap().meta.text, img.meta.text);
+}
+
+#[test]
+fn chosen_bit_depth_sets_the_header_and_packing() {
+    let img = Image::from_u16(5, 2, ChannelLayout::Rgb, &(0..30u16).map(|i| i * 2000).collect::<Vec<_>>()).unwrap();
+    for (choice, bits, packing) in [(DpxBits::Bits8, 8, 0), (DpxBits::Bits10, 10, 1), (DpxBits::Bits12, 12, 1), (DpxBits::Bits16, 16, 0)] {
+        let out = encode(&img, Format::Dpx, &opts(Some(choice))).unwrap();
+        assert_eq!((out[ELEMENT0 + 23], u16::from_be_bytes([out[ELEMENT0 + 24], out[ELEMENT0 + 25]])), (bits, packing), "{choice:?}");
+        let back = decode(&out).unwrap();
+        assert_eq!((back.width(), back.height(), back.layout()), (5, 2, ChannelLayout::Rgb));
+    }
+    // Without a choice the depth follows the image.
+    let gray8 = Image::from_u8(3, 1, ChannelLayout::Gray, vec![0, 128, 255]).unwrap();
+    assert_eq!(encode(&gray8, Format::Dpx, &EncodeOptions::default()).unwrap()[ELEMENT0 + 23], 8);
+    assert_eq!(encode(&img, Format::Dpx, &EncodeOptions::default()).unwrap()[ELEMENT0 + 23], 16);
+    let float = img.convert(ChannelLayout::Rgb, SampleType::F32);
+    assert_eq!(encode(&float, Format::Dpx, &EncodeOptions::default()).unwrap()[ELEMENT0 + 23], 16);
+    assert!(fidelity_warnings(&float, Format::Dpx).contains(&FidelityWarning::DepthReduced { from: SampleType::F32, to: SampleType::U16 }));
+}
+
+#[test]
+fn gray_with_alpha_is_written_as_luma_with_a_warning() {
+    let img = Image::from_u8(2, 1, ChannelLayout::GrayA, vec![10, 128, 200, 255]).unwrap();
+    let out = encode(&img, Format::Dpx, &EncodeOptions::default()).unwrap();
+    assert_eq!(out[ELEMENT0 + 20], 6);
+    assert_eq!(decode(&out).unwrap().as_u8().unwrap(), &[10, 200]);
+    assert!(fidelity_warnings(&img, Format::Dpx).contains(&FidelityWarning::AlphaDiscarded));
+}
+
+#[test]
+fn only_free_form_text_is_reported_as_dropped() {
+    let mut img = Image::from_u8(1, 1, ChannelLayout::Rgb, vec![1, 2, 3]).unwrap();
+    img.meta.text = vec![("DPX:Project".into(), "Reel 7".into())];
+    assert!(!fidelity_warnings(&img, Format::Dpx).contains(&FidelityWarning::TextDropped));
+    img.meta.text.push(("Comment".into(), "from a PNG".into()));
+    assert!(fidelity_warnings(&img, Format::Dpx).contains(&FidelityWarning::TextDropped));
+}
+
+#[test]
+fn stored_orientation_is_turned_upright() {
+    // Orientation 4: the stored lines are the image's columns, left to right.
+    let mut fx = Fixture::new(6, 8, 0, 3, 1);
+    fx.codes = vec![1, 2, 3];
+    fx.orientation = 4;
+    let img = decode(&fx.bytes()).unwrap();
+    assert_eq!((img.width(), img.height(), img.as_u8().unwrap()), (1, 3, &[1u8, 2, 3][..]));
+}
+
+#[test]
+fn unsupported_and_damaged_files_error_instead_of_panicking() {
+    let unsupported = |bytes: Vec<u8>, what: &str| {
+        assert!(matches!(decode(&bytes), Err(CodecError::Unsupported { format: Format::Dpx, .. })), "{what}");
+    };
+    unsupported(Fixture { descriptor: 100, ..Fixture::new(50, 8, 0, 2, 2) }.bytes(), "ABGR descriptor");
+    unsupported(Fixture { encoding: 1, ..Fixture::new(50, 10, 1, 2, 2) }.bytes(), "run-length encoding");
+    unsupported(Fixture { signed: true, ..Fixture::new(50, 16, 0, 2, 2) }.bytes(), "signed samples");
+    let mut float = Fixture::new(50, 16, 0, 2, 2).bytes();
+    float[ELEMENT0 + 23] = 32;
+    unsupported(float, "32-bit float");
+    let mut method_b = Fixture::new(50, 12, 1, 2, 2).bytes();
+    method_b[ELEMENT0 + 24..ELEMENT0 + 26].copy_from_slice(&2u16.to_be_bytes());
+    unsupported(method_b, "12-bit method B");
+
+    let good = Fixture::new(51, 10, 1, 9, 9).bytes();
+    let mut no_elements = good.clone();
+    no_elements[770..772].copy_from_slice(&0u16.to_be_bytes());
+    let mut past_end = good.clone();
+    past_end[ELEMENT0 + 28..ELEMENT0 + 32].copy_from_slice(&u32::MAX.wrapping_sub(1).to_be_bytes());
+    let mut huge = good.clone();
+    huge[772..780].copy_from_slice(&[0xFF; 8]);
+    for (what, bytes) in [
+        ("header cut short", good[..900].to_vec()),
+        ("truncated element", good[..good.len() - 1].to_vec()),
+        ("no image elements", no_elements),
+        ("data offset past the end", past_end),
+        ("absurd size", huge),
+        ("magic alone", b"SDPX".to_vec()),
+    ] {
+        assert!(decode_as(Format::Dpx, &bytes).is_err(), "{what}");
+    }
+}
diff --git a/crates/codecs/tests/exr_cryptomatte.rs b/crates/codecs/tests/exr_cryptomatte.rs
index f5f76c3adb..28ad71e191 100644
--- a/crates/codecs/tests/exr_cryptomatte.rs
+++ b/crates/codecs/tests/exr_cryptomatte.rs
@@ -164,6 +164,56 @@ fn short_channel_suffixes_decode_too() {
     assert_eq!(buf.at(3, 3), &[(cube, 1.0)]);
 }
 
+/// A 4x4 layer `crypto` of one RGBA set `crypto00.<r>/<g>/<b>/<a>` with the given suffixes:
+/// rank 0 (red/green) holds `cube` at 0.6 everywhere, rank 1 (blue/alpha) holds `sphere`
+/// at 0.4 everywhere, the second (ID, coverage) pair the specification stores per set.
+fn cryptomatte_file_rgba(suffixes: [&str; 4]) -> Vec<u8> {
+    let (w, h) = (4usize, 4usize);
+    let [r, g, b, a] = suffixes;
+    let mk = |s: &str, v: f32| AnyChannel::new(format!("crypto00.{s}").as_str(), FlatSamples::F32(vec![v; w * h]));
+    let list = vec![mk(r, cryptomatte_id("cube")), mk(g, 0.6), mk(b, cryptomatte_id("sphere")), mk(a, 0.4)];
+    let key = cryptomatte_key("crypto");
+    let mut attrs = LayerAttributes::named("crypto");
+    attrs.other.insert(text(&format!("cryptomatte/{key}/name")), AttributeValue::Text(text("crypto")));
+    let layer = Layer::new(
+        (w, h),
+        attrs,
+        Encoding { compression: Compression::Uncompressed, blocks: Blocks::ScanLines, line_order: LineOrder::Increasing },
+        AnyChannels::sort(list.into_iter().collect()),
+    );
+    let image = exr::image::Image::from_layers(ImageAttributes::new(IntegerBounds::new((0, 0), (w, h))), vec![layer]);
+    let mut out = std::io::Cursor::new(Vec::new());
+    image.write().to_buffered(&mut out).expect("synthetic cryptomatte exr writes");
+    out.into_inner()
+}
+
+#[test]
+fn blue_alpha_rank_of_a_set_decodes_too() {
+    // Each RGBA set holds two ranks: (red, green) and (blue, alpha). Both must come back.
+    let bytes = cryptomatte_file_rgba(["red", "green", "blue", "alpha"]);
+    let found = cryptomatte_layers(&bytes, &Limits::default()).unwrap();
+    assert_eq!(found.len(), 1);
+    assert_eq!(found[0].channels, ["crypto00"], "one set, listed once");
+    let buf = decode_cryptomatte(&bytes, "crypto", &Limits::default()).unwrap();
+    let (cube, sphere) = (cryptomatte_id("cube"), cryptomatte_id("sphere"));
+    for y in 0..4 {
+        for x in 0..4 {
+            assert_eq!(buf.at(x, y), &[(cube, 0.6), (sphere, 0.4)], "({x}, {y})");
+        }
+    }
+}
+
+#[test]
+fn uppercase_channel_suffixes_decode_both_ranks() {
+    // Blender and others write `.R/.G/.B/.A`; suffixes match regardless of case.
+    for suffixes in [["R", "G", "B", "A"], ["Red", "Green", "Blue", "Alpha"], ["r", "g", "b", "a"]] {
+        let bytes = cryptomatte_file_rgba(suffixes);
+        let buf = decode_cryptomatte(&bytes, "crypto", &Limits::default()).unwrap();
+        let (cube, sphere) = (cryptomatte_id("cube"), cryptomatte_id("sphere"));
+        assert_eq!(buf.at(2, 1), &[(cube, 0.6), (sphere, 0.4)], "{suffixes:?}");
+    }
+}
+
 #[test]
 fn unknown_layer_name_is_unsupported() {
     let bytes = cryptomatte_file("crypto_asset");
diff --git a/crates/codecs/tests/exr_multipart.rs b/crates/codecs/tests/exr_multipart.rs
index c8f9a3bc3f..f106d37791 100644
--- a/crates/codecs/tests/exr_multipart.rs
+++ b/crates/codecs/tests/exr_multipart.rs
@@ -197,3 +197,32 @@ fn parts_are_capped_together() {
     let e = exr_info(&aov_file(), &limits).unwrap_err().to_string();
     assert!(e.contains("across 3 parts"), "{e}");
 }
+
+/// Two ZIP1 parts of 4x4 RGBA; every chunk of part 0 is then overwritten with garbage, so
+/// inflating it fails.
+fn file_with_corrupt_first_part() -> Vec<u8> {
+    let px = |k: f32| -> Vec<(&'static str, Vec<f32>)> { ["R", "G", "B", "A"].iter().map(|c| (*c, vec![k; 16])).collect() };
+    let mut bytes = write_image(vec![layer_f32("first", Compression::ZIP1, &px(0.25)), layer_f32("second", Compression::ZIP1, &px(0.75))]);
+    let mut cursor = std::io::Cursor::new(&bytes[..]);
+    exr::meta::MetaData::read_from_buffered(&mut cursor, false).unwrap();
+    let table = cursor.position() as usize;
+    // Part 0 owns the first four of the eight chunks (one scan line per ZIP1 block).
+    for i in 0..4 {
+        let at = table + i * 8;
+        let offset = u64::from_le_bytes(bytes[at..at + 8].try_into().unwrap()) as usize;
+        let size = u32::from_le_bytes(bytes[offset + 8..offset + 12].try_into().unwrap()) as usize;
+        bytes[offset + 12..offset + 12 + size].fill(0xA5);
+    }
+    bytes
+}
+
+#[test]
+fn decoding_one_part_does_not_decode_the_others() {
+    let bytes = file_with_corrupt_first_part();
+    // Part 0 is unreadable ...
+    assert!(decode_exr_part(&bytes, 0, &DecodeOptions::default()).is_err());
+    // ... but asking for part 1 must not touch it.
+    let img = decode_exr_part(&bytes, 1, &DecodeOptions::default()).expect("part 1 decodes on its own");
+    assert_eq!((img.width(), img.height()), (4, 4));
+    assert!(img.to_normalized().iter().all(|v| near(*v, 0.75)), "wrong pixels");
+}
diff --git a/crates/codecs/tests/limits.rs b/crates/codecs/tests/limits.rs
index 3613b0871d..6969fea922 100644
--- a/crates/codecs/tests/limits.rs
+++ b/crates/codecs/tests/limits.rs
@@ -93,6 +93,30 @@ fn png_bomb_header_rejected_before_alloc() {
     assert!(is_limit(decode(&b)));
 }
 
+#[test]
+fn png_header_at_the_default_limit_needs_a_plausible_file_size() {
+    // 32768 x 32768 x RGBA16 is exactly the default max_alloc: it passes the dimension limits,
+    // but a ~100 byte file cannot hold it (zlib tops out near 1032:1), so it is refused before
+    // the 8 GiB output buffer is allocated.
+    let mut ihdr = Vec::new();
+    ihdr.extend_from_slice(&32768u32.to_be_bytes());
+    ihdr.extend_from_slice(&32768u32.to_be_bytes());
+    ihdr.extend_from_slice(&[16, 6, 0, 0, 0]);
+    let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
+    b.extend(png_chunk(b"IHDR", &ihdr));
+    b.extend(png_chunk(b"IDAT", &[0x78, 0x9C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01]));
+    b.extend(png_chunk(b"IEND", &[]));
+    assert!(is_limit(decode(&b)));
+}
+
+#[test]
+fn png_highly_compressible_image_still_decodes() {
+    let img = Image::from_u8(3000, 3000, ChannelLayout::Rgba, vec![255u8; 3000 * 3000 * 4]).unwrap();
+    let b = encode(&img, Format::Png, &EncodeOptions::default()).unwrap();
+    assert!(b.len() < 100_000, "{}", b.len());
+    assert_eq!(decode(&b).unwrap().width(), 3000);
+}
+
 const PNG_TEXT_BUDGET: usize = 64 << 10;
 
 fn png_text_decode(bytes: &[u8], max_alloc: usize) -> Result<Image, CodecError> {
diff --git a/crates/codecs/tests/malformed.rs b/crates/codecs/tests/malformed.rs
index fea7aedf3a..b6da84b072 100644
--- a/crates/codecs/tests/malformed.rs
+++ b/crates/codecs/tests/malformed.rs
@@ -60,7 +60,7 @@ fn truncated_files_mostly_error() {
     // Chopping off the second half must not silently succeed for formats
     // with length-checked rasters.
     for (f, bytes) in samples() {
-        if matches!(f, Format::Png | Format::Pnm | Format::Fits | Format::Qoi | Format::OpenExr | Format::Tiff | Format::Bmp) {
+        if matches!(f, Format::Png | Format::Pnm | Format::Fits | Format::Dpx | Format::Qoi | Format::OpenExr | Format::Tiff | Format::Bmp) {
             let r = decode_as_with(f, &bytes[..bytes.len() / 2], &tight());
             assert!(r.is_err(), "{f:?} decoded half a file");
         }
diff --git a/crates/codecs/tests/metadata.rs b/crates/codecs/tests/metadata.rs
index 76ff9c9385..d8f4d80a9a 100644
--- a/crates/codecs/tests/metadata.rs
+++ b/crates/codecs/tests/metadata.rs
@@ -34,7 +34,11 @@ fn check_format(format: Format) {
     } else {
         assert!(warnings.contains(&FidelityWarning::IccDropped), "{format:?}");
     }
-    if c.exif {
+    if c.exif && format == Format::Tiff {
+        // TIFF writes the block's directories as its own and rebuilds a block from them on
+        // reading (tests/tiff_exif.rs); IFD0's orientation here is the image's.
+        assert!(!warnings.contains(&FidelityWarning::ExifDropped), "{format:?}");
+    } else if c.exif {
         assert_eq!(back.meta.exif, img.meta.exif, "{format:?} exif");
     } else {
         assert!(warnings.contains(&FidelityWarning::ExifDropped), "{format:?}");
diff --git a/crates/codecs/tests/pcx.rs b/crates/codecs/tests/pcx.rs
new file mode 100644
index 0000000000..89661cb8eb
--- /dev/null
+++ b/crates/codecs/tests/pcx.rs
@@ -0,0 +1,100 @@
+use photocraft_codecs::{ChannelLayout, CodecError, Format, SampleType, caps, decode, decode_as, detect, encode, from_extension};
+
+fn header(bits: u8, planes: u8, width: u16, height: u16, stride: u16) -> Vec<u8> {
+    let mut b = vec![0u8; 128];
+    b[0] = 0x0a; // ZSoft
+    b[1] = 5; // PC Paintbrush 3.0+
+    b[2] = 1; // RLE
+    b[3] = bits;
+    b[8..10].copy_from_slice(&(width - 1).to_le_bytes());
+    b[10..12].copy_from_slice(&(height - 1).to_le_bytes());
+    b[12..14].copy_from_slice(&300u16.to_le_bytes());
+    b[14..16].copy_from_slice(&150u16.to_le_bytes());
+    b[65] = planes;
+    b[66..68].copy_from_slice(&stride.to_le_bytes());
+    b[68..70].copy_from_slice(&1u16.to_le_bytes());
+    b
+}
+
+fn rle_row(out: &mut Vec<u8>, row: &[u8]) {
+    for &value in row {
+        if value >= 0xc0 {
+            out.extend_from_slice(&[0xc1, value]);
+        } else {
+            out.push(value);
+        }
+    }
+}
+
+#[test]
+fn pcx_is_readable_but_not_writable() {
+    assert_eq!(from_extension("archive.PCX"), Some(Format::Pcx));
+    assert!(caps(Format::Pcx).read && !caps(Format::Pcx).write);
+    let img = photocraft_codecs::Image::from_u8(1, 1, ChannelLayout::Rgb, vec![0, 0, 0]).unwrap();
+    assert!(matches!(encode(&img, Format::Pcx, &Default::default()), Err(CodecError::Unsupported { .. })));
+}
+
+#[test]
+fn decodes_three_plane_rgb_and_keeps_dpi() {
+    let mut b = header(8, 3, 2, 1, 2);
+    for row in [&[255, 0][..], &[0, 255][..], &[0, 0][..]] {
+        rle_row(&mut b, row);
+    }
+    assert_eq!(detect(&b), Some(Format::Pcx));
+    let im = decode(&b).unwrap();
+    assert_eq!(im.layout(), ChannelLayout::Rgb);
+    assert_eq!(im.sample_type(), SampleType::U8);
+    assert_eq!(im.dimensions(), (2, 1));
+    assert_eq!(im.data(), &[255, 0, 0, 0, 255, 0]);
+    assert_eq!(im.meta.dpi, Some((300.0, 150.0)));
+}
+
+#[test]
+fn decodes_256_colour_vga_palette() {
+    let mut b = header(8, 1, 2, 1, 2);
+    rle_row(&mut b, &[1, 2]);
+    b.push(0x0c);
+    let mut palette = vec![0; 256 * 3];
+    palette[3..6].copy_from_slice(&[255, 0, 0]);
+    palette[6..9].copy_from_slice(&[0, 255, 0]);
+    b.extend(palette);
+    assert_eq!(decode(&b).unwrap().data(), &[255, 0, 0, 0, 255, 0]);
+}
+
+#[test]
+fn decodes_4bit_and_monochrome_palettes() {
+    let mut four = header(4, 1, 2, 1, 2);
+    four[16 + 3..16 + 6].copy_from_slice(&[255, 0, 0]);
+    four[16 + 6..16 + 9].copy_from_slice(&[0, 0, 255]);
+    rle_row(&mut four, &[0x12, 0]);
+    assert_eq!(decode(&four).unwrap().data(), &[255, 0, 0, 0, 0, 255]);
+
+    let mut one = header(1, 1, 2, 1, 2);
+    one[16 + 3..16 + 6].copy_from_slice(&[255, 0, 0]);
+    rle_row(&mut one, &[0x80, 0]);
+    assert_eq!(decode(&one).unwrap().data(), &[255, 0, 0, 0, 0, 0]);
+}
+
+#[test]
+fn rejects_truncated_and_overshooting_rle_without_panicking() {
+    let mut b = header(8, 3, 2, 1, 2);
+    assert!(decode_as(Format::Pcx, &b).is_err(), "header alone is truncated");
+    b.extend([0xc5, 0xff]); // a five-pixel run cannot cross a two-byte row
+    assert!(decode_as(Format::Pcx, &b).is_err());
+    let mut b = header(8, 3, 2, 1, 2);
+    b.extend([0xc1]); // missing run value
+    assert!(decode_as(Format::Pcx, &b).is_err());
+    let mut b = header(8, 3, 2, 1, 2);
+    b[66..68].copy_from_slice(&0u16.to_le_bytes());
+    assert_eq!(detect(&b), None, "invalid stride is not a PCX signature");
+}
+
+#[test]
+fn refuses_headers_that_exceed_allocation_budget() {
+    let mut b = header(8, 3, 3000, 3000, 3000);
+    // The default decoder rejects the allocation before reading any scanline.
+    let opts = photocraft_codecs::DecodeOptions { limits: photocraft_codecs::Limits { max_alloc: 1024, ..Default::default() }, ..Default::default() };
+    assert!(matches!(photocraft_codecs::decode_as_with(Format::Pcx, &b, &opts), Err(CodecError::LimitExceeded(_))));
+    b[2] = 0;
+    assert_eq!(detect(&b), None, "unsupported uncompressed encoding");
+}
diff --git a/crates/codecs/tests/resolution.rs b/crates/codecs/tests/resolution.rs
index 5eb6acad3a..15ddc95749 100644
--- a/crates/codecs/tests/resolution.rs
+++ b/crates/codecs/tests/resolution.rs
@@ -425,16 +425,38 @@ fn png_phys_outranks_its_exif() {
     img.meta.exif = Some(camera_exif(&LE));
     let png = encode(&img, Format::Png, &EncodeOptions::default()).unwrap();
     near(decode(&png).unwrap().meta.dpi, 300.0);
+    near(decode(&with_phys(&png, 5906)).unwrap().meta.dpi, 150.0);
+}
+
+/// `png` with a `pHYs` chunk of `ppm` pixels per metre after IHDR.
+fn with_phys(png: &[u8], ppm: u32) -> Vec<u8> {
     let mut body = b"pHYs".to_vec();
-    body.extend_from_slice(&5906u32.to_be_bytes());
-    body.extend_from_slice(&5906u32.to_be_bytes());
+    body.extend_from_slice(&ppm.to_be_bytes());
+    body.extend_from_slice(&ppm.to_be_bytes());
     body.push(1);
     let mut chunk = 9u32.to_be_bytes().to_vec();
     chunk.extend_from_slice(&body);
     chunk.extend_from_slice(&crc32(&body).to_be_bytes());
     let ihdr_end = 8 + 8 + 13 + 4;
-    let with_phys = [&png[..ihdr_end], &chunk, &png[ihdr_end..]].concat();
-    near(decode(&with_phys).unwrap().meta.dpi, 150.0114);
+    [&png[..ihdr_end], &chunk, &png[ihdr_end..]].concat()
+}
+
+#[test]
+fn png_phys_of_a_whole_ppi_reads_back_whole() {
+    // pHYs holds whole pixels per metre: 300 ppi is stored as 11811 (299.9994 ppi), 72 as 2835
+    // (72.009). The whole number that rounds to the stored value is read, as Photoshop does; a
+    // value no whole ppi rounds to stays as it is.
+    let img = Image::from_raw(4, 4, ChannelLayout::Rgb, SampleType::U8, vec![90; 48]).unwrap();
+    let png = encode(&img, Format::Png, &EncodeOptions { embed_metadata: false, ..Default::default() }).unwrap();
+    for (ppm, want) in [(11811, 300.0), (2835, 72.0), (3937, 100.0), (11812, 300.0248)] {
+        let (x, y) = decode(&with_phys(&png, ppm)).unwrap().meta.dpi.unwrap();
+        assert!((x - want).abs() < 1e-4 && (y - want).abs() < 1e-4, "{ppm} px/m: {x} × {y}, wanted {want}");
+    }
+    // And a 300 ppi PNG written by the encoder opens at exactly 300.
+    let mut img = img;
+    img.meta.dpi = Some((300.0, 300.0));
+    let png = encode(&img, Format::Png, &EncodeOptions::default()).unwrap();
+    assert_eq!(decode(&png).unwrap().meta.dpi, Some((300.0, 300.0)));
 }
 
 /// `camera_exif` plus IFD1, the embedded thumbnail a camera (or the last editor) wrote:
diff --git a/crates/codecs/tests/roundtrip.rs b/crates/codecs/tests/roundtrip.rs
index 742de21598..4cb50c0057 100644
--- a/crates/codecs/tests/roundtrip.rs
+++ b/crates/codecs/tests/roundtrip.rs
@@ -134,6 +134,9 @@ mod pnm {
 mod fits {
     cases!(Format::Fits);
 }
+mod dpx {
+    cases!(Format::Dpx);
+}
 mod qoi {
     cases!(Format::Qoi);
 }
diff --git a/crates/codecs/tests/source_settings.rs b/crates/codecs/tests/source_settings.rs
new file mode 100644
index 0000000000..9da82dbe79
--- /dev/null
+++ b/crates/codecs/tests/source_settings.rs
@@ -0,0 +1,111 @@
+//! Reading back the settings a lossy file was saved with: a JPEG's quality from its
+//! quantisation tables, a WebP's lossy or lossless encoding (and its quality).
+
+mod common;
+use common::*;
+use photocraft_codecs::*;
+
+fn photo(w: u32, h: u32, layout: ChannelLayout) -> Image {
+    synth(w, h, layout, SampleType::U8, 5, 0.03)
+}
+
+#[test]
+fn jpeg_quality_is_estimated_within_two() {
+    for layout in [ChannelLayout::Rgb, ChannelLayout::Gray] {
+        let img = photo(40, 24, layout);
+        for q in [1u8, 5, 10, 25, 40, 50, 60, 70, 75, 80, 85, 90, 95, 98, 100] {
+            let bytes = encode(&img, Format::Jpeg, &EncodeOptions { jpeg_quality: q, ..Default::default() }).unwrap();
+            let est = jpeg_quality(&bytes).unwrap_or_else(|| panic!("{layout:?} q{q}: no estimate"));
+            assert!(est.abs_diff(q) <= 2, "{layout:?}: saved at {q}, estimated {est}");
+        }
+    }
+}
+
+#[test]
+fn jpeg_quality_of_hand_built_tables() {
+    // A minimal JPEG prefix: SOI, one DQT holding the Annex K luminance table (quality 50) in
+    // zig-zag order, then SOS.
+    let luma: [u8; 64] = [
+        16, 11, 12, 14, 12, 10, 16, 14, 13, 14, 18, 17, 16, 19, 24, 40, 26, 24, 22, 22, 24, 49, 35, 37, 29, 40, 58, 51, 61, 60, 57, 51, 56, 55, 64, 72, 92, 78,
+        64, 68, 87, 69, 55, 56, 80, 109, 81, 87, 95, 98, 103, 104, 103, 62, 77, 113, 121, 112, 100, 120, 92, 101, 103, 99,
+    ];
+    let mut b = vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 67, 0x00];
+    b.extend_from_slice(&luma);
+    b.extend_from_slice(&[0xFF, 0xDA, 0, 2]);
+    assert_eq!(jpeg_quality(&b), Some(50));
+}
+
+#[test]
+fn hostile_jpeg_tables_give_no_estimate_and_never_panic() {
+    let img = photo(16, 16, ChannelLayout::Rgb);
+    let good = encode(&img, Format::Jpeg, &EncodeOptions { jpeg_quality: 70, ..Default::default() }).unwrap();
+    // Every truncation of a real file.
+    for n in 0..good.len().min(800) {
+        let _ = jpeg_quality(&good[..n]);
+    }
+    let cases: Vec<Vec<u8>> = vec![
+        vec![],
+        vec![0xFF],
+        vec![0xFF, 0xD8],
+        // A DQT whose length runs past the end.
+        vec![0xFF, 0xD8, 0xFF, 0xDB, 0xFF, 0xFF, 0x00, 1, 2, 3],
+        // A DQT of length 0 and 1 (less than its own length field).
+        vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 0x00],
+        vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 0x01],
+        // A table cut short, a bad precision, a slot past 3, a 16-bit table cut mid-entry.
+        [vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 12, 0x00], vec![9; 9]].concat(),
+        [vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 67, 0x70], vec![9; 64]].concat(),
+        [vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 67, 0x0F], vec![9; 64]].concat(),
+        [vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 68, 0x10], vec![0xFF; 65]].concat(),
+        // All-zero and all-0xFF tables.
+        [vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 67, 0x00], vec![0; 64]].concat(),
+        [vec![0xFF, 0xD8, 0xFF, 0xDB, 0x00, 131, 0x10], vec![0xFF; 128]].concat(),
+        vec![0xFF; 64],
+    ];
+    for c in &cases {
+        let _ = jpeg_quality(c);
+    }
+    assert_eq!(jpeg_quality(&[0xFF, 0xD8, 0xFF, 0xDB, 0x00, 0x00]), None);
+    assert_eq!(jpeg_quality(b"not a jpeg at all"), None);
+    let png = encode(&img, Format::Png, &EncodeOptions::default()).unwrap();
+    assert_eq!(jpeg_quality(&png), None);
+}
+
+#[test]
+fn webp_lossless_and_lossy_are_told_apart() {
+    let img = photo(33, 21, ChannelLayout::Rgb);
+    let lossless = encode(&img, Format::WebP, &EncodeOptions::default()).unwrap();
+    assert_eq!(webp_encoding(&lossless), Some(WebpEncoding::Lossless));
+    for q in [10u8, 30, 50, 75, 80, 90, 100] {
+        let bytes = encode(&img, Format::WebP, &EncodeOptions { webp_lossless: false, webp_quality: q, ..Default::default() }).unwrap();
+        let Some(WebpEncoding::Lossy { quality: Some(est) }) = webp_encoding(&bytes) else { panic!("q{q}: {:?}", webp_encoding(&bytes)) };
+        assert!(est.abs_diff(q) <= 2, "lossy WebP saved at {q}, estimated {est}");
+    }
+    // With alpha and metadata (the extended container).
+    let rgba = photo(20, 20, ChannelLayout::Rgba);
+    let bytes = encode(&rgba, Format::WebP, &EncodeOptions { webp_lossless: false, webp_quality: 60, ..Default::default() }).unwrap();
+    assert!(matches!(webp_encoding(&bytes), Some(WebpEncoding::Lossy { quality: Some(58..=62) })), "{:?}", webp_encoding(&bytes));
+}
+
+#[test]
+fn hostile_webp_never_panics() {
+    let img = photo(24, 24, ChannelLayout::Rgb);
+    for opts in [EncodeOptions::default(), EncodeOptions { webp_lossless: false, ..Default::default() }] {
+        let good = encode(&img, Format::WebP, &opts).unwrap();
+        for n in 0..good.len().min(400) {
+            let _ = webp_encoding(&good[..n]);
+        }
+        let mut flipped = good.clone();
+        for i in 12..flipped.len().min(64) {
+            flipped[i] ^= 0xA5;
+            let _ = webp_encoding(&flipped);
+        }
+    }
+    let mut huge = b"RIFF\0\0\0\0WEBPVP8 ".to_vec();
+    huge.extend_from_slice(&u32::MAX.to_le_bytes());
+    let _ = webp_encoding(&huge);
+    let mut anmf = b"RIFF\0\0\0\0WEBPANMF".to_vec();
+    anmf.extend_from_slice(&3u32.to_le_bytes());
+    let _ = webp_encoding(&anmf);
+    assert_eq!(webp_encoding(b"RIFF\0\0\0\0WAVE"), None);
+}
diff --git a/crates/codecs/tests/tiff_exif.rs b/crates/codecs/tests/tiff_exif.rs
new file mode 100644
index 0000000000..92e8c91df0
--- /dev/null
+++ b/crates/codecs/tests/tiff_exif.rs
@@ -0,0 +1,168 @@
+//! EXIF in TIFF: an EXIF block's Exif and GPS directories and IFD0's descriptive tags are
+//! written as the TIFF's own directories (IFD0 pointing to them, as cameras and Photoshop write
+//! them) and read back into a block.
+
+use photocraft_codecs::*;
+
+/// A classic TIFF stream builder for EXIF blocks: directories of (tag, type, count, value bytes).
+struct Block {
+    le: bool,
+}
+
+type Entry = (u16, u16, u32, Vec<u8>);
+
+impl Block {
+    fn u16(&self, v: u16) -> [u8; 2] {
+        if self.le { v.to_le_bytes() } else { v.to_be_bytes() }
+    }
+    fn u32(&self, v: u32) -> [u8; 4] {
+        if self.le { v.to_le_bytes() } else { v.to_be_bytes() }
+    }
+    fn rational(&self, n: u32, d: u32) -> Vec<u8> {
+        [self.u32(n), self.u32(d)].concat()
+    }
+    /// IFD0 (with pointers to `exif` and `gps` appended) followed by the two directories.
+    fn build(&self, mut ifd0: Vec<Entry>, exif: Vec<Entry>, gps: Vec<Entry>) -> Vec<u8> {
+        let size = |d: &[Entry]| 2 + 12 * d.len() + 4 + d.iter().filter(|e| e.3.len() > 4).map(|e| e.3.len().next_multiple_of(2)).sum::<usize>();
+        ifd0.push((34665, 4, 1, vec![0; 4]));
+        ifd0.push((34853, 4, 1, vec![0; 4]));
+        let at_exif = 8 + size(&ifd0);
+        let at_gps = at_exif + size(&exif);
+        let n = ifd0.len();
+        ifd0[n - 2].3 = self.u32(at_exif as u32).to_vec();
+        ifd0[n - 1].3 = self.u32(at_gps as u32).to_vec();
+        let mut out = if self.le { b"II".to_vec() } else { b"MM".to_vec() };
+        out.extend(self.u16(42));
+        out.extend(self.u32(8));
+        for d in [ifd0, exif, gps] {
+            let start = out.len();
+            let mut extra = start + 2 + 12 * d.len() + 4;
+            let mut values = Vec::new();
+            out.extend(self.u16(d.len() as u16));
+            for (tag, ty, count, v) in &d {
+                out.extend(self.u16(*tag));
+                out.extend(self.u16(*ty));
+                out.extend(self.u32(*count));
+                if v.len() <= 4 {
+                    let mut inline = v.clone();
+                    inline.resize(4, 0);
+                    out.extend(inline);
+                } else {
+                    out.extend(self.u32(extra as u32));
+                    values.extend(v);
+                    if v.len() % 2 == 1 {
+                        values.push(0);
+                    }
+                    extra += v.len().next_multiple_of(2);
+                }
+            }
+            out.extend(self.u32(0));
+            out.extend(values);
+        }
+        out
+    }
+}
+
+/// The entries (tag, type, count, value bytes in the block's order) of IFD0 and of the
+/// directories its tags `34665` and `34853` point to.
+fn dirs(b: &[u8]) -> (bool, Vec<Entry>, Vec<Entry>, Vec<Entry>) {
+    let le = &b[..2] == b"II";
+    let u16 = |at: usize| if le { u16::from_le_bytes([b[at], b[at + 1]]) } else { u16::from_be_bytes([b[at], b[at + 1]]) };
+    let u32 = |at: usize| {
+        let s = [b[at], b[at + 1], b[at + 2], b[at + 3]];
+        if le { u32::from_le_bytes(s) } else { u32::from_be_bytes(s) }
+    };
+    let size = |ty: u16| match ty {
+        3 | 8 => 2,
+        4 | 9 | 11 | 13 => 4,
+        5 | 10 | 12 => 8,
+        _ => 1,
+    };
+    let read = |at: usize| -> Vec<Entry> {
+        (0..usize::from(u16(at)))
+            .map(|i| {
+                let e = at + 2 + 12 * i;
+                let (tag, ty, count) = (u16(e), u16(e + 2), u32(e + 4));
+                let len = count as usize * size(ty);
+                let at = if len <= 4 { e + 8 } else { u32(e + 8) as usize };
+                (tag, ty, count, b[at..at + len].to_vec())
+            })
+            .collect()
+    };
+    let ifd0 = read(u32(4) as usize);
+    let sub = |tag: u16| ifd0.iter().find(|e| e.0 == tag).map(|e| read(u32_of(&e.3, le) as usize)).unwrap_or_default();
+    let (exif, gps) = (sub(34665), sub(34853));
+    (le, ifd0.into_iter().filter(|e| !matches!(e.0, 34665 | 34853)).collect(), exif, gps)
+}
+
+fn u32_of(v: &[u8], le: bool) -> u32 {
+    let s = [v[0], v[1], v[2], v[3]];
+    if le { u32::from_le_bytes(s) } else { u32::from_be_bytes(s) }
+}
+
+/// The entries of `d` with their values in little-endian order, sorted by tag.
+fn normalized(d: &[Entry], le: bool) -> Vec<(u16, u16, u32, Vec<u8>)> {
+    let swap = |ty: u16, v: &[u8]| -> Vec<u8> {
+        let n = match ty {
+            3 | 8 => 2,
+            4 | 5 | 9 | 10 | 11 | 13 => 4,
+            12 => 8,
+            _ => 1,
+        };
+        if le || n == 1 { v.to_vec() } else { v.chunks(n).flat_map(|c| c.iter().rev().copied()).collect() }
+    };
+    let mut v: Vec<_> = d.iter().map(|e| (e.0, e.1, e.2, swap(e.1, &e.3))).collect();
+    v.sort_by_key(|e| e.0);
+    v
+}
+
+fn camera_block(le: bool) -> Vec<u8> {
+    let b = Block { le };
+    let ascii = |s: &str| [s.as_bytes(), b"\0"].concat();
+    b.build(
+        vec![(271, 2, 4, ascii("Cam")), (272, 2, 9, ascii("Model X1")), (315, 2, 16, ascii("A. Photographer")), (274, 3, 1, b.u16(1).to_vec())],
+        vec![
+            (33434, 5, 1, b.rational(1, 125)),
+            (34855, 3, 1, b.u16(200).to_vec()),
+            (36867, 2, 20, ascii("2026:10:13 09:30:00")),
+            (37386, 5, 1, b.rational(50, 1)),
+            (37500, 7, 6, b"maker!".to_vec()),
+        ],
+        vec![(1, 2, 2, ascii("N")), (2, 5, 3, [b.rational(51, 1), b.rational(30, 1), b.rational(0, 1)].concat())],
+    )
+}
+
+#[test]
+fn exif_round_trips_through_a_tiff_in_either_byte_order() {
+    for le in [true, false] {
+        let block = camera_block(le);
+        let mut img = Image::from_raw(4, 3, ChannelLayout::Rgb, SampleType::U8, vec![90; 36]).unwrap();
+        img.meta.exif = Some(block.clone());
+        let tiff = encode(&img, Format::Tiff, &EncodeOptions::default()).unwrap();
+        assert!(fidelity_warnings(&img, Format::Tiff).iter().all(|w| *w != FidelityWarning::ExifDropped));
+        let back = decode(&tiff).unwrap().meta.exif.expect("EXIF read back");
+        let (ble, b0, bexif, bgps) = dirs(&back);
+        let (ole, o0, oexif, ogps) = dirs(&block);
+        assert_eq!(normalized(&bexif, ble), normalized(&oexif, ole), "Exif directory (le {le})");
+        assert_eq!(normalized(&bgps, ble), normalized(&ogps, ole), "GPS directory (le {le})");
+        // IFD0's descriptive tags come along; its orientation is the image's own.
+        let descriptive: Vec<_> = o0.into_iter().filter(|e| e.0 != 274).collect();
+        assert_eq!(normalized(&b0, ble), normalized(&descriptive, ole), "IFD0 (le {le})");
+    }
+}
+
+#[test]
+fn a_tiff_without_exif_directories_reads_no_exif() {
+    let mut img = Image::from_raw(2, 2, ChannelLayout::Gray, SampleType::U8, vec![0; 4]).unwrap();
+    img.meta.text = vec![("Artist".into(), "A. Photographer".into())];
+    let tiff = encode(&img, Format::Tiff, &EncodeOptions::default()).unwrap();
+    assert_eq!(decode(&tiff).unwrap().meta.exif, None);
+}
+
+#[test]
+fn no_exif_is_written_without_embed_metadata() {
+    let mut img = Image::from_raw(2, 2, ChannelLayout::Gray, SampleType::U8, vec![0; 4]).unwrap();
+    img.meta.exif = Some(camera_block(true));
+    let tiff = encode(&img, Format::Tiff, &EncodeOptions { embed_metadata: false, ..Default::default() }).unwrap();
+    assert_eq!(decode(&tiff).unwrap().meta.exif, None);
+}
diff --git a/crates/codecs/tests/tiff_regressions.rs b/crates/codecs/tests/tiff_regressions.rs
index a4524e0874..d823f33f4a 100644
--- a/crates/codecs/tests/tiff_regressions.rs
+++ b/crates/codecs/tests/tiff_regressions.rs
@@ -1,3 +1,6 @@
+mod common;
+
+use common::tiffgen::*;
 use photocraft_codecs::{Image, decode, exif_orientation, upright_exif};
 
 fn classic_white_is_zero() -> Vec<u8> {
@@ -95,3 +98,79 @@ fn big_tiff_orientation_6_and_8_are_applied_to_decoded_pixels() {
         assert_eq!(image.data(), &upright, "orientation {orientation}");
     }
 }
+
+fn with_compression(mut dir: Dir, code: u64) -> Dir {
+    for entry in &mut dir.entries {
+        if entry.0 == 259 {
+            entry.2 = vec![V::N(code)];
+        }
+    }
+    dir
+}
+
+#[test]
+fn jpeg_compressed_tiff_decodes() {
+    // A flat mid-grey 16x16 image as a baseline JPEG stored in one strip (Compression = 7).
+    let mut jpeg = Vec::new();
+    let gray = vec![100u8; 16 * 16];
+    jpeg_encoder::Encoder::new(&mut jpeg, 95).encode(&gray, 16, 16, jpeg_encoder::ColorType::Luma).expect("encode the JPEG strip");
+    let mut dir = with_compression(strips(16, 16, 8, 1, 1, 16, &[0; 256]), 7);
+    dir.chunks = vec![jpeg];
+    let bytes = build(true, false, &[dir], &[0]).bytes;
+
+    let image = decode(&bytes).expect("a JPEG-compressed TIFF should decode");
+    assert_eq!(image.dimensions(), (16, 16));
+    assert!(image.data().iter().all(|&v| v.abs_diff(100) <= 4), "{:?}", image.data().get(..4));
+}
+
+#[test]
+fn ccitt_group4_tiff_decodes() {
+    // 8x3 bilevel: a white row, then two black rows. Bits: V0 | H(white 0, black 8) | V0 V0 | EOFB.
+    let bits = "1".to_string() + "001" + "00110101" + "000101" + "11" + "000000000001" + "000000000001";
+    let mut data = Vec::new();
+    for chunk in bits.as_bytes().chunks(8) {
+        let mut byte = 0u8;
+        for (i, c) in chunk.iter().enumerate() {
+            if *c == b'1' {
+                byte |= 0x80 >> i;
+            }
+        }
+        data.push(byte);
+    }
+    let mut dir = with_compression(strips(8, 3, 1, 1, 0, 3, &[0; 3]), 4);
+    dir.chunks = vec![data];
+    let bytes = build(true, false, &[dir], &[0]).bytes;
+
+    let image = decode(&bytes).expect("a CCITT G4 TIFF should decode");
+    assert_eq!(image.dimensions(), (8, 3));
+    let d = image.data();
+    assert_eq!(d.len(), 24, "{d:?}");
+    assert!(d[..8].iter().all(|&v| v == d[0]), "{d:?}");
+    assert!(d[8..].iter().all(|&v| v == d[8]), "{d:?}");
+    assert_ne!(d[0], d[8], "{d:?}");
+    assert_eq!(d[0], 255, "white row of a WhiteIsZero image");
+}
+
+/// #4484: a TIFF saved with the default options must open in software that only reads
+/// baseline TIFF (embroidery and plotter tools, older readers). Like Photoshop's default, that
+/// means uncompressed strips with no predictor, classic offsets and unassociated alpha.
+#[test]
+fn default_tiff_is_baseline() {
+    use photocraft_codecs::{ChannelLayout, EncodeOptions, Format, SampleType, encode};
+    use std::io::Cursor;
+    use tiff::tags::Tag;
+
+    for layout in [ChannelLayout::Rgb, ChannelLayout::Rgba] {
+        let img = common::synth(33, 21, layout, SampleType::U8, 7, 0.4);
+        let bytes = encode(&img, Format::Tiff, &EncodeOptions::default()).expect("encode");
+        assert!(bytes.starts_with(b"II*\0") || bytes.starts_with(b"MM\0*"), "{layout:?}: not a classic TIFF");
+        let mut dec = tiff::decoder::Decoder::new(Cursor::new(&bytes[..])).expect("open");
+        assert_eq!(dec.get_tag_u32(Tag::Compression).ok(), Some(1), "{layout:?}: Compression");
+        assert_eq!(dec.find_tag(Tag::Predictor).ok().flatten().and_then(|v| v.into_u16().ok()).unwrap_or(1), 1, "{layout:?}: Predictor");
+        assert!(dec.find_tag(Tag::TileWidth).ok().flatten().is_none(), "{layout:?}: tiled");
+        assert_eq!(dec.get_tag_u32(Tag::PlanarConfiguration).ok().unwrap_or(1), 1, "{layout:?}: planar");
+        let extra = dec.find_tag(Tag::ExtraSamples).ok().flatten().and_then(|v| v.into_u16_vec().ok());
+        assert_eq!(extra, if layout == ChannelLayout::Rgba { Some(vec![2]) } else { None }, "{layout:?}: ExtraSamples");
+        assert_eq!(decode(&bytes).expect("decode").data(), img.data(), "{layout:?}: round trip");
+    }
+}
diff --git a/crates/codecs/tests/xpm.rs b/crates/codecs/tests/xpm.rs
new file mode 100644
index 0000000000..aa0b3bf0b0
--- /dev/null
+++ b/crates/codecs/tests/xpm.rs
@@ -0,0 +1,123 @@
+use photocraft_codecs::{ChannelLayout, CodecError, Format, Image, caps, decode, decode_as, detect, encode, from_extension};
+
+const SAMPLE: &[u8] = br#"/* XPM */
+static char *icon[] = {
+"2 2 3 1",
+". c #ff0000",
+"  c None",
+"+ c #00ff00",
+".+",
+" +"
+};
+"#;
+
+#[test]
+fn xpm3_decodes_palette_transparency_and_spaces_in_keys() {
+    assert_eq!(detect(SAMPLE), Some(Format::Xpm));
+    assert_eq!(from_extension("icon.XPM"), Some(Format::Xpm));
+    let img = decode(SAMPLE).unwrap();
+    assert_eq!(img.layout(), ChannelLayout::Rgba);
+    assert_eq!(img.dimensions(), (2, 2));
+    assert_eq!(img.data(), &[255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 255, 0, 255]);
+}
+
+#[test]
+fn rgb_precisions_and_x11_name() {
+    let xpm = br#"/* XPM */
+static char *i[] = {
+"3 1 3 1",
+"a c #f00",
+"b c #ffff00000000",
+"c c gray70",
+"abc"
+};"#;
+    let img = decode(xpm).unwrap();
+    assert_eq!(img.data(), &[255, 0, 0, 255, 255, 0, 0, 255, 179, 179, 179, 255]);
+}
+
+#[test]
+fn rejects_truncation_unsupported_colours_and_unknown_keys() {
+    for bytes in [
+        &b"/* XPM */\nstatic char *i[] = { \"1 1 1 1\", \"a c None\" };"[..],
+        &b"/* XPM */\nstatic char *i[] = { \"1 1 1 1\", \"a c NotAColor\", \"a\" };"[..],
+        &b"/* XPM */\nstatic char *i[] = { \"1 1 1 1\", \"a c #a\xC3\xA9\", \"a\" };"[..],
+        &b"/* XPM */\nstatic char *i[] = { \"1 1 1 1\", \"a c #+f0000\", \"a\" };"[..],
+        &b"/* XPM */\nstatic char *i[] = { \"1 1 1 1\", \"a c black\", \"z\" };"[..],
+        &b"/* XPM */\nstatic char *i[] = { \"1 1 1 1\", \"a c black\", \"aa\" };"[..],
+        &b"/* XPM */\nstatic char *i[] = { \"1 1 2 1\", \"a c black\", \"a c white\", \"a\" };"[..],
+    ] {
+        assert!(decode_as(Format::Xpm, bytes).is_err(), "{:?}", bytes);
+    }
+    assert!(decode_as(Format::Xpm, b"/* XPM */\n\"4294967295 4294967295 1 1\"").is_err());
+    assert!(decode_as(Format::Xpm, b"/* XPM */\n\"2 1 1 1\" \"a c black\" \"aa\" /* bad").is_err());
+}
+
+#[test]
+fn x11_names_and_field_priority() {
+    let xpm = br#"/* XPM */
+static char *i[] = {
+"4 1 4 1",
+"a c LightGray",
+"b c DarkBlue",
+"c m black g white c light blue",
+"d m black g4 red g green",
+"abcd"
+};"#;
+    let image = decode(xpm).unwrap();
+    assert_eq!(image.data(), &[211, 211, 211, 255, 0, 0, 139, 255, 173, 216, 230, 255, 0, 255, 0, 255]);
+}
+
+#[test]
+fn named_x11_colors_use_x11_not_css_values() {
+    let bytes = br#"/* XPM */
+static char *icon[] = {
+"6 1 6 1",
+"a c gray",
+"b c maroon",
+"c c purple",
+"d c LightGoldenrodYellow",
+"e c DarkSlateGray4",
+"f c Ghost White",
+"abcdef"
+};"#;
+    let image = decode(bytes).unwrap();
+    assert_eq!(image.data(), &[190, 190, 190, 255, 176, 48, 96, 255, 160, 32, 240, 255, 250, 250, 210, 255, 82, 139, 139, 255, 248, 248, 255, 255,]);
+}
+
+#[test]
+fn xpm2_decodes_crlf_comments_spaces_and_multichar_keys() {
+    let bytes = b"! XPM2\r\n! exported by an icon tool\r\n2 2 3 2\r\n.a c #f00\r\n!_ c None\r\nzz c DarkBlue\r\n.a!_\r\nzz.a\r\n";
+    assert_eq!(detect(bytes), Some(Format::Xpm));
+    let image = decode(bytes).unwrap();
+    assert_eq!(image.dimensions(), (2, 2));
+    assert_eq!(image.data(), &[255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 139, 255, 255, 0, 0, 255]);
+}
+
+#[test]
+fn xpm2_allows_exclamation_as_a_pixel_key_and_preserves_space_keys() {
+    let bytes = b"! XPM2\n2 1 2 1\n! c red\n  c None\n! \n";
+    let image = decode(bytes).unwrap();
+    assert_eq!(image.data(), &[255, 0, 0, 255, 0, 0, 0, 0]);
+}
+
+#[test]
+fn xpm2_malformed_inputs_return_errors() {
+    for bytes in [
+        &b"! XPM2\n1 1 1 1\na c black\n"[..],
+        &b"! XPM2\n1 1 1 1\na c black\nb\n"[..],
+        &b"! XPM2\n1 1 1 1\na c #a\xc3\xa9\na\n"[..],
+        &b"! XPM2 invalid\n1 1 1 1\na c black\na\n"[..],
+        &b"! XPM2\n100000 100000 1 1\na c red\na\n"[..],
+    ] {
+        assert!(decode_as(Format::Xpm, bytes).is_err(), "{bytes:?}");
+    }
+    assert_ne!(detect(b"! XPM23\n1 1 1 1\na c black\na\n"), Some(Format::Xpm));
+}
+
+#[test]
+fn xpm_is_import_only() {
+    assert!(caps(Format::Xpm).read);
+    assert!(!caps(Format::Xpm).write);
+    let image = Image::from_u8(1, 1, ChannelLayout::Rgba, vec![0, 0, 0, 0]).unwrap();
+    assert!(matches!(encode(&image, Format::Xpm, &Default::default()), Err(CodecError::Unsupported { .. })));
+}
diff --git a/crates/compose/src/adjust.rs b/crates/compose/src/adjust.rs
index 0f26c61327..22a8cf063a 100644
--- a/crates/compose/src/adjust.rs
+++ b/crates/compose/src/adjust.rs
@@ -3,8 +3,8 @@
 //! Formulas are documented approximations of Photoshop behaviour. Exact matching is tuned in
 //! milestone M7 against Photoshop-rendered PSD composites (the oracle in `testkit`).
 
-use photocraft_color::SampleType;
-use photocraft_color::convert::{D50, SRGB_TO_XYZ_D50, XYZ_D50_TO_SRGB, mat3_mul, rgb_to_gray, srgb_to_linear};
+use photocraft_color::convert::{D50, SRGB_TO_XYZ_D50, XYZ_D50_TO_SRGB, lab_to_srgb, mat3_mul, rgb_to_gray, srgb_to_lab, srgb_to_linear};
+use photocraft_color::{ColorMode, SampleType};
 use photocraft_doc::Adjustment;
 use photocraft_doc::adjust::{CurvePoint, HueRange, LevelsChannel, ToneSpace, lut3d_len};
 
@@ -45,14 +45,16 @@ impl Transfer {
             t => t,
         }
     }
-    fn decode(self, v: f32) -> f32 {
+    /// Tone-encoded value → linear light.
+    pub fn decode(self, v: f32) -> f32 {
         match self {
             Transfer::Srgb => photocraft_color::convert::srgb_to_linear(v.max(0.0)),
             Transfer::Gamma(1.0) => v.max(0.0),
             Transfer::Gamma(g) => v.max(0.0).powf(g),
         }
     }
-    fn encode(self, v: f32) -> f32 {
+    /// Linear light → tone-encoded value.
+    pub fn encode(self, v: f32) -> f32 {
         match self {
             Transfer::Srgb => photocraft_color::convert::linear_to_srgb(v.max(0.0)),
             Transfer::Gamma(1.0) => v.max(0.0),
@@ -92,11 +94,8 @@ pub fn apply_depth(adj: &Adjustment, buf: &mut Buffer, transfer: Transfer, depth
             // 27.11, brightness +40 with contrast +30 maps 128 to 185 (brightness first), while
             // the corpus's brightness -23 with contrast -26 (psd-tools) needs contrast first;
             // contrast 80 keeps 128 at 128 (a 0.5 pivot moved it to 130).
-            let b = brightness / 255.0;
-            let c = contrast.clamp(-100.0, 99.0);
-            let k = if c >= 0.0 { 1.0 / (1.0 - c / 100.0) } else { 1.0 + c / 100.0 };
-            let (pre, post) = if c >= 0.0 { (b, 0.0) } else { (0.0, b) };
-            map_rgb(buf, |px| px.map(|v| ((v + pre - LEGACY_PIVOT) * k + LEGACY_PIVOT + post).clamp(0.0, 1.0)))
+            let f = legacy_brightness_contrast(*brightness, *contrast);
+            map_rgb(buf, |px| px.map(&f))
         }
         Adjustment::BrightnessContrast { brightness, contrast, .. } => {
             // Modern (CS3+) Brightness/Contrast, reverse-engineered from Photoshop ground truth
@@ -159,14 +158,16 @@ pub fn apply_depth(adj: &Adjustment, buf: &mut Buffer, transfer: Transfer, depth
             map_rgb(buf, |c| {
                 let (dh, ds, dl) = match &table {
                     Some(t) => {
-                        // Range edits follow the pixel's original hue, faded out towards grey (greys have no hue).
+                        // Range edits follow the pixel's original hue, in full however dull the colour
+                        // (Photoshop's merged images, #4089). Greys stay grey: no hue to shift, no
+                        // saturation to scale, and range Lightness moves towards a channel they share.
                         let h0 = rgb_to_hsl(c).0;
-                        let chroma = ((c[0].max(c[1]).max(c[2]) - c[0].min(c[1]).min(c[2])) * 4.0).min(1.0);
-                        (lut(&t[0], h0) * chroma, lut(&t[1], h0) * chroma, lut(&t[2], h0) * chroma)
+                        (lut(&t[0], h0), lut(&t[1], h0), lut(&t[2], h0))
                     }
                     None => (0.0, 0.0, 0.0),
                 };
-                hue_saturation(c, *hue + dh, (*saturation / 100.0 + ds).clamp(-1.0, 1.0), (*lightness / 100.0 + dl).clamp(-1.0, 1.0), *colorize)
+                let out = hue_saturation(c, *hue + dh, (*saturation / 100.0 + ds).clamp(-1.0, 1.0), (*lightness / 100.0).clamp(-1.0, 1.0), *colorize);
+                range_lightness(out, dl)
             })
         }
         Adjustment::Vibrance { vibrance, saturation } => {
@@ -191,7 +192,9 @@ pub fn apply_depth(adj: &Adjustment, buf: &mut Buffer, transfer: Transfer, depth
         Adjustment::BlackWhite { weights, tint } => map_rgb(buf, |c| {
             let g = black_white_gray(c, weights);
             match tint {
-                Some(t) => std::array::from_fn(|i| (g * t[i] * 2.0).clamp(0.0, 1.0) * 0.5 + g * 0.5),
+                // Photoshop tints like the Color blend mode: the tint's hue and saturation at the
+                // grey's luminosity (SetLum + ClipColor), measured in Photoshop 27.11.
+                Some(t) => photocraft_color::blend::set_lum(*t, g).map(|v| v.clamp(0.0, 1.0)),
                 None => [g; 3],
             }
         }),
@@ -236,6 +239,155 @@ pub fn apply_depth(adj: &Adjustment, buf: &mut Buffer, transfer: Transfer, depth
     }
 }
 
+/// Legacy Brightness/Contrast as one channel's tone curve (see [`apply_depth`]).
+fn legacy_brightness_contrast(brightness: f32, contrast: f32) -> impl Fn(f32) -> f32 {
+    let b = brightness / 255.0;
+    let c = contrast.clamp(-100.0, 99.0);
+    let k = if c >= 0.0 { 1.0 / (1.0 - c / 100.0) } else { 1.0 + c / 100.0 };
+    let (pre, post) = if c >= 0.0 { (b, 0.0) } else { (0.0, b) };
+    move |v: f32| ((v + pre - LEGACY_PIVOT) * k + LEGACY_PIVOT + post).clamp(0.0, 1.0)
+}
+
+/// Applies an adjustment in a document of colour `mode`: [`apply_depth`], except that in Lab
+/// and CMYK documents the adjustments Photoshop evaluates on the document's own channels do so
+/// (see [`lab_channel_adjustment`] and [`cmyk_channel_adjustment`]).
+pub fn apply_in(adj: &Adjustment, buf: &mut Buffer, transfer: Transfer, depth: Option<SampleType>, mode: ColorMode) {
+    if mode == ColorMode::Lab && lab_channel_adjustment(adj) {
+        apply_lab(adj, buf, depth);
+    } else if mode == ColorMode::Cmyk && cmyk_channel_adjustment(adj) {
+        use photocraft_color::convert::{cmyk_to_rgb, rgb_to_cmyk};
+        map_rgb(buf, |c| {
+            let mut ink = rgb_to_cmyk(c);
+            stored_channels(adj, mode, depth, &mut ink, rgb_to_gray(c));
+            cmyk_to_rgb(ink)
+        });
+    } else {
+        apply_depth(adj, buf, transfer, depth);
+    }
+}
+
+/// Whether a Lab document evaluates `adj` on its L, a and b channels rather than on the screen
+/// colour: Invert and Posterize (L, a and b alike), Brightness/Contrast (L only), Threshold
+/// (split on L, neutral result) and Gradient Map (driven by L). Levels and Curves carry their own
+/// Lab records ([`ToneSpace::Lab`]); everything else stays on the screen colour.
+pub fn lab_channel_adjustment(adj: &Adjustment) -> bool {
+    matches!(
+        adj,
+        Adjustment::Invert
+            | Adjustment::Posterize { .. }
+            | Adjustment::Threshold { .. }
+            | Adjustment::BrightnessContrast { .. }
+            | Adjustment::GradientMap { .. }
+    )
+}
+
+/// Whether a CMYK document evaluates `adj` on its inks rather than on the screen colour: Invert
+/// and Posterize (each ink, black included, so paper inverts to 400% ink) and Threshold (paper or
+/// 100% black ink alone). Photoshop corpus cmyk8 and cmyk16 invert, posterize-4 and threshold-128
+/// follow these rules on the files' own inks on every pixel; here the inks are the screen colour
+/// separated through the document's CMYK profile, so neutrals carry the black that profile
+/// generates rather than the file's.
+pub fn cmyk_channel_adjustment(adj: &Adjustment) -> bool {
+    stored_channel_adjustment(adj)
+}
+
+/// Whether [`stored_channels`] evaluates `adj`: Invert, Posterize and Threshold.
+pub fn stored_channel_adjustment(adj: &Adjustment) -> bool {
+    matches!(adj, Adjustment::Invert | Adjustment::Posterize { .. } | Adjustment::Threshold { .. })
+}
+
+/// Invert, Posterize or Threshold on one pixel's own channels in a Lab or CMYK document of
+/// `depth` (`None`: unknown, treated as 8-bit): `ch` holds L, a, b normalised as [`lab_norm`]
+/// gives them, or the C, M, Y, K inks (0: none); `gray` is the pixel's luma, which CMYK Threshold
+/// compares. Lab Invert turns 8-bit bytes `v` into `255 - v` (a becomes -1 - a) and mirrors a and
+/// b around neutral at 16 bits (photoshop corpus lab16 invert.psd: neutral stays neutral).
+pub fn stored_channels(adj: &Adjustment, mode: ColorMode, depth: Option<SampleType>, ch: &mut [f32], gray: f32) {
+    let lab = mode == ColorMode::Lab;
+    match adj {
+        Adjustment::Invert => {
+            let mirror = if lab && depth.is_some_and(|d| d != SampleType::U8) { 256.0 / 255.0 } else { 1.0 };
+            for (i, v) in ch.iter_mut().enumerate() {
+                *v = if i > 0 { mirror } else { 1.0 } - v.clamp(0.0, 1.0);
+            }
+        }
+        Adjustment::Posterize { levels } => ch.iter_mut().for_each(|v| *v = posterize(*v, *levels)),
+        Adjustment::Threshold { level } => {
+            // On the 8-bit grid, like the RGB threshold.
+            let t = (level * 255.0).round();
+            let out = if lab {
+                let white = ch.first().is_some_and(|l| (l.clamp(0.0, 1.0) * 255.0).round() >= t);
+                [if white { 1.0 } else { 0.0 }, 128.0 / 255.0, 128.0 / 255.0, 0.0]
+            } else {
+                [0.0, 0.0, 0.0, if (gray * 255.0).round() < t { 1.0 } else { 0.0 }]
+            };
+            ch.iter_mut().zip(out).for_each(|(v, o)| *v = o);
+        }
+        _ => {}
+    }
+}
+
+/// Encoded sRGB → Lab normalised the way Photoshop's channels hold it: L/100, (a+128)/255,
+/// (b+128)/255.
+fn lab_norm(c: [f32; 3]) -> [f32; 3] {
+    let l = srgb_to_lab(c);
+    [l[0] / 100.0, (l[1] + 128.0) / 255.0, (l[2] + 128.0) / 255.0]
+}
+
+/// The inverse of [`lab_norm`].
+fn lab_denorm(n: [f32; 3]) -> [f32; 3] {
+    lab_to_srgb([n[0] * 100.0, n[1] * 255.0 - 128.0, n[2] * 255.0 - 128.0])
+}
+
+/// The Lab evaluation of a [`lab_channel_adjustment`] in a document of `depth` (no-op for any
+/// other adjustment).
+fn apply_lab(adj: &Adjustment, buf: &mut Buffer, depth: Option<SampleType>) {
+    match adj {
+        // L → 100 - L and a, b mirrored about neutral; each channel posterized (see `stored_channels`).
+        Adjustment::Invert | Adjustment::Posterize { .. } => map_rgb(buf, |c| {
+            let mut n = lab_norm(c);
+            stored_channels(adj, ColorMode::Lab, depth, &mut n, 0.0);
+            lab_denorm(n)
+        }),
+        Adjustment::Threshold { level } => {
+            // Split on L alone (on the 8-bit grid); the result is neutral black or white.
+            let t = (level * 255.0).round();
+            map_rgb(buf, |c| [if (lab_norm(c)[0].clamp(0.0, 1.0) * 255.0).round() >= t { 1.0 } else { 0.0 }; 3])
+        }
+        Adjustment::BrightnessContrast { brightness, contrast, legacy } => {
+            let legacy_curve = legacy_brightness_contrast(*brightness, *contrast);
+            let curve = |v: f32| if *legacy { legacy_curve(v) } else { modern_contrast(modern_brightness(v, *brightness), *contrast).clamp(0.0, 1.0) };
+            // The tone curve on L only. Added as the difference of two round trips (like
+            // `tone_in_space`) so a and b, and colours a round trip moves, stay put.
+            map_rgb(buf, |c| {
+                let n = lab_norm(c);
+                let l = curve(n[0]);
+                if l == n[0] {
+                    return c;
+                }
+                let (before, after) = (lab_denorm(n), lab_denorm([l, n[1], n[2]]));
+                std::array::from_fn(|i| (c[i] + after[i] - before[i]).clamp(0.0, 1.0))
+            })
+        }
+        Adjustment::GradientMap { stops, reverse, dither } => {
+            let (w, x0, y0) = (buf.rect.width().max(1) as usize, buf.rect.x0, buf.rect.y0);
+            for (i, p) in buf.px.iter_mut().enumerate() {
+                if p[3] <= 0.0 {
+                    continue;
+                }
+                // Driven by L: equal lightness maps to the same stop colour whatever the chroma.
+                let l = lab_norm([p[0], p[1], p[2]])[0].clamp(0.0, 1.0);
+                let mut o = gradient(stops, if *reverse { 1.0 - l } else { l });
+                if *dither {
+                    let d = bayer4(x0 + (i % w) as i32, y0 + (i / w) as i32) / 255.0;
+                    o = o.map(|v| (v + d).clamp(0.0, 1.0));
+                }
+                p[..3].copy_from_slice(&o);
+            }
+        }
+        _ => {}
+    }
+}
+
 /// Float RGB curve channels with no edit must preserve samples outside the LUT domain.
 /// Edited curves retain the existing spline/LUT behaviour until HDR extrapolation has an oracle.
 pub fn float_tone_identity(adj: &Adjustment, depth: Option<SampleType>) -> [bool; 3] {
@@ -293,7 +445,7 @@ pub fn tone_luts_depth(adj: &Adjustment, depth: Option<SampleType>) -> [Vec<f32>
 /// through the conversions the document's surfaces use. The change is added as a difference of
 /// two round trips, so channels a curve leaves alone (and out-of-gamut colours) stay exact.
 fn tone_in_space(space: ToneSpace, luts: &[Vec<f32>; 4], c: [f32; 3]) -> [f32; 3] {
-    use photocraft_color::convert::{cmyk_to_rgb, lab_to_srgb, rgb_to_cmyk, srgb_to_lab};
+    use photocraft_color::convert::{cmyk_to_rgb, rgb_to_cmyk};
     let (before, after) = match space {
         ToneSpace::Cmyk => {
             let ink = rgb_to_cmyk(c);
@@ -336,21 +488,32 @@ pub fn hue_range_tables(ranges: &[HueRange; 6]) -> [Vec<f32>; 3] {
 /// Colorize sets the hue and saturation instead of shifting them; at 0% it leaves only the
 /// lightness, as in Photoshop (#2326). Ticking Colorize in the dialog starts saturation at 25%.
 pub fn hue_saturation(c: [f32; 3], hue: f32, s: f32, l: f32, colorize: bool) -> [f32; 3] {
-    let (mut hh, mut ss, ll) = rgb_to_hsl(c);
+    let lighten = |v: f32| if l > 0.0 { v + (1.0 - v) * l } else { v * (1.0 + l) };
     if colorize {
-        hh = hue.rem_euclid(360.0) / 360.0;
-        ss = s.abs().min(1.0);
-    } else {
-        hh = (hh + hue / 360.0).rem_euclid(1.0);
-        ss = (ss * (1.0 + s)).clamp(0.0, 1.0);
+        // Colorize builds the colour at the lightened (or darkened) lightness, so black with
+        // Lightness +30 becomes a 30 % lightness colour, not grey (measured in Photoshop 27.11).
+        let (_, _, ll) = rgb_to_hsl(c);
+        return hsl_to_rgb(hue.rem_euclid(360.0) / 360.0, s.abs().min(1.0), lighten(ll));
     }
-    let mut rgb = hsl_to_rgb(hh, ss, ll);
-    if l > 0.0 {
-        rgb = rgb.map(|v| v + (1.0 - v) * l);
-    } else if l < 0.0 {
-        rgb = rgb.map(|v| v * (1.0 + l));
-    }
-    rgb
+    // Photoshop applies Lightness first, then rotates the hue and scales the saturation of the
+    // result: Hue +40, Saturation +25, Lightness -10 turns (240, 160, 30) into (173, 243, 0), not
+    // (168, 230, 14) (Photoshop 27.11 corpus file adjustments/rgb8/hue-saturation).
+    let (hh, ss, ll) = rgb_to_hsl(c.map(lighten));
+    let hh = (hh + hue / 360.0).rem_euclid(1.0);
+    // Raising saturation divides by 1 - s, lowering it multiplies by 1 + s: +50 % doubles it
+    // (measured in Photoshop 27.11); +100 % saturates any colour that has some.
+    let ss = if s > 0.0 { ss / (1.0 - s).max(1.0 / 512.0) } else { ss * (1.0 + s) }.clamp(0.0, 1.0);
+    hsl_to_rgb(hh, ss, ll)
+}
+
+/// A colour range's Lightness, applied after the master edits. It moves each channel towards the
+/// pixel's brightest channel when raised and towards its darkest when lowered, not towards white
+/// or black: Blues +50 turns (0, 29, 115) into (57, 71, 115), Blues -50 turns (102, 128, 204) into
+/// (102, 115, 153) (measured in Photoshop 27.11).
+pub fn range_lightness(c: [f32; 3], l: f32) -> [f32; 3] {
+    let l = l.clamp(-1.0, 1.0);
+    let target = if l > 0.0 { c[0].max(c[1]).max(c[2]) } else { c[0].min(c[1]).min(c[2]) };
+    c.map(|v| v + (target - v) * l.abs())
 }
 
 /// Black & White grey value. Each colour is the sum of a grey part (its smallest channel), a
@@ -387,6 +550,10 @@ pub fn bayer4(x: i32, y: i32) -> f32 {
 
 /// Samples a 3D LUT (`n`³ RGB triplets, red fastest) at `c`, trilinear or tetrahedral.
 pub fn lut3d_sample(lut: &[f32], n: usize, c: [f32; 3], tetrahedral: bool) -> [f32; 3] {
+    // A degenerate or short table can't be sampled: leave the colour alone.
+    if n < 2 || n.checked_pow(3).and_then(|c| c.checked_mul(3)).is_none_or(|len| lut.len() < len) {
+        return c;
+    }
     let m = (n - 1) as f32;
     let pos = c.map(|v| v.clamp(0.0, 1.0) * m);
     let i0 = pos.map(|p| (p.floor() as usize).min(n - 2));
@@ -438,8 +605,9 @@ const BALANCE_LEVELS: f32 = 0.39;
 /// - Preserve Luminosity off: a slider only moves its own channel. Midtones is gamma 2^−a.
 ///   Shadows is gamma 2^(−a/2) after a black point at 0.39·|a| when lowered; highlights is
 ///   gamma 2^(−a/2) after a white point at 1 − 0.39·a when raised.
-/// - Preserve Luminosity on: midtones is gamma 2^(−a/2) on the slider's channel and 2^(a/2) on
-///   the other two. Shadows and highlights go by the differences between a tone's three sliders:
+/// - Preserve Luminosity on: midtones uses gamma 2^((max(a) + min(a))/2 − a_ch),
+///   preserving the one-slider behaviour without summing offsets when multiple sliders move.
+///   Shadows and highlights go by the differences between a tone's three sliders:
 ///   each channel gets a plain black point at 0.39·(max − its own) for shadows and a plain white
 ///   point at 1 − 0.39·(its own − min) for highlights (so one raised shadows slider darkens the
 ///   other two channels, and two raised together darken only the third).
@@ -453,28 +621,27 @@ pub fn color_balance_channel(tones: [[f32; 3]; 3], preserve_luminosity: bool, ch
     let mut v = v.clamp(0.0, 1.0);
     for (tone, sliders) in [(2, highlights), (0, shadows), (1, midtones)] {
         let a: [f32; 3] = sliders.map(|s| (s / 100.0).clamp(-1.0, 1.0));
-        if preserve_luminosity && tone != 1 {
+        if preserve_luminosity {
             let own = a.get(ch).copied().unwrap_or(0.0);
             let (lo, hi) = a.iter().fold((f32::MAX, f32::MIN), |m, x| (m.0.min(*x), m.1.max(*x)));
-            v = if tone == 0 { black(v, BALANCE_LEVELS * (hi - own)) } else { white(v, 1.0 - BALANCE_LEVELS * (own - lo)) };
+            v = match tone {
+                0 => black(v, BALANCE_LEVELS * (hi - own)),
+                1 => v.powf(2f32.powf((hi + lo) / 2.0 - own)),
+                _ => white(v, 1.0 - BALANCE_LEVELS * (own - lo)),
+            };
             continue;
         }
         for (src, slider) in sliders.iter().enumerate() {
             let a = (slider / 100.0).clamp(-1.0, 1.0);
-            let own = src == ch;
-            if a == 0.0 || (!preserve_luminosity && !own) {
+            if a == 0.0 || src != ch {
                 continue;
             }
-            v = match (tone, preserve_luminosity) {
-                (1, false) => v.powf(2f32.powf(-a)),
-                (1, true) => v.powf(2f32.powf(if own { -a } else { a } / 2.0)),
-                (0, false) if a < 0.0 => black(v, BALANCE_LEVELS * -a).powf(2f32.powf(-a / 2.0)),
-                (0, false) => v.powf(2f32.powf(-a / 2.0)),
-
-                (2, false) if a > 0.0 => white(v, 1.0 - BALANCE_LEVELS * a).powf(2f32.powf(-a / 2.0)),
-                (2, false) => v.powf(2f32.powf(-a / 2.0)),
-
-                _ => v,
+            v = match tone {
+                1 => v.powf(2f32.powf(-a)),
+                0 if a < 0.0 => black(v, BALANCE_LEVELS * -a).powf(2f32.powf(-a / 2.0)),
+                0 => v.powf(2f32.powf(-a / 2.0)),
+                2 if a > 0.0 => white(v, 1.0 - BALANCE_LEVELS * a).powf(2f32.powf(-a / 2.0)),
+                _ => v.powf(2f32.powf(-a / 2.0)),
             };
         }
     }
@@ -502,10 +669,12 @@ pub fn selective_color_weights(c: [f32; 3]) -> [f32; 9] {
     ]
 }
 
-/// Photoshop Selective Color (approximation): each range shifts the cyan, magenta and yellow ink
-/// (1 − R, G, B) by its percentage, plus its black percentage on every ink, weighted by how much
-/// the colour belongs to the range. Relative mode scales the shift by the ink already present
-/// (so it can't tint pure white); absolute adds it outright.
+/// Photoshop Selective Color: each range shifts the cyan, magenta and yellow ink (1 − R, G, B) by
+/// its percentage, plus its black percentage on every ink, weighted by how much the colour belongs
+/// to the range. Relative mode scales the shift by the ink already present (so it can't tint pure
+/// white). Absolute mode scales it by the room the ink has: adding ink by min(1, 2 × (1 − ink)),
+/// removing it by min(1, 2 × ink), so Neutrals Cyan +50 darkens red 64 by 32, not 64 (all 72
+/// absolute range × ink cases within 1 level of Photoshop 27.11).
 pub fn selective_color(c: [f32; 3], relative: bool, adj: &[[f32; 4]; 9]) -> [f32; 3] {
     let w = selective_color_weights(c);
     let mut delta = [0.0f32; 3];
@@ -516,7 +685,14 @@ pub fn selective_color(c: [f32; 3], relative: bool, adj: &[[f32; 4]; 9]) -> [f32
         let a = adj[r].map(|v| v / 100.0);
         for i in 0..3 {
             let ink = 1.0 - c[i];
-            let d = if relative { (a[i] + a[3]) * ink } else { a[i] + a[3] };
+            let d = a[i] + a[3];
+            let d = if relative {
+                d * ink
+            } else if d > 0.0 {
+                d * (2.0 * (1.0 - ink)).min(1.0)
+            } else {
+                d * (2.0 * ink).min(1.0)
+            };
             delta[i] += d * wr;
         }
     }
@@ -938,6 +1114,30 @@ mod lookup_tests {
         }
     }
 
+    /// Photoshop 27.11, measured: absolute Selective Color on greys (red channel after one range's
+    /// cyan change).
+    #[test]
+    fn absolute_selective_color_matches_photoshop() {
+        // (range index, cyan %, grey, Photoshop's red)
+        let measured = [
+            (7, 50.0, 64u8, 32u8),
+            (7, 50.0, 192, 129),
+            (7, -50.0, 192, 223),
+            (7, -50.0, 64, 128),
+            (6, -50.0, 192, 224),
+            (6, -50.0, 240, 253),
+            (8, 50.0, 64, 32),
+            (8, 50.0, 16, 2),
+        ];
+        for (range, cyan, grey, want) in measured {
+            let mut adj = [[0.0f32; 4]; 9];
+            adj[range][0] = cyan;
+            let g = grey as f32 / 255.0;
+            let got = selective_color([g; 3], false, &adj)[0] * 255.0;
+            assert!((got - want as f32).abs() <= 1.5, "range {range} cyan {cyan} grey {grey}: {got} vs {want}");
+        }
+    }
+
     #[test]
     fn selective_color_zero_is_identity_and_ranges_are_local() {
         let zero = [[0.0f32; 4]; 9];
@@ -1054,6 +1254,26 @@ mod tone_tests {
         }
     }
 
+    #[test]
+    fn color_balance_midtones_with_multiple_sliders_preserve_luminosity() {
+        // A shared offset depends on the two extremes, not the sum of moved sliders.
+        // The old per-slider product leaves red/blue unchanged for [30, 0, 30].
+        let tones = [[0.0; 3], [30.0, 0.0, 30.0], [0.0; 3]];
+        for input in [0.25_f32, 0.5, 0.75] {
+            for (ch, offset) in [-0.15_f32, 0.15, -0.15].into_iter().enumerate() {
+                let expected = input.powf(2f32.powf(offset));
+                let actual = color_balance_channel(tones, true, ch, input);
+                assert!((actual - expected).abs() < 1e-6, "channel {ch}, input {input}: {actual} vs {expected}");
+            }
+            // Preserve Luminosity off must still affect only the moved channels.
+            assert_eq!(color_balance_channel(tones, false, 1, input), input);
+            // One moved slider retains its previous half-strength compensation.
+            let single = [[0.0; 3], [30.0, 0.0, 0.0], [0.0; 3]];
+            assert!((color_balance_channel(single, true, 0, input) - input.powf(2f32.powf(-0.15))).abs() < 1e-6);
+            assert!((color_balance_channel(single, true, 1, input) - input.powf(2f32.powf(0.15))).abs() < 1e-6);
+        }
+    }
+
     #[test]
     fn levels_and_curves_apply_each_channel_before_the_master() {
         // These two affine tone adjustments describe the same mapping:
@@ -1193,6 +1413,82 @@ mod tone_tests {
         }
     }
 
+    /// Photoshop 27.11, measured: Hue/Saturation raising saturation, and Colorize with Lightness.
+    #[test]
+    fn hue_saturation_matches_photoshop() {
+        // (input, hue, saturation, lightness, colorize, Photoshop's output)
+        type Case = ([u8; 3], f32, f32, f32, bool, [u8; 3]);
+        let measured: [Case; 8] = [
+            ([204, 102, 102], 0.0, 50.0, 0.0, false, [254, 51, 51]),
+            ([204, 159, 102], 0.0, 50.0, 0.0, false, [254, 164, 51]),
+            ([204, 102, 102], 0.0, -50.0, 0.0, false, [178, 127, 127]),
+            ([0, 0, 0], 120.0, 100.0, 30.0, true, [0, 152, 0]),
+            ([28, 28, 28], 120.0, 100.0, 30.0, true, [0, 192, 0]),
+            ([160, 160, 160], 30.0, 25.0, -40.0, true, [120, 96, 73]),
+            ([252, 252, 252], 30.0, 25.0, -40.0, true, [177, 151, 126]),
+            ([255, 143, 0], 30.0, 25.0, -40.0, true, [95, 76, 58]),
+        ];
+        for (input, hue, saturation, lightness, colorize, want) in measured {
+            let a = Adjustment::HueSaturation { hue, saturation, lightness, colorize, ranges: HueRange::defaults() };
+            let c = input.map(|v| v as f32 / 255.0);
+            let mut b = Buffer { rect: Rect::new(0, 0, 1, 1), px: vec![[c[0], c[1], c[2], 1.0]] };
+            apply(&a, &mut b);
+            for (i, w) in want.iter().enumerate() {
+                let got = b.px[0][i] * 255.0;
+                assert!((got - *w as f32).abs() <= 2.0, "{input:?} h{hue} s{saturation} l{lightness} colorize {colorize}, channel {i}: {got} vs {w}");
+            }
+        }
+    }
+
+    /// Photoshop 27.11, measured: a range's Lightness (Blues ±50) moves towards the brightest or darkest channel.
+    #[test]
+    fn range_lightness_matches_photoshop() {
+        let measured = [
+            ([0u8, 29, 115], 0.5, [57u8, 71, 115]),
+            ([0, 64, 255], 0.5, [125, 157, 255]),
+            ([102, 128, 204], 0.5, [152, 165, 204]),
+            ([102, 128, 204], -0.5, [102, 115, 154]),
+            ([0, 18, 115], -0.5, [0, 9, 58]),
+        ];
+        for (input, l, want) in measured {
+            let got = range_lightness(input.map(|v| v as f32 / 255.0), l);
+            for i in 0..3 {
+                assert!((got[i] * 255.0 - want[i] as f32).abs() <= 2.5, "{input:?} channel {i}: {} vs {}", got[i] * 255.0, want[i]);
+            }
+        }
+    }
+
+    /// Photoshop's own render (merged image of psd-tools `adjustments/huesaturation_lightness_rgb.psd`,
+    /// layer "Hue/Saturation 1"): a dull magenta gets the whole range edit, as a vivid one does (#4089).
+    #[test]
+    fn hue_ranges_apply_in_full_to_dull_colours() {
+        let range = |lightness: f32, bounds: [f32; 4]| HueRange { hue: 0.0, saturation: 0.0, lightness, bounds };
+        let ranges = [
+            range(-11.0, [-57.0, 4.0, 82.0, 175.0]),
+            range(100.0, [12.0, 45.0, 75.0, 105.0]),
+            HueRange::neutral(2),
+            HueRange::neutral(3),
+            HueRange::neutral(4),
+            range(100.0, [-117.0, -50.0, 39.0, 104.0]),
+        ];
+        let a = Adjustment::HueSaturation { hue: 0.0, saturation: 0.0, lightness: 17.0, colorize: false, ranges };
+        let measured = [([126u8, 97, 120], [148u8, 148, 148]), ([131, 103, 125], [152, 152, 152]), ([95, 69, 90], [122, 122, 122])];
+        for (input, want) in measured {
+            let c = input.map(|v| v as f32 / 255.0);
+            let mut b = Buffer { rect: Rect::new(0, 0, 1, 1), px: vec![[c[0], c[1], c[2], 1.0]] };
+            apply(&a, &mut b);
+            for (i, w) in want.iter().enumerate() {
+                let got = b.px[0][i] * 255.0;
+                assert!((got - *w as f32).abs() <= 2.0, "{input:?} channel {i}: {got} vs {w}");
+            }
+        }
+        // Greys have no hue, so the ranges leave them alone: only the master Lightness moves them.
+        let mut b = Buffer { rect: Rect::new(0, 0, 1, 1), px: vec![[0.4, 0.4, 0.4, 1.0]] };
+        apply(&a, &mut b);
+        let p = b.px[0];
+        assert!((p[0] - p[1]).abs() < 1e-6 && (p[1] - p[2]).abs() < 1e-6 && (p[0] - (0.4 + 0.6 * 0.17)).abs() < 1e-4, "{p:?}");
+    }
+
     #[test]
     fn black_white_weights() {
         let d = [40.0, 60.0, 40.0, 60.0, 20.0, 80.0];
@@ -1204,6 +1500,31 @@ mod tone_tests {
         assert!(black_white_gray([1.0, 0.0, 0.0], &w) > black_white_gray([1.0, 0.0, 0.0], &d));
     }
 
+    /// Photoshop 27.11, measured: Black & White (default weights) with Tint over greys. The tint
+    /// is blended like the Color blend mode: its hue and saturation at the grey's luminosity.
+    #[test]
+    fn black_white_tint_matches_photoshop() {
+        let weights = [40.0, 60.0, 40.0, 60.0, 20.0, 80.0];
+        let measured: [([u8; 3], u8, [u8; 3]); 6] = [
+            ([255, 0, 0], 24, [81, 1, 1]),
+            ([255, 0, 0], 120, [255, 64, 64]),
+            ([255, 0, 0], 240, [255, 235, 235]),
+            ([0xe1, 0xd3, 0xb3], 120, [133, 119, 87]),
+            ([0xe1, 0xd3, 0xb3], 24, [33, 24, 1]),
+            ([0x40, 0x20, 0x10], 120, [144, 112, 96]),
+        ];
+        for (tint, grey, want) in measured {
+            let tint = Some(tint.map(|v| v as f32 / 255.0));
+            let mut b = Buffer { rect: Rect::new(0, 0, 1, 1), px: vec![[grey as f32 / 255.0; 4]] };
+            b.px[0][3] = 1.0;
+            apply(&Adjustment::BlackWhite { weights, tint }, &mut b);
+            for (i, w) in want.iter().enumerate() {
+                let got = b.px[0][i] * 255.0;
+                assert!((got - *w as f32).abs() <= 2.5, "tint {tint:?} grey {grey} channel {i}: {got} vs {w}");
+            }
+        }
+    }
+
     #[test]
     fn gradient_map_dither_stays_close() {
         let stops = vec![(0.0, [0.0; 3]), (1.0, [1.0; 3])];
@@ -1214,8 +1535,162 @@ mod tone_tests {
         assert!(a.px.iter().zip(&b.px).all(|(x, y)| (x[0] - y[0]).abs() <= 0.5 / 255.0 + 1e-6));
         assert!(a.px.iter().zip(&b.px).any(|(x, y)| x[0] != y[0]));
     }
+
+    /// `adj` applied in a Lab document to one encoded sRGB colour, returned as (L, a, b).
+    fn in_lab(adj: &Adjustment, c: [f32; 3]) -> [f32; 3] {
+        let mut b = Buffer::filled(crate::Rect::new(0, 0, 1, 1), [c[0], c[1], c[2], 1.0]);
+        apply_in(adj, &mut b, Transfer::Srgb, Some(SampleType::U8), ColorMode::Lab);
+        srgb_to_lab([b.px[0][0], b.px[0][1], b.px[0][2]])
+    }
+
+    /// A muted, in-gamut colour from (L, a, b).
+    fn lab(l: f32, a: f32, b: f32) -> [f32; 3] {
+        lab_to_srgb([l, a, b])
+    }
+
+    fn near(got: [f32; 3], want: [f32; 3], tol: f32) -> bool {
+        got.iter().zip(want).all(|(g, w)| (g - w).abs() <= tol)
+    }
+
+    #[test]
+    fn lab_invert_flips_l_a_and_b() {
+        let got = in_lab(&Adjustment::Invert, lab(30.0, 12.0, -18.0));
+        // n -> 1 - n: L -> 100 - L, a -> -a - 1, b -> -b - 1 (mirrored on the 0..255 grid).
+        assert!(near(got, [70.0, -13.0, 17.0], 0.6), "{got:?}");
+        // On the screen colour it would not be a mirror in Lab.
+        let mut rgb = Buffer::filled(crate::Rect::new(0, 0, 1, 1), [0.0, 0.0, 0.0, 1.0]);
+        let c = lab(30.0, 12.0, -18.0);
+        rgb.px[0] = [c[0], c[1], c[2], 1.0];
+        apply(&Adjustment::Invert, &mut rgb);
+        assert!(!near(srgb_to_lab([rgb.px[0][0], rgb.px[0][1], rgb.px[0][2]]), got, 1.0));
+    }
+
+    #[test]
+    fn sixteen_bit_lab_invert_keeps_greys_neutral() {
+        // 16-bit Lab Invert mirrors a and b around neutral (photoshop corpus lab16 invert.psd);
+        // 8-bit bytes land one step off it.
+        let mut b = Buffer::filled(crate::Rect::new(0, 0, 1, 1), [0.0, 0.0, 0.0, 1.0]);
+        let c = lab(40.0, 0.0, 0.0);
+        b.px[0] = [c[0], c[1], c[2], 1.0];
+        apply_in(&Adjustment::Invert, &mut b, Transfer::Srgb, Some(SampleType::U16), ColorMode::Lab);
+        let got = srgb_to_lab([b.px[0][0], b.px[0][1], b.px[0][2]]);
+        assert!(near(got, [60.0, 0.0, 0.0], 0.05), "{got:?}");
+        assert!(near(in_lab(&Adjustment::Invert, c), [60.0, -1.0, -1.0], 0.1));
+    }
+
+    /// `adj` applied in a CMYK document to one encoded sRGB colour.
+    fn in_cmyk(adj: &Adjustment, c: [f32; 3]) -> [f32; 3] {
+        let mut b = Buffer::filled(crate::Rect::new(0, 0, 1, 1), [c[0], c[1], c[2], 1.0]);
+        apply_in(adj, &mut b, Transfer::Srgb, Some(SampleType::U8), ColorMode::Cmyk);
+        [b.px[0][0], b.px[0][1], b.px[0][2]]
+    }
+
+    #[test]
+    fn cmyk_invert_posterize_and_threshold_work_on_the_inks() {
+        use photocraft_color::convert::{cmyk_to_rgb, rgb_to_cmyk};
+        // Paper inverts to all four inks at 100%, not to RGB black (photoshop corpus cmyk8 invert.psd).
+        assert!(near(in_cmyk(&Adjustment::Invert, [1.0; 3]), cmyk_to_rgb([1.0; 4]), 2e-3));
+        let red = [0.9, 0.2, 0.1];
+        assert!(near(in_cmyk(&Adjustment::Invert, red), cmyk_to_rgb(rgb_to_cmyk(red).map(|v| 1.0 - v)), 2e-3));
+        let two = cmyk_to_rgb(rgb_to_cmyk(red).map(|v| if v >= 0.5 { 1.0 } else { 0.0 }));
+        assert!(near(in_cmyk(&Adjustment::Posterize { levels: 2 }, red), two, 2e-3));
+        // Threshold's black is the black ink alone (threshold-128.psd), its white the paper.
+        let t = Adjustment::Threshold { level: 0.5 };
+        assert!(near(in_cmyk(&t, [0.2; 3]), cmyk_to_rgb([0.0, 0.0, 0.0, 1.0]), 2e-3));
+        assert!(near(in_cmyk(&t, [0.8; 3]), cmyk_to_rgb([0.0; 4]), 2e-3));
+    }
+
+    #[test]
+    fn lab_posterize_steps_l_a_and_b() {
+        let got = in_lab(&Adjustment::Posterize { levels: 2 }, lab(70.0, 20.0, -30.0));
+        // Two levels: each normalised channel snaps to 0 or 1 (L 100, a and b at +127 / -128).
+        assert!(near(got, srgb_to_lab(lab_denorm([1.0, 1.0, 0.0])), 1e-3), "{got:?}");
+        let grey = in_lab(&Adjustment::Posterize { levels: 255 }, lab(50.0, 0.0, 0.0));
+        assert!(near(grey, [50.0, 0.0, 0.0], 1.1), "255 levels is within a step of the identity: {grey:?}");
+    }
+
+    #[test]
+    fn lab_threshold_splits_on_l_with_a_neutral_result() {
+        let t = Adjustment::Threshold { level: 0.5 };
+        // A saturated blue (L ≈ 32) and yellow (L ≈ 97): black and white, nothing in between.
+        for (c, white) in [([0.0, 0.0, 1.0], false), ([1.0, 1.0, 0.0], true), (lab(52.0, 40.0, 30.0), true), (lab(48.0, -40.0, 30.0), false)] {
+            let mut b = Buffer::filled(crate::Rect::new(0, 0, 1, 1), [c[0], c[1], c[2], 1.0]);
+            apply_in(&t, &mut b, Transfer::Srgb, None, ColorMode::Lab);
+            let v = if white { 1.0 } else { 0.0 };
+            assert_eq!(b.px[0], [v, v, v, 1.0], "{c:?}");
+        }
+    }
+
+    #[test]
+    fn lab_brightness_contrast_moves_l_only() {
+        for legacy in [false, true] {
+            let adj = Adjustment::BrightnessContrast { brightness: 40.0, contrast: 30.0, legacy };
+            let before = [45.0, 15.0, -20.0];
+            let got = in_lab(&adj, lab(before[0], before[1], before[2]));
+            assert!(got[0] > before[0] + 5.0, "{legacy}: L rises: {got:?}");
+            assert!((got[1] - before[1]).abs() < 0.5 && (got[2] - before[2]).abs() < 0.5, "{legacy}: a, b kept: {got:?}");
+        }
+    }
+
+    #[test]
+    fn lab_gradient_map_follows_l() {
+        let stops = vec![(0.0, [1.0, 0.0, 0.0]), (1.0, [0.0, 0.0, 1.0])];
+        for reverse in [false, true] {
+            let map = Adjustment::GradientMap { stops: stops.clone(), reverse, dither: false };
+            // A grey and a saturated colour with the same L map to the same colour.
+            let grey = in_lab(&map, lab(60.0, 0.0, 0.0));
+            let green = in_lab(&map, lab(60.0, -50.0, 40.0));
+            assert!(near(grey, green, 1e-3), "{reverse}: {grey:?} vs {green:?}");
+            let t = if reverse { 0.4 } else { 0.6 };
+            let want = srgb_to_lab([1.0 - t, 0.0, t]);
+            assert!(near(grey, want, 0.05), "{reverse}: {grey:?} vs {want:?}");
+        }
+    }
+
+    #[test]
+    fn other_modes_and_adjustments_keep_the_screen_colour_path() {
+        let c = [0.2, 0.5, 0.7, 1.0];
+        let lab_only = [Adjustment::Invert, Adjustment::Threshold { level: 0.47 }, Adjustment::Posterize { levels: 4 }];
+        for adj in
+            lab_only.iter().chain([&Adjustment::HueSaturation { hue: 30.0, saturation: 0.0, lightness: 0.0, colorize: false, ranges: HueRange::defaults() }])
+        {
+            for mode in [ColorMode::Rgb, ColorMode::Cmyk, ColorMode::Grayscale, ColorMode::Lab] {
+                let (mut a, mut b) = (Buffer::filled(crate::Rect::new(0, 0, 1, 1), c), Buffer::filled(crate::Rect::new(0, 0, 1, 1), c));
+                apply_in(adj, &mut a, Transfer::Srgb, None, mode);
+                apply_depth(adj, &mut b, Transfer::Srgb, None);
+                let own = (mode == ColorMode::Lab && lab_channel_adjustment(adj)) || (mode == ColorMode::Cmyk && cmyk_channel_adjustment(adj));
+                assert_eq!(a.px == b.px, !own, "{adj:?} in {mode:?}");
+            }
+        }
+        // Transparent pixels are left alone and odd values never panic.
+        let mut t = Buffer::filled(crate::Rect::new(0, 0, 2, 1), [f32::NAN, 2.0, -1.0, 0.0]);
+        for adj in lab_only.iter().chain([&Adjustment::GradientMap { stops: vec![], reverse: true, dither: true }]) {
+            for mode in [ColorMode::Lab, ColorMode::Cmyk] {
+                apply_in(adj, &mut t, Transfer::Srgb, None, mode);
+                let mut odd = Buffer::filled(crate::Rect::new(0, 0, 1, 1), [f32::NAN, f32::INFINITY, -3.0, 1.0]);
+                apply_in(adj, &mut odd, Transfer::Srgb, Some(SampleType::U16), mode);
+            }
+        }
+        assert!(t.px[0][1] == 2.0);
+    }
 }
 
 /// Legacy Brightness/Contrast scales contrast around 128 of 255 (contrast 80 keeps 128 at 128,
 /// measured on Photoshop 27.11; a 0.5 pivot moved it to 130).
 pub const LEGACY_PIVOT: f32 = 128.0 / 255.0;
+
+#[cfg(test)]
+mod lut3d_guard_tests {
+    use super::lut3d_sample;
+
+    #[test]
+    fn degenerate_or_short_tables_leave_the_colour_alone() {
+        let c = [0.2, 0.4, 0.6];
+        for tetra in [false, true] {
+            assert_eq!(lut3d_sample(&[], 0, c, tetra), c);
+            assert_eq!(lut3d_sample(&[0.0; 3], 1, c, tetra), c);
+            assert_eq!(lut3d_sample(&[0.0; 3], 2, c, tetra), c);
+            assert_eq!(lut3d_sample(&[0.0; 24], usize::MAX, c, tetra), c);
+        }
+    }
+}
diff --git a/crates/compose/src/advanced.rs b/crates/compose/src/advanced.rs
index 4a9cb3e89b..6809c9e865 100644
--- a/crates/compose/src/advanced.rs
+++ b/crates/compose/src/advanced.rs
@@ -84,10 +84,10 @@ pub fn shapeless(layer: &Layer) -> bool {
     !layer.advanced.transparency_shapes && (layer.advanced.knockout != Knockout::None || effects::has_effects(layer))
 }
 
-/// The Background layer of a stack: the bottom layer, a locked, opaque-by-convention pixel layer
-/// named "Background" (how PSD import and File › New create it).
+/// Whether `l`, the bottom layer of a stack, is the Background: identified by its locks and kind,
+/// never by its (localized) name ([`photocraft_doc::Document::background`]).
 pub fn is_background(l: &Layer) -> bool {
-    l.name == "Background" && l.locks.transparency && !l.clipped && matches!(l.content, LayerContent::Raster(_))
+    l.has_background_traits()
 }
 
 /// What a deep knockout reveals over `rect`: the document's initial backdrop with its Background
diff --git a/crates/compose/src/advanced_tests.rs b/crates/compose/src/advanced_tests.rs
index c4e437a4b6..c19b0dc92f 100644
--- a/crates/compose/src/advanced_tests.rs
+++ b/crates/compose/src/advanced_tests.rs
@@ -246,6 +246,26 @@ fn blend_interior_effects_as_group_puts_overlays_under_fill_opacity() {
     }
 }
 
+#[test]
+fn interior_effects_blend_over_the_layer_mode_unless_grouped() {
+    // #3996: #888888 under a black Color-mode layer with a red Overlay colour overlay. The
+    // layer's mode applies to its own pixels (grey stays grey), then the overlay blends onto
+    // that result and tints it; as a group the overlay of black is black, so grey remains.
+    let grey = 136.0 / 255.0;
+    let lift = 1.0 - 2.0 * (1.0 - grey);
+    for depth in DEPTHS {
+        let mut d = doc(depth, false);
+        d.layers.push(solid(&d, "grey", full(&d), [grey, grey, grey, 1.0]));
+        let mut l = solid(&d, "black", full(&d), [0.0, 0.0, 0.0, 1.0]);
+        l.blend = BlendMode::Color;
+        l.effects.items = vec![Effect::ColorOverlay { common: FxCommon::new(BlendMode::Overlay, 1.0), color: Color::rgb(1.0, 0.0, 0.0) }];
+        d.layers.push(l);
+        check(&d, 2, 2, [1.0, lift, lift, 1.0], "default: overlay over the Color blend");
+        d.layers[1].advanced.blend_interior = true;
+        check(&d, 2, 2, [grey, grey, grey, 1.0], "as group: overlay inside the Color blend");
+    }
+}
+
 #[test]
 fn transparency_shapes_off_spreads_effects_over_the_whole_layer() {
     for depth in DEPTHS {
@@ -406,6 +426,26 @@ fn vector_mask_hides_effects() {
     }
 }
 
+/// The per-render vector-mask cache must key masks by content: `hiding_mask` and
+/// `effects_source` hand it temporary clones whose addresses get reused (#4426).
+#[test]
+fn vector_mask_cache_does_not_mix_up_layers() {
+    use photocraft_doc::{Path, Subpath, VectorMask};
+    for depth in DEPTHS {
+        let mut d = doc(depth, true);
+        for (name, color, x0, x1) in [("a", BLUE, -4.0, 6.0), ("b", GREEN, 6.0, 16.0)] {
+            let mut l = solid(&d, name, full(&d), color);
+            l.effects.items = vec![inside_stroke()];
+            l.advanced.vector_mask_hides_effects = true;
+            let path = Path::new(vec![Subpath::polygon(&[(x0, -4.0), (x1, -4.0), (x1, 12.0), (x0, 12.0)])]);
+            l.vector_mask = Some(VectorMask::new(path));
+            d.layers.push(l);
+        }
+        check(&d, 2, 4, BLUE, "layer A inside its own mask");
+        check(&d, 9, 4, GREEN, "layer B inside its own mask");
+    }
+}
+
 #[test]
 fn defaults_take_the_plain_paths() {
     let d = doc(SampleType::U8, true);
@@ -437,3 +477,26 @@ fn a_knockout_background_does_not_recurse() {
     let got = render(&d, Rect::from_xywh(0, 0, 1, 1)).px[0];
     assert!(got[3] <= 1.0);
 }
+
+/// The Background is found by its structure, not its English name: a file from a German or
+/// Japanese Photoshop calls it "Hintergrund" or "背景", and a deep knockout still reveals it. A
+/// bottom layer merely called "Background", without the Background's locks, is not one.
+#[test]
+fn deep_knockout_reveals_a_localized_background() {
+    for depth in DEPTHS {
+        for name in ["Hintergrund", "背景", "Arrière-plan"] {
+            let mut d = doc(depth, true);
+            d.layers[0].name = name.into();
+            let green = solid(&d, "green", full(&d), GREEN);
+            d.layers.push(green);
+            d.layers.push(knocker(&d, Knockout::Deep));
+            check(&d, 2, 2, WHITE, name);
+        }
+        let mut d = doc(depth, true);
+        d.layers[0].locks = Default::default();
+        let green = solid(&d, "green", full(&d), GREEN);
+        d.layers.push(green);
+        d.layers.push(knocker(&d, Knockout::Deep));
+        check(&d, 2, 2, [0.0; 4], "an unlocked layer named Background");
+    }
+}
diff --git a/crates/compose/src/bounds.rs b/crates/compose/src/bounds.rs
index 1055487f13..985a400e08 100644
--- a/crates/compose/src/bounds.rs
+++ b/crates/compose/src/bounds.rs
@@ -5,7 +5,7 @@
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex, Weak};
 
-use photocraft_geom::{Rect, TILE_SIZE};
+use photocraft_geom::Rect;
 use photocraft_raster::{Surface, Tile};
 
 struct Entry {
@@ -15,25 +15,23 @@ struct Entry {
     bounds: Option<(u16, u16, u16, u16)>,
 }
 
-fn cache() -> &'static Mutex<HashMap<usize, Entry>> {
-    static C: std::sync::OnceLock<Mutex<HashMap<usize, Entry>>> = std::sync::OnceLock::new();
-    C.get_or_init(Default::default)
+/// The entries, and the size past which dead ones are dropped (see [`next_sweep`]).
+struct Cache {
+    entries: HashMap<usize, Entry>,
+    sweep_at: usize,
 }
 
-/// Pixels of `t` that differ from `dp` (tile-local half-open bounds).
-fn scan(t: &Tile, dp: &[u8]) -> Option<(u16, u16, u16, u16)> {
-    let bpp = dp.len();
-    let ts = TILE_SIZE as usize;
-    let (mut x0, mut y0, mut x1, mut y1) = (usize::MAX, usize::MAX, 0usize, 0usize);
-    for (y, row) in t.bytes().chunks_exact(ts * bpp).enumerate() {
-        let Some(first) = row.chunks_exact(bpp).position(|px| px != dp) else { continue };
-        let last = ts - 1 - row.chunks_exact(bpp).rev().position(|px| px != dp).unwrap_or(0);
-        x0 = x0.min(first);
-        x1 = x1.max(last + 1);
-        y0 = y0.min(y);
-        y1 = y + 1;
-    }
-    (x0 != usize::MAX).then_some((x0 as u16, y0 as u16, x1 as u16, y1 as u16))
+const MIN_SWEEP: usize = 1 << 16;
+
+/// The size at which to sweep again after a sweep left `survivors` live entries: twice that (at
+/// least [`MIN_SWEEP`]), so a cache full of live tiles isn't swept again on every call.
+fn next_sweep(survivors: usize) -> usize {
+    survivors.saturating_mul(2).max(MIN_SWEEP)
+}
+
+fn cache() -> &'static Mutex<Cache> {
+    static C: std::sync::OnceLock<Mutex<Cache>> = std::sync::OnceLock::new();
+    C.get_or_init(|| Mutex::new(Cache { entries: HashMap::new(), sweep_at: MIN_SWEEP }))
 }
 
 /// `Surface::content_bounds`, cached per tile.
@@ -45,18 +43,19 @@ pub fn content_bounds(s: &Surface) -> Rect {
     let mut dp = vec![0u8; fmt.bytes_per_pixel()];
     photocraft_raster::encode_pixel(&fmt, &s.default_pixel(), &mut dp);
     let mut c = cache().lock().unwrap_or_else(|e| e.into_inner());
-    if c.len() > 1 << 16 {
-        c.retain(|_, e| e.tile.strong_count() > 0);
+    if c.entries.len() > c.sweep_at {
+        c.entries.retain(|_, e| e.tile.strong_count() > 0);
+        c.sweep_at = next_sweep(c.entries.len());
     }
     let mut out = Rect::EMPTY;
     for (coord, t) in s.tiles() {
         let key = Arc::as_ptr(t) as usize;
-        let hit = c.get(&key).filter(|e| e.tile.upgrade().is_some_and(|u| Arc::ptr_eq(&u, t)) && *e.default == *dp).map(|e| e.bounds);
+        let hit = c.entries.get(&key).filter(|e| e.tile.upgrade().is_some_and(|u| Arc::ptr_eq(&u, t)) && *e.default == *dp).map(|e| e.bounds);
         let b = match hit {
             Some(b) => b,
             None => {
-                let b = scan(t, &dp);
-                c.insert(key, Entry { tile: Arc::downgrade(t), default: dp.clone().into_boxed_slice(), bounds: b });
+                let b = t.content_bounds(&dp);
+                c.entries.insert(key, Entry { tile: Arc::downgrade(t), default: dp.clone().into_boxed_slice(), bounds: b });
                 b
             }
         };
@@ -68,3 +67,25 @@ pub fn content_bounds(s: &Surface) -> Rect {
     }
     out
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sweeps_again_only_past_twice_the_survivors() {
+        // A cache of live tiles past the minimum isn't swept on every call (it used to be).
+        assert_eq!(next_sweep(0), MIN_SWEEP);
+        assert_eq!(next_sweep(MIN_SWEEP / 2), MIN_SWEEP);
+        assert_eq!(next_sweep(MIN_SWEEP), 2 * MIN_SWEEP);
+        assert_eq!(next_sweep(usize::MAX), usize::MAX);
+    }
+
+    #[test]
+    fn a_shared_tile_reads_the_same_bounds_at_every_coordinate() {
+        let mut s = Surface::new(photocraft_color::PixelFormat::RGBA8);
+        s.fill_rect(Rect::new(-300, 10, 1300, 900), &[0.2, 0.4, 0.6, 1.0]);
+        assert_eq!(content_bounds(&s), Rect::new(-300, 10, 1300, 900));
+        assert_eq!(content_bounds(&s), s.content_bounds(), "cached");
+    }
+}
diff --git a/crates/compose/src/effects.rs b/crates/compose/src/effects.rs
index d77941847c..6966254547 100644
--- a/crates/compose/src/effects.rs
+++ b/crates/compose/src/effects.rs
@@ -4,8 +4,9 @@
 //! drop shadows, outer glows, outer bevel, then the layer itself (content at
 //! fill opacity) with pattern/gradient/colour overlays, satin, inner glows,
 //! inner shadows, strokes and the inner bevel on top. Exterior effects blend
-//! straight into the backdrop with their own modes; the layer and its
-//! interior effects blend with the layer's mode. Emboss and pillow emboss then
+//! straight into the backdrop with their own modes; the layer blends with its
+//! mode and the interior effects paint over the result, or blend with it as a
+//! group (Blend Interior Effects as Group, [`premerges_layer`]). Emboss and pillow emboss then
 //! shade the composited result (inside and outside halves). Layer opacity
 //! applies to the whole stack; fill opacity only to the layer's own pixels.
 //!
@@ -14,10 +15,10 @@
 //! of strokes blend onto the backdrop with their own modes, an upper stroke covering the
 //! lower ones. Drop shadows are knocked out only through see-through fill.
 //!
-//! Shapes come from the layer's alpha (after its mask). Strokes and spread / choke measure
-//! distances with a 5 × 5 chamfer metric seeded at sub-pixel edge offsets (as Photoshop does);
-//! precise glows and chiselled bevels use an exact Euclidean distance transform. Soft falloffs
-//! are two box blurs (a tent).
+//! Shapes come from the layer's alpha (after its mask). A stroke's outer edge, and precise glows /
+//! chiselled bevels, use an exact Euclidean transform: a 5 × 5 chamfer's level sets are polygons,
+//! which a wide stroke shows as flat facets (#3646). Inside stroke edges and spread / choke keep the
+//! cheaper chamfer. Soft falloffs are two box blurs (a tent).
 
 use photocraft_color::blend::BlendMode;
 use photocraft_doc::Pattern;
@@ -43,7 +44,7 @@ pub fn margin(layer: &Layer) -> i32 {
             Effect::DropShadow(s) | Effect::InnerShadow(s) => s.distance + s.size,
             Effect::OuterGlow(g) | Effect::InnerGlow(g) => g.size,
             Effect::Stroke(s) => s.size,
-            Effect::Satin(s) => s.distance + s.size,
+            Effect::Satin(s) => satin_distance(s) + s.size,
             Effect::BevelEmboss(b) => b.size + b.soften,
             _ => 0.0,
         };
@@ -94,6 +95,10 @@ impl Map {
     /// Shifted copy (bilinear), outside reads `outside`.
     fn shifted(&self, dx: f32, dy: f32, outside: f32) -> Map {
         let mut out = Map::new(self.w, self.h, 0.0);
+        // A hostile distance (±1e30, inf, NaN) would overflow the i64 offsets below; no shift beyond
+        // 2^30 px can land inside a map, so clamp (non-finite shifts read as none).
+        let reach = |d: f32| if d.is_finite() { d.clamp(-1.0e9, 1.0e9) } else { 0.0 };
+        let (dx, dy) = (reach(dx), reach(dy));
         let (fx, fy) = (dx.floor(), dy.floor());
         let (ax, ay) = (dx - fx, dy - fy);
         let s = |x: i64, y: i64| if x < 0 || y < 0 || x >= self.w as i64 || y >= self.h as i64 { outside } else { self.v[y as usize * self.w + x as usize] };
@@ -389,12 +394,30 @@ fn dist_outside(s: &Map) -> Vec<f32> {
 /// Distance metric for effect distance fields.
 #[derive(Clone, Copy, PartialEq)]
 enum Metric {
-    /// Exact Euclidean (precise glows, bevels).
+    /// Exact Euclidean (effect edges).
     Euclidean,
-    /// 5 × 5 chamfer (strokes, spread / choke; see [`chamfer_nearest`]).
+    /// 5 × 5 chamfer (inside strokes, spread / choke; see [`chamfer_nearest`]).
     Chamfer,
 }
 
+/// Outside width from which a stroke's outer edge uses the exact Euclidean transform instead of
+/// the fitted 5 × 5 chamfer.
+///
+/// The chamfer's level sets are octagons: measured against a point source, its distance exceeds
+/// the Euclidean radius by up to `0.027 · r` px — 0.48 px at r = 18 (the widest outside stroke any
+/// Photoshop oracle matches with the chamfer) and 1.6 px at r = 60, where a wide stroke's boundary
+/// visibly facets (#3646). Half a pixel of deviation is reached at r ≈ 19, so strokes narrower
+/// than 20 px keep the chamfer, whose sub-pixel edge seeding Photoshop matches at small offsets,
+/// and wider ones stay round.
+pub const STROKE_CHAMFER_MAX: f32 = 20.0;
+
+/// Whether a stroke whose outside edge is `out_w` px wide uses the exact Euclidean transform (round)
+/// rather than the 5 × 5 chamfer's octagon ([`STROKE_CHAMFER_MAX`]). The CPU compositor and the GPU
+/// compositor's `program_with` both call this, so a stroke picks the same field in each.
+pub fn stroke_outside_exact(out_w: f32) -> bool {
+    out_w >= STROKE_CHAMFER_MAX
+}
+
 fn dist_outside_by(s: &Map, m: Metric) -> Vec<f32> {
     if m == Metric::Chamfer {
         // Seeds start at their sub-pixel edge offset (1 − coverage).
@@ -882,6 +905,16 @@ fn contour_lut(c: &Contour) -> Option<Vec<f32>> {
     }
 }
 
+/// Satin's coverage transfer: the contour read from its far end, `|c(1 − v) − c(1)|`. Measured in
+/// Photoshop 27.11: Cone and Cone − Inverted Satins are identical, and a Gaussian Satin runs under
+/// the diagonal (0.36 at 0.5) while the same Gaussian on a glow or gloss runs over it (0.65).
+/// `None` = identity.
+pub fn satin_lut(c: &Contour) -> Option<Vec<f32>> {
+    let lut = contour_lut(c)?;
+    let end = lut.last().copied().unwrap_or(1.0);
+    Some(lut.iter().rev().map(|v| (v - end).abs()).collect())
+}
+
 /// Interpolated lookup in a 0..=1 table (as the GPU's `lut()`).
 fn lut_at(l: &[f32], v: f32) -> f32 {
     let x = v.clamp(0.0, 1.0) * (l.len() - 1) as f32;
@@ -1114,27 +1147,24 @@ fn shadow_map(shape: &Map, s: &Shadow, light: &GlobalLight, inner: bool, origin:
 }
 
 fn glow_map(shape: &Map, g: &Glow, inner: bool, origin: (i32, i32)) -> Map {
-    let src = if inner {
-        match g.source {
-            GlowSource::Edge => shape.clone().map(|a| 1.0 - a),
-            GlowSource::Center => shape.clone(),
-        }
-    } else {
-        shape.clone()
-    };
+    // An inner glow is built from the edge inwards; a centre-source glow is its inverse, taken
+    // after the contour and Range (Photoshop 27.11, measured: the centre glow is exactly
+    // 1 − the edge glow, for both techniques).
+    let src = if inner { shape.clone().map(|a| 1.0 - a) } else { shape.clone() };
     let mut m = match g.technique {
         GlowTechnique::Precise => {
-            // An inner glow, from either source, measures from the edge inwards; a centre glow is
-            // the inverse below (the distance outside is ≤ 0 everywhere inside, #966).
+            // Coverage falls linearly from 0.5 at the edge to 0 at `size + 1` px (centre to
+            // centre), solid within the spread / choke: after the default 50 % Range that is
+            // Photoshop's 1 − D / (size + 1) beyond the solid part (measured: outer and inner,
+            // sizes 10 and 20, spread 0 and 40 %, choke 0 and 30 %: within 1 level; other Range
+            // values are unmeasured). The distances here are 0.5 px short of centre to centre.
             let d = if inner { dist_inside(shape) } else { dist_outside(&src) };
             let solid = g.size * g.spread;
-            let soft = (g.size - solid).max(1e-3);
+            let soft = (g.size + 1.0 - solid).max(1e-3);
             let mut m = Map::new(shape.w, shape.h, 0.0);
             for (o, d) in m.v.iter_mut().zip(d) {
-                *o = if d <= solid { 1.0 } else { (1.0 - (d - solid) / soft).clamp(0.0, 1.0) };
-            }
-            if inner && g.source == GlowSource::Center {
-                m = m.map(|v| 1.0 - v);
+                let d = d + 0.5;
+                *o = if d <= solid { 1.0 } else { 0.5 * (1.0 - (d - solid) / soft).clamp(0.0, 1.0) };
             }
             m
         }
@@ -1142,16 +1172,13 @@ fn glow_map(shape: &Map, g: &Glow, inner: bool, origin: (i32, i32)) -> Map {
             let (r, bw) = spread_split(g.size, g.spread);
             let mut m = dilate(&src, r);
             blur(&mut m, bw);
-            if inner && g.source == GlowSource::Center {
-                // Brightest in the middle: coverage from the distance to the edge.
-                let mut e = dilate(&shape.clone().map(|a| 1.0 - a), r);
-                blur(&mut e, bw);
-                m = e.map(|v| 1.0 - v);
-            }
             m
         }
     };
     m = apply_lut(m, glow_lut(g));
+    if inner && g.source == GlowSource::Center {
+        m = m.map(|v| 1.0 - v);
+    }
     noise(&mut m, g.noise, origin.0, origin.1);
     if inner {
         for (v, a) in m.v.iter_mut().zip(&shape.v) {
@@ -1461,7 +1488,9 @@ pub fn bevel_geom(b: &Bevel) -> BevelGeom {
     BevelGeom {
         paint,
         width,
-        depth: b.depth * if smooth { width } else { size } * sign,
+        // A bevel rises `depth × width / 2` px: Smooth with a slope falling from `depth` at the
+        // edge (the tent), a chisel with the constant slope of its ramp (see `bevel_chisel_h`).
+        depth: b.depth * if smooth { width } else { size / 2.0 } * sign,
         pillow: b.style == BevelStyle::PillowEmboss,
         chisel_soft: if b.technique == BevelTechnique::ChiselSoft { (size / 4.0).max(1.0) } else { 0.0 },
     }
@@ -1482,10 +1511,13 @@ fn bevel_height(shape: &Map, b: &Bevel, g: &BevelGeom, tex: &TextureCtx, pattern
         let sharp = sharp_edges(shape);
         let (din, dout) = (bevel_dist_inside(shape, &sharp, size), bevel_dist_outside(shape, &sharp, size));
         let mut h = Map::new(shape.w, shape.h, 0.0);
+        let soft = g.chisel_soft > 0.0;
         for i in 0..h.v.len() {
-            h.v[i] = bevel_chisel_h(g.paint, size, din[i], dout[i]);
+            h.v[i] = bevel_chisel_h(g.paint, size, din[i], dout[i], soft);
         }
-        if g.chisel_soft > 0.0 {
+        // Inner and outer Chisel Soft are not blurred in Photoshop (their facets equal Chisel
+        // Hard's across a straight edge); emboss styles keep the blur until measured.
+        if soft && g.paint == BevelPaint::Both {
             tent(&mut h, g.chisel_soft);
         }
         h
@@ -1527,17 +1559,46 @@ pub struct TextureCtx<'a> {
 }
 
 /// Chiselled height from the inside / outside distances (keep in sync with `fs_mbevelh`).
-pub fn bevel_chisel_h(paint: BevelPaint, size: f32, din: f32, dout: f32) -> f32 {
+///
+/// Photoshop 27.11, measured across straight edges (sizes 10 and 20, depth 100 and 300): a chisel
+/// facet has the constant slope `depth × size / (2 (size + 1))`, i.e. one height step of
+/// `1 / (size + 1)` per pixel at the `depth × size / 2` scale of [`bevel_geom`]. Inner Hard's ramp
+/// runs from half a pixel beyond the edge to `size + ½` (the facet is flat right up to the edge
+/// pixel); Inner Soft starts a pixel further out, so its edge pixel is steeper; Outer Hard ends a
+/// pixel further out. All within 1 level of Photoshop on those profiles.
+pub fn bevel_chisel_h(paint: BevelPaint, size: f32, din: f32, dout: f32, soft: bool) -> f32 {
+    let ramp = size + 1.0;
     match paint {
-        BevelPaint::Outer => 1.0 - (dout / size).clamp(0.0, 1.0),
-        BevelPaint::Both => {
-            if din > 0.0 {
-                0.5 + 0.5 * (din / (size / 2.0)).clamp(0.0, 1.0)
+        BevelPaint::Outer if !soft => {
+            let top = (size + 2.0) / ramp;
+            if dout > 0.0 { ((size + 1.5 - dout) / ramp).clamp(0.0, top) } else { top }
+        }
+        // Outer Soft: Outer Hard's ramp a pixel shorter, with a steeper edge pixel.
+        BevelPaint::Outer => {
+            if dout > 0.0 {
+                1.0 - ((dout + 0.5) / ramp).clamp(0.0, 1.0)
             } else {
-                0.5 - 0.5 * (dout / (size / 2.0)).clamp(0.0, 1.0)
+                (size + 2.0) / ramp
+            }
+        }
+        BevelPaint::Both => {
+            let half = size / 2.0 + 0.5;
+            if din > 0.0 { 0.5 + 0.5 * (din / half).clamp(0.0, 1.0) } else { 0.5 - 0.5 * (dout / half).clamp(0.0, 1.0) }
+        }
+        BevelPaint::Inner if soft => {
+            if din > 0.0 {
+                ((din + 1.5) / ramp).clamp(0.0, (size + 2.0) / ramp)
+            } else {
+                0.0
+            }
+        }
+        BevelPaint::Inner => {
+            if din > 0.0 {
+                ((din + 0.5) / ramp).clamp(0.0, 1.0)
+            } else {
+                0.0
             }
         }
-        BevelPaint::Inner => (din / size).clamp(0.0, 1.0),
     }
 }
 
@@ -1555,7 +1616,9 @@ fn bevel_maps(shape: &Map, b: &Bevel, light: &GlobalLight, tex: &TextureCtx, pat
     // past the blur's reach (a raised 4-neighbour: it still slopes; psd-tools layer_effects'
     // emboss shadow runs one row past it), outer bevels don't (Photoshop oracle
     // bevel-outer-smooth).
-    let reach_past = g.paint == BevelPaint::Both;
+    // Outer chisel bevels too: the pixel where their ramp reaches zero still slopes (Photoshop
+    // 27.11 shades it, half strength, at `size + 1½` px out).
+    let reach_past = g.paint == BevelPaint::Both || (g.paint == BevelPaint::Outer && b.technique != BevelTechnique::Smooth);
     let on_bevel = |x: i64, y: i64| {
         hmap.get(x, y) > BEVEL_H_EPS || (reach_past && [(1, 0), (-1, 0), (0, 1), (0, -1)].iter().any(|(dx, dy)| hmap.get(x + dx, y + dy) > BEVEL_H_EPS))
     };
@@ -1612,9 +1675,14 @@ pub struct FxMaps {
     per: Vec<Vec<Map>>,
     bevel_paint: Vec<BevelPaint>,
     din: Option<Vec<f32>>,
+    /// Stroke outside distance below [`STROKE_CHAMFER_MAX`]: the fitted 5 × 5 chamfer.
     dout: Option<Vec<f32>>,
-    /// Shape layers: distance outside the vector outline (from local coverage).
+    /// Stroke outside distance at or above [`STROKE_CHAMFER_MAX`]: the exact Euclidean transform.
+    dout_exact: Option<Vec<f32>>,
+    /// Shape layers: chamfer distance outside the vector outline (from local coverage).
     vdout: Option<Vec<f32>>,
+    /// Shape layers: exact Euclidean distance outside the vector outline (from local coverage).
+    vdout_exact: Option<Vec<f32>>,
     /// `shape` joins the alpha with a filled shape's outline (`crate::effect_outline`).
     outline: bool,
     /// Frames of gradient strokes by outside width (bits): see [`stroke_frame`].
@@ -1633,7 +1701,14 @@ impl FxMaps {
     pub fn bytes(&self) -> usize {
         let n = self.shape.v.len();
         let maps: usize = self.per.iter().map(Vec::len).sum();
-        (1 + maps + usize::from(self.din.is_some()) + usize::from(self.dout.is_some()) + usize::from(self.vdout.is_some())) * n * 4
+        (1 + maps
+            + usize::from(self.din.is_some())
+            + usize::from(self.dout.is_some())
+            + usize::from(self.dout_exact.is_some())
+            + usize::from(self.vdout.is_some())
+            + usize::from(self.vdout_exact.is_some()))
+            * n
+            * 4
     }
 
     fn crop_vec(&self, v: &[f32], to: Rect, fill: f32) -> Vec<f32> {
@@ -1659,8 +1734,14 @@ impl FxMaps {
     }
 }
 
+/// The distance the two satin copies are offset by. Photoshop draws Distance 0 as 1 px (an
+/// edge band of 2/size, measured in Photoshop 27.11), not as two copies cancelling out.
+pub fn satin_distance(s: &photocraft_doc::effects::Satin) -> f32 {
+    s.distance.max(1.0)
+}
+
 fn satin_map(shape: &Map, s: &photocraft_doc::effects::Satin) -> Map {
-    let (dx, dy) = offset(s.angle, s.distance);
+    let (dx, dy) = offset(s.angle, satin_distance(s));
     let mut a = shape.shifted(dx, dy, 0.0);
     let mut b = shape.shifted(-dx, -dy, 0.0);
     // Two box passes of the satin size (fitted: 0.2 % mean error on psd-tools layer_effects).
@@ -1670,7 +1751,7 @@ fn satin_map(shape: &Map, s: &photocraft_doc::effects::Satin) -> Map {
     if s.invert {
         m = m.map(|v| 1.0 - v);
     }
-    let mut m = apply_contour(m, &s.contour);
+    let mut m = apply_lut(m, satin_lut(&s.contour));
     for (v, a) in m.v.iter_mut().zip(&shape.v) {
         *v *= a;
     }
@@ -1714,10 +1795,34 @@ pub(crate) fn build_maps_prepared(
         .collect();
     let has_stroke = items.iter().any(|e| matches!(e, Effect::Stroke(_)));
     let vector_shape = matches!(layer.content, photocraft_doc::LayerContent::Shape(_));
-    let (din, dout) = if has_stroke { (Some(dist_inside_by(&shape, Metric::Chamfer)), Some(dist_outside_by(&shape, Metric::Chamfer))) } else { (None, None) };
-    // Without an outline (unfilled shapes), estimate the vector outline from local coverage.
+    // A stroke's outer edge keeps the 5 × 5 chamfer while its outside width is under
+    // `STROKE_CHAMFER_MAX` — Photoshop matches the chamfer's sub-pixel edge seeding at small
+    // offsets — and uses the exact Euclidean transform at or above it, where the chamfer's octagon
+    // facets a wide stroke (#3646). Inside stroke distances always keep the chamfer. Each outer
+    // field is built only when a stroke of that width is present; the compositor picks per stroke,
+    // so one layer may hold both a narrow and a wide stroke.
+    let out_widths: Vec<f32> =
+        items.iter().filter_map(|e| if let Effect::Stroke(st) = e { Some(stroke_widths(st).1) } else { None }).filter(|w| *w > 0.0).collect();
+    let chamfer_out = out_widths.iter().any(|&w| !stroke_outside_exact(w));
+    let exact_out = out_widths.iter().any(|&w| stroke_outside_exact(w));
+    let (din, dout, dout_exact) = if has_stroke {
+        (
+            Some(dist_inside_by(&shape, Metric::Chamfer)),
+            chamfer_out.then(|| dist_outside_by(&shape, Metric::Chamfer)),
+            exact_out.then(|| dist_outside_by(&shape, Metric::Euclidean)),
+        )
+    } else {
+        (None, None, None)
+    };
+    // Without an outline (unfilled shapes), estimate the vector outline from local coverage; it
+    // picks the chamfer or the exact transform the same way.
     let outline = crate::effect_outline(layer).is_some();
-    let vdout = (has_stroke && vector_shape && !outline).then(|| dist_outside_by(&local_coverage(&shape), Metric::Chamfer));
+    let (vdout, vdout_exact) = if has_stroke && vector_shape && !outline {
+        let lc = local_coverage(&shape);
+        (chamfer_out.then(|| dist_outside_by(&lc, Metric::Chamfer)), exact_out.then(|| dist_outside_by(&lc, Metric::Euclidean)))
+    } else {
+        (None, None)
+    };
     let mut frames: Vec<(u32, Rect)> = Vec::new();
     for e in &items {
         if let Effect::Stroke(st) = e
@@ -1729,7 +1834,7 @@ pub(crate) fn build_maps_prepared(
             }
         }
     }
-    FxMaps { rect, shape, per, bevel_paint, din, dout, vdout, outline, frames }
+    FxMaps { rect, shape, per, bevel_paint, din, dout, dout_exact, vdout, vdout_exact, outline, frames }
 }
 
 /// Far outside any shape (distance fill for cropped distance fields).
@@ -1745,6 +1850,14 @@ fn knock_out_exterior(map: &mut Map, shape: &Map, fill_opacity: f32) {
     }
 }
 
+/// Blend Interior Effects as Group off (Photoshop's default): the layer's mode applies to its
+/// own pixels only, and the interior effects paint over the blended result. The layer is merged
+/// into the backdrop before they paint, so an Overlay colour overlay on a black Color-mode layer
+/// tints the grey beneath it (#3996). Normal-like modes give the same result either way.
+pub fn premerges_layer(layer: &Layer) -> bool {
+    !layer.advanced.blend_interior && !matches!(layer.blend, BlendMode::Normal | BlendMode::PassThrough | BlendMode::Dissolve)
+}
+
 /// Composites `content` (the layer's own pixels over `big`, alpha already
 /// masked, clipped layers applied) plus its effects into `backdrop`.
 pub fn composite_with_effects(layer: &Layer, content: &Buffer, backdrop: &mut Buffer, maps: &FxMaps, layer_bounds: Rect, patterns: &[Pattern]) {
@@ -1843,6 +1956,13 @@ pub(crate) fn composite_with_effects_prepared(
         }
     };
     let mut lay = Buffer { rect: big, px: content.px.iter().zip(&shape.v).enumerate().map(|(i, (p, a))| [p[0], p[1], p[2], lay_alpha(i, p, *a)]).collect() };
+    let gamma = crate::text_gamma(layer);
+    let premerge = premerges_layer(layer);
+    if premerge {
+        for (lp, wp) in lay.px.iter_mut().zip(&work.px) {
+            *lp = psblend::composite_gamma(layer.blend, *wp, *lp, 1.0, gamma);
+        }
+    }
     let rel = |m: Map| -> Map {
         let v = m.v.iter().zip(&shape.v).map(|(m, a)| if inside(*a) { (m / a).min(1.0) } else { 0.0 }).collect();
         Map { w: m.w, h: m.h, v }
@@ -1897,10 +2017,13 @@ pub(crate) fn composite_with_effects_prepared(
     // Strokes. Inside parts are painted over the layer (bottom instance first); outside parts
     // are slid beneath it, so the first listed (top) instance is processed first.
     let strokes: Vec<&photocraft_doc::StrokeFx> = items.iter().filter_map(|e| if let Effect::Stroke(s) = e { Some(s) } else { None }).collect();
-    let (din, dout) = match (&maps.din, &maps.dout) {
-        (Some(a), Some(b)) if !strokes.is_empty() => (maps.crop_vec(a, big, 0.0), maps.crop_vec(b, big, FAR)),
-        _ => (Vec::new(), Vec::new()),
-    };
+    let ready = !strokes.is_empty();
+    let din = if ready { maps.din.as_ref().map(|a| maps.crop_vec(a, big, 0.0)).unwrap_or_default() } else { Vec::new() };
+    // A stroke's outer edge picks the chamfer or the exact field by its width
+    // ([`stroke_outside_exact`]); both are cropped here, and only the ones a stroke needs exist.
+    let crop_out = |v: &Option<Vec<f32>>| v.as_ref().map(|b| maps.crop_vec(b, big, FAR));
+    let (dout, dout_exact, vdout, vdout_exact) =
+        if ready { (crop_out(&maps.dout), crop_out(&maps.dout_exact), crop_out(&maps.vdout), crop_out(&maps.vdout_exact)) } else { (None, None, None, None) };
     let widths = stroke_widths;
     // A gradient stroke aligned with the layer spans the stroke's own extent.
     let frame = |st: &photocraft_doc::StrokeFx| maps.stroke_frame(st).unwrap_or(sb);
@@ -1928,7 +2051,9 @@ pub(crate) fn composite_with_effects_prepared(
     for (p, a) in lay.px.iter_mut().zip(&shape.v) {
         p[3] *= a.min(1.0);
     }
-    let vdout = maps.vdout.as_ref().filter(|_| vector_shape && !strokes.is_empty()).map(|v| maps.crop_vec(v, big, FAR));
+    // Shape layers without a filled outline stroke their vector outline, estimated from local
+    // coverage; every other layer strokes its shape. The width then picks the field.
+    let vector_outline = vector_shape && !maps.outline;
     // Outside parts lie beneath the layer and blend onto the backdrop with their own mode. A
     // higher stroke covers the ones below it (Photoshop: a Multiply stroke listed above a wider
     // Normal stroke multiplies the backdrop, not the lower stroke). Each stroke's share is its
@@ -1946,7 +2071,14 @@ pub(crate) fn composite_with_effects_prepared(
             // Shape layers: Photoshop strokes the vector outline (estimated from local coverage
             // for unfilled shapes); the stroke never shows through the shape's pixels. Along a
             // filled shape's outline it covers the part of each edge pixel outside the path.
-            let d = vdout.as_ref().unwrap_or(&dout);
+            let exact = stroke_outside_exact(out_w);
+            let d: &[f32] = if vector_outline {
+                (if exact { vdout_exact.as_deref() } else { vdout.as_deref() }).unwrap_or_default()
+            } else if exact {
+                dout_exact.as_deref().unwrap_or_default()
+            } else {
+                dout.as_deref().unwrap_or_default()
+            };
             let mut share = vec![0.0f32; w * h];
             for (i, sh) in share.iter_mut().enumerate() {
                 let band = (out_w + 0.5 - d[i]).clamp(0.0, 1.0);
@@ -2005,8 +2137,7 @@ pub(crate) fn composite_with_effects_prepared(
     }
 
     // Layer (with interior effects) onto the exterior result, in the layer's mode.
-    let mode = if layer.blend == BlendMode::PassThrough { BlendMode::Normal } else { layer.blend };
-    let gamma = crate::text_gamma(layer);
+    let mode = if premerge || layer.blend == BlendMode::PassThrough { BlendMode::Normal } else { layer.blend };
     for (wp, lp) in work.px.iter_mut().zip(&lay.px) {
         if lp[3] > 0.0 {
             *wp = psblend::composite_gamma(mode, *wp, *lp, 1.0, gamma);
@@ -2111,15 +2242,23 @@ pub enum FieldKind {
     BevelOutside,
     /// `bevel_dist_inside` of the shape: the inside distance of chiselled bevels.
     BevelInside,
-    /// Chamfer distance outside the shape: outside strokes, and the spread of drop shadows and
-    /// softer outer glows ([`dilate`]).
+    /// Chamfer distance outside the shape: a narrow raster stroke's outer edge (see
+    /// [`stroke_outside_exact`]), and the spread of drop shadows and softer outer glows
+    /// ([`dilate`]); their metric is fitted to Photoshop (#224) and keeps the sub-pixel seeding.
     StrokeOutside,
     /// Chamfer distance outside `1 - alpha`: the choke of inner shadows and softer inner glows.
     ChokeInside,
     /// Stroke distance inside the shape.
     StrokeInside,
-    /// Stroke distance outside a shape layer's outline (from its local coverage).
+    /// Exact Euclidean distance outside the shape: a wide raster stroke's outer edge (see
+    /// [`stroke_outside_exact`]). The chamfer's level sets are polygons (an ~8-fold octagon), so a
+    /// wide stroke's outer boundary facets; the shadow / glow spread above keeps the chamfer (#3646).
+    StrokeOutsideExact,
+    /// Stroke distance outside a shape layer's outline (from its local coverage), exact Euclidean.
     StrokeOutsideVector,
+    /// Chamfer distance outside a shape layer's outline (from its local coverage): a narrow vector
+    /// stroke's outer edge, where the chamfer matches Photoshop (see [`STROKE_CHAMFER_MAX`]).
+    StrokeOutsideVectorChamfer,
 }
 
 /// The `kind` distance field of the shape `alpha` (row-major `w × h`). Values past `reach` pixels
@@ -2134,7 +2273,9 @@ pub fn distance_field(kind: FieldKind, alpha: Vec<f32>, w: usize, h: usize, reac
         FieldKind::StrokeOutside => dist_outside_by(&s, Metric::Chamfer),
         FieldKind::ChokeInside => dist_outside_by(&s.map(|a| 1.0 - a), Metric::Chamfer),
         FieldKind::StrokeInside => dist_inside_by(&s, Metric::Chamfer),
-        FieldKind::StrokeOutsideVector => dist_outside_by(&local_coverage(&s), Metric::Chamfer),
+        FieldKind::StrokeOutsideExact => dist_outside_by(&s, Metric::Euclidean),
+        FieldKind::StrokeOutsideVector => dist_outside_by(&local_coverage(&s), Metric::Euclidean),
+        FieldKind::StrokeOutsideVectorChamfer => dist_outside_by(&local_coverage(&s), Metric::Chamfer),
     }
 }
 
@@ -2340,6 +2481,40 @@ mod tests {
         assert!(at(&maps[0], 20, 15) < 0.05);
     }
 
+    /// Photoshop 27.11, measured across a straight edge (size 10, depth 100 %, light from the top
+    /// at 30°): a chisel facet has the slope `depth × size / (2 (size + 1))`, flat right up to the
+    /// edge pixel for Inner Hard; Inner Soft's edge pixel is half as steep again; Outer Hard
+    /// still shades, partly, the pixel where its ramp reaches zero `size + 1½` px out.
+    #[test]
+    fn chisel_facets_match_photoshop() {
+        let amount = |g: f32| {
+            let (se, ce) = 30f32.to_radians().sin_cos();
+            ((g * ce + se) / (1.0 + g * g).sqrt() - se) / (1.0 - se)
+        };
+        let n = 80;
+        let shape = square(n, 20, 60);
+        let maps = |style, technique| {
+            let mut b = bevel_of(style, technique);
+            b.size = 10.0;
+            bevel_maps(&shape, &b, &GlobalLight::default(), &no_tex(), &PreparedPatterns::new(&[], PREPARED_PATTERN_BYTES)).0
+        };
+        let at = |m: &Map, y: usize| m.v[y * n + 40];
+        let facet = amount(10.0 / 22.0);
+        let hard = maps(BevelStyle::InnerBevel, BevelTechnique::ChiselHard);
+        for y in 20..30 {
+            assert!((at(&hard[0], y) - facet).abs() < 0.01, "inner hard facet at row {y}: {} vs {facet}", at(&hard[0], y));
+        }
+        assert!(at(&hard[0], 30) > 0.05 && at(&hard[0], 30) < facet, "one partial pixel at the end");
+        let soft = maps(BevelStyle::InnerBevel, BevelTechnique::ChiselSoft);
+        assert!((at(&soft[0], 20) - amount(1.5 * 10.0 / 22.0)).abs() < 0.01, "steeper edge pixel: {}", at(&soft[0], 20));
+        assert!((at(&soft[0], 24) - facet).abs() < 0.01, "then Chisel Hard's facet");
+        let outer = maps(BevelStyle::OuterBevel, BevelTechnique::ChiselHard);
+        // Below the shape (rows 60..): shadow facet through 10½ px, partial at 11½.
+        assert!((at(&outer[1], 70) - at(&outer[1], 61)).abs() < 1e-4);
+        assert!(at(&outer[1], 71) > 0.05 && at(&outer[1], 71) < at(&outer[1], 70));
+        assert_eq!(at(&outer[1], 72), 0.0);
+    }
+
     #[test]
     fn emboss_paints_both_sides_and_pillow_flips_the_outside() {
         let shape = square(40, 10, 30);
@@ -2883,6 +3058,51 @@ mod tests {
         assert!(glow_lut(&g).is_none());
     }
 
+    /// Photoshop 27.11, measured on a 128 px square (Normal, black, 100 %, Range 50 %): a precise
+    /// glow's coverage across the edge, and a centre-source inner glow as 1 − the edge glow.
+    #[test]
+    fn glows_match_photoshop() {
+        let glow = |technique, size: f32, spread: f32, source| Glow {
+            common: photocraft_doc::FxCommon::new(BlendMode::Normal, 1.0),
+            paint: FxPaint::Color(photocraft_color::Color::BLACK),
+            technique,
+            spread,
+            size,
+            contour: Contour::Linear,
+            anti_alias: false,
+            range: 0.5,
+            jitter: 0.0,
+            noise: 0.0,
+            source,
+        };
+        let n = 60;
+        let mut shape = Map::new(n, n, 0.0);
+        for y in 20..40 {
+            for x in 20..40 {
+                shape.v[y * n + x] = 1.0;
+            }
+        }
+        let at = |m: &Map, x: usize| m.v[30 * n + x];
+        // Outer, precise, size 10: Photoshop's black glow over white reads 47, 93, 140, 186, 232
+        // at 2, 4, 6, 8 and 10 px out from the edge pixel (alpha 1 − D / 11).
+        let m = glow_map(&shape, &glow(GlowTechnique::Precise, 10.0, 0.0, GlowSource::Edge), false, (0, 0));
+        for (d, ps) in [(2, 47.0f32), (4, 93.0), (6, 140.0), (8, 186.0), (10, 232.0)] {
+            let got = 255.0 * (1.0 - at(&m, 20 - d));
+            assert!((got - ps).abs() <= 1.5, "outer precise at {d} px: {got} vs Photoshop {ps}");
+        }
+        // Spread 40 %: solid for the first 4 px.
+        let m = glow_map(&shape, &glow(GlowTechnique::Precise, 10.0, 0.4, GlowSource::Edge), false, (0, 0));
+        assert!((at(&m, 16) - 1.0).abs() < 1e-6 && at(&m, 14) < 1.0);
+        // Centre source = 1 − edge, for both techniques.
+        for t in [GlowTechnique::Precise, GlowTechnique::Softer] {
+            let e = glow_map(&shape, &glow(t, 6.0, 0.0, GlowSource::Edge), true, (0, 0));
+            let c = glow_map(&shape, &glow(t, 6.0, 0.0, GlowSource::Center), true, (0, 0));
+            for x in 20..40 {
+                assert!((at(&c, x) - (1.0 - at(&e, x))).abs() < 1e-5, "{t:?} at {x}");
+            }
+        }
+    }
+
     #[test]
     fn offsets_follow_light() {
         let (dx, dy) = offset(120.0, 10.0);
@@ -2899,6 +3119,28 @@ mod tests {
         m
     }
 
+    #[test]
+    fn satin_at_distance_zero_matches_photoshop() {
+        // Photoshop 27.11, Satin black 100 %, angle 90°, Linear contour, distance 0, size 5 over a
+        // #808080 square: the rows from the top edge read 82, 102, 123, 128.
+        let s = photocraft_doc::effects::Satin {
+            common: photocraft_doc::FxCommon::new(BlendMode::Normal, 1.0),
+            color: photocraft_color::Color::BLACK,
+            angle: 90.0,
+            distance: 0.0,
+            size: 5.0,
+            contour: Contour::Linear,
+            anti_alias: false,
+            invert: false,
+        };
+        let m = satin_map(&square_shape(60), &s);
+        for (row, gray) in [(5, 82.0), (7, 102.0), (9, 123.0), (11, 128.0), (30, 128.0)] {
+            let want = 1.0 - gray / 128.0;
+            let got = m.v[row * 60 + 30];
+            assert!((got - want).abs() < 0.02, "row {row}: {got} vs {want}");
+        }
+    }
+
     fn shadow(noise: f32, origin: (i32, i32)) -> Map {
         let s = Shadow {
             common: photocraft_doc::FxCommon::new(BlendMode::Multiply, 1.0),
@@ -2960,4 +3202,13 @@ mod tests {
         let diff: f32 = plain.v.iter().zip(&noisy.v).map(|(a, b)| (a - b).abs()).sum();
         assert!(diff > 5.0, "glow noise changes the coverage: {diff}");
     }
+
+    #[test]
+    fn shifting_by_hostile_distances_does_not_overflow() {
+        let m = square_shape(12);
+        for d in [1.0e30, -1.0e30, f32::INFINITY, f32::NAN] {
+            let s = m.shifted(d, d, 0.0);
+            assert_eq!(s.v.len(), 144);
+        }
+    }
 }
diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rs
index 37c6167e99..8813b122d9 100644
--- a/crates/compose/src/lib.rs
+++ b/crates/compose/src/lib.rs
@@ -24,6 +24,7 @@ pub mod fill_layout;
 pub mod gradient_fill;
 pub mod masks;
 pub mod multichannel;
+pub mod native;
 pub mod pattern;
 pub mod proxy;
 pub mod psblend;
@@ -57,11 +58,23 @@ impl Buffer {
     }
     pub fn to_rgba8(&self) -> Rgba8Image {
         let mut img = Rgba8Image::new(self.rect.width(), self.rect.height());
-        for (o, p) in img.pixels.as_chunks_mut::<4>().0.iter_mut().zip(&self.px) {
-            for (dst, v) in o.iter_mut().zip(p) {
-                *dst = (v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
+        let quantize = |out: &mut [[u8; 4]], src: &[[f32; 4]]| {
+            for (o, p) in out.iter_mut().zip(src) {
+                for (dst, v) in o.iter_mut().zip(p) {
+                    *dst = (v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
+                }
             }
+        };
+        let out = img.pixels.as_chunks_mut::<4>().0;
+        // In parallel off wasm: a 24 MP composite took 120 ms on one core (the CPU canvas,
+        // previews, thumbnails and 8-bit exports all come through here).
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            use rayon::prelude::*;
+            out.par_chunks_mut(16 * 1024).zip(self.px.par_chunks(16 * 1024)).for_each(|(o, p)| quantize(o, p));
         }
+        #[cfg(target_arch = "wasm32")]
+        quantize(out, &self.px);
         img
     }
     /// Flatten over an opaque background colour.
@@ -87,6 +100,11 @@ pub fn render(doc: &Document, rect: Rect) -> Buffer {
     render_tiled(doc, rect, RENDER_TILE)
 }
 
+/// Most pixels one [`render`] call will produce (2^30, a 16 GiB buffer; 32768² px). Larger rects
+/// (a hostile canvas size is up to 300000 px a side) return an empty buffer instead of aborting
+/// on allocation; callers wanting more render in pieces.
+pub const MAX_RENDER_PIXELS: u64 = 1 << 30;
+
 /// [`render`] with an explicit tile size (tests check tile independence).
 pub fn render_tiled(doc: &Document, rect: Rect, tile: i32) -> Buffer {
     let patterns = pattern::PreparedPatterns::new(&doc.patterns, pattern::PREPARED_PATTERN_BYTES).in_mode(doc.pixel_format().mode);
@@ -106,8 +124,12 @@ fn render_tiled_with(doc: &Document, rect: Rect, tile: i32, cx: &Ctx) -> Buffer
     if rect.is_empty() {
         return Buffer::transparent(rect);
     }
+    // Refuse rects too large to hold: an empty buffer, not an allocation failure.
+    if u64::from(rect.width()) * u64::from(rect.height()) > MAX_RENDER_PIXELS {
+        return Buffer::transparent(Rect::EMPTY);
+    }
     cx.set_fx_clip(rect);
-    if rect.width() as i32 <= tile && rect.height() as i32 <= tile {
+    if i64::from(rect.width()) <= i64::from(tile) && i64::from(rect.height()) <= i64::from(tile) {
         return photocraft_color::convert::with_cmyk_space(cmyk, || {
             let mut buf = multichannel::backdrop(doc, rect);
             in_blend_space(lab, hdr, || composite_stack_at(&doc.layers, &mut buf, cx, advanced::Scope::ROOT));
@@ -232,20 +254,48 @@ pub fn band_rows_for(width: u32, requested: i32) -> i32 {
 /// The document's composite as a pixel surface in `fmt` (straight RGBA converted to its model
 /// and depth), optionally flattened over an opaque `background`; rendered and written in bands,
 /// so no full-size float composite is held. Tiles equal to the default pixel are pruned.
+///
+/// Fully transparent pixels are written as the default pixel. Converting transparent black
+/// leaves colour behind in CMYK (K = 100%) and Lab (neutral a/b = 0.5), and those pixels would
+/// otherwise count as content: the result would span the whole canvas.
+///
+/// A CMYK document of plain Normal layers is composited in its ink values instead
+/// ([`native::flatten_cmyk`]), so flattening doesn't round-trip its pixels through RGB (#3778).
 pub fn flatten_to_surface(doc: &Document, fmt: photocraft_color::PixelFormat, background: Option<[f32; 3]>) -> Surface {
+    composite_to_surface(doc, doc.bounds(), fmt, background)
+}
+
+/// [`flatten_to_surface`] over `rect` only (the rest of the surface stays empty).
+pub fn composite_to_surface(doc: &Document, rect: Rect, fmt: photocraft_color::PixelFormat, background: Option<[f32; 3]>) -> Surface {
+    let paper = background.is_some_and(|bg| bg == [1.0; 3]);
+    if (background.is_none() || paper)
+        && let Some(s) = native::flatten_cmyk(doc, rect, fmt, paper)
+    {
+        return s;
+    }
     let mut s = Surface::new(fmt);
     let n = fmt.channels();
+    let empty = s.default_pixel();
     let mut data = Vec::new();
-    let _ = render_bands(doc, doc.bounds(), 0, |band| -> Result<(), ()> {
+    // The composite separates back to CMYK through the document's own profile, the one its
+    // pixels were read through.
+    let cmyk = cmyk_space(doc);
+    let _ = render_bands(doc, rect, 0, |band| -> Result<(), ()> {
         let band = match background {
             Some(bg) => band.over_background(bg),
             None => band,
         };
         data.clear();
         data.resize(band.px.len() * n, 0.0);
-        for (p, out) in band.px.iter().zip(data.chunks_exact_mut(n)) {
-            photocraft_raster::from_rgba_into(&fmt, *p, out);
-        }
+        photocraft_color::convert::with_cmyk_space(cmyk.as_ref(), || {
+            for (p, out) in band.px.iter().zip(data.chunks_exact_mut(n)) {
+                if fmt.alpha && (p[3] <= 0.0 || p[3].is_nan()) && empty.len() == n {
+                    out.copy_from_slice(&empty);
+                } else {
+                    photocraft_raster::from_rgba_into(&fmt, *p, out);
+                }
+            }
+        });
         s.write_region(band.rect, &data);
         Ok(())
     });
@@ -294,13 +344,19 @@ pub fn thumbnail(doc: &Document, max_side: u32) -> Rgba8Image {
     thumbnail_buffer(doc, max_side).to_rgba8()
 }
 
+/// Width and height of [`thumbnail`]`(doc, max_side)`.
+pub fn thumbnail_size(doc: &Document, max_side: u32) -> (u32, u32) {
+    let b = doc.bounds();
+    let longest = b.width().max(b.height()).max(1);
+    let scale = (max_side as f32 / longest as f32).min(1.0);
+    (((b.width() as f32 * scale).round() as u32).max(1), ((b.height() as f32 * scale).round() as u32).max(1))
+}
+
 /// [`thumbnail`] as straight-alpha floats (for callers that colour-convert it first).
 pub fn thumbnail_buffer(doc: &Document, max_side: u32) -> Buffer {
     let b = doc.bounds();
     let longest = b.width().max(b.height()).max(1);
-    let scale = (max_side as f32 / longest as f32).min(1.0);
-    let w = ((b.width() as f32 * scale).round() as u32).max(1);
-    let h = ((b.height() as f32 * scale).round() as u32).max(1);
+    let (w, h) = thumbnail_size(doc, max_side);
     let k = longest / max_side.max(1).saturating_mul(2);
     if k >= 2 && doc.size.area() > PROXY_THUMBNAIL_PIXELS && proxy::proxy_faithful(doc) {
         render_reduced(&proxy::proxy_document(doc, k), w, h)
@@ -416,18 +472,27 @@ fn render_reduced_in_bands(doc: &Document, b: Rect, w: u32, h: u32, damage: Opti
     Buffer { rect: out, px: acc }
 }
 
+type VectorMaskSlot = std::sync::Arc<std::sync::OnceLock<photocraft_vector::CompiledVectorMask>>;
+
 #[derive(Default)]
 struct RenderVectorMasks {
-    masks: std::sync::Mutex<std::collections::HashMap<usize, std::sync::Arc<std::sync::OnceLock<photocraft_vector::CompiledVectorMask>>>>,
+    /// Compiled masks by content. Callers pass temporary clones (see `advanced.rs`), so an
+    /// address cannot identify a mask: a dropped clone's address is reused by the next one.
+    masks: std::sync::Mutex<Vec<(photocraft_doc::VectorMask, VectorMaskSlot)>>,
 }
 
 impl RenderVectorMasks {
     fn values(&self, mask: &photocraft_doc::VectorMask, rect: Rect) -> Vec<f32> {
-        // Addresses identify immutable mask instances only for this render's lifetime.
-        let key = std::ptr::from_ref(mask) as usize;
         let slot = {
             let mut masks = self.masks.lock().unwrap_or_else(|e| e.into_inner());
-            masks.entry(key).or_default().clone()
+            match masks.iter().find(|(m, _)| m == mask) {
+                Some((_, slot)) => slot.clone(),
+                None => {
+                    let slot = VectorMaskSlot::default();
+                    masks.push((mask.clone(), slot.clone()));
+                    slot
+                }
+            }
         };
         // Compilation is sequential. Rendering can enter Rayon and must happen after
         // initialization, so waiting tiles cannot re-enter a slot still being built.
@@ -618,6 +683,19 @@ pub fn layer_bounds(layer: &Layer, canvas: Rect) -> Rect {
         LayerContent::Fill(_) => canvas,
         _ => {
             let b = layer.surface().map_or(Rect::EMPTY, bounds::content_bounds);
+            let b = match &layer.content {
+                LayerContent::Shape(sh) => {
+                    let p = shape_bounds(sh).map(|r| r.intersect(&canvas)).unwrap_or(Rect::EMPTY);
+                    if !b.is_empty() && !p.is_empty() {
+                        b.union(&p)
+                    } else if !p.is_empty() {
+                        p
+                    } else {
+                        b
+                    }
+                }
+                _ => b,
+            };
             // Effects follow a filled shape's outline, also where its fill is transparent.
             match effect_outline(layer).and_then(|_| paint_bounds(layer)).filter(|_| effects::has_effects(layer)) {
                 Some(p) if !b.is_empty() => b.union(&p),
@@ -715,6 +793,17 @@ pub fn paint_bounds(layer: &Layer) -> Option<Rect> {
     (!r.is_empty()).then_some(r)
 }
 
+/// The bounding box of a shape layer's vector content: its path control bounds plus stroke width.
+pub fn shape_bounds(sh: &photocraft_doc::ShapeLayer) -> Option<Rect> {
+    if sh.fill.is_none() && sh.stroke.as_ref().is_none_or(|s| s.width <= 0.0 || s.opacity <= 0.0) {
+        return None;
+    }
+    let (x0, y0, x1, y1) = sh.path.control_bounds()?;
+    let stroke_margin = sh.stroke.as_ref().filter(|s| s.opacity > 0.0).map_or(0.0, |s| s.width.ceil()) as i32;
+    let r = Rect::new(x0.floor() as i32, y0.floor() as i32, x1.ceil() as i32, y1.ceil() as i32).inflate(stroke_margin);
+    (!r.is_empty()).then_some(r)
+}
+
 /// The layer's effective mask over `rect` (row-major), read once per tile: the pixel mask
 /// times the rasterized vector mask.
 fn mask_vals(layer: &Layer, rect: Rect, cx: &Ctx) -> Option<Vec<f32>> {
@@ -1068,7 +1157,7 @@ fn blend_if_weight(layer: &Layer, mode: photocraft_color::ColorMode, this: Optio
     let mut k = 1.0;
     for (side, px) in [this, under].into_iter().enumerate() {
         let Some(p) = px else { continue };
-        let v = |c: usize| p[c].clamp(0.0, 1.0) * 255.0;
+        let v = |c: usize| blend_if_level(p[c]);
         match mode {
             // Gray is the colour channels' luma (Rec. 601 weights), then R, G, B.
             M::Rgb => {
@@ -1089,6 +1178,17 @@ fn blend_if_weight(layer: &Layer, mode: photocraft_color::ColorMode, this: Optio
     k
 }
 
+/// A channel value on Blend If's 0..=255 scale. Compositing can leave an 8- or 16-bit level a few
+/// millionths off (a level-20 backdrop composited at partial alpha reads 19.999998), which would
+/// put it on the wrong side of a hard point at that level: a value that close to a level is that
+/// level. Values of those depths that aren't on a level are at least 1/257 away from one. The GPU
+/// compositor (`compose.wgsl` `blend_if_weight`) snaps alike.
+fn blend_if_level(x: f32) -> f32 {
+    let v = x.clamp(0.0, 1.0) * 255.0;
+    let r = v.round();
+    if (v - r).abs() < 1e-4 { r } else { v }
+}
+
 /// Apply `layer`'s Blend If to a finished composite: `out` (the backdrop with the layer drawn)
 /// is mixed back towards `before` (the backdrop without it) where the ranges hide the layer.
 /// Mixing premultiplied colour by `k` equals compositing the layer at `k` × its alpha, since
@@ -1248,7 +1348,7 @@ fn composite_layer_plain(layer: &Layer, clipped: &[Layer], backdrop: &mut Buffer
     // Adjustment layers transform the backdrop, then blend the result back in.
     if let LayerContent::Adjustment(adj) = &layer.content {
         let mut adjusted = backdrop.clone();
-        adjust::apply_depth(adj, &mut adjusted, cx.transfer, Some(cx.depth));
+        adjust::apply_in(adj, &mut adjusted, cx.transfer, Some(cx.depth), cx.mode);
         // Clipped layers onto an adjustment are uncommon; they composite atop the adjusted result.
         advanced::composite_clipped(clipped, &mut adjusted, cx);
         let mv = mask_vals(layer, rect, cx);
@@ -1352,7 +1452,8 @@ fn split_parts(layer: &Layer, rect: Rect, cx: &Ctx) -> Option<(Buffer, Buffer, O
 // ---------------------------------------------------------------------------------------------
 // Layer-effect map cache
 
-/// Order-independent identity of a layer's pixels, masks, effects and (for groups) children.
+/// Order-independent identity of a layer's pixels, masks, effects, Advanced Blending and Blend If
+/// and (for groups) children.
 /// Pixels are identified by their copy-on-write tile pointers; cache entries pin a clone of the
 /// layer so those tiles (and their addresses) stay alive while the entry exists.
 fn layer_identity(layer: &Layer, h: &mut std::collections::hash_map::DefaultHasher) {
@@ -1410,6 +1511,10 @@ fn layer_identity(layer: &Layer, h: &mut std::collections::hash_map::DefaultHash
         format!("{vm:?}").hash(h);
     }
     format!("{:?}", layer.effects).hash(h);
+    // Transparency Shapes Layer picks the shape (content or the whole layer); a group child's
+    // Blend If and knockout change the composite a styled group's shape comes from.
+    layer.advanced.hash(h);
+    layer.blend_if.hash(h);
     h.write_u8(0xfe);
 }
 
@@ -1492,7 +1597,8 @@ fn effect_region(layer: &Layer, rect: Rect, cx: &Ctx) -> (Rect, bool) {
 fn effect_maps(layer: &Layer, rect: Rect, cx: &Ctx) -> std::sync::Arc<effects::FxMaps> {
     use std::hash::{Hash, Hasher};
     let (region, clipped) = effect_region(layer, rect, cx);
-    if std::env::var_os("PHOTOCRAFT_FX_NOCACHE").is_some() {
+    static NO_CACHE: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    if *NO_CACHE.get_or_init(|| std::env::var_os("PHOTOCRAFT_FX_NOCACHE").is_some()) {
         let shape = if region.is_empty() { Vec::new() } else { effect_shape(layer, region, cx) };
         return std::sync::Arc::new(effects::build_maps_prepared(layer, shape, region, &cx.light, &texture_ctx(layer, region, cx), cx.patterns));
     }
@@ -1589,7 +1695,7 @@ fn composite_atop_any(layer: &Layer, base: &mut Buffer, cx: &Ctx) {
     let rect = base.rect;
     if let LayerContent::Adjustment(adj) = &layer.content {
         let mut adjusted = base.clone();
-        adjust::apply_depth(adj, &mut adjusted, cx.transfer, Some(cx.depth));
+        adjust::apply_in(adj, &mut adjusted, cx.transfer, Some(cx.depth), cx.mode);
         let mv = mask_vals(layer, rect, cx);
         for (i, p) in base.px.iter_mut().enumerate() {
             let k = layer.opacity * layer.fill_opacity * mask_k(&mv, i);
@@ -1674,6 +1780,18 @@ fn blend_into_fill(backdrop: &mut Buffer, src: &Buffer, mode: BlendMode, opacity
 
 /// [`blend_into`] mixing coverage in a `gamma` space (type layers).
 fn blend_into_g(backdrop: &mut Buffer, src: &Buffer, mode: BlendMode, opacity: f32, gamma: f32) {
+    // The blend space is constant in this loop. Some TLS implementations synchronise even a
+    // boolean read, so select the common Normal kernel once instead of once per pixel.
+    if mode == BlendMode::Normal && gamma == 1.0 && !psblend::LAB_MIX.with(|l| l.get()) {
+        for (i, b) in backdrop.px.iter_mut().enumerate() {
+            let s = src.px[i];
+            if s[3] <= 0.0 {
+                continue;
+            }
+            *b = psblend::composite_normal_rgb(*b, s, opacity);
+        }
+        return;
+    }
     let rect = backdrop.rect;
     let w = rect.width() as i32;
     for (i, b) in backdrop.px.iter_mut().enumerate() {
diff --git a/crates/compose/src/masks.rs b/crates/compose/src/masks.rs
index c14f73e083..d70947ec7c 100644
--- a/crates/compose/src/masks.rs
+++ b/crates/compose/src/masks.rs
@@ -344,7 +344,15 @@ fn build_mask(layer: &Layer, canvas: Rect) -> Surface {
     // mask's painted tiles when the vector mask lets them through outside the path, each grown
     // by its feather.
     let mut area = match vm.and_then(|vm| vm.path.control_bounds()) {
-        Some((x0, y0, x1, y1)) => grow(Rect::new(x0.floor() as i32 - 2, y0.floor() as i32 - 2, x1.ceil() as i32 + 2, y1.ceil() as i32 + 2), sv),
+        Some((x0, y0, x1, y1)) => grow(
+            Rect::new(
+                (x0.floor() as i32).saturating_sub(2),
+                (y0.floor() as i32).saturating_sub(2),
+                (x1.ceil() as i32).saturating_add(2),
+                (y1.ceil() as i32).saturating_add(2),
+            ),
+            sv,
+        ),
         None => Rect::EMPTY,
     };
     if let Some(m) = pixel
@@ -761,4 +769,14 @@ mod tests {
         l.vector_mask = None;
         assert!(combined_mask(&l, canvas).is_none());
     }
+
+    #[test]
+    fn hostile_path_coordinates_do_not_overflow() {
+        let mut l = Layer::raster("l", PixelFormat::RGBA8);
+        let knots = [(-1.0e30, -1.0e30), (1.0e30, 0.0), (0.0, 1.0e30)].iter().map(|&(x, y)| Knot::corner(x, y)).collect();
+        let mut path = Path::default();
+        path.subpaths.push(Subpath { knots, closed: true, ..Default::default() });
+        l.vector_mask = Some(VectorMask::new(path));
+        let _ = combined_mask(&l, Rect::new(0, 0, 8, 8));
+    }
 }
diff --git a/crates/compose/src/multichannel.rs b/crates/compose/src/multichannel.rs
index 63bec04bf6..88c0b2f359 100644
--- a/crates/compose/src/multichannel.rs
+++ b/crates/compose/src/multichannel.rs
@@ -3,7 +3,8 @@
 //! Ink density `v` (the channel value, 1 = solid) of an ink with display colour `c` and solidity
 //! `s` turns the colour underneath `p` into `(1 − s·v)·p·(1 − v + v·c) + s·v·c`: transparent inks
 //! (solidity 0) multiply like overprinted process inks, opaque ones cover what is below, which is
-//! how Photoshop previews spot channels.
+//! how Photoshop previews spot channels. An alpha-type channel of a Multichannel document
+//! (selected / masked areas) still prints, as a transparent black ink, like Photoshop shows it.
 
 use photocraft_doc::Document;
 use photocraft_geom::Rect;
@@ -15,7 +16,7 @@ pub fn inks(doc: &Document, rect: Rect) -> Buffer {
     let mut buf = Buffer::filled(rect, [1.0, 1.0, 1.0, 1.0]);
     let mut vals = Vec::new();
     for ch in &doc.channels {
-        let Some((ink, solidity)) = ch.spot else { continue };
+        let (ink, solidity) = ch.spot.unwrap_or((photocraft_color::Color::BLACK, 0.0));
         if ch.surface.content_bounds().intersect(&rect).is_empty() {
             continue;
         }
@@ -65,7 +66,15 @@ mod tests {
         assert_eq!(r.px[1], [0.0, 1.0, 1.0, 1.0]);
         assert_eq!(r.px[2], [0.0, 0.0, 1.0, 1.0]);
         assert_eq!(r.px[3], [1.0, 0.0, 1.0, 1.0]);
-        // Alpha channels and other modes are not inks.
+        // An alpha-type channel prints as a black ink.
+        let mut k = Surface::new(fmt);
+        k.write_region(Rect::new(0, 0, 4, 1), &[0.5, 0.0, 0.0, 0.0]);
+        doc.channels.push(AlphaChannel::new("Alpha", k));
+        let r = crate::flatten(&doc);
+        // 0.5 is stored as 128/255 in an 8-bit channel: within one 8-bit step.
+        assert!((r.px[0][0] - 0.5).abs() <= 1.0 / 255.0 && (r.px[0][1] - 0.5).abs() <= 1.0 / 255.0, "{:?}", r.px[0]);
+        assert_eq!(r.px[1], [0.0, 1.0, 1.0, 1.0]);
+        // Other modes have no inks.
         doc.mode = ColorMode::Rgb;
         assert_eq!(crate::flatten(&doc).px[1][3], 0.0);
     }
diff --git a/crates/compose/src/native.rs b/crates/compose/src/native.rs
new file mode 100644
index 0000000000..9eafd18cc6
--- /dev/null
+++ b/crates/compose/src/native.rs
@@ -0,0 +1,101 @@
+//! Mode-native flattening of plain CMYK layer stacks (#3778).
+//!
+//! The compositor works in display RGB, so flattening a CMYK document through it reads every ink
+//! value through the profile and separates it again: even a lone Background comes back with
+//! different ink. When every visible layer is a plain raster layer in Normal mode (no masks,
+//! effects, clipping or advanced blending), the composite needs no colour conversion at all:
+//! Normal mixes ink values linearly, as Photoshop does in CMYK, so it is worked out on the stored
+//! values and an opaque layer keeps them exactly.
+
+use photocraft_color::blend::BlendMode;
+use photocraft_color::{ColorMode, PixelFormat};
+use photocraft_doc::{Document, Layer, LayerContent};
+use photocraft_geom::Rect;
+use photocraft_raster::Surface;
+
+/// Process channels of a CMYK pixel.
+const INKS: usize = 4;
+
+/// A layer the native path can composite: a visible raster layer the compositor would only blend
+/// Normally at its opacity.
+fn plain(layer: &Layer) -> Option<&Surface> {
+    let LayerContent::Raster(s) = &layer.content else { return None };
+    let simple = layer.blend == BlendMode::Normal
+        && !layer.clipped
+        && layer.mask.as_ref().is_none_or(|m| !m.enabled)
+        && layer.vector_mask.as_ref().is_none_or(|v| !v.enabled)
+        && !crate::effects::has_effects(layer)
+        && layer.excluded_channels == 0
+        && layer.blend_if.is_default()
+        && layer.advanced.is_default()
+        && layer.video.is_none()
+        && s.format().mode == ColorMode::Cmyk;
+    simple.then_some(s)
+}
+
+/// The composite of `doc` over `rect` in `fmt`, worked out in ink values, or `None` when the
+/// document isn't CMYK or a visible layer needs the full compositor (see the module docs).
+/// `paper` flattens onto white paper (no ink) and makes the result opaque.
+pub fn flatten_cmyk(doc: &Document, rect: Rect, fmt: PixelFormat, paper: bool) -> Option<Surface> {
+    if doc.mode != ColorMode::Cmyk || fmt.mode != ColorMode::Cmyk || doc.layers.iter().any(|l| l.clipped) {
+        return None;
+    }
+    let mut stack = Vec::new();
+    for layer in doc.layers.iter().filter(|l| l.visible) {
+        let alpha = (layer.opacity * layer.fill_opacity).clamp(0.0, 1.0);
+        stack.push((plain(layer)?, alpha));
+    }
+    let mut out = Surface::new(fmt);
+    if rect.is_empty() {
+        return Some(out);
+    }
+    let n = fmt.channels();
+    let w = rect.width() as usize;
+    let rows = crate::band_rows_for(rect.width(), 0);
+    let (mut acc, mut src, mut data) = (Vec::new(), Vec::new(), Vec::new());
+    let mut y = rect.y0;
+    while y < rect.y1 {
+        let band = Rect::new(rect.x0, y, rect.x1, y.saturating_add(rows).min(rect.y1));
+        // Straight C, M, Y, K, alpha per pixel, starting transparent.
+        acc.clear();
+        acc.resize(w * band.height() as usize, [0.0f32; INKS + 1]);
+        for &(surf, opacity) in &stack {
+            if opacity <= 0.0 || (surf.content_bounds().intersect(&band).is_empty() && surf.default_pixel().iter().all(|v| *v == 0.0)) {
+                continue;
+            }
+            let sf = surf.format();
+            let sn = sf.channels();
+            surf.read_region_into(band, &mut src);
+            for (d, s) in acc.iter_mut().zip(src.chunks_exact(sn)) {
+                let sa = if sf.alpha { s[INKS] } else { 1.0 } * opacity;
+                if sa <= 0.0 {
+                    continue;
+                }
+                let oa = sa + d[INKS] * (1.0 - sa);
+                let keep = d[INKS] * (1.0 - sa);
+                for c in 0..INKS {
+                    // An opaque pixel replaces what is below exactly (no rounding through the mix).
+                    d[c] = if sa >= 1.0 { s[c] } else { (s[c] * sa + d[c] * keep) / oa };
+                }
+                d[INKS] = oa;
+            }
+        }
+        data.clear();
+        data.resize(acc.len() * n, 0.0);
+        for (p, o) in acc.iter().zip(data.chunks_exact_mut(n)) {
+            // White paper carries no ink, so flattening onto it scales the ink by coverage.
+            let a = p[INKS];
+            let k = if paper && a < 1.0 { a } else { 1.0 };
+            for c in 0..INKS {
+                o[c] = p[c] * k;
+            }
+            if fmt.alpha {
+                o[INKS] = if paper { 1.0 } else { a };
+            }
+        }
+        out.write_region(band, &data);
+        y = band.y1;
+    }
+    out.prune();
+    Some(out)
+}
diff --git a/crates/compose/src/pattern.rs b/crates/compose/src/pattern.rs
index a55c2c8abc..d107ecf4e7 100644
--- a/crates/compose/src/pattern.rs
+++ b/crates/compose/src/pattern.rs
@@ -45,7 +45,7 @@ impl<'a> PreparedPatterns<'a> {
 
     pub(crate) fn get(&self, id: &str, name: &str) -> Option<Arc<Tile>> {
         let p = photocraft_doc::pattern::find(self.patterns, id, name)?;
-        if p.is_empty() {
+        if !p.is_paintable() {
             return None;
         }
         let bytes = usize::try_from(p.width)
@@ -87,9 +87,13 @@ impl<'a> PreparedPatterns<'a> {
 /// colour mode `mode`. A pattern keeps its own colours (an RGB pattern stays RGB, in the
 /// library and in the document), but in a Grayscale or CMYK document it paints that mode's
 /// colours: what Edit › Fill writes into the document's pixels, and what Photoshop shows (the
-/// pattern in colour in its picker, filled in grey).
+/// pattern in colour in its picker, filled in grey). Empty for a pattern that isn't
+/// [paintable](Pattern::is_paintable).
 pub fn pattern_rgba(p: &Pattern, mode: ColorMode) -> Vec<[f32; 4]> {
-    let mut px = vec![[0.0f32; 4]; (p.width as usize).saturating_mul(p.height as usize)];
+    let Some(n) = p.is_paintable().then(|| usize::try_from(p.pixel_count()).ok()).flatten() else {
+        return Vec::new();
+    };
+    let mut px = vec![[0.0f32; 4]; n];
     p.surface.read_rgba_into(p.rect(), &mut px);
     let paints_in = matches!(mode, ColorMode::Grayscale | ColorMode::Bitmap | ColorMode::Duotone | ColorMode::Cmyk);
     if paints_in && p.surface.format().mode != mode {
@@ -117,8 +121,9 @@ impl Tile {
     }
 
     /// The tile of `p` painted into a document of colour mode `mode` (see [`pattern_rgba`]).
+    /// `None` when the pattern isn't [paintable](Pattern::is_paintable).
     pub fn new_in(p: &Pattern, mode: ColorMode) -> Option<Tile> {
-        if p.is_empty() {
+        if !p.is_paintable() {
             return None;
         }
         let (w, h) = (p.width as usize, p.height as usize);
@@ -154,7 +159,7 @@ impl Tile {
                 if wx == 0.0 {
                     continue;
                 }
-                let p = self.at(x0 + dx, y0 + dy);
+                let p = self.at(x0.saturating_add(dx), y0.saturating_add(dy));
                 let k = wx * wy;
                 for c in 0..4 {
                     acc[c] += p[c] * k;
@@ -255,6 +260,17 @@ mod tests {
         assert_eq!(px[8], [0.0, 0.0, 1.0, 1.0]); // x = 4
     }
 
+    #[test]
+    fn patterns_too_large_to_paint_are_skipped_without_allocating() {
+        // Only the size is declared (no tiles): a hostile file can claim any size.
+        let p = Pattern { id: "big".into(), name: "Big".into(), width: 9000, height: 8000, surface: Surface::new(PixelFormat::RGBA8) };
+        assert!(!p.is_paintable());
+        assert!(Tile::new(&p).is_none());
+        assert!(pattern_rgba(&p, ColorMode::Rgb).is_empty());
+        let list = [p];
+        assert!(PreparedPatterns::new(&list, 0).get("big", "").is_none());
+    }
+
     #[test]
     fn link_phase_scale_and_angle_move_the_origin() {
         let t = Tile::new(&checker()).unwrap();
@@ -271,4 +287,14 @@ mod tests {
         let (u, v) = rot.map(1.0, 3.0);
         assert!((u - -3.0).abs() < 1e-9 && (v - 1.0).abs() < 1e-9, "{u},{v}");
     }
+
+    #[test]
+    fn sampling_at_hostile_phases_does_not_overflow() {
+        let patterns = [checker()];
+        let prepared = PreparedPatterns::new(&patterns, PREPARED_PATTERN_BYTES);
+        let t = prepared.get(&patterns[0].id, "").unwrap();
+        for u in [1.0e30, -1.0e30, f64::INFINITY, f64::NAN] {
+            let _ = t.sample(u, u);
+        }
+    }
 }
diff --git a/crates/compose/src/proxy.rs b/crates/compose/src/proxy.rs
index 5560fae374..84c9348029 100644
--- a/crates/compose/src/proxy.rs
+++ b/crates/compose/src/proxy.rs
@@ -20,12 +20,15 @@ pub fn downsample(s: &Surface, k: u32) -> Surface {
     let bpp = s.format().bytes_per_pixel();
     let (x0, x1) = (b.x0.div_euclid(k), b.x1.div_euclid(k) + i32::from(b.x1.rem_euclid(k) != 0));
     let (y0, y1) = (b.y0.div_euclid(k), b.y1.div_euclid(k) + i32::from(b.y1.rem_euclid(k) != 0));
-    let w = (x1 - x0).max(0) as usize;
+    let w = x1.saturating_sub(x0).max(0) as usize;
     let mut row = vec![0u8; w * bpp];
     for oy in y0..y1 {
-        let src = s.to_interleaved(Rect::new(x0 * k, oy * k, x1 * k, oy * k + 1));
+        let src = s.to_interleaved(Rect::new(x0.saturating_mul(k), oy.saturating_mul(k), x1.saturating_mul(k), oy.saturating_mul(k).saturating_add(1)));
         for (i, px) in row.chunks_exact_mut(bpp).enumerate() {
-            px.copy_from_slice(&src[i * k as usize * bpp..(i * k as usize + 1) * bpp]);
+            // Saturated edges (a surface at the i32 limits) can make `src` shorter than expected.
+            if let Some(from) = (i * k as usize * bpp).checked_add(bpp).and_then(|end| src.get(i * k as usize * bpp..end)) {
+                px.copy_from_slice(from);
+            }
         }
         out.write_interleaved(Rect::new(x0, oy, x1, oy + 1), &row);
     }
@@ -79,19 +82,59 @@ pub fn proxy_document(doc: &Document, k: u32) -> Document {
         c.surface = downsample(&c.surface, k);
     }
     p.selection = p.selection.as_ref().map(|s| downsample(s, k));
+    if let Some(mask) = &mut p.quick_mask {
+        mask.surface = downsample(&mask.surface, k);
+    }
     p
 }
 
 /// Whether a proxy composite is a faithful reduction of `doc`: layer effects (whose sizes are in
-/// document pixels) and vector masks (paths in document coordinates) would not scale with it.
+/// document pixels) and nonempty vector masks (paths in document coordinates) would not scale
+/// with it. Empty vector masks have constant coverage, including inversion and density.
+/// Nonempty paths can still anchor fill layouts even when their mask density is zero.
 pub fn proxy_faithful(doc: &Document) -> bool {
-    doc.walk().iter().all(|(_, _, l)| !crate::effects::has_effects(l) && l.vector_mask.as_ref().is_none_or(|v| !v.enabled))
+    doc.walk().iter().all(|(_, _, l)| !crate::effects::has_effects(l) && l.vector_mask.as_ref().is_none_or(|v| !v.enabled || v.path.is_empty()))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use photocraft_color::{Color, ColorMode, PixelFormat, SampleType};
+    use photocraft_doc::vector::{Knot, Path, Subpath, VectorMask};
+    use photocraft_doc::{Effect, Fill, GradientStyle, LayerMask};
+
+    fn two_colors(size: Size, depth: SampleType) -> Document {
+        let mut doc = Document::new("mask", size, ColorMode::Rgb, depth);
+        let format = doc.pixel_format();
+        for (name, color) in [("blue", [0.0, 0.0, 1.0, 1.0]), ("red", [1.0, 0.0, 0.0, 1.0])] {
+            doc.layers.push(Layer::new(name, LayerContent::Raster(Surface::with_default(format, &color))));
+        }
+        doc
+    }
+
+    fn assert_same_pixels(actual: &crate::Buffer, expected: &crate::Buffer) {
+        assert_same_pixels_within(actual, expected, 1e-6);
+    }
+
+    fn assert_same_pixels_within(actual: &crate::Buffer, expected: &crate::Buffer, tolerance: f32) {
+        assert_eq!(actual.rect, expected.rect);
+        assert_eq!(actual.px.len(), expected.px.len());
+        for (a, b) in actual.px.iter().zip(&expected.px) {
+            assert!(a.iter().zip(b).all(|(a, b)| (a - b).abs() <= tolerance), "{a:?} != {b:?}");
+        }
+    }
+
+    fn u16_coverage(value: f32) -> f32 {
+        // Feathered masks use the existing U16 combined-mask surface, including its default.
+        (value.clamp(0.0, 1.0) * 65535.0 + 0.5).floor() / 65535.0
+    }
+
+    fn opacity_reference(doc: &Document, coverage: f32) -> Document {
+        let mut reference = doc.clone();
+        reference.layers[1].vector_mask = None;
+        reference.layers[1].opacity *= coverage;
+        reference
+    }
 
     #[test]
     fn downsample_picks_every_kth_pixel() {
@@ -134,4 +177,151 @@ mod tests {
         assert_eq!((s.pixel(7, 15)[0], s.pixel(8, 0)[0]), (1.0, 0.0));
         assert!(proxy_document(&Document::new("n", Size::new(8, 8), ColorMode::Rgb, SampleType::U8), 4).selection.is_none());
     }
+
+    #[test]
+    fn proxy_scales_quick_mask_at_every_depth() {
+        for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+            let mut doc = Document::new("mask", Size::new(16, 12), ColorMode::Rgb, depth);
+            let mut surface = Surface::new(PixelFormat::new(ColorMode::Grayscale, depth, false));
+            surface.fill_rect(Rect::new(0, 0, 8, 12), &[1.0]);
+            let mut mask = photocraft_doc::AlphaChannel::new("Quick Mask", surface);
+            mask.opacity = 0.25;
+            doc.quick_mask = Some(mask);
+            for k in [1, 2, 4] {
+                let proxy = proxy_document(&doc, k);
+                let mask = proxy.quick_mask.as_ref().unwrap();
+                assert_eq!(mask.surface.pixel((8 / k - 1) as i32, 0), vec![1.0]);
+                assert_eq!(mask.surface.pixel((8 / k) as i32, 0), vec![0.0], "depth {depth:?}, factor {k}");
+                assert_eq!(mask.opacity, 0.25);
+                assert_eq!(mask.surface.format().sample, depth);
+            }
+            assert_eq!(doc.quick_mask.as_ref().unwrap().surface.pixel(7, 0), vec![1.0], "source stays intact");
+        }
+    }
+
+    #[test]
+    fn proxy_accepts_empty_paths_but_keeps_geometry_and_effect_guards() {
+        let mut doc = two_colors(Size::new(32, 16), SampleType::F32);
+        doc.layers[1].vector_mask = Some(VectorMask::new(Path::new(vec![Subpath::default()])));
+        assert!(proxy_faithful(&doc));
+        // A lone knot has no fillable segments, but still carries document coordinates.
+        doc.layers[1].vector_mask.as_mut().unwrap().path.subpaths[0].knots.push(Knot::corner(12.0, 8.0));
+        assert!(!proxy_faithful(&doc));
+        doc.layers[1].vector_mask.as_mut().unwrap().enabled = false;
+        assert!(proxy_faithful(&doc));
+        doc.layers[1].vector_mask = Some(VectorMask::new(Path::default()));
+        doc.layers[1].effects.items.push(Effect::default_drop_shadow());
+        doc.layers[1].effects.enabled = true;
+        assert!(!proxy_faithful(&doc));
+        doc.layers[1].effects.items[0].set_enabled(false);
+        assert!(proxy_faithful(&doc));
+    }
+
+    #[test]
+    fn empty_vector_masks_keep_constant_coverage_at_every_depth() {
+        for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+            let mut doc = two_colors(Size::new(32, 16), depth);
+            for path in [Path::default(), Path::new(vec![Subpath::default()])] {
+                for inverted in [false, true] {
+                    for density in [0.0, 0.25, 1.0] {
+                        for feather in [0.0, 4.0] {
+                            let mut mask = VectorMask::new(path.clone());
+                            mask.path.inverted = inverted;
+                            mask.density = density;
+                            mask.feather = feather;
+                            doc.layers[1].vector_mask = Some(mask);
+                            assert!(proxy_faithful(&doc));
+                            let coverage = if inverted { 1.0 - density } else { 1.0 };
+                            let coverage = if feather > 0.0 { u16_coverage(coverage) } else { coverage };
+                            let expected = [coverage, 0.0, 1.0 - coverage, 1.0];
+                            let full = crate::render(&doc, doc.bounds());
+                            for pixel in &full.px {
+                                assert!(pixel.iter().zip(expected).all(|(a, b)| (a - b).abs() < 1e-6), "{depth:?} {inverted} {density} {feather}: {pixel:?}");
+                            }
+                            let proxy = proxy_document(&doc, 4);
+                            assert_eq!(proxy.layers[1].vector_mask, doc.layers[1].vector_mask);
+                            let reference = proxy_document(&opacity_reference(&doc, coverage), 4);
+                            assert_same_pixels(&crate::render(&proxy, proxy.bounds()), &crate::render(&reference, reference.bounds()));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn empty_vector_mask_multiplies_a_feathered_pixel_mask_on_the_proxy() {
+        let mut doc = two_colors(Size::new(32, 16), SampleType::F32);
+        let mut surface = Surface::with_default(PixelFormat::new(ColorMode::Grayscale, SampleType::F32, false), &[0.25]);
+        surface.fill_rect(Rect::new(0, 0, 16, 16), &[0.75]);
+        doc.layers[1].mask = Some(LayerMask { surface, density: 0.5, feather: 2.0, ..LayerMask::reveal_all() });
+        let mut mask = VectorMask::new(Path { inverted: true, ..Path::default() });
+        mask.density = 0.75;
+        mask.feather = 8.0;
+        doc.layers[1].vector_mask = Some(mask);
+        assert!(proxy_faithful(&doc));
+        let reference = opacity_reference(&doc, 0.25);
+        for k in [1, 2, 4] {
+            let (actual, expected) = (proxy_document(&doc, k), proxy_document(&reference, k));
+            // Q(0.25 * pixel) versus 0.25 * Q(pixel): U16 rounding differs by at most
+            // 0.625 / 65535. Allow one U16 level plus a small float arithmetic allowance.
+            assert_same_pixels_within(&crate::render(&actual, actual.bounds()), &crate::render(&expected, expected.bounds()), 1.0 / 65535.0 + 1e-6);
+        }
+    }
+
+    #[test]
+    fn empty_vector_masks_keep_the_pixel_mask_gradient_frame() {
+        let mut doc = two_colors(Size::new(32, 16), SampleType::F32);
+        doc.layers[1].content = LayerContent::Fill(Fill::gradient(vec![(0.0, Color::BLACK), (1.0, Color::WHITE)], 0.0, 1.0, GradientStyle::Linear, false));
+        let mut pixel = LayerMask::hide_all();
+        pixel.surface.fill_rect(Rect::new(8, 4, 24, 12), &[1.0]);
+        doc.layers[1].mask = Some(pixel);
+        for inverted in [false, true] {
+            let mut mask = VectorMask::new(Path { inverted, ..Path::default() });
+            mask.density = 0.5;
+            mask.feather = 3.0;
+            doc.layers[1].vector_mask = Some(mask);
+            assert!(proxy_faithful(&doc));
+            assert_eq!(crate::fill_frame(&doc.layers[1], doc.bounds()), Rect::new(8, 4, 24, 12));
+            let actual = proxy_document(&doc, 4);
+            assert_eq!(crate::fill_frame(&actual.layers[1], actual.bounds()), Rect::new(2, 1, 6, 3));
+            let reference = proxy_document(&opacity_reference(&doc, u16_coverage(if inverted { 0.5 } else { 1.0 })), 4);
+            assert_same_pixels(&crate::render(&actual, actual.bounds()), &crate::render(&reference, reference.bounds()));
+        }
+    }
+
+    #[test]
+    fn zero_density_geometry_still_blocks_the_proxy_and_anchors_a_gradient() {
+        let mut doc = Document::new("gradient", Size::new(64, 32), ColorMode::Rgb, SampleType::F32);
+        let fill = Fill::gradient(vec![(0.0, Color::BLACK), (1.0, Color::WHITE)], 0.0, 1.0, GradientStyle::Linear, false);
+        let mut layer = Layer::new("gradient", LayerContent::Fill(fill));
+        let path = Path::new(vec![Subpath::polygon(&[(16.0, 8.0), (48.0, 8.0), (48.0, 24.0), (16.0, 24.0)])]);
+        let mut mask = VectorMask::new(path);
+        mask.density = 0.0;
+        layer.vector_mask = Some(mask);
+        doc.layers.push(layer);
+        assert!(!proxy_faithful(&doc));
+        assert_eq!(crate::fill_frame(&doc.layers[0], doc.bounds()), Rect::new(16, 8, 48, 24));
+        // Density zero reveals all pixels, but the unscaled path would still move the fill.
+        let forced_proxy = proxy_document(&doc, 4);
+        let exact = crate::render_reduced(&doc, 16, 8);
+        let wrong = crate::render(&forced_proxy, forced_proxy.bounds());
+        assert!(exact.px.iter().zip(&wrong.px).any(|(a, b)| (a[0] - b[0]).abs() > 0.1));
+    }
+
+    #[test]
+    fn large_thumbnail_keeps_inverted_empty_mask_coverage() {
+        // Default-only surfaces exercise the large-document branch without allocating 17 MP.
+        let mut doc = two_colors(Size::new(4200, 4200), SampleType::F32);
+        let mut mask = VectorMask::new(Path { inverted: true, ..Path::default() });
+        mask.density = 0.75;
+        mask.feather = 8.0;
+        doc.layers[1].vector_mask = Some(mask);
+        assert!(doc.size.area() > crate::PROXY_THUMBNAIL_PIXELS);
+        assert!(proxy_faithful(&doc));
+        let actual = crate::thumbnail_buffer(&doc, 4);
+        assert_eq!(actual.rect, Rect::new(0, 0, 4, 4));
+        let coverage = u16_coverage(0.25);
+        assert_eq!(actual.px, vec![[coverage, 0.0, 1.0 - coverage, 1.0]; 16]);
+    }
 }
diff --git a/crates/compose/src/psblend.rs b/crates/compose/src/psblend.rs
index afd8412347..4cff6f3082 100644
--- a/crates/compose/src/psblend.rs
+++ b/crates/compose/src/psblend.rs
@@ -210,13 +210,7 @@ pub fn composite(mode: BlendMode, backdrop: [f32; 4], source: [f32; 4], opacity:
         return [r[0], r[1], r[2], ao];
     }
     if mode == BlendMode::Normal {
-        // Fast path: B(Cb, Cs) = Cs.
-        if ao <= 0.0 {
-            return [0.0; 4];
-        }
-        let kb = ab * (1.0 - as_);
-        let inv = 1.0 / ao;
-        return [(kb * backdrop[0] + as_ * source[0]) * inv, (kb * backdrop[1] + as_ * source[1]) * inv, (kb * backdrop[2] + as_ * source[2]) * inv, ao];
+        return normal_rgb(backdrop, source, as_, ao);
     }
     let cb = [backdrop[0], backdrop[1], backdrop[2]];
     let cs = [source[0], source[1], source[2]];
@@ -232,6 +226,29 @@ pub fn composite(mode: BlendMode, backdrop: [f32; 4], source: [f32; 4], opacity:
     out
 }
 
+/// Normal mixing outside Lab, for callers that select the blend space once per buffer.
+#[inline]
+pub(crate) fn composite_normal_rgb(backdrop: [f32; 4], source: [f32; 4], opacity: f32) -> [f32; 4] {
+    let ab = backdrop[3];
+    let as_ = source[3] * opacity;
+    if as_ <= 0.0 {
+        return backdrop;
+    }
+    let ao = as_ + ab * (1.0 - as_);
+    normal_rgb(backdrop, source, as_, ao)
+}
+
+#[inline]
+fn normal_rgb(backdrop: [f32; 4], source: [f32; 4], as_: f32, ao: f32) -> [f32; 4] {
+    // B(Cb, Cs) = Cs. Keep the scalar composite's operation order and straight alpha.
+    if ao <= 0.0 {
+        return [0.0; 4];
+    }
+    let kb = backdrop[3] * (1.0 - as_);
+    let inv = 1.0 / ao;
+    [(kb * backdrop[0] + as_ * source[0]) * inv, (kb * backdrop[1] + as_ * source[1]) * inv, (kb * backdrop[2] + as_ * source[2]) * inv, ao]
+}
+
 /// Photoshop's "Blend Text Colors Using Gamma" (Color Settings › Advanced, on at 1.45 by
 /// default): type layers mix their colour with the backdrop in linear light raised to 1 / 1.45
 /// ([`text_encode`]), so anti-aliased glyph edges come out lighter over dark backdrops than a
diff --git a/crates/compose/src/shape_split.rs b/crates/compose/src/shape_split.rs
index 3c1a4b106c..9f0143f889 100644
--- a/crates/compose/src/shape_split.rs
+++ b/crates/compose/src/shape_split.rs
@@ -21,6 +21,27 @@ fn cache() -> &'static Mutex<(HashMap<u64, Entry>, u64)> {
 }
 
 const CAPACITY: usize = 32;
+/// Most pixel bytes the split parts may hold (#4530): each entry is two canvas-sized surfaces,
+/// so 32 of them at 24 MP could hold several GB outside every memory budget.
+#[cfg(not(test))]
+const BUDGET: usize = 256 << 20;
+/// Small under test, so a few 512² shapes exercise the eviction.
+#[cfg(test)]
+const BUDGET: usize = 8 << 20;
+
+/// Pixel bytes of one entry's (fill, stroke) parts (the pinned shape pixels are the document's).
+fn entry_bytes(parts: &(Surface, Surface)) -> usize {
+    [&parts.0, &parts.1].iter().map(|s| s.tiles().map(|(_, t)| t.bytes().len()).sum::<usize>()).sum()
+}
+
+/// Drop every cached split (Edit › Purge › All), returning the parts' pixel bytes. Callers may
+/// still hold returned surfaces, so this is not a measure of freed process memory.
+pub fn purge_cache() -> usize {
+    let mut c = cache().lock().unwrap_or_else(|e| e.into_inner());
+    let bytes = c.0.values().map(|e| entry_bytes(&e.0)).sum();
+    c.0.clear();
+    bytes
+}
 
 /// (fill only, stroke only) of a stroked shape, rendered over `canvas` in RGBA at `depth`.
 /// `None` without a stroke. Where the shape's pixels
@@ -56,11 +77,20 @@ pub fn split(sh: &ShapeLayer, canvas: Rect, depth: SampleType) -> Option<(Surfac
         fit_stroke(&parts.0, &mut parts.1, cache, canvas);
     }
     let mut c = cache().lock().unwrap_or_else(|e| e.into_inner());
-    if c.0.len() >= CAPACITY
-        && let Some(old) = c.0.iter().min_by_key(|e| (e.1).1).map(|e| *e.0)
-    {
+    // Least recently used first, until the new entry fits both the count and the byte budget.
+    let new_bytes = entry_bytes(&parts);
+    loop {
+        let held: usize = c.0.values().map(|e| entry_bytes(&e.0)).sum();
+        if c.0.len() < CAPACITY && held.saturating_add(new_bytes) <= BUDGET {
+            break;
+        }
+        let Some(old) = c.0.iter().min_by_key(|e| (e.1).1).map(|e| *e.0) else { break };
         c.0.remove(&old);
     }
+    if new_bytes > BUDGET {
+        // Larger than the whole budget on its own: use it, don't keep it.
+        return Some(parts);
+    }
     let tick = c.1;
     c.0.insert(key, (parts.clone(), tick, sh.cache.clone()));
     Some(parts)
@@ -117,3 +147,40 @@ fn fit_stroke(fill: &Surface, stroke: &mut Surface, cache: &Surface, canvas: Rec
     }
     stroke.write_region(r, &out);
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use photocraft_color::Color;
+    use photocraft_doc::Fill;
+    use photocraft_doc::vector::{Path, ShapeStroke, Subpath};
+
+    fn shape(x: f64) -> ShapeLayer {
+        ShapeLayer {
+            path: Path::new(vec![Subpath::polygon(&[(x, 10.0), (x + 400.0, 10.0), (x + 400.0, 500.0), (x, 500.0)])]),
+            fill: Some(Fill::Solid(Color::rgb(0.2, 0.4, 0.6))),
+            stroke: Some(ShapeStroke { width: 6.0, ..ShapeStroke::default() }),
+            live: None,
+            cache: None,
+            psd_raw: None,
+        }
+    }
+
+    fn held() -> usize {
+        cache().lock().unwrap_or_else(|e| e.into_inner()).0.values().map(|e| entry_bytes(&e.0)).sum()
+    }
+
+    /// The split cache stays within its byte budget, evicting the least recently used, and
+    /// Edit › Purge › All empties it (#4530).
+    #[test]
+    fn split_cache_keeps_to_its_budget_and_purges() {
+        let canvas = Rect::new(0, 0, 1024, 512);
+        for i in 0..6 {
+            let parts = split(&shape(f64::from(i) * 10.0), canvas, SampleType::U8).expect("stroked");
+            assert!(entry_bytes(&parts) > 0);
+            assert!(held() <= BUDGET, "shape {i}: {} bytes held", held());
+        }
+        // Other tests share the cache, so only what this test can rely on: a purge frees bytes.
+        assert!(purge_cache() > 0, "something to purge");
+    }
+}
diff --git a/crates/compose/src/tests.rs b/crates/compose/src/tests.rs
index 853767ae81..f9e49ac04e 100644
--- a/crates/compose/src/tests.rs
+++ b/crates/compose/src/tests.rs
@@ -40,6 +40,147 @@ fn normal_layer_over_background() {
     assert!(close4(px(&d, 5, 1), [1.0; 4]));
 }
 
+// The pre-optimisation Normal formula, independent of the production helper. Its operation
+// order matters: an algebraically equivalent premultiplied mix can round differently.
+fn original_normal_rgb(backdrop: [f32; 4], source: [f32; 4], opacity: f32) -> [f32; 4] {
+    let ab = backdrop[3];
+    let as_ = source[3] * opacity;
+    if as_ <= 0.0 {
+        return backdrop;
+    }
+    let ao = as_ + ab * (1.0 - as_);
+    if ao <= 0.0 {
+        return [0.0; 4];
+    }
+    let kb = ab * (1.0 - as_);
+    let inv = 1.0 / ao;
+    [(kb * backdrop[0] + as_ * source[0]) * inv, (kb * backdrop[1] + as_ * source[1]) * inv, (kb * backdrop[2] + as_ * source[2]) * inv, ao]
+}
+
+#[test]
+fn normal_rgb_kernel_preserves_scalar_bits() {
+    let subnormal = f32::from_bits(1);
+    let backdrops = [[0.0, -0.0, 2.0, 0.0], [0.2, 0.4, 0.6, 0.5], [2.0, -0.25, 4.0, 1.0], [-1.0, 0.01, 1.0, -0.5], [1.0, -0.0, f32::MIN_POSITIVE, subnormal]];
+    let sources = [
+        [0.9, 0.1, 0.3, 1.0],
+        [0.25, 2.0, -1.0, 0.5],
+        [subnormal, 1e-20, 1.0, subnormal],
+        [0.5, 0.2, 0.7, -0.0],
+        [0.5, 0.2, 0.7, -0.5],
+        [f32::NAN, 0.2, 0.7, 0.0],
+    ];
+    for b in backdrops {
+        for s in sources {
+            for opacity in [-1.0, -0.0, 0.0, 0.5, 1.0, 2.0] {
+                let want = original_normal_rgb(b, s, opacity);
+                let got = psblend::composite_normal_rgb(b, s, opacity);
+                assert_eq!(got.map(f32::to_bits), want.map(f32::to_bits), "{b:?} / {s:?} / {opacity}");
+            }
+        }
+    }
+}
+
+fn normal_rgb_test_buffers(fmt: PixelFormat) -> (Buffer, Buffer) {
+    let rect = Rect::new(-3, -2, 5, 0);
+    let mut bottom = Surface::new(fmt);
+    let mut top = Surface::new(fmt);
+    for y in rect.y0..rect.y1 {
+        for x in rect.x0..rect.x1 {
+            let i = ((y - rect.y0) * rect.width() as i32 + x - rect.x0) as usize;
+            let t = i as f32 / 16.0;
+            let b = [2.0 * t, 0.4, -0.25 + t, [0.0, 0.25, 0.75, 1.0][i % 4]];
+            let s = [0.9 - t, 0.1 + t, 0.3, [0.0, -0.0, 0.5, 1.0][i % 4]];
+            bottom.write_pixel(x, y, &photocraft_raster::from_rgba(&fmt, b));
+            top.write_pixel(x, y, &photocraft_raster::from_rgba(&fmt, s));
+        }
+    }
+    (surface_to_buffer(&bottom, rect), surface_to_buffer(&top, rect))
+}
+
+// Keep the old buffer dispatch as an oracle for the specialised loop and all of its fallbacks.
+fn original_blend_into_g(backdrop: &mut Buffer, src: &Buffer, mode: BlendMode, opacity: f32, gamma: f32) {
+    let rect = backdrop.rect;
+    let w = rect.width() as i32;
+    for (i, b) in backdrop.px.iter_mut().enumerate() {
+        let mut s = src.px[i];
+        if s[3] <= 0.0 {
+            continue;
+        }
+        let mut mode = mode;
+        if mode == BlendMode::Dissolve {
+            let x = rect.x0 + (i as i32 % w);
+            let y = rect.y0 + (i as i32 / w);
+            s[3] = if dissolve_noise(x, y) < s[3] * opacity { 1.0 } else { 0.0 };
+            mode = BlendMode::Normal;
+            *b = blend::composite(mode, *b, s, 1.0);
+            continue;
+        }
+        *b = blend::composite_gamma(mode, *b, s, opacity, gamma);
+    }
+}
+
+fn assert_buffer_bits(got: &Buffer, want: &Buffer) {
+    assert_eq!(got.rect, want.rect);
+    assert_eq!(got.px.len(), want.px.len());
+    for (i, (got, want)) in got.px.iter().zip(&want.px).enumerate() {
+        assert_eq!(got.map(f32::to_bits), want.map(f32::to_bits), "pixel {i}: {got:?} vs {want:?}");
+    }
+}
+
+#[test]
+fn normal_rgb_buffer_dispatch_and_fallbacks_preserve_bits() {
+    for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA16, PixelFormat::RGBA32F] {
+        let (bottom, top) = normal_rgb_test_buffers(fmt);
+        for lab in [false, true] {
+            psblend::with_lab_mix(lab, || {
+                psblend::with_hdr(fmt.sample == SampleType::F32, || {
+                    for mode in BlendMode::LAYER_MODES {
+                        for gamma in [1.0, psblend::TEXT_GAMMA] {
+                            for opacity in [0.0, 0.5, 1.0] {
+                                let mut got = bottom.clone();
+                                let mut want = bottom.clone();
+                                original_blend_into_g(&mut want, &top, mode, opacity, gamma);
+                                blend_into_g(&mut got, &top, mode, opacity, gamma);
+                                assert_buffer_bits(&got, &want);
+                            }
+                        }
+                    }
+                });
+            });
+        }
+    }
+}
+
+#[test]
+fn normal_rgb_buffer_preserves_alpha_skip_and_nested_scopes() {
+    let rect = Rect::new(-1, -1, 2, 0);
+    let bottom = Buffer::filled(rect, [-0.0, 0.4, 2.0, 0.75]);
+    let top = Buffer { rect, px: vec![[f32::NAN, 0.3, 0.1, -0.5], [0.2, 0.3, 0.1, -0.0], [0.2, 0.3, 0.1, f32::NAN]] };
+    psblend::with_lab_mix(true, || {
+        psblend::with_hdr(true, || {
+            psblend::with_lab_mix(false, || {
+                psblend::with_hdr(false, || {
+                    let mut got = bottom.clone();
+                    let mut want = bottom.clone();
+                    original_blend_into_g(&mut want, &top, BlendMode::Normal, -1.0, 1.0);
+                    blend_into_g(&mut got, &top, BlendMode::Normal, -1.0, 1.0);
+                    assert_buffer_bits(&got, &want);
+                    assert_eq!(got.px[0].map(f32::to_bits), bottom.px[0].map(f32::to_bits));
+                    assert_eq!(got.px[1].map(f32::to_bits), bottom.px[1].map(f32::to_bits));
+                });
+                assert!(psblend::HDR.with(|h| h.get()));
+            });
+            assert!(psblend::LAB_MIX.with(|l| l.get()));
+            assert!(psblend::HDR.with(|h| h.get()));
+            let mut got = bottom.clone();
+            let mut want = bottom.clone();
+            original_blend_into_g(&mut want, &top, BlendMode::Normal, 0.5, 1.0);
+            blend_into_g(&mut got, &top, BlendMode::Normal, 0.5, 1.0);
+            assert_buffer_bits(&got, &want);
+        });
+    });
+}
+
 #[test]
 fn opacity_and_fill_multiply() {
     let mut d = doc_white(4, 4);
@@ -451,6 +592,20 @@ fn render_is_tile_independent() {
     }
 }
 
+/// A Lab Invert layer in a 16-bit document keeps a grey neutral (the compositor passes the
+/// document's depth to `adjust::apply_in`).
+#[test]
+fn a_16_bit_lab_invert_layer_keeps_greys_neutral() {
+    let mut d = Document::new("lab", Size::new(2, 2), ColorMode::Lab, SampleType::U16);
+    let mut bg = Layer::raster("bg", d.pixel_format());
+    bg.surface_mut().unwrap().fill_rect(Rect::new(0, 0, 2, 2), &[0.25, 128.0 / 255.0, 128.0 / 255.0, 1.0]);
+    d.layers.push(bg);
+    d.layers.push(Layer::new("inv", LayerContent::Adjustment(Adjustment::Invert)));
+    let p = px(&d, 1, 1);
+    let lab = photocraft_color::convert::srgb_to_lab([p[0], p[1], p[2]]);
+    assert!((lab[0] - 75.0).abs() < 0.1 && lab[1].abs() < 0.05 && lab[2].abs() < 0.05, "{lab:?}");
+}
+
 #[test]
 fn cmyk_document_renders_via_rgb() {
     let mut d = Document::new("c", Size::new(2, 2), ColorMode::Cmyk, SampleType::U8);
@@ -463,6 +618,34 @@ fn cmyk_document_renders_via_rgb() {
     assert!(p[0] < 0.3 && (p[0] - p[1]).abs() < 0.05 && (p[1] - p[2]).abs() < 0.05 && p[3] == 1.0, "{p:?}");
 }
 
+/// Transparent pixels convert to colour in CMYK (K = 100%) and Lab (a/b = 0.5). A flattened
+/// surface must still treat them as empty, or its content spans the whole canvas.
+#[test]
+fn flatten_to_surface_leaves_transparent_pixels_empty_in_every_mode() {
+    let modes = [
+        (ColorMode::Rgb, [SampleType::U8, SampleType::U16, SampleType::F32].as_slice()),
+        (ColorMode::Grayscale, &[SampleType::U8, SampleType::U16, SampleType::F32]),
+        (ColorMode::Cmyk, &[SampleType::U8, SampleType::U16]),
+        (ColorMode::Lab, &[SampleType::U8, SampleType::U16]),
+    ];
+    for (mode, samples) in modes {
+        for &sample in samples {
+            let mut d = Document::new("t", Size::new(300, 200), mode, sample);
+            let fmt = PixelFormat::new(mode, sample, true);
+            let mut l = Layer::raster("dot", fmt);
+            let opaque: Vec<f32> = photocraft_raster::from_rgba(&fmt, [0.9, 0.4, 0.1, 1.0]);
+            l.surface_mut().unwrap().fill_rect(Rect::new(120, 80, 140, 90), &opaque);
+            d.layers.push(l);
+            let s = flatten_to_surface(&d, fmt, None);
+            assert_eq!(s.content_bounds(), Rect::new(120, 80, 140, 90), "{mode:?} {sample:?}");
+            // Over a background everything is content, as before.
+            let fmt_opaque = PixelFormat::new(mode, sample, false);
+            let s = flatten_to_surface(&d, fmt_opaque, Some([1.0, 1.0, 1.0]));
+            assert_eq!(s.rgba(5, 5)[3], 1.0, "{mode:?} {sample:?}: background stays opaque");
+        }
+    }
+}
+
 #[test]
 fn sixteen_bit_and_float_layers_composite() {
     for fmt in [PixelFormat::RGBA16, PixelFormat::RGBA32F] {
@@ -1132,17 +1315,61 @@ fn shapeless_effect_maps_cover_only_the_band_being_rendered() {
 // ---------- PSD-fidelity effect semantics (fitted on Photoshop composites) ----------
 
 #[test]
-fn stroke_corners_follow_the_5x5_chamfer_metric() {
-    // Square 10..30, outside stroke 3: pixel (9, 7) is offset (1, 3) from the corner pixel.
-    // Photoshop measures √5 + 1 = 3.236 there (exact distance 3.162): coverage 3 + 1 − 3.236.
+fn stroke_edges_use_the_chamfer_when_narrow_and_the_exact_distance_when_wide() {
+    // #3646: a narrow stroke's outer edge keeps the 5 × 5 chamfer, whose sub-pixel seeding
+    // Photoshop matches at small offsets (see `stroke_outside_exact`); only a wide one — where the
+    // chamfer's octagon facets (see `a_wide_outside_stroke_is_round_not_a_polygon`) — uses the
+    // exact Euclidean transform.
+    // Square 10..30, outside stroke 3: (9, 7) is offset (1, 3) from the corner pixel. Photoshop
+    // measures √5 + 1 = 3.236 there, so coverage is 3 + 1 − 3.236 = 0.764 (the exact distance is
+    // 3.162, coverage 0.838).
     let d = fx_doc(vec![stroke(3.0, StrokePosition::Outside)]);
     let a = 1.0 - px(&d, 9, 7)[0]; // blue stroke over white: red channel drops by coverage
     assert!((a - 0.764).abs() < 0.01, "{a}");
-    // (2, 2) stays Euclidean (two diagonal steps).
+    // (2, 2) is the same in both metrics (two diagonal steps).
     let a = 1.0 - px(&d, 8, 8)[0];
     assert!((a - 1.0).abs() < 0.01, "{a}");
 }
 
+#[test]
+fn the_stroke_metric_switches_at_the_fitted_threshold() {
+    // The widest outside stroke any Photoshop oracle matches with the chamfer is 18 px
+    // (ag-psd read-write/strokes): its octagon deviates 0.48 px from a circle there; 20 px keeps
+    // it. Wider strokes (the 60 px #3646 case) are round.
+    assert!(!crate::effects::stroke_outside_exact(18.0));
+    assert!(crate::effects::stroke_outside_exact(crate::effects::STROKE_CHAMFER_MAX));
+    assert!(crate::effects::stroke_outside_exact(60.0));
+}
+
+#[test]
+fn a_wide_outside_stroke_is_round_not_a_polygon() {
+    // A point source dilated by 60 px must stay a circle. The 5 × 5 chamfer's octagonal level set
+    // made the boundary swing ~2.5 px at this radius (~10 px at 245 px) — the "low-poly" #3646.
+    let mut d = doc_white(170, 170);
+    let mut l = solid_layer("dot", Rect::new(85, 85, 86, 86), [1.0, 0.0, 0.0, 1.0]);
+    l.effects.items = vec![stroke(60.0, StrokePosition::Outside)];
+    d.layers.push(l);
+    let buf = render(&d, Rect::new(0, 0, 170, 170));
+    let at = |x: i32, y: i32| buf.px[(y as usize) * 170 + x as usize];
+    let (mut lo, mut hi) = (f64::MAX, 0.0f64);
+    let stroke_at = |x: i32, y: i32| x >= 0 && y >= 0 && x < 170 && y < 170 && at(x, y)[2] > 0.5 && at(x, y)[0] < 0.5;
+    for k in 0..72 {
+        let th = (k as f64) * std::f64::consts::TAU / 72.0;
+        let (dx, dy) = (th.cos(), th.sin());
+        let mut r = 0.0f64;
+        let mut t = 0.0f64;
+        while t < 84.0 {
+            if stroke_at((85.0 + dx * t).round() as i32, (85.0 + dy * t).round() as i32) {
+                r = t;
+            }
+            t += 0.25;
+        }
+        lo = lo.min(r);
+        hi = hi.max(r);
+    }
+    assert!(hi - lo <= 2.0, "the 60 px stroke boundary swings {lo}..{hi} px — a polygon, not a circle (#3646)");
+}
+
 #[test]
 fn inside_stroke_respects_partial_edge_coverage() {
     // A 25 %-alpha edge column puts the edge 0.75 px further out: a 3 px inside stroke then
@@ -1330,6 +1557,22 @@ fn blend_if_underlying_layer_hides_by_the_backdrop_value() {
     assert!(close4(px(&d, 6, 1), [1.0, 1.0, 1.0, 1.0]));
 }
 
+/// An 8-bit backdrop at level `k` counts as `k` for a hard Underlying black point at `k`, also
+/// over a semi-transparent backdrop, where compositing leaves the value a few millionths off the
+/// level (19.999998 for 20 before #4395); the GPU compositor agrees.
+#[test]
+fn blend_if_hard_point_includes_its_own_level() {
+    for k in 0..=255u8 {
+        let v = f32::from(k) / 255.0;
+        let mut d = Document::new("t", Size::new(2, 1), ColorMode::Rgb, SampleType::U8);
+        d.layers.push(solid_layer("under", Rect::new(0, 0, 2, 1), [v, v, v, 184.0 / 255.0]));
+        let mut l = solid_layer("top", Rect::new(0, 0, 2, 1), [1.0, 0.0, 0.0, 1.0]);
+        l.blend_if.set(1, [FULL, range([k, k], [255, 255])]);
+        d.layers.push(l);
+        assert!(close4(px(&d, 0, 0), [1.0, 0.0, 0.0, 1.0]), "level {k} is hidden by a black point at {k}");
+    }
+}
+
 #[test]
 fn blend_if_split_point_fades_like_opacity() {
     // A split black point (Alt-drag) at 50/150 shows a value-100 layer at half strength, which
@@ -2203,3 +2446,195 @@ fn outer_glow_does_not_paint_through_a_zero_fill_layer() {
         assert!(opaque[0] > 0.9 && opaque[1] > 0.8, "{technique:?}: opaque fill disappeared: {opaque:?}");
     }
 }
+
+// Lab documents: Invert mirrors L, a and b; Threshold splits on L with a neutral result; Gradient
+// Map follows L. Rendered through the document compositor at every depth.
+#[test]
+fn lab_documents_evaluate_invert_threshold_and_gradient_map_on_lab() {
+    use photocraft_color::convert::{lab_to_srgb, srgb_to_lab};
+    let c = lab_to_srgb([30.0, 12.0, -18.0]);
+    for depth in SampleType::ALL {
+        let render = |adj: Adjustment| {
+            let mut d = Document::with_background("t", Size::new(4, 4), ColorMode::Lab, depth, Color::rgb(c[0], c[1], c[2]));
+            d.layers.push(Layer::new("adj", LayerContent::Adjustment(adj)));
+            let p = flatten(&d).px[5];
+            srgb_to_lab([p[0], p[1], p[2]])
+        };
+        let near = |got: [f32; 3], want: [f32; 3], tol: f32| got.iter().zip(want).all(|(g, w)| (g - w).abs() <= tol);
+        let inv = render(Adjustment::Invert);
+        // 8-bit bytes become 255 - v (a, b one step past the mirror); 16 bits mirror them exactly.
+        let want = if depth == SampleType::U8 { [70.0, -13.0, 17.0] } else { [70.0, -12.0, 18.0] };
+        assert!(near(inv, want, 0.5), "{depth:?}: {inv:?}");
+        let th = render(Adjustment::Threshold { level: 0.25 });
+        assert!(near(th, [100.0, 0.0, 0.0], 0.5), "{depth:?}: L 30 is above level 64: {th:?}");
+        let gm = render(Adjustment::GradientMap { stops: vec![(0.0, [0.0; 3]), (1.0, [1.0; 3])], reverse: false, dither: false });
+        let want = srgb_to_lab([0.3; 3]);
+        assert!(near(gm, want, 1.0), "{depth:?}: L 30 → 30 % of the way: {gm:?} vs {want:?}");
+    }
+}
+
+/// `adj` over a one-colour Lab document (background `rgb`) at `depth`, read back as Lab.
+fn lab_doc_adjusted(rgb: [f32; 3], adj: Adjustment, depth: SampleType) -> [f32; 3] {
+    let mut doc = Document::with_background("lab", Size::new(4, 4), ColorMode::Lab, depth, Color::rgb(rgb[0], rgb[1], rgb[2]));
+    doc.layers.push(Layer::new("adj", LayerContent::Adjustment(adj)));
+    let p = px(&doc, 1, 1);
+    photocraft_color::convert::srgb_to_lab([p[0], p[1], p[2]])
+}
+
+fn near3(got: [f32; 3], want: [f32; 3], tol: f32, what: &str) {
+    assert!(got.iter().zip(want).all(|(g, w)| (g - w).abs() <= tol), "{what}: got {got:?}, want {want:?}");
+}
+
+/// A muted, in-gamut colour (L ≈ 46, a ≈ 10, b ≈ -20) and its Lab coordinates.
+const MUTED: [f32; 3] = [0.40, 0.42, 0.60];
+
+#[test]
+fn lab_documents_invert_and_posterize_l_a_and_b() {
+    let lab = photocraft_color::convert::srgb_to_lab(MUTED);
+    for depth in SampleType::ALL {
+        // Invert: L -> 100 - L and a, b -> their opposites (-a - 1 on the 8-bit 0..255 grid).
+        let inv = lab_doc_adjusted(MUTED, Adjustment::Invert, depth);
+        let step = if depth == SampleType::U8 { 1.0 } else { 0.0 };
+        near3(inv, [100.0 - lab[0], -lab[1] - step, -lab[2] - step], 1.0, &format!("{depth:?} invert"));
+        // An RGB invert would land elsewhere: lightness 100 - L is the Lab rule.
+        let rgb_inv = photocraft_color::convert::srgb_to_lab(MUTED.map(|v| 1.0 - v));
+        assert!((rgb_inv[0] - inv[0]).abs() > 2.0, "{depth:?}: {rgb_inv:?} vs {inv:?}");
+        // Posterize, three levels: the same steps on L, a and b (here all land on the middle
+        // step: L ≈ 50 and a, b ≈ -1, a neutral grey).
+        let post = lab_doc_adjusted(MUTED, Adjustment::Posterize { levels: 3 }, depth);
+        let n = [lab[0] / 100.0, (lab[1] + 128.0) / 255.0, (lab[2] + 128.0) / 255.0].map(|v| adjust::posterize(v, 3));
+        let want = [n[0] * 100.0, n[1] * 255.0 - 128.0, n[2] * 255.0 - 128.0];
+        assert!(want[0] > 45.0 && want[1].abs() < 2.0 && want[2].abs() < 2.0, "{want:?}");
+        near3(post, want, 1.0, &format!("{depth:?} posterize"));
+    }
+}
+
+#[test]
+fn lab_documents_brightness_contrast_moves_lightness_only() {
+    let lab = photocraft_color::convert::srgb_to_lab(MUTED);
+    for depth in SampleType::ALL {
+        for legacy in [true, false] {
+            let got = lab_doc_adjusted(MUTED, Adjustment::BrightnessContrast { brightness: 40.0, contrast: 20.0, legacy }, depth);
+            assert!(got[0] > lab[0] + 5.0, "{depth:?} legacy {legacy}: {got:?}");
+            near3([lab[0], got[1], got[2]], lab, 0.75, &format!("{depth:?} legacy {legacy}: a, b kept"));
+        }
+    }
+}
+
+#[test]
+fn lab_documents_threshold_on_lightness_with_a_neutral_result() {
+    for depth in SampleType::ALL {
+        // A saturated yellow is light (L ≈ 97): white, not a coloured result.
+        let yellow = lab_doc_adjusted([1.0, 1.0, 0.0], Adjustment::Threshold { level: 0.5 }, depth);
+        near3(yellow, [100.0, 0.0, 0.0], 0.5, &format!("{depth:?} yellow"));
+        // Pure blue has L ≈ 30: black.
+        let blue = lab_doc_adjusted([0.0, 0.0, 1.0], Adjustment::Threshold { level: 0.5 }, depth);
+        near3(blue, [0.0, 0.0, 0.0], 0.5, &format!("{depth:?} blue"));
+        // Mid grey L 53.4 against level 128 (n 0.502): Lab L decides, not RGB luminance.
+        let level = 0.52;
+        let grey = lab_doc_adjusted([0.5; 3], Adjustment::Threshold { level }, depth);
+        near3(grey, [100.0, 0.0, 0.0], 0.5, &format!("{depth:?} grey"));
+    }
+}
+
+#[test]
+fn lab_documents_gradient_map_follows_lightness() {
+    let stops = vec![(0.0, [0.0, 0.0, 1.0]), (1.0, [1.0, 1.0, 0.0])];
+    // A grey and a saturated colour of the same L map to the same colour.
+    let red = [0.9, 0.1, 0.1];
+    let l = photocraft_color::convert::srgb_to_lab(red)[0];
+    let grey = photocraft_color::convert::lab_to_srgb([l, 0.0, 0.0]);
+    for depth in SampleType::ALL {
+        for reverse in [false, true] {
+            let adj = Adjustment::GradientMap { stops: stops.clone(), reverse, dither: false };
+            let a = lab_doc_adjusted(red, adj.clone(), depth);
+            let b = lab_doc_adjusted(grey, adj.clone(), depth);
+            near3(a, b, 1.0, &format!("{depth:?} reverse {reverse}"));
+            let t = if reverse { 1.0 - l / 100.0 } else { l / 100.0 };
+            let want = photocraft_color::convert::srgb_to_lab([t, t, 1.0 - t]);
+            near3(a, want, 1.5, &format!("{depth:?} reverse {reverse}"));
+        }
+    }
+    // In RGB documents the map still follows RGB luminance: red and grey differ there.
+    let mut buf = Buffer::filled(Rect::new(0, 0, 1, 1), [red[0], red[1], red[2], 1.0]);
+    let adj = Adjustment::GradientMap { stops, reverse: false, dither: false };
+    adjust::apply_in(&adj, &mut buf, adjust::Transfer::Srgb, None, ColorMode::Rgb);
+    let mut grey_buf = Buffer::filled(Rect::new(0, 0, 1, 1), [grey[0], grey[1], grey[2], 1.0]);
+    adjust::apply_in(&adj, &mut grey_buf, adjust::Transfer::Srgb, None, ColorMode::Rgb);
+    assert!((buf.px[0][0] - grey_buf.px[0][0]).abs() > 0.05, "{:?} {:?}", buf.px[0], grey_buf.px[0]);
+}
+
+#[test]
+fn render_refuses_rects_beyond_the_pixel_cap() {
+    let doc = Document::new("c", Size::new(4, 4), ColorMode::Rgb, SampleType::U8);
+    // 2^32 - 1 px wide: the width wraps negative as an i32, which once took the single-tile path.
+    for tile in [crate::RENDER_TILE, 1 << 20] {
+        let b = crate::render_tiled(&doc, Rect::new(i32::MIN, 0, i32::MAX, 1), tile);
+        assert!(b.px.is_empty() && b.rect.is_empty());
+    }
+}
+
+// The effect-map cache key covers Transparency Shapes Layer and Blend If: both change the shape
+// the maps are built from (a layer's own, or a styled group's children composite) without
+// touching pixels, masks or effects, and stale maps kept stroking a hole the layer no longer
+// had. Each case renders with the cache warm, edits, renders again and compares with a cold
+// render. (A purge by a concurrent test only makes the warm render cold, never a false failure.)
+#[test]
+fn effect_cache_follows_transparency_shapes_layer() {
+    let mut d = doc_white(32, 32);
+    let mut l = solid_layer("holed", Rect::new(0, 0, 32, 32), [0.9, 0.2, 0.2, 1.0]);
+    l.surface_mut().unwrap().fill_rect(Rect::new(12, 12, 20, 20), &[0.0, 0.0, 0.0, 0.0]);
+    l.effects.items = vec![stroke(2.0, StrokePosition::Outside)];
+    assert!(l.advanced.transparency_shapes);
+    d.layers.push(l);
+    let on = render(&d, d.bounds());
+    d.layers[1].advanced.transparency_shapes = false;
+    let warm = render(&d, d.bounds());
+    purge_effect_cache();
+    let cold = render(&d, d.bounds());
+    assert!(on.px != cold.px, "the stroke should stop rimming the hole");
+    assert!(warm.px == cold.px, "stale effect maps after turning Transparency Shapes Layer off");
+}
+
+#[test]
+fn effect_cache_follows_a_group_childs_blend_if() {
+    let mut d = doc_white(32, 32);
+    let mut child = solid_layer("bw", Rect::new(4, 4, 16, 28), [0.0, 0.0, 0.0, 1.0]);
+    child.surface_mut().unwrap().fill_rect(Rect::new(16, 4, 28, 28), &[1.0, 1.0, 1.0, 1.0]);
+    let mut g = Layer::group("g", vec![child]);
+    g.effects.items = vec![Effect::DropShadow(Shadow { size: 2.0, spread: 0.0, ..shadow(3.0, 90.0) })];
+    d.layers.push(g);
+    let before = render(&d, d.bounds());
+    let LayerContent::Group(grp) = &mut d.layers[1].content else { panic!("not a group") };
+    // Gray › This Layer: black point at 128 hides the black half.
+    grp.children[0].blend_if.set(0, [range([128, 128], [255, 255]), FULL]);
+    let warm = render(&d, d.bounds());
+    purge_effect_cache();
+    let cold = render(&d, d.bounds());
+    assert!(before.px != cold.px, "Blend If should change the group's shadow");
+    assert!(warm.px == cold.px, "stale group effect maps after a child's Blend If changed");
+}
+
+#[test]
+fn shape_layer_bounds_includes_vector_bounds_clipped_to_canvas_and_preserves_effects() {
+    let canvas = Rect::new(0, 0, 100, 100);
+    let subpath = photocraft_doc::vector::Subpath::polygon(&[(-20.0, -20.0), (50.0, -20.0), (50.0, 50.0), (-20.0, 50.0)]);
+    let path = photocraft_doc::vector::Path { subpaths: vec![subpath], ..Default::default() };
+    let sh = photocraft_doc::vector::ShapeLayer {
+        path,
+        fill: Some(photocraft_doc::Fill::Solid(photocraft_doc::Color::BLACK)),
+        stroke: Some(photocraft_doc::vector::ShapeStroke { width: 4.0, opacity: 1.0, ..Default::default() }),
+        ..Default::default()
+    };
+    let mut layer = Layer::new("shape", LayerContent::Shape(sh));
+
+    // Vector bounds reach outside canvas (-24..54), but layer_bounds clips vector bounds to canvas:
+    let b = layer_bounds(&layer, canvas);
+    assert_eq!(b, Rect::new(0, 0, 54, 54), "shape vector bounds must clip to canvas and not reach past it");
+
+    // When the shape has layer effects, layer_bounds preserves effects union handling:
+    layer.effects.items = vec![Effect::DropShadow(Shadow { size: 5.0, spread: 0.0, ..shadow(5.0, 90.0) })];
+    let b_fx = layer_bounds(&layer, canvas);
+    assert!(!b_fx.is_empty());
+    assert!(b_fx.contains_rect(&b));
+}
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index c92b6db735..c4f7f523d1 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -99,6 +99,32 @@ pub struct Locks {
 }
 
 impl Locks {
+    /// Set the lock a command names (`transparency`, `pixels`, `position`, `artboard`, `all`);
+    /// false for an unknown name. Lock Image Pixels includes Lock Transparent Pixels, so, as in
+    /// Photoshop, locking the pixels clears the transparency lock, and that one stays off while the
+    /// pixels are locked (#4892).
+    pub fn set(&mut self, key: &str, on: bool) -> bool {
+        match key {
+            "transparency" => self.transparency = on && !self.pixels,
+            "pixels" => {
+                self.pixels = on;
+                if on {
+                    self.transparency = false;
+                }
+            }
+            "position" => self.position = on,
+            "artboard" => self.artboard = on,
+            "all" => self.all = on,
+            _ => return false,
+        }
+        true
+    }
+
+    /// Whether any lock is set: Photoshop then shows the lock icon on the layer's row.
+    pub fn any(self) -> bool {
+        self.transparency || self.pixels || self.position || self.artboard || self.all
+    }
+
     pub fn union(self, o: Locks) -> Locks {
         Locks {
             transparency: self.transparency || o.transparency,
@@ -636,6 +662,13 @@ pub struct Layer {
 }
 
 impl Layer {
+    /// Whether the layer has the Background's own properties: an unclipped pixel layer with
+    /// transparency and position locked. Only the bottom layer of a document with them is the
+    /// Background: use [`Document::background`] / [`Document::is_background`] to identify it.
+    pub fn has_background_traits(&self) -> bool {
+        self.locks.transparency && self.locks.position && !self.clipped && matches!(self.content, LayerContent::Raster(_))
+    }
+
     pub fn new(name: impl Into<String>, content: LayerContent) -> Self {
         Layer {
             id: LayerId::fresh(),
@@ -832,6 +865,10 @@ pub struct Document {
     pub layers: Vec<Layer>,
     pub channels: Vec<AlphaChannel>,
     pub guides: Guides,
+    /// The rulers' zero point in document pixels (`[x, y]`), dragged from the ruler corner. The
+    /// rulers, the Info panel and other position readouts measure from it; `[0, 0]` (the
+    /// image's top-left) is the default.
+    pub ruler_origin: [f64; 2],
     /// Active selection as a grayscale coverage surface (None = no selection).
     pub selection: Option<Surface>,
     pub metadata: Metadata,
@@ -875,6 +912,32 @@ pub struct Document {
     pub variables: Variables,
     /// Window › Timeline (None until a video timeline is created).
     pub timeline: Option<Timeline>,
+    /// How the document's lossy file was encoded (its JPEG quality, WebP lossy or lossless), so
+    /// a save writes it back the same way rather than at fixed defaults.
+    pub file_encoding: FileEncoding,
+}
+
+/// The encoder settings a document's file was opened or saved with: what File › Save and the
+/// Save As defaults reuse for that format. Empty for a new document or a file without lossy
+/// options. Qualities are on the codecs' 1–100 scale.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct FileEncoding {
+    /// JPEG quality (estimated from the file's quantisation tables on open).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jpeg_quality: Option<u8>,
+    /// WebP: `Some(true)` lossless (VP8L), `Some(false)` lossy (VP8 at [`Self::webp_quality`]).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub webp_lossless: Option<bool>,
+    /// Lossy WebP quality.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub webp_quality: Option<u8>,
+}
+
+impl FileEncoding {
+    pub fn is_empty(&self) -> bool {
+        *self == FileEncoding::default()
+    }
 }
 
 /// Where a layer lives in the tree: indices from the root down.
@@ -893,6 +956,7 @@ impl Document {
             layers: Vec::new(),
             channels: Vec::new(),
             guides: Guides::default(),
+            ruler_origin: [0.0, 0.0],
             selection: None,
             metadata: Metadata::default(),
             global_light: GlobalLight::default(),
@@ -913,6 +977,7 @@ impl Document {
             slices: Slices::default(),
             variables: Variables::default(),
             timeline: None,
+            file_encoding: FileEncoding::default(),
         }
     }
 
@@ -1008,11 +1073,35 @@ impl Document {
         (1..=path.len()).filter_map(|n| self.layer_at(path.get(..n)?)).fold(Locks::default(), |a, l| a.union(l.locks))
     }
 
+    /// Whether the layer at `path` is shown: it and every group around it are visible.
+    pub fn shown_at(&self, path: &[usize]) -> bool {
+        (1..=path.len()).all(|n| path.get(..n).and_then(|p| self.layer_at(p)).is_some_and(|l| l.visible))
+    }
+
     /// [`Self::locks_at`] for the layer `id`.
     pub fn effective_locks(&self, id: LayerId) -> Locks {
         self.path_of(id).map_or_else(Locks::default, |p| self.locks_at(&p))
     }
 
+    /// The Background layer, identified structurally as Photoshop does, never by its name (a file
+    /// from a German or Japanese Photoshop names it "Hintergrund" or "背景"): the bottom layer of
+    /// the stack, a pixel layer that is not clipped, with transparency and position locked (a PSD
+    /// stores it without a transparency channel and transparency-protected; File › New and opaque
+    /// flat files create it the same way).
+    pub fn background(&self) -> Option<&Layer> {
+        self.layers.first().filter(|l| Layer::has_background_traits(l))
+    }
+
+    /// [`Self::background`], mutably.
+    pub fn background_mut(&mut self) -> Option<&mut Layer> {
+        self.layers.first_mut().filter(|l| Layer::has_background_traits(l))
+    }
+
+    /// Whether `id` is the document's Background layer ([`Self::background`]).
+    pub fn is_background(&self, id: LayerId) -> bool {
+        self.background().is_some_and(|b| b.id == id)
+    }
+
     pub fn layer(&self, id: LayerId) -> Option<&Layer> {
         fn rec(layers: &[Layer], id: LayerId) -> Option<&Layer> {
             layers.iter().find_map(|l| if l.id == id { Some(l) } else { l.children().and_then(|ch| rec(ch, id)) })
@@ -1085,6 +1174,16 @@ impl Document {
         id
     }
 
+    /// Insert `layer` directly below the layer `below` (or at the bottom of the root if None).
+    pub fn insert_below(&mut self, below: Option<LayerId>, layer: Layer) -> LayerId {
+        let id = layer.id;
+        match below.and_then(|b| self.path_of(b)).and_then(|path| self.siblings_mut(&path)) {
+            Some((sib, idx)) => sib.insert(idx, layer),
+            None => self.layers.insert(0, layer),
+        }
+        id
+    }
+
     pub fn remove(&mut self, id: LayerId) -> Option<Layer> {
         let path = self.path_of(id)?;
         let (sib, idx) = self.siblings_mut(&path)?;
@@ -1142,6 +1241,19 @@ mod tests {
         Document::with_background("t", Size::new(100, 50), ColorMode::Rgb, SampleType::U8, Color::WHITE)
     }
 
+    #[test]
+    fn any_lock_counts_every_lock() {
+        assert!(!Locks::default().any());
+        let each = [
+            Locks { transparency: true, ..Locks::default() },
+            Locks { pixels: true, ..Locks::default() },
+            Locks { position: true, ..Locks::default() },
+            Locks { artboard: true, ..Locks::default() },
+            Locks { all: true, ..Locks::default() },
+        ];
+        assert!(each.iter().all(|k| k.any()));
+    }
+
     #[test]
     fn unused_link_group_never_wraps() {
         let mut d = doc();
@@ -1178,6 +1290,30 @@ mod tests {
         assert_eq!(s.pixel(100, 0), vec![0.0; 4]);
     }
 
+    /// The Background is the locked bottom pixel layer, whatever it is called.
+    #[test]
+    fn background_is_structural_not_named() {
+        let mut d = doc();
+        let id = d.layers[0].id;
+        assert!(d.is_background(id));
+        for name in ["Hintergrund", "背景", "Arrière-plan"] {
+            d.layers[0].name = name.into();
+            assert_eq!(d.background().map(|l| l.id), Some(id), "{name}");
+        }
+        // A layer called "Background" without the locks, or above the bottom, is not it.
+        let mut top = Layer::raster("Background", d.pixel_format());
+        top.locks.transparency = true;
+        top.locks.position = true;
+        let top_id = top.id;
+        d.layers.push(top);
+        assert!(!d.is_background(top_id));
+        d.layers[0].locks.position = false;
+        assert!(d.background().is_none());
+        d.layers[0].locks.position = true;
+        d.layers[0].clipped = true;
+        assert!(d.background_mut().is_none());
+    }
+
     #[test]
     fn max_group_depth_counts_nesting_without_recursing() {
         let mut d = doc();
@@ -1245,6 +1381,17 @@ mod tests {
         assert!(d.layer(a).is_none());
     }
 
+    #[test]
+    fn insert_below_lands_under_the_reference() {
+        let mut d = doc();
+        let bg = d.layers[0].id;
+        let a = d.insert_above(Some(bg), Layer::raster("A", d.pixel_format()));
+        let b = d.insert_below(Some(a), Layer::raster("B", d.pixel_format()));
+        let names: Vec<_> = d.layers.iter().map(|l| l.name.as_str()).collect();
+        assert_eq!(names, ["Background", "B", "A"]);
+        assert_eq!(d.layers[1].id, b);
+    }
+
     #[test]
     fn groups_walk_and_paths() {
         let mut d = doc();
diff --git a/crates/doc/src/pattern.rs b/crates/doc/src/pattern.rs
index 47279e2c86..9a43c0a467 100644
--- a/crates/doc/src/pattern.rs
+++ b/crates/doc/src/pattern.rs
@@ -5,6 +5,13 @@
 use photocraft_geom::Rect;
 use photocraft_raster::Surface;
 
+/// Largest pattern edge a file may declare (the PSD reader's limit; Define Pattern stops at 4000).
+pub const MAX_EDGE: u32 = 30_000;
+
+/// Most pixels a pattern may have to be painted. Renderers expand a pattern into a 16-byte-per-pixel
+/// working copy, so this keeps that copy at 1 GiB; larger patterns paint nothing.
+pub const MAX_PAINT_PIXELS: u64 = 1 << 26;
+
 /// One pattern tile. Pixels cover `0..width × 0..height` of `surface`, in any pixel format
 /// (depth and colour model are the pattern's own, as in Photoshop).
 #[derive(Clone, Debug, PartialEq)]
@@ -57,6 +64,16 @@ impl Pattern {
     pub fn is_empty(&self) -> bool {
         self.width == 0 || self.height == 0
     }
+
+    /// Pixels in the tile (`width × height`, never overflowing).
+    pub fn pixel_count(&self) -> u64 {
+        u64::from(self.width) * u64::from(self.height)
+    }
+
+    /// Whether the tile has pixels and is small enough to paint (see [`MAX_PAINT_PIXELS`]).
+    pub fn is_paintable(&self) -> bool {
+        !self.is_empty() && self.pixel_count() <= MAX_PAINT_PIXELS
+    }
 }
 
 /// Display form of a stored pattern name (see [`Pattern::display_name`]).
diff --git a/crates/doc/src/text.rs b/crates/doc/src/text.rs
index fc586e3c2c..6f7836fa46 100644
--- a/crates/doc/src/text.rs
+++ b/crates/doc/src/text.rs
@@ -209,13 +209,18 @@ pub struct ParagraphRun {
 }
 
 /// Point text grows from its anchor (text-space origin = first baseline at the anchor);
-/// paragraph (box) text wraps inside a rectangle.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
+/// paragraph (box) text wraps inside a rectangle; path text runs along a curve.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub enum TextShape {
     #[default]
     Point,
     /// Text-space pixels, before the layer transform.
     Box { x: f32, y: f32, width: f32, height: f32 },
+    /// Type on a path: one line laid out like point text, then each glyph is placed on `path`
+    /// (text-space pixels, before the layer transform) by arc length and turned to follow the
+    /// curve. `start` is the arc-length offset (px) of the text origin along the path; `flip`
+    /// puts the text on the other side of the path.
+    Path { path: super::vector::Subpath, start: f32, flip: bool },
 }
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index d15e0f985a..741d927a3f 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -34,6 +34,8 @@ photocraft-plugins = { workspace = true }
 blake3 = { version = "1.8", default-features = false, features = ["pure"] }
 photocraft-codecs = { workspace = true }
 flate2 = { workspace = true }
+craft-print = { workspace = true }
+
 # Photoshop `.kys` shortcut sets (`edit.keyboardShortcuts` `importKys`); already in the tree
 # through photocraft-ui-egui and usvg.
 roxmltree = "0.20"
diff --git a/crates/engine/examples/bench_blur_tool.rs b/crates/engine/examples/bench_blur_tool.rs
new file mode 100644
index 0000000000..c470263440
--- /dev/null
+++ b/crates/engine/examples/bench_blur_tool.rs
@@ -0,0 +1,62 @@
+//! Reproducible soft Blur strokes on a 24 MP striped document. Run in release mode.
+//! Setup, Undo and the output fingerprint are excluded from the timing.
+use std::time::Instant;
+
+use photocraft_engine::{EngineError, Session};
+use photocraft_geom::Rect;
+use serde_json::json;
+
+fn run() -> Result<(), Box<dyn std::error::Error>> {
+    for depth in [8, 16, 32] {
+        let mut session = Session::new();
+        session.execute("file.new", json!({"width":6000,"height":4000,"depth":depth,"mode":"rgb"}))?;
+        session.execute("layer.new.layer", json!({}))?;
+        session.edit("stripes", |doc, active| {
+            let id = active.ok_or_else(|| EngineError::Other("no layer".into()))?;
+            let surface = doc.layer_mut(id).and_then(|l| l.surface_mut()).ok_or_else(|| EngineError::Other("no surface".into()))?;
+            for x in (0..6000).step_by(64) {
+                let color = if x % 128 == 0 { [0.9, 0.3, 0.1, 1.0] } else { [0.1, 0.4, 0.8, 1.0] };
+                surface.fill_rect(Rect::new(x, 0, (x + 64).min(6000), 4000), &color);
+            }
+            Ok(())
+        })?;
+        for size in [100, 500, 1000] {
+            let params = json!({"points":[[2500,2000],[3500,2000]],"size":size,"hardness":20,"strength":50,"spacing":25});
+            let mut times = Vec::new();
+            let mut fingerprint = 0u64;
+            for sample in 0..6 {
+                let start = Instant::now();
+                session.execute("paint.blur", params.clone())?;
+                let ms = start.elapsed().as_secs_f64() * 1000.0;
+                if sample > 0 {
+                    times.push(ms);
+                }
+                if sample == 5 {
+                    let st = session.active().ok_or("no document")?;
+                    let surface = st.doc.layer(st.active_layer.ok_or("no layer")?).and_then(|l| l.surface()).ok_or("no surface")?;
+                    for y in (1500..2500).step_by(17) {
+                        for x in (2000..4000).step_by(13) {
+                            for channel in surface.rgba(x, y) {
+                                fingerprint = fingerprint.wrapping_mul(16777619) ^ u64::from(channel.to_bits());
+                            }
+                        }
+                    }
+                }
+                session.execute("edit.undo", json!({}))?;
+            }
+            times.sort_by(f64::total_cmp);
+            println!(
+                "depth={depth} size={size} median_ms={:.3} min_ms={:.3} max_ms={:.3} sampled_fingerprint={fingerprint:016x}",
+                times[2], times[0], times[4]
+            );
+        }
+    }
+    Ok(())
+}
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("{error}");
+        std::process::exit(1);
+    }
+}
diff --git a/crates/engine/examples/bench_web_palette.rs b/crates/engine/examples/bench_web_palette.rs
new file mode 100644
index 0000000000..5ed1c3a3b0
--- /dev/null
+++ b/crates/engine/examples/bench_web_palette.rs
@@ -0,0 +1,30 @@
+//! Compare generated-palette and edited fixed-palette GIF exports on a 24 MP image.
+//! cargo run --release -p photocraft-engine --example bench_web_palette
+use std::time::Instant;
+
+use photocraft_engine::web_cmds::{WebSettings, optimize};
+use photocraft_geom::Rect;
+use serde_json::json;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (w, h) = (6000usize, 4000usize);
+    let mut pixels = Vec::new();
+    pixels.try_reserve_exact(w * h)?;
+    for y in 0..h {
+        for x in 0..w {
+            pixels.push([x as f32 / w as f32, 0.5 + ((x + y) as f32 * 0.002).sin() * 0.3, y as f32 / h as f32, 1.0]);
+        }
+    }
+    let settings = WebSettings::from_params(&json!({"format": "gif", "colors": 128, "dither": "diffusion"}), "bench")?;
+    let rect = Rect::new(0, 0, w as i32, h as i32);
+    let started = Instant::now();
+    let original = optimize(&pixels, w, rect, &settings, None, None, 72.0, false)?;
+    println!("24 MP generated palette: {:.1} ms", started.elapsed().as_secs_f64() * 1000.0);
+    let mut edited = settings;
+    edited.color_table = Some(original.color_table);
+    edited.color_table_edits.insert(0, [0, 255, 0]);
+    let started = Instant::now();
+    let result = optimize(&pixels, w, rect, &edited, None, None, 72.0, false)?;
+    println!("24 MP edited fixed palette: {:.1} ms ({} bytes)", started.elapsed().as_secs_f64() * 1000.0, result.bytes.len());
+    Ok(())
+}
diff --git a/crates/engine/src/actions_cmds.rs b/crates/engine/src/actions_cmds.rs
index 9b4a758d9a..3b3ffd1f01 100644
--- a/crates/engine/src/actions_cmds.rs
+++ b/crates/engine/src/actions_cmds.rs
@@ -36,11 +36,26 @@ pub struct Action {
     /// Indices of steps excluded from playback (unchecked in the Actions panel).
     #[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
     pub disabled: BTreeSet<usize>,
+    /// Indices of steps whose dialog Photoshop shows during playback (the panel's dialog
+    /// toggle column). Headless playback runs them with their recorded params; the flag is
+    /// kept so Save Actions writes it back.
+    #[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
+    pub dialogs: BTreeSet<usize>,
+    /// The action set the action belongs to: the folder Photoshop shows in the Actions panel,
+    /// filled by Load Actions (`actions.load`) and written by Save Actions (`actions.save`).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub set: Option<String>,
 }
 
 impl Action {
     pub fn new(name: impl Into<String>, steps: Vec<(String, Value)>) -> Self {
-        Self { name: name.into(), steps, disabled: BTreeSet::new() }
+        Self { name: name.into(), steps, disabled: BTreeSet::new(), dialogs: BTreeSet::new(), set: None }
+    }
+
+    /// Apply `f` to every per-step index set (`disabled`, `dialogs`) after steps moved.
+    pub(crate) fn remap_steps(&mut self, f: impl Fn(usize) -> Option<usize>) {
+        self.disabled = self.disabled.iter().filter_map(|&i| f(i)).collect();
+        self.dialogs = self.dialogs.iter().filter_map(|&i| f(i)).collect();
     }
 
     pub fn step_enabled(&self, step: usize) -> bool {
@@ -100,10 +115,11 @@ pub fn replayable(id: &str) -> bool {
             && (shell_view_command(id) || shell_save_command(id) || crate::commands::find(id).is_some_and(|c| c.journal)))
 }
 
-/// File › Save and Save As, recorded by the desktop shell once the save has a path (#2032).
-/// The shell replays them; batch and droplets write to their destination folder instead.
+/// File › Save, Save As and Save a Copy, recorded by the desktop shell once the save has a path
+/// (#2032, #4373). The shell replays them; batch and droplets write to their destination folder
+/// instead.
 pub fn shell_save_command(id: &str) -> bool {
-    matches!(id, "file.save" | "file.saveAs")
+    matches!(id, "file.save" | "file.saveAs" | "file.saveACopy")
 }
 
 /// View-only menu commands recorded by the desktop shell. Headless playback reports
@@ -166,7 +182,7 @@ fn num(v: &Value) -> Option<i64> {
     v.as_i64().or_else(|| v.as_f64().filter(|f| f.is_finite()).map(|f| f.round() as i64))
 }
 
-fn resolve(list: &[Action], p: &Value, cmd: &str) -> Result<usize> {
+pub(crate) fn resolve(list: &[Action], p: &Value, cmd: &str) -> Result<usize> {
     let Some(v) = p.get("action") else {
         return Err(bad(cmd, "needs \"action\" (a name or an index)"));
     };
@@ -210,7 +226,7 @@ fn from_step(p: &Value, len: usize) -> Result<usize> {
 }
 
 fn list(s: &mut Session, _p: &Value) -> Result<Value> {
-    let actions: Vec<Value> = s.actions.list.iter().map(|a| json!({"name": a.name, "steps": a.steps.len()})).collect();
+    let actions: Vec<Value> = s.actions.list.iter().map(|a| json!({"name": a.name, "steps": a.steps.len(), "set": a.set})).collect();
     let recording = s.actions.recording.and_then(|(_, i)| s.actions.list.get(i).map(|a| a.name.clone()));
     Ok(json!({"actions": actions, "recording": recording}))
 }
@@ -219,7 +235,7 @@ fn get(s: &mut Session, p: &Value) -> Result<Value> {
     let idx = resolve(&s.actions.list, p, "actions.get")?;
     let action = &s.actions.list[idx];
     let steps: Vec<Value> = action.steps.iter().map(|(id, params)| json!([id, params])).collect();
-    Ok(json!({"name": action.name, "steps": steps, "disabled": action.disabled}))
+    Ok(json!({"name": action.name, "steps": steps, "disabled": action.disabled, "dialogs": action.dialogs, "set": action.set}))
 }
 
 fn record(s: &mut Session, p: &Value) -> Result<Value> {
@@ -260,7 +276,7 @@ pub fn pending_steps(s: &Session, action: usize) -> impl Iterator<Item = &(Strin
     s.journal.iter().skip(from).filter(|(id, _)| replayable(id))
 }
 
-fn flush_recording(s: &mut Session) -> Result<()> {
+pub(crate) fn flush_recording(s: &mut Session) -> Result<()> {
     let Some((_, idx)) = s.actions.recording else { return Ok(()) };
     if idx >= s.actions.list.len() {
         return Err(bad("actions.stop", "the action being recorded no longer exists"));
@@ -338,7 +354,7 @@ pub fn finish_playback(s: &mut Session, recording: Option<(usize, usize)>, actio
 /// Nested playback returns a structured failure even though the command itself succeeded.
 /// Promote it to the caller's failed step so no later parent steps run after a child fails.
 pub fn nested_failure(id: &str, value: &Value) -> Option<String> {
-    (id == "actions.play").then(|| value.get("failed")).flatten().map(|failure| {
+    (id == "actions.play" || id == "actions.conditional").then(|| value.get("failed")).flatten().map(|failure| {
         format!(
             "action `{}` step {} failed: {}",
             value.get("action").and_then(Value::as_str).unwrap_or(""),
@@ -359,7 +375,7 @@ fn play(s: &mut Session, p: &Value) -> Result<Value> {
     })
 }
 
-fn not_playing(s: &Session, cmd: &str) -> Result<()> {
+pub(crate) fn not_playing(s: &Session, cmd: &str) -> Result<()> {
     if s.actions.playing > 0 { Err(bad(cmd, "cannot edit actions during playback")) } else { Ok(()) }
 }
 
@@ -386,7 +402,7 @@ fn move_item(s: &mut Session, p: &Value) -> Result<Value> {
         let action = &mut s.actions.list[idx];
         let moved = action.steps.remove(step);
         action.steps.insert(to, moved);
-        action.disabled = action.disabled.iter().map(|&i| moved_index(i, step, to)).collect();
+        action.remap_steps(|i| Some(moved_index(i, step, to)));
         let result = json!({"action": action.name, "step": to});
         s.actions.touch();
         Ok(result)
@@ -434,7 +450,15 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
         }
         let action = &mut s.actions.list[idx];
         action.steps.remove(step);
-        action.disabled = action.disabled.iter().filter(|&&i| i != step).map(|&i| if i > step { i - 1 } else { i }).collect();
+        action.remap_steps(|i| {
+            if i == step {
+                None
+            } else if i > step {
+                Some(i - 1)
+            } else {
+                Some(i)
+            }
+        });
         let result = json!({"action": action.name, "deletedStep": step, "steps": action.steps.len()});
         s.actions.touch();
         return Ok(result);
@@ -546,7 +570,7 @@ pub fn specs() -> Vec<CommandSpec> {
             label: "List Actions",
             menu: &[],
             shortcut: None,
-            params: "{} → {actions:[{name, steps:count}], recording:name|null}",
+            params: "{} → {actions:[{name, steps:count, set:name|null}], recording:name|null}",
             enabled: always,
             run: list,
             journal: false,
@@ -556,7 +580,7 @@ pub fn specs() -> Vec<CommandSpec> {
             label: "Get Action",
             menu: &[],
             shortcut: None,
-            params: r##"{"action":name|index} → {name, steps:[[id, params]…], disabled:[step…]} (steps is the shape file.automate.batch and droplets take; disabled lists the 0-based steps playback skips)"##,
+            params: r##"{"action":name|index} → {name, steps:[[id, params]…], disabled:[step…], dialogs:[step…], set:name|null} (steps is the shape file.automate.batch and droplets take; disabled lists the 0-based steps playback skips; dialogs the steps whose dialog Photoshop would show; set the action set from Load Actions)"##,
             enabled: always,
             run: get,
             journal: false,
@@ -679,11 +703,17 @@ mod tests {
     #[test]
     fn rename_keeps_calls_and_function_key_and_rejects_bad_names() {
         let mut s = Session::new();
-        s.actions.list.push(Action { name: "Action 1".into(), steps: vec![("layer.new.layer".into(), json!({}))], disabled: Default::default() });
+        s.actions.list.push(Action {
+            name: "Action 1".into(),
+            steps: vec![("layer.new.layer".into(), json!({}))],
+            disabled: Default::default(),
+            ..Default::default()
+        });
         s.actions.list.push(Action {
             name: "Caller".into(),
             steps: vec![("actions.play".into(), json!({"action": "Action 1"}))],
             disabled: Default::default(),
+            ..Default::default()
         });
         s.edit_prefs(|p| p.shortcuts.insert(format!("{PLAY_SHORTCUT_PREFIX}Action 1"), "F2".into()));
         assert_eq!(s.execute("actions.rename", json!({"action": 0, "name": "Sepia"})).unwrap()["action"], "Sepia");
@@ -950,7 +980,12 @@ mod tests {
     #[test]
     fn play_refuses_recursion() {
         let mut s = Session::new();
-        s.actions.list.push(Action { name: "Loop".into(), steps: vec![("actions.play".into(), json!({"action": "Loop"}))], disabled: Default::default() });
+        s.actions.list.push(Action {
+            name: "Loop".into(),
+            steps: vec![("actions.play".into(), json!({"action": "Loop"}))],
+            disabled: Default::default(),
+            ..Default::default()
+        });
         let r = s.execute("actions.play", json!({"action": "Loop"})).unwrap();
         assert_eq!(r["ran"], 0);
         assert_eq!(r["failed"]["id"], "actions.play");
@@ -969,6 +1004,7 @@ mod tests {
             name: "Open".into(),
             steps: vec![("file.open".into(), json!({"path": "/etc/passwd"})), ("layer.new.layer".into(), json!({}))],
             disabled: Default::default(),
+            ..Default::default()
         });
         let r = s.execute("actions.play", json!({"action": "Open"})).unwrap();
         assert_eq!(r["ran"], 0);
@@ -1046,6 +1082,7 @@ mod tests {
             name: "Child".into(),
             steps: vec![("layer.new.layer".into(), json!({"name": "Child layer"}))],
             disabled: Default::default(),
+            ..Default::default()
         });
         s.execute("actions.record", json!({"name": "Parent"})).unwrap();
         s.execute("layer.new.layer", json!({"name": "Before"})).unwrap();
@@ -1075,8 +1112,14 @@ mod tests {
             name: "A".into(),
             steps: vec![("actions.play".into(), json!({"action": "B"})), ("file.new".into(), json!({"width": 2,"height": 2}))],
             disabled: Default::default(),
+            ..Default::default()
+        });
+        s.actions.list.push(Action {
+            name: "B".into(),
+            steps: vec![("actions.play".into(), json!({"action": "A"}))],
+            disabled: Default::default(),
+            ..Default::default()
         });
-        s.actions.list.push(Action { name: "B".into(), steps: vec![("actions.play".into(), json!({"action": "A"}))], disabled: Default::default() });
         let r = s.execute("actions.play", json!({"action": "A"})).unwrap();
         assert!(r["failed"]["error"].as_str().unwrap().contains("recursive"));
         assert!(s.documents().is_empty());
@@ -1092,6 +1135,7 @@ mod tests {
                 name: format!("N{i}"),
                 steps: if i < 16 { vec![("actions.play".into(), json!({"action":format!("N{}", i + 1)}))] } else { vec![] },
                 disabled: Default::default(),
+                ..Default::default()
             });
         }
         let r = s.execute("actions.play", json!({"action": "N0"})).unwrap();
@@ -1136,7 +1180,7 @@ mod tests {
     #[test]
     fn new_names_do_not_collide_with_named_calls() {
         let mut s = Session::new();
-        s.actions.list.push(Action { name: "Action 2".into(), steps: vec![], disabled: Default::default() });
+        s.actions.list.push(Action { name: "Action 2".into(), steps: vec![], disabled: Default::default(), ..Default::default() });
         assert_eq!(s.execute("actions.record", json!({})).unwrap()["action"], "Action 3");
         s.execute("actions.stop", json!({})).unwrap();
         assert!(s.execute("actions.record", json!({"name":"Action 2"})).is_err());
@@ -1148,7 +1192,7 @@ mod tests {
         let mut s = Session::new();
         s.execute("file.new", json!({"width":4,"height":4})).unwrap();
         for name in ["A", "B", "C"] {
-            s.actions.list.push(Action { name: name.into(), steps: vec![], disabled: Default::default() });
+            s.actions.list.push(Action { name: name.into(), steps: vec![], disabled: Default::default(), ..Default::default() });
         }
         s.execute("actions.record", json!({"action":"B"})).unwrap();
         s.execute("layer.new.layer", json!({"name":"before"})).unwrap();
@@ -1224,4 +1268,44 @@ mod tests {
         assert!(bad.actions.list.is_empty());
         let _ = std::fs::remove_dir_all(&dir);
     }
+
+    /// AUTO-219-4: a recording made on one document replays on a second one — a crop, a filter,
+    /// a selection fill and styled text all act on the document the replay runs in.
+    #[test]
+    fn a_recorded_edit_run_replays_on_a_second_document() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 64, "height": 64, "background": "white"})).unwrap();
+        s.execute("actions.record", json!({"name": "Studio"})).unwrap();
+        s.execute("image.crop", json!({"x": 8, "y": 8, "width": 48, "height": 48})).unwrap();
+        s.execute("filter.blur.gaussianBlur", json!({"radius": 2})).unwrap();
+        s.execute("select.rect", json!({"x": 10, "y": 10, "width": 12, "height": 12})).unwrap();
+        s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+        s.execute("select.deselect", json!({})).unwrap();
+        s.execute("type.create", json!({"x": 10, "y": 36, "text": "Hi", "size": 12, "color": "#000000"})).unwrap();
+        s.execute("type.setStyle", json!({"fauxBold": true})).unwrap();
+        let stopped = s.execute("actions.stop", json!({})).unwrap();
+        let steps = stopped["steps"].as_u64().unwrap();
+        assert!(steps >= 7, "the recording keeps every family: {stopped}");
+
+        // The second document: a different size, background and name. The replay must act here.
+        s.execute("file.new", json!({"width": 100, "height": 80, "background": "black", "name": "Second"})).unwrap();
+        let played = s.execute("actions.play", json!({"action": "Studio"})).unwrap();
+        assert!(played.get("failed").is_none(), "replay: {played}");
+        assert_eq!(played["ran"].as_u64(), Some(steps), "every step ran: {played}");
+        let d = &s.active().unwrap().doc;
+        assert_eq!((d.size.width, d.size.height), (48, 48), "the crop replayed onto the second document");
+        assert_eq!(pixel(&s, 0, 16, 16), vec![1.0, 0.0, 0.0, 1.0], "the selection fill replayed");
+        assert_eq!(pixel(&s, 0, 2, 2), vec![0.0, 0.0, 0.0, 1.0], "outside the selection stays black");
+        let last = d.layers.last().unwrap();
+        match &last.content {
+            photocraft_doc::LayerContent::Text(t) => {
+                assert_eq!(t.text, "Hi", "the styled text replayed");
+                assert!(t.char_runs().iter().any(|r| r.style.faux_bold), "the bold run replayed");
+            }
+            other => panic!("expected the recorded type layer, got {other:?}"),
+        }
+        // The first document is untouched.
+        let first = &s.documents()[0].doc;
+        assert_eq!((first.size.width, first.size.height), (48, 48), "the recording document keeps its own crop");
+    }
 }
diff --git a/crates/engine/src/actions_edit_cmds.rs b/crates/engine/src/actions_edit_cmds.rs
new file mode 100644
index 0000000000..1f9cce3431
--- /dev/null
+++ b/crates/engine/src/actions_edit_cmds.rs
@@ -0,0 +1,457 @@
+//! Editing an action's steps and its set, as the Actions panel does beyond recording:
+//! `actions.insert` (Photoshop's Insert Stop… and Insert Menu Item…), `actions.dialog` (the
+//! panel's dialog toggle column) and `actions.assignSet` (which set folder an action sits in).
+//!
+//! All three refuse to run during playback, commit pending recorded steps first, and keep the
+//! per-step flag sets (`disabled`, `dialogs`) in step with the moved indices, like
+//! `actions.move` and `actions.delete`.
+
+use serde_json::{Value, json};
+
+use crate::actions_cmds::{flush_recording, not_playing, pending_steps, resolve};
+use crate::commands::CommandSpec;
+use crate::{EngineError, Result, Session};
+
+fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
+    EngineError::BadParams { cmd: cmd.into(), msg: msg.into() }
+}
+
+fn always(_: &Session) -> std::result::Result<(), String> {
+    Ok(())
+}
+
+fn index(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(|n| usize::try_from(n).ok()).map(Some).ok_or_else(|| bad(cmd, format!("`{key}` must be a non-negative integer"))),
+    }
+}
+
+/// Whether `id` can be a step: a registered command, a Play Action call, or one of the desktop
+/// shell's recorded save/view commands.
+fn is_step_command(id: &str) -> bool {
+    crate::commands::find(id).is_some() || id == "actions.play" || crate::actions_cmds::shell_save_command(id) || crate::actions_cmds::shell_view_command(id)
+}
+
+fn insert(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "actions.insert";
+    not_playing(s, cmd)?;
+    let idx = resolve(&s.actions.list, p, cmd)?;
+    let id = match p.get("id") {
+        Some(Value::String(id)) if !id.trim().is_empty() => id.trim().to_string(),
+        _ => return Err(bad(cmd, "needs `id`, the command the step runs")),
+    };
+    if !is_step_command(&id) {
+        return Err(bad(cmd, format!("unknown command `{id}`")));
+    }
+    let params = match p.get("params") {
+        None | Some(Value::Null) => json!({}),
+        Some(v @ Value::Object(_)) => v.clone(),
+        Some(_) => return Err(bad(cmd, "`params` must be an object")),
+    };
+    if id == "actions.play" {
+        // Refuse the one cycle visible here; deeper ones are caught at playback.
+        let target = params.get("action");
+        let is_self = target.and_then(Value::as_str) == Some(s.actions.list[idx].name.as_str()) || target.and_then(Value::as_u64) == Some(idx as u64);
+        if is_self {
+            return Err(bad(cmd, "an action cannot play itself"));
+        }
+    }
+    let len = s.actions.list[idx].steps.len().saturating_add(pending_steps(s, idx).count());
+    let at = index(p, "at", cmd)?.unwrap_or(len);
+    if at > len {
+        return Err(bad(cmd, format!("`at` {at} is past the last step ({len})")));
+    }
+    if s.actions.recording.is_some_and(|(_, i)| i == idx) {
+        flush_recording(s)?;
+    }
+    let action = &mut s.actions.list[idx];
+    action.steps.insert(at, (id.clone(), params));
+    action.remap_steps(|i| Some(if i >= at { i + 1 } else { i }));
+    let result = json!({"action": action.name, "step": at, "id": id, "steps": action.steps.len()});
+    s.actions.touch();
+    Ok(result)
+}
+
+/// The panel's dialog toggle column. With `step`, switch one step's dialog on or off; without
+/// it, every step (all on unless all already are, like clicking the action's own toggle).
+fn dialog(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "actions.dialog";
+    not_playing(s, cmd)?;
+    let idx = resolve(&s.actions.list, p, cmd)?;
+    let enabled = match p.get("enabled") {
+        None | Some(Value::Null) => None,
+        Some(Value::Bool(b)) => Some(*b),
+        Some(_) => return Err(bad(cmd, "`enabled` must be true or false")),
+    };
+    let step = index(p, "step", cmd)?;
+    let len = s.actions.list[idx].steps.len().saturating_add(pending_steps(s, idx).count());
+    if step.is_some_and(|step| step >= len) {
+        return Err(bad(cmd, "step is out of range"));
+    }
+    if s.actions.recording.is_some_and(|(_, i)| i == idx) {
+        flush_recording(s)?;
+    }
+    let action = &mut s.actions.list[idx];
+    match step {
+        Some(step) => {
+            if enabled.unwrap_or(!action.dialogs.contains(&step)) {
+                action.dialogs.insert(step);
+            } else {
+                action.dialogs.remove(&step);
+            }
+        }
+        None if enabled.unwrap_or(action.dialogs.len() < action.steps.len()) => action.dialogs = (0..action.steps.len()).collect(),
+        None => action.dialogs.clear(),
+    }
+    let result = json!({"action": action.name, "dialogs": action.dialogs});
+    s.actions.touch();
+    Ok(result)
+}
+
+fn assign_set(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "actions.assignSet";
+    not_playing(s, cmd)?;
+    let idx = resolve(&s.actions.list, p, cmd)?;
+    let set = match p.get("set") {
+        None | Some(Value::Null) => None,
+        Some(Value::String(n)) if !n.trim().is_empty() => Some(n.trim().to_string()),
+        Some(Value::String(_)) => return Err(bad(cmd, "`set` is empty; pass null to take the action out of its set")),
+        Some(_) => return Err(bad(cmd, "`set` must be a name or null")),
+    };
+    let action = &mut s.actions.list[idx];
+    action.set = set;
+    let result = json!({"action": action.name, "set": action.set});
+    s.actions.touch();
+    Ok(result)
+}
+
+/// The conditions of Photoshop's Insert Conditional, by their string ids.
+pub const CONDITIONS: &[&str] = &[
+    "always",
+    "never",
+    "isOpen",
+    "landscape",
+    "square",
+    "portrait",
+    "modeIsRGB",
+    "modeIsCMYK",
+    "modeIsGrayscale",
+    "modeIsLab",
+    "modeIsBitmap",
+    "modeIsIndexed",
+    "modeIsDuotone",
+    "modeIsMultichannel",
+    "depth8",
+    "depth16",
+    "depth32",
+    "unsaved",
+    "hasSelection",
+    "hasLayers",
+    "hasAlphaChannels",
+    "isBackground",
+    "isPixelLayer",
+    "isAdjustmentLayer",
+    "isShapeLayer",
+    "isTypeLayer",
+    "isSmartObject",
+    "isLayerGroup",
+    "isLocked",
+    "isVisible",
+    "hasPixelMask",
+    "hasVectorMask",
+    "hasEffects",
+];
+
+/// Whether `condition` holds for the active document and layer. Layer conditions are false
+/// without a document or an active layer; `isOpen` is whether a document is open.
+pub fn evaluate(s: &Session, condition: &str) -> Result<bool> {
+    use photocraft_color::ColorMode;
+    use photocraft_doc::LayerContent;
+    if !CONDITIONS.contains(&condition) {
+        return Err(bad("actions.conditional", format!("unknown condition `{condition}` ({})", CONDITIONS.join("|"))));
+    }
+    let Some(d) = s.active() else { return Ok(condition == "always") };
+    let doc = &d.doc;
+    let layer = d.active_layer.and_then(|id| doc.layer(id));
+    let (w, h) = (doc.size.width, doc.size.height);
+    Ok(match condition {
+        "always" | "isOpen" => true,
+        "never" => false,
+        "landscape" => w > h,
+        "square" => w == h,
+        "portrait" => h > w,
+        "modeIsRGB" => doc.mode == ColorMode::Rgb,
+        "modeIsCMYK" => doc.mode == ColorMode::Cmyk,
+        "modeIsGrayscale" => doc.mode == ColorMode::Grayscale,
+        "modeIsLab" => doc.mode == ColorMode::Lab,
+        "modeIsBitmap" => doc.mode == ColorMode::Bitmap,
+        "modeIsIndexed" => doc.mode == ColorMode::Indexed,
+        "modeIsDuotone" => doc.mode == ColorMode::Duotone,
+        "modeIsMultichannel" => doc.mode == ColorMode::Multichannel,
+        "depth8" => doc.depth == photocraft_color::SampleType::U8,
+        "depth16" => doc.depth == photocraft_color::SampleType::U16,
+        "depth32" => doc.depth == photocraft_color::SampleType::F32,
+        "unsaved" => d.is_dirty(),
+        "hasSelection" => doc.selection.is_some(),
+        // More than a lone Background: any layer that isn't the background.
+        "hasLayers" => doc.walk().iter().any(|(_, _, l)| !doc.is_background(l.id)),
+        "hasAlphaChannels" => !doc.channels.is_empty(),
+        "isBackground" => layer.is_some_and(|l| doc.is_background(l.id)),
+        "isPixelLayer" => layer.is_some_and(|l| matches!(l.content, LayerContent::Raster(_)) && !doc.is_background(l.id)),
+        "isAdjustmentLayer" => layer.is_some_and(|l| matches!(l.content, LayerContent::Adjustment(_))),
+        "isShapeLayer" => layer.is_some_and(|l| matches!(l.content, LayerContent::Shape(_))),
+        "isTypeLayer" => layer.is_some_and(|l| matches!(l.content, LayerContent::Text(_))),
+        "isSmartObject" => layer.is_some_and(|l| matches!(l.content, LayerContent::Smart(_))),
+        "isLayerGroup" => layer.is_some_and(|l| l.is_group()),
+        "isLocked" => layer.is_some_and(|l| l.locks.all || l.locks.pixels || l.locks.position || l.locks.transparency),
+        "isVisible" => layer.is_some_and(|l| l.visible),
+        "hasPixelMask" => layer.is_some_and(|l| l.mask.is_some()),
+        "hasVectorMask" => layer.is_some_and(|l| l.vector_mask.is_some()),
+        "hasEffects" => layer.is_some_and(|l| !l.effects.items.is_empty()),
+        _ => false,
+    })
+}
+
+/// Photoshop's Insert Conditional as a step: test the condition, play `then` or `else`.
+fn conditional(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "actions.conditional";
+    let condition = match p.get("if") {
+        Some(Value::String(c)) => c.clone(),
+        _ => return Err(bad(cmd, format!("needs `if`, one of {}", CONDITIONS.join("|")))),
+    };
+    let branch = |key: &str| -> Result<Option<String>> {
+        match p.get(key) {
+            None | Some(Value::Null) => Ok(None),
+            Some(Value::String(n)) if !n.trim().is_empty() => Ok(Some(n.clone())),
+            Some(Value::String(_)) => Ok(None),
+            Some(_) => Err(bad(cmd, format!("`{key}` must be an action name or null"))),
+        }
+    };
+    let (then, otherwise) = (branch("then")?, branch("else")?);
+    let holds = evaluate(s, &condition)?;
+    let played = if holds { then } else { otherwise };
+    let mut out = json!({"if": condition, "holds": holds, "played": played});
+    if let Some(name) = played {
+        let r = s.execute("actions.play", json!({"action": name}))?;
+        if let Some(f) = r.get("failed") {
+            out["failed"] = f.clone();
+        }
+        out["ran"] = r.get("ran").cloned().unwrap_or(json!(0));
+        out["action"] = json!(name);
+    }
+    Ok(out)
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec {
+            id: "actions.insert",
+            label: "Insert Step",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"action":name|index, "id":command id, "params":{}?, "at":index?=end} → {action, step, id, steps}. Inserts a step at the 0-based position (Photoshop's Insert Stop… with id actions.stopMessage, Insert Menu Item… with any command). Pending recorded steps count; flags of the steps after it follow them."##,
+            enabled: always,
+            run: insert,
+            journal: false,
+        },
+        CommandSpec {
+            id: "actions.dialog",
+            label: "Toggle Step Dialog",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"action":name|index, "step":index?, "enabled":bool?} → {action, dialogs:[step…]}. The Actions panel's dialog toggle: the desktop shell shows the step's dialog, seeded with its recorded params, and resumes playback when it is confirmed; headless playback runs the recorded params. Omitted enabled flips it; without step, every step: on unless all already are, or as enabled says."##,
+            enabled: always,
+            run: dialog,
+            journal: false,
+        },
+        CommandSpec {
+            id: "actions.conditional",
+            label: "Conditional",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"if":condition, "then":action name|null, "else":action name|null} → {if, holds, played, ran?, failed?}. Photoshop's Insert Conditional: conditions always|never|isOpen|landscape|square|portrait|modeIsRGB|modeIsCMYK|modeIsGrayscale|modeIsLab|modeIsBitmap|modeIsIndexed|modeIsDuotone|modeIsMultichannel|depth8|depth16|depth32|unsaved|hasSelection|hasLayers|hasAlphaChannels|isBackground|isPixelLayer|isAdjustmentLayer|isShapeLayer|isTypeLayer|isSmartObject|isLayerGroup|isLocked|isVisible|hasPixelMask|hasVectorMask|hasEffects (layer conditions test the active layer). The branch plays as actions.play does; its failure stops the calling action."##,
+            enabled: always,
+            run: conditional,
+            journal: true,
+        },
+        CommandSpec {
+            id: "actions.assignSet",
+            label: "Move to Set",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"action":name|index, "set":name|null} → {action, set}. The set folder the Actions panel shows the action under (what Load Actions fills and Save Actions writes); null takes it out of any set."##,
+            enabled: always,
+            run: assign_set,
+            journal: false,
+        },
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::actions_cmds::Action;
+
+    fn session_with(steps: &[&str]) -> Session {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
+        s.actions.list.push(Action::new("A", steps.iter().map(|id| (id.to_string(), json!({}))).collect()));
+        s
+    }
+
+    #[test]
+    fn insert_places_the_step_and_shifts_the_flags() {
+        let mut s = session_with(&["select.all", "select.inverse", "select.deselect"]);
+        s.execute("actions.toggle", json!({"action": "A", "step": 1})).unwrap();
+        s.execute("actions.dialog", json!({"action": "A", "step": 2})).unwrap();
+        let r = s
+            .execute("actions.insert", json!({"action": "A", "at": 1, "id": "actions.stopMessage", "params": {"message": "Check", "allowContinue": true}}))
+            .unwrap();
+        assert_eq!((r["step"].as_u64(), r["steps"].as_u64()), (Some(1), Some(4)));
+        let a = &s.actions.list[0];
+        assert_eq!(a.steps[1], ("actions.stopMessage".to_string(), json!({"message": "Check", "allowContinue": true})));
+        assert_eq!(a.disabled.iter().copied().collect::<Vec<_>>(), [2], "the switched-off step moved down one");
+        assert_eq!(a.dialogs.iter().copied().collect::<Vec<_>>(), [3]);
+        // Default position: the end. A bare id works for a parameterless command.
+        let r = s.execute("actions.insert", json!({"action": 0, "id": "layer.new.layer"})).unwrap();
+        assert_eq!(r["step"], 4);
+        assert_eq!(s.actions.list[0].steps[4].0, "layer.new.layer");
+        // Playback runs the inserted stop and continues past it.
+        let played = s.execute("actions.play", json!({"action": "A"})).unwrap();
+        assert_eq!(played["ran"], 4, "{played}");
+        assert!(played.get("failed").is_none(), "{played}");
+    }
+
+    #[test]
+    fn insert_while_recording_keeps_pending_steps_in_order() {
+        let mut s = session_with(&[]);
+        s.execute("actions.record", json!({"action": "A"})).unwrap();
+        s.execute("layer.new.layer", json!({"name": "One"})).unwrap();
+        s.execute("actions.insert", json!({"action": "A", "at": 0, "id": "select.all"})).unwrap();
+        s.execute("layer.new.layer", json!({"name": "Two"})).unwrap();
+        s.execute("actions.stop", json!({})).unwrap();
+        let ids: Vec<&str> = s.actions.list[0].steps.iter().map(|(id, _)| id.as_str()).collect();
+        assert_eq!(ids, ["select.all", "layer.new.layer", "layer.new.layer"]);
+    }
+
+    #[test]
+    fn dialog_toggles_one_step_or_all() {
+        let mut s = session_with(&["select.all", "select.inverse"]);
+        assert_eq!(s.execute("actions.dialog", json!({"action": "A", "step": 0})).unwrap()["dialogs"], json!([0]));
+        assert_eq!(s.execute("actions.dialog", json!({"action": "A", "step": 0})).unwrap()["dialogs"], json!([]));
+        assert_eq!(s.execute("actions.dialog", json!({"action": "A", "step": 1, "enabled": true})).unwrap()["dialogs"], json!([1]));
+        assert_eq!(s.execute("actions.dialog", json!({"action": "A"})).unwrap()["dialogs"], json!([0, 1]), "not all on: all on");
+        assert_eq!(s.execute("actions.dialog", json!({"action": "A"})).unwrap()["dialogs"], json!([]), "all on: all off");
+        assert_eq!(s.execute("actions.dialog", json!({"action": "A", "enabled": true})).unwrap()["dialogs"], json!([0, 1]));
+        assert_eq!(s.execute("actions.get", json!({"action": "A"})).unwrap()["dialogs"], json!([0, 1]));
+        // Deleting a step keeps the flags of the others in place.
+        s.execute("actions.delete", json!({"action": "A", "step": 0})).unwrap();
+        assert_eq!(s.actions.list[0].dialogs.iter().copied().collect::<Vec<_>>(), [0]);
+    }
+
+    #[test]
+    fn conditional_tests_the_document_and_plays_a_branch() {
+        let mut s = session_with(&[]);
+        s.actions.list.push(Action::new("Yes", vec![("layer.new.layer".into(), json!({"name": "yes"}))]));
+        s.actions.list.push(Action::new("No", vec![("layer.new.layer".into(), json!({"name": "no"}))]));
+        let names = |s: &Session| s.active().unwrap().doc.walk().iter().map(|(_, _, l)| l.name.clone()).collect::<Vec<_>>();
+        // 8 × 8: square, not landscape; one Background: no layers yet.
+        for (cond, expect) in [
+            ("square", true),
+            ("landscape", false),
+            ("portrait", false),
+            ("modeIsRGB", true),
+            ("modeIsCMYK", false),
+            ("depth8", true),
+            ("hasLayers", false),
+            ("hasSelection", false),
+            ("isBackground", true),
+            ("isPixelLayer", false),
+            ("hasEffects", false),
+            ("always", true),
+            ("never", false),
+            ("isOpen", true),
+        ] {
+            assert_eq!(evaluate(&s, cond).unwrap(), expect, "{cond}");
+        }
+        let r = s.execute("actions.conditional", json!({"if": "square", "then": "Yes", "else": "No"})).unwrap();
+        assert_eq!((r["holds"].as_bool(), r["played"].as_str(), r["ran"].as_u64()), (Some(true), Some("Yes"), Some(1)));
+        assert_eq!(names(&s).last().map(String::as_str), Some("yes"));
+        for (cond, expect) in [("hasLayers", true), ("isPixelLayer", true), ("isBackground", false), ("isVisible", true)] {
+            assert_eq!(evaluate(&s, cond).unwrap(), expect, "{cond}");
+        }
+        let r = s.execute("actions.conditional", json!({"if": "landscape", "then": "Yes", "else": "No"})).unwrap();
+        assert_eq!((r["holds"].as_bool(), r["played"].as_str()), (Some(false), Some("No")));
+        assert_eq!(names(&s).last().map(String::as_str), Some("no"));
+        // No branch for the outcome: nothing plays, no error.
+        let r = s.execute("actions.conditional", json!({"if": "landscape", "then": "Yes"})).unwrap();
+        assert!(r["played"].is_null());
+        // A failing branch reports like a nested Play, and stops a calling action.
+        s.actions.list.push(Action::new("Bad", vec![("layer.delete".into(), json!({"layer": 999}))]));
+        let r = s.execute("actions.conditional", json!({"if": "always", "then": "Bad"})).unwrap();
+        assert!(r["failed"].is_object(), "{r}");
+        assert!(crate::actions_cmds::nested_failure("actions.conditional", &r).is_some());
+        s.actions.list.push(Action::new(
+            "Caller",
+            vec![("actions.conditional".into(), json!({"if": "always", "then": "Bad"})), ("layer.new.layer".into(), json!({"name": "after"}))],
+        ));
+        let played = s.execute("actions.play", json!({"action": "Caller"})).unwrap();
+        assert_eq!(played["failed"]["step"], 0, "{played}");
+        assert_ne!(names(&s).last().map(String::as_str), Some("after"));
+        // Without a document only always/never answer; layer conditions are false.
+        let t = Session::new();
+        assert!(evaluate(&t, "always").unwrap());
+        assert!(!evaluate(&t, "isOpen").unwrap());
+        assert!(!evaluate(&t, "isBackground").unwrap());
+        for p in [json!({}), json!({"if": "sometimes"}), json!({"if": 3}), json!({"if": "always", "then": 5}), json!({"if": "always", "then": "Nope"})] {
+            assert!(
+                s.execute("actions.conditional", p.clone()).is_err() || s.execute("actions.conditional", p.clone()).unwrap().get("failed").is_some(),
+                "{p}"
+            );
+        }
+    }
+
+    #[test]
+    fn assign_set_moves_an_action_between_folders() {
+        let mut s = session_with(&["select.all"]);
+        assert_eq!(s.execute("actions.assignSet", json!({"action": "A", "set": " Retouch "})).unwrap()["set"], "Retouch");
+        assert_eq!(s.actions.list[0].set.as_deref(), Some("Retouch"));
+        assert_eq!(s.execute("actions.list", json!({})).unwrap()["actions"][0]["set"], "Retouch");
+        assert_eq!(s.execute("actions.assignSet", json!({"action": 0, "set": null})).unwrap()["set"], Value::Null);
+        assert_eq!(s.actions.list[0].set, None);
+    }
+
+    #[test]
+    fn bad_params_fail_gracefully() {
+        let mut s = session_with(&["select.all"]);
+        let before = s.actions.list.clone();
+        for p in [
+            json!({}),
+            json!({"action": "A"}),
+            json!({"action": "A", "id": ""}),
+            json!({"action": "A", "id": 5}),
+            json!({"action": "A", "id": "not.a.command"}),
+            json!({"action": "A", "id": "select.all", "at": 2}),
+            json!({"action": "A", "id": "select.all", "at": -1}),
+            json!({"action": "A", "id": "select.all", "params": "x"}),
+            json!({"action": "A", "id": "actions.play", "params": {"action": "A"}}),
+            json!({"action": 9, "id": "select.all"}),
+        ] {
+            assert!(s.execute("actions.insert", p.clone()).is_err(), "{p}");
+        }
+        for p in
+            [json!({}), json!({"action": "A", "step": 1}), json!({"action": "A", "step": "x"}), json!({"action": "A", "enabled": "yes"}), json!({"action": 3})]
+        {
+            assert!(s.execute("actions.dialog", p.clone()).is_err(), "{p}");
+        }
+        for p in [json!({}), json!({"action": "A", "set": ""}), json!({"action": "A", "set": 7}), json!({"action": "B", "set": "S"})] {
+            assert!(s.execute("actions.assignSet", p.clone()).is_err(), "{p}");
+        }
+        assert_eq!(s.actions.list, before, "rejected edits change nothing");
+        // Nothing edits during playback.
+        s.actions.list.push(Action::new("Loop", vec![("actions.insert".into(), json!({"action": "A", "id": "select.all"}))]));
+        let played = s.execute("actions.play", json!({"action": "Loop"})).unwrap();
+        assert!(played["failed"]["error"].as_str().unwrap().contains("playback"), "{played}");
+    }
+}
diff --git a/crates/engine/src/adjust_cmds.rs b/crates/engine/src/adjust_cmds.rs
index 42dd44d767..c1393bb94c 100644
--- a/crates/engine/src/adjust_cmds.rs
+++ b/crates/engine/src/adjust_cmds.rs
@@ -11,7 +11,7 @@
 
 use photocraft_algo::tone::{self, HdrToning, MatchColor, ShadowsHighlights};
 use photocraft_doc::{Adjustment, Document, Layer, LayerContent, Rect};
-use photocraft_raster::{Surface, from_rgba_into, to_rgba};
+use photocraft_raster::{Surface, to_rgba};
 use serde_json::{Value, json};
 
 use crate::commands::CommandSpec;
@@ -202,17 +202,8 @@ fn process_surface(surf: &mut Surface, selection: Option<&Surface>, f: &mut dyn
     let raw = surf.read_region(r);
     let mut px: Vec<[f32; 4]> = raw.chunks_exact(n).map(|q| to_rgba(&fmt, q)).collect();
     let orig = px.clone();
-    let w = r.width() as usize;
     f(&mut px, r);
-    let mut out = Vec::with_capacity(raw.len());
-    for (i, (a, o)) in px.iter().zip(&orig).enumerate() {
-        let k = selection.map_or(1.0, |sel| sel.sample_channel(r.x0 + (i % w) as i32, r.y0 + (i / w) as i32, 0));
-        let mixed: [f32; 4] = std::array::from_fn(|c| o[c] + (a[c] - o[c]) * k);
-        let mut enc = [0.0f32; 8];
-        let m = from_rgba_into(&fmt, mixed, &mut enc);
-        out.extend_from_slice(&enc[..m]);
-    }
-    surf.write_region(r, &out);
+    surf.write_region(r, &crate::pixels::mix_through_selection(&fmt, r, &orig, &px, selection));
 }
 
 /// One history step running `f` on the active pixel layer (or targeted channel or layer mask).
@@ -343,14 +334,54 @@ fn shadows_highlights_params(p: &Value) -> ShadowsHighlights {
 }
 
 fn replace_color(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "image.adjustments.replaceColor";
     let c = crate::commands::color_param(p, "color", s.tools.foreground);
     let fuzz = num(p, "fuzziness", 40.0).clamp(0.0, 200.0);
     let (h, sat, l) = (num(p, "hue", 0.0).clamp(-180.0, 180.0), num(p, "saturation", 0.0).clamp(-100.0, 100.0), num(p, "lightness", 0.0).clamp(-100.0, 100.0));
-    rgba_edit(s, "Replace Color", p, |px, _| {
-        tone::replace_color(px, [c[0], c[1], c[2]], fuzz, h, sat, l);
+    // Localized Color Clusters, as in Select › Color Range: the colour only matches within Range
+    // (a percentage of the canvas's longer side) of where it was picked.
+    let points = sample_points(p).map_err(|m| bad(CMD, m))?;
+    let localized = if p.get("localized").and_then(Value::as_bool).unwrap_or(false) {
+        if points.is_empty() {
+            return Err(bad(CMD, "localized clusters need eyedropper `points` (where the colour was picked)"));
+        }
+        let canvas = s.active().ok_or(EngineError::NoDocument)?.doc.bounds();
+        Some(num(p, "range", 100.0).clamp(0.0, 100.0) / 100.0 * canvas.width().max(canvas.height()) as f32)
+    } else {
+        None
+    };
+    rgba_edit(s, "Replace Color", p, |px, r| match localized {
+        Some(radius) => {
+            let samples: Vec<_> = points
+                .iter()
+                .map(|&(x, y)| photocraft_algo::selection::RangeSample { color: [c[0], c[1], c[2]], at: Some((x - r.x0 as f32, y - r.y0 as f32)) })
+                .collect();
+            let mask = photocraft_algo::selection::color_range_samples(px, r.width() as usize, &samples, fuzz, Some(radius));
+            tone::replace_color_masked(px, &mask, h, sat, l);
+        }
+        None => {
+            tone::replace_color(px, [c[0], c[1], c[2]], fuzz, h, sat, l);
+        }
     })
 }
 
+/// The `points` of a command (`[[x, y], …]` in document pixels), or a message saying what is wrong.
+fn sample_points(p: &Value) -> std::result::Result<Vec<(f32, f32)>, String> {
+    let Some(pts) = p.get("points") else { return Ok(Vec::new()) };
+    let pts = pts.as_array().ok_or("`points` must be [[x, y], …]")?;
+    pts.iter()
+        .map(|pt| {
+            pt.as_array()
+                .and_then(|a| match a.as_slice() {
+                    [x, y] => Some((x.as_f64()? as f32, y.as_f64()? as f32)),
+                    _ => None,
+                })
+                .filter(|(x, y)| x.is_finite() && y.is_finite())
+                .ok_or_else(|| format!("bad point {pt} in `points` (want [x, y])"))
+        })
+        .collect()
+}
+
 /// Straight RGBA pixels and an optional coverage mask for a document's layer (or its composite).
 /// Pixels plus an optional coverage mask.
 type Sample = (Vec<[f32; 4]>, Option<Vec<f32>>);
@@ -428,6 +459,7 @@ fn hdr_toning(s: &mut Session, p: &Value) -> Result<Value> {
         let data: Vec<f32> = px.iter().flat_map(|q| photocraft_raster::from_rgba(&fmt, *q)).collect();
         let mut bg = Layer::raster("Background", fmt);
         bg.locks.transparency = true;
+        bg.locks.position = true;
         crate::pixels_mut(&mut bg)?.write_region(doc.bounds(), &data);
         *active = Some(bg.id);
         doc.layers = vec![bg];
@@ -462,7 +494,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "image.adjustments.replaceColor",
             "Replace Color…",
             ["Image", "Adjustments"],
-            r##"{"color":json,"fuzziness":0..200=40,"hue":-180..180=0,"saturation":-100..100=0,"lightness":-100..100=0} (color: "#rrggbb", default the foreground colour)"##,
+            r##"{"localized":bool=false,"color":color,"fuzziness":0..200=40,"range":0..100=100,"hue":-180..180=0,"saturation":-100..100=0,"lightness":-100..100=0,"points":[[x,y],…]?} (color: "#rrggbb", default the foreground colour; Localized Color Clusters: "points" where the colour was picked, "range" % of the longer side)"##,
             has_pixels,
             replace_color
         ),
diff --git a/crates/engine/src/adjust_cmds/tests.rs b/crates/engine/src/adjust_cmds/tests.rs
index 9f8f07db63..8fa053e86e 100644
--- a/crates/engine/src/adjust_cmds/tests.rs
+++ b/crates/engine/src/adjust_cmds/tests.rs
@@ -503,3 +503,38 @@ fn a_targeted_mask_enables_editing_it_on_any_layer() {
     assert!(s.execute("image.adjustments.invert", mask).is_err());
     assert_eq!(rgba(&s, 23, 3), pixels);
 }
+
+#[test]
+fn replace_color_localized_clusters_only_change_the_colour_near_the_sample() {
+    // The same cream on the left (x < 8) and the right (x ≥ 40), grey between.
+    let cream = [0.9, 0.88, 0.79, 1.0];
+    let mut s = session(8, "rgb");
+    paint(&mut s, |x, _| if !(8..40).contains(&x) { cream } else { [0.5, 0.5, 0.5, 1.0] });
+    let base = |s: &Session| (rgba(s, 3, 16), rgba(s, 44, 16), rgba(s, 20, 16));
+    let (left, right, grey) = base(&s);
+    let shift = json!({"color": "#e6e0c9", "fuzziness": 20, "hue": 180, "saturation": 60});
+    // Without clusters the colour is replaced everywhere (unchanged behaviour).
+    s.execute("image.adjustments.replaceColor", shift.clone()).unwrap();
+    assert!(changed(rgba(&s, 3, 16), left) > 0.05 && changed(rgba(&s, 44, 16), right) > 0.05);
+    s.execute("edit.undo", json!({})).unwrap();
+    // Picked on the left with Range 50 % (24 px): only the left cream changes.
+    let mut local = shift.clone();
+    local["points"] = json!([[2, 16]]);
+    local["localized"] = json!(true);
+    local["range"] = json!(50);
+    s.execute("image.adjustments.replaceColor", local.clone()).unwrap();
+    assert!(changed(rgba(&s, 3, 16), left) > 0.05, "near the sample");
+    assert_eq!(rgba(&s, 44, 16), right, "the same colour far from the sample");
+    assert_eq!(rgba(&s, 20, 16), grey);
+    s.execute("edit.undo", json!({})).unwrap();
+    // Inside a selection that doesn't start at the origin the sample stays where it was picked.
+    s.execute("select.rect", json!({"x": 1, "y": 4, "width": 46, "height": 24})).unwrap();
+    s.execute("image.adjustments.replaceColor", local).unwrap();
+    assert!(changed(rgba(&s, 3, 16), left) > 0.05);
+    assert_eq!(rgba(&s, 44, 16), right);
+    // Clusters need a place to be near.
+    let err = s.execute("image.adjustments.replaceColor", json!({"localized": true})).unwrap_err();
+    assert!(err.to_string().contains("points"), "{err}");
+    let err = s.execute("image.adjustments.replaceColor", json!({"points": [[1]]})).unwrap_err();
+    assert!(err.to_string().contains("bad point"), "{err}");
+}
diff --git a/crates/engine/src/adjust_params.rs b/crates/engine/src/adjust_params.rs
index 02fdc26b1b..69fc2d76f3 100644
--- a/crates/engine/src/adjust_params.rs
+++ b/crates/engine/src/adjust_params.rs
@@ -73,7 +73,7 @@ pub fn default_for(kind: &str, mode: ColorMode) -> Result<Adjustment> {
 /// None or of another kind). `mode` picks the Levels/Curves channel space when neither the params
 /// nor the base name one.
 pub fn from_params(kind: &str, p: &Value, base: Option<&Adjustment>, mode: ColorMode) -> Result<Adjustment> {
-    let cmd = format!("adjustment `{kind}`");
+    let cmd = format!("{kind} adjustment");
     if !p.is_object() && !p.is_null() {
         return Err(bad(&cmd, "params must be an object"));
     }
@@ -952,8 +952,10 @@ pub fn parse_curve(cmd: &str, key: &str, v: &Value) -> Result<Vec<CurvePoint>> {
     let mut pts = Vec::with_capacity(a.len());
     for q in a {
         let q = q.as_array().filter(|q| q.len() == 2).ok_or_else(err)?;
-        let x = q.first().and_then(Value::as_f64).filter(|x| x.is_finite()).ok_or_else(err)?;
-        let y = q.get(1).and_then(Value::as_f64).filter(|y| y.is_finite()).ok_or_else(err)?;
+        // Like Photoshop, a point outside 0..255 is refused rather than moved onto the edge.
+        let level = |v: Option<&Value>| v.and_then(Value::as_f64).filter(|v| (-1e-6..=255.0 + 1e-6).contains(v));
+        let x = level(q.first()).ok_or_else(err)?;
+        let y = level(q.get(1)).ok_or_else(err)?;
         pts.push(CurvePoint { input: (x as f32).clamp(0.0, 255.0) / 255.0, output: (y as f32).clamp(0.0, 255.0) / 255.0 });
     }
     pts.sort_by(|a, b| a.input.total_cmp(&b.input));
@@ -1212,6 +1214,17 @@ mod tests {
         assert!(matches!(a, Adjustment::Levels { master, .. } if master.in_white > master.in_black));
     }
 
+    #[test]
+    fn curve_points_outside_0_255_are_refused_as_the_message_says() {
+        // Photoshop refuses them too ("the settings in the file are invalid"); they used to be
+        // moved onto the edge silently.
+        for pts in [json!([[0, 0], [300, 255]]), json!([[0, -1], [255, 255]]), json!([[0, 0]])] {
+            let e = from_params("curves", &json!({ "points": pts }), None, ColorMode::Rgb).unwrap_err().to_string();
+            assert!(e.contains("[input, output] pairs in 0..255") && e.contains("`curves adjustment`"), "{e}");
+        }
+        assert!(from_params("curves", &json!({"points": [[0, 0], [128.5, 140], [255, 255]]}), None, ColorMode::Rgb).is_ok());
+    }
+
     fn curves_parts(a: &Adjustment) -> (&[CurvePoint], &[Vec<CurvePoint>; 3]) {
         match a {
             Adjustment::Curves { master, per_channel, .. } => (master, per_channel),
@@ -1625,7 +1638,8 @@ mod tests {
     #[test]
     fn destructive_levels_dont_clip_in_32_bit() {
         // Input 15..230, gamma 1.3, output 10..245: integer documents stop at the output range,
-        // while float documents preserve the curve's signed and HDR values beyond it.
+        // while float documents preserve the curve's signed and HDR values beyond it (the
+        // compose-side `levels_dont_clip_in_32_bit` pins the same curve, #2592).
         let params = json!({"inBlack": 15, "inWhite": 230, "gamma": 1.3, "outBlack": 10, "outWhite": 245});
         for depth in [8, 16, 32] {
             let mut s = crate::Session::new();
@@ -1706,4 +1720,26 @@ mod tests {
             }
         }
     }
+    #[test]
+    fn destructive_levels_match_independent_signed_hdr_endpoints() {
+        // Input 15..230, gamma 1.3, output 10..245: black and white land on the output range in
+        // integer documents. Float32 keeps HDR values outside 0..1, as the compositor's real-file
+        // Levels oracle does. These independently calculated endpoints use the signed-power
+        // curve at black and white, not display-clipped values.
+        let params = json!({"inBlack": 15, "inWhite": 230, "gamma": 1.3, "outBlack": 10, "outWhite": 245});
+        for (depth, low, high, tolerance) in [(8, 10.0, 245.0, 0.6), (16, 10.0, 245.0, 0.6), (32, -20.308_89, 265.750_3, 0.01)] {
+            let mut s = crate::Session::new();
+            s.execute("file.new", json!({"width": 16, "height": 16, "depth": depth, "background": "white"})).unwrap();
+            s.execute("select.rect", json!({"x": 0, "y": 0, "width": 8, "height": 16})).unwrap();
+            s.execute("edit.fill", json!({"color": "#000000"})).unwrap();
+            s.execute("select.deselect", json!({})).unwrap();
+            s.execute("image.adjustments.levels", params.clone()).unwrap();
+            let px = pixels(&s);
+            assert!((px[0][0] * 255.0 - low).abs() < tolerance, "black @{depth}: {:?}", px[0]);
+            assert!((px[1][0] * 255.0 - high).abs() < tolerance, "white @{depth}: {:?}", px[1]);
+            if depth == 32 {
+                assert!(px[0][0] < 0.0 && px[1][0] > 1.0, "HDR endpoints must remain unclipped");
+            }
+        }
+    }
 }
diff --git a/crates/engine/src/align_cmds.rs b/crates/engine/src/align_cmds.rs
index 26cd1acc39..b54f4b7a73 100644
--- a/crates/engine/src/align_cmds.rs
+++ b/crates/engine/src/align_cmds.rs
@@ -17,6 +17,9 @@
 //! Laplacian pyramid, each coefficient from the layer sharpest at that scale
 //! ([`pyramid::fuse_stack`]; `haloControl` keeps a bright object's defocused glow out of the
 //! coarse levels).
+//! Stack Images can also add a hidden Depth layer, the layer each pixel is sharpest in by depth
+//! from focus ([`photocraft_algo::dff`]): black = the bottom layer, white = the top, so that once
+//! on a layer mask it drives Lens Blur's depth map.
 
 use photocraft_algo::panorama::Layout;
 use photocraft_algo::pyramid;
@@ -169,6 +172,10 @@ fn auto_blend(s: &mut Session, p: &Value) -> Result<Value> {
             _ => return Err(bad(cmd, format!("`haloControl` must be a number from 0 to {}", pyramid::HALO_MAX))),
         },
     };
+    let want_depth = p.get("depthMap").and_then(Value::as_bool).unwrap_or(false);
+    if want_depth && method != "stack" {
+        return Err(bad(cmd, "`depthMap` needs `method`: stack"));
+    }
     let st = s.active().ok_or(EngineError::NoDocument)?;
     let doc: std::sync::Arc<Document> = st.doc.clone();
     let mut area = Rect::EMPTY;
@@ -223,9 +230,33 @@ fn auto_blend(s: &mut Session, p: &Value) -> Result<Value> {
         let blended = seamless.then(|| b.composite.read_region(area));
         (weights, blended)
     };
+    // The depth map: the layer each pixel is sharpest in, from the focus volume guided by the
+    // merged picture (or, without one, by the per-pixel pick), as a hidden gray layer, black =
+    // the bottom layer, white = the top, ready for Lens Blur's depth map once on a mask.
+    let depth_px = want_depth.then(|| {
+        let n = fmt.channels();
+        let guide: Vec<f32> = match &blended {
+            Some(px) => (0..w * h)
+                .map(|i| {
+                    let c = to_rgba(&fmt, &px[i * n..(i + 1) * n]);
+                    0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]
+                })
+                .collect(),
+            None => (0..w * h).map(|i| luma.iter().zip(&weights).map(|(l, wt)| l[i] * wt[i]).sum()).collect(),
+        };
+        let refs: Vec<&[f32]> = luma.iter().map(Vec::as_slice).collect();
+        let dm = photocraft_algo::dff::depth_from_focus(&refs, &guide, w, h, &photocraft_algo::dff::DepthParams::default());
+        let scale = 1.0 / (ids.len() - 1).max(1) as f32;
+        let mut out = vec![0.0f32; w * h * n];
+        for (i, d) in dm.depth.iter().enumerate() {
+            let g = (d * scale).clamp(0.0, 1.0);
+            photocraft_raster::from_rgba_into(&fmt, [g, g, g, 1.0], &mut out[i * n..(i + 1) * n]);
+        }
+        out
+    });
     let top = *ids.last().ok_or_else(|| EngineError::Other("Auto-Blend needs two or more layers".into()))?;
     let label = "Auto-Blend Layers";
-    let new_layer = s.edit(label, |doc, active| {
+    let (new_layer, depth_layer) = s.edit(label, |doc, active| {
         for (id, wt) in ids.iter().zip(&weights) {
             let l = doc.layer_mut(*id).ok_or(EngineError::NoLayer(*id))?;
             let mut mask = LayerMask::hide_all();
@@ -233,17 +264,33 @@ fn auto_blend(s: &mut Session, p: &Value) -> Result<Value> {
             mask.surface.prune();
             l.mask = Some(mask);
         }
-        let Some(px) = &blended else { return Ok(None) };
+        let mut below = top;
+        let depth_id = depth_px.as_ref().map(|px| {
+            let mut l = Layer::raster(doc.next_layer_name("Depth"), fmt);
+            l.visible = false;
+            if let Some(surf) = l.surface_mut() {
+                surf.write_region(area, px);
+                surf.prune();
+            }
+            below = doc.insert_above(Some(below), l);
+            below
+        });
+        let Some(px) = &blended else {
+            if depth_id.is_some() {
+                *active = depth_id;
+            }
+            return Ok((None, depth_id));
+        };
         let mut l = Layer::raster(doc.next_layer_name("Blended"), fmt);
         if let Some(surf) = l.surface_mut() {
             surf.write_region(area, px);
             surf.prune();
         }
-        let nid = doc.insert_above(Some(top), l);
+        let nid = doc.insert_above(Some(below), l);
         *active = Some(nid);
-        Ok(Some(nid))
+        Ok((Some(nid), depth_id))
     })?;
-    Ok(json!({"method": method, "layers": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "blended": new_layer.map(|l| l.0)}))
+    Ok(json!({"method": method, "layers": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "blended": new_layer.map(|l| l.0), "depth": depth_layer.map(|l| l.0)}))
 }
 
 macro_rules! spec {
@@ -260,7 +307,12 @@ pub fn specs() -> Vec<CommandSpec> {
             r##"{"projection":"auto|perspective|cylindrical|spherical|collage|reposition","reference":layer id?=bottom selected layer,"geometricCorrection":bool=false,"interpolation":"bicubic|bilinear|nearest","registration":"auto|features|intensity"}"##,
             auto_align
         ),
-        spec!("edit.autoBlendLayers", "Auto-Blend Layers…", r##"{"method":"panorama|stack","seamlessTones":bool=true,"haloControl":0..8=2}"##, auto_blend),
+        spec!(
+            "edit.autoBlendLayers",
+            "Auto-Blend Layers…",
+            r##"{"method":"panorama|stack","seamlessTones":bool=true,"haloControl":0..8=2,"depthMap":bool=false}"##,
+            auto_blend
+        ),
     ]
 }
 
@@ -533,4 +585,56 @@ mod tests {
             }
         }
     }
+
+    /// Three layers, each sharp in one third: the Depth layer says which, black to white from
+    /// the bottom layer to the top, hidden, and undone with the rest.
+    #[test]
+    fn auto_blend_stack_depth_map() {
+        for depth in [8, 16, 32] {
+            let mut s = Session::new();
+            s.execute("file.new", json!({"width": 96, "height": 48, "depth": depth, "background": "transparent"})).unwrap();
+            let mut ids = Vec::new();
+            for k in 0..3 {
+                s.execute("layer.new.layer", json!({"name": format!("L{k}")})).unwrap();
+                s.edit("third", |doc, active| {
+                    let surf = doc.layer_mut(active.unwrap()).unwrap().surface_mut().unwrap();
+                    for y in 0..48 {
+                        for x in 0..96 {
+                            let v = if x / 32 == k && ((x / 2) + (y / 2)) % 2 == 0 {
+                                0.2
+                            } else if x / 32 == k {
+                                0.8
+                            } else {
+                                0.5
+                            };
+                            surf.fill_rect(Rect::new(x, y, x + 1, y + 1), &[v, v, v, 1.0]);
+                        }
+                    }
+                    Ok(())
+                })
+                .unwrap();
+                ids.push(s.active().unwrap().active_layer.unwrap());
+            }
+            select(&mut s, &ids);
+            assert!(s.execute("edit.autoBlendLayers", json!({"method": "panorama", "depthMap": true})).is_err());
+            for seamless in [false, true] {
+                let r = s.execute("edit.autoBlendLayers", json!({"method": "stack", "seamlessTones": seamless, "depthMap": true})).unwrap();
+                let doc = &s.active().unwrap().doc;
+                let d = doc.layer(LayerId(r["depth"].as_u64().unwrap())).unwrap();
+                assert!(!d.visible && d.name.starts_with("Depth"), "depth {depth}: {} visible {} {r}", d.name, d.visible);
+                let surf = d.surface().unwrap();
+                for (x, want) in [(8, 0.0), (48, 0.5), (88, 1.0)] {
+                    let px = surf.pixel(x, 24);
+                    assert!((px[0] - want).abs() < 0.2 && (px[3] - 1.0).abs() < 1e-3, "depth {depth} seamless {seamless} x {x}: {px:?}");
+                }
+                assert_eq!(r["blended"].is_null(), !seamless);
+                if seamless {
+                    // The merged layer sits above the depth layer and is the active one.
+                    assert_eq!(s.active().unwrap().active_layer, Some(LayerId(r["blended"].as_u64().unwrap())));
+                }
+                s.undo();
+                assert!(s.active().unwrap().doc.layer(LayerId(r["depth"].as_u64().unwrap())).is_none());
+            }
+        }
+    }
 }
diff --git a/crates/engine/src/allocation.rs b/crates/engine/src/allocation.rs
index 322e3ebd22..7c29ecc8ee 100644
--- a/crates/engine/src/allocation.rs
+++ b/crates/engine/src/allocation.rs
@@ -48,7 +48,7 @@ pub(crate) fn read_region(surface: &photocraft_raster::Surface, area: photocraft
     Ok(out)
 }
 
-fn error(purpose: &str, detail: &str) -> EngineError {
+pub(crate) fn error(purpose: &str, detail: &str) -> EngineError {
     EngineError::Other(format!("not enough memory for {purpose} ({detail}); the document was not changed"))
 }
 
diff --git a/crates/engine/src/analysis_cmds.rs b/crates/engine/src/analysis_cmds.rs
index b369479ce0..64af849e59 100644
--- a/crates/engine/src/analysis_cmds.rs
+++ b/crates/engine/src/analysis_cmds.rs
@@ -670,7 +670,7 @@ fn straighten(s: &mut Session, p: &Value) -> Result<Value> {
         return Ok(json!({"angle": 0.0}));
     }
     let st = s.active().ok_or(EngineError::NoDocument)?;
-    let active_bg = st.active_layer.and_then(|id| d.layer(id)).is_some_and(|l| l.name == "Background" && l.locks.position);
+    let active_bg = st.active_layer.and_then(|id| d.layer(id)).is_some_and(|l| d.is_background(l.id));
     let crop = p.get("crop").and_then(Value::as_bool).unwrap_or(active_bg || st.active_layer.is_none());
     let (w0, h0) = (f64::from(d.size.width), f64::from(d.size.height));
     compound(s, "Straighten", |s| {
@@ -842,6 +842,23 @@ fn count_delete_group(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(count_json(doc(s)?.as_ref()))
 }
 
+/// A size parameter (`markerSize`, `labelSize`) clamped to `lo..=hi`: `None` when absent or null.
+/// Whole numbers sent as JSON floats (`8.0`, as UIs and recorded actions do) count; fractions,
+/// negatives and non-numbers are bad params rather than silently ignored. Clamping happens in
+/// `u64`/`f64`, so a huge value can't wrap through `as u32`.
+fn whole_size(cmd: &str, p: &Value, key: &str, lo: u32, hi: u32) -> Result<Option<u32>> {
+    let v = match p.get(key) {
+        None | Some(Value::Null) => return Ok(None),
+        Some(v) => v,
+    };
+    let n = match (v.as_u64(), v.as_f64()) {
+        (Some(n), _) => n.clamp(u64::from(lo), u64::from(hi)),
+        (None, Some(f)) if f.is_finite() && f >= 0.0 && f.fract() == 0.0 => f.clamp(f64::from(lo), f64::from(hi)) as u64,
+        _ => return Err(bad(cmd, format!("`{key}` = {v} must be a whole number ({lo}..={hi})"))),
+    };
+    Ok(Some(u32::try_from(n).unwrap_or(hi)))
+}
+
 fn count_set_group(s: &mut Session, p: &Value) -> Result<Value> {
     const CMD: &str = "count.setGroup";
     let d = doc(s)?;
@@ -853,11 +870,11 @@ fn count_set_group(s: &mut Session, p: &Value) -> Result<Value> {
     if let Some(c) = color_of(p, "color") {
         grp.color = c;
     }
-    if let Some(v) = p.get("markerSize").and_then(Value::as_u64) {
-        grp.marker_size = (v as u32).clamp(1, 10);
+    if let Some(v) = whole_size(CMD, p, "markerSize", 1, 10)? {
+        grp.marker_size = v;
     }
-    if let Some(v) = p.get("labelSize").and_then(Value::as_u64) {
-        grp.label_size = (v as u32).clamp(8, 72);
+    if let Some(v) = whole_size(CMD, p, "labelSize", 8, 72)? {
+        grp.label_size = v;
     }
     if let Some(v) = p.get("visible").and_then(Value::as_bool) {
         grp.visible = v;
diff --git a/crates/engine/src/analysis_cmds/tests.rs b/crates/engine/src/analysis_cmds/tests.rs
index c043665b11..e5272d558d 100644
--- a/crates/engine/src/analysis_cmds/tests.rs
+++ b/crates/engine/src/analysis_cmds/tests.rs
@@ -349,3 +349,40 @@ fn now_iso_shape() {
     assert_eq!(t.len(), 20, "{t}");
     assert!(t.ends_with('Z') && &t[4..5] == "-");
 }
+
+#[test]
+fn count_set_group_takes_sizes_sent_as_whole_floats() {
+    // The options bar sends `{"markerSize": 8.0, "labelSize": 20.0}`; `as_u64` read neither, so
+    // the fields did nothing.
+    let mut s = session(100, 100, 8);
+    s.execute("count.add", json!({"x": 10, "y": 10})).unwrap();
+    s.execute("count.setGroup", json!({"markerSize": 8.0, "labelSize": 20.0})).unwrap();
+    let g = &d(&s).measurement.count_groups[0];
+    assert_eq!((g.marker_size, g.label_size), (8, 20));
+    // Out-of-range whole numbers clamp, also huge ones that `as u32` would have wrapped.
+    s.execute("count.setGroup", json!({"markerSize": 4_294_967_297u64, "labelSize": 1e300})).unwrap();
+    let g = &d(&s).measurement.count_groups[0];
+    assert_eq!((g.marker_size, g.label_size), (10, 72));
+}
+
+#[test]
+fn count_set_group_rejects_sizes_that_are_not_whole_numbers() {
+    let mut s = session(100, 100, 8);
+    s.execute("count.add", json!({"x": 10, "y": 10})).unwrap();
+    s.execute("count.setGroup", json!({"markerSize": 3, "labelSize": 12})).unwrap();
+    let past = s.active().unwrap().history.past_len();
+    for p in [
+        json!({"markerSize": 8.5}),
+        json!({"labelSize": 12.25}),
+        json!({"markerSize": -2}),
+        json!({"labelSize": -9.0}),
+        json!({"markerSize": "8"}),
+        json!({"labelSize": true}),
+    ] {
+        let err = s.execute("count.setGroup", p.clone()).unwrap_err();
+        assert!(matches!(err, EngineError::BadParams { .. }), "{p}: {err}");
+    }
+    let g = &d(&s).measurement.count_groups[0];
+    assert_eq!((g.marker_size, g.label_size), (3, 12), "a rejected call changes nothing");
+    assert_eq!(s.active().unwrap().history.past_len(), past);
+}
diff --git a/crates/engine/src/atn_cmds.rs b/crates/engine/src/atn_cmds.rs
new file mode 100644
index 0000000000..391c21abd8
--- /dev/null
+++ b/crates/engine/src/atn_cmds.rs
@@ -0,0 +1,3250 @@
+//! Photoshop Actions files (`.atn`): Load Actions (`actions.load`) and Save Actions
+//! (`actions.save`), plus the two step commands a Photoshop set needs: `actions.stopMessage`
+//! (Photoshop's Insert Stop) and `actions.photoshopStep` (a step PhotoCraft has no command for
+//! yet, kept verbatim so Save Actions writes it back unchanged).
+//!
+//! Parsing and writing live in `photocraft-psd` (`atn`); this module maps Photoshop *events*
+//! (`gaussianBlur` with `Rds`, `make` of an adjustment layer, `set` of the selection…) onto
+//! PhotoCraft commands and back. An event is keyed by both its four-character code (`GsnB`,
+//! older files) and its string name (`gaussianBlur`, Photoshop 2024 and later), as the two are
+//! interchangeable in Photoshop. The table ([`EVENTS`]) is bidirectional: a step that was
+//! imported exports to the same event. Events outside it become `actions.photoshopStep` steps,
+//! which fail at playback with the step's Photoshop name, so an action never silently skips
+//! work; tool selections and other steps with no document effect are imported switched off.
+//!
+//! Layer references by name (`select` of layer "Shadow") become `{"layer": "Shadow"}`, which
+//! `commands::layer_param` resolves in whatever document the action plays on (#219).
+
+use photocraft_psd::atn::{self, AtnAction, AtnEvent, AtnFile, AtnItem};
+use photocraft_psd::descriptor::{Class, Descriptor, Id, ReferenceItem, UnicodeString, Value as D};
+use serde_json::{Map, Value, json};
+
+use crate::actions_cmds::Action;
+use crate::commands::CommandSpec;
+use crate::{EngineError, Result, Session};
+
+/// A step PhotoCraft cannot play yet, kept verbatim (`{"event", "name", "descriptor": base64}`).
+pub const PHOTOSHOP_STEP: &str = "actions.photoshopStep";
+/// Photoshop's Insert Stop: `{"message", "allowContinue"}`.
+pub const STOP_MESSAGE: &str = "actions.stopMessage";
+/// The set name Save Actions uses for actions that came from no set.
+pub const DEFAULT_SET: &str = "PhotoCraft Actions";
+
+fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
+    EngineError::BadParams { cmd: cmd.into(), msg: msg.into() }
+}
+
+fn always(_: &Session) -> std::result::Result<(), String> {
+    Ok(())
+}
+
+// ------------------------------------------------------------------ descriptor access
+
+fn num(v: &D) -> Option<f64> {
+    match v {
+        D::Integer(i) => Some(f64::from(*i)),
+        D::LargeInteger(i) => Some(*i as f64),
+        D::Double(d) | D::UnitFloat { value: d, .. } => Some(*d),
+        _ => None,
+    }
+    .filter(|f| f.is_finite())
+}
+
+fn trimmed(id: &Id) -> String {
+    String::from_utf8_lossy(id.as_bytes()).trim_end().to_string()
+}
+
+fn get_num(d: &Descriptor, k: &str) -> Option<f64> {
+    d.get(k).and_then(num)
+}
+
+fn get_bool(d: &Descriptor, k: &str) -> Option<bool> {
+    match d.get(k) {
+        Some(D::Boolean(b)) => Some(*b),
+        _ => None,
+    }
+}
+
+fn get_text(d: &Descriptor, k: &str) -> Option<String> {
+    match d.get(k) {
+        Some(D::Text(t)) => Some(t.to_string_lossy()),
+        _ => None,
+    }
+}
+
+/// An enumerated value's id, trailing spaces removed (`Ordn.Trgt` → `"Trgt"`).
+fn get_enum(d: &Descriptor, k: &str) -> Option<String> {
+    match d.get(k) {
+        Some(D::Enumerated { value, .. }) => Some(trimmed(value)),
+        _ => None,
+    }
+}
+
+fn get_obj<'a>(d: &'a Descriptor, k: &str) -> Option<&'a Descriptor> {
+    match d.get(k) {
+        Some(D::Descriptor(o) | D::GlobalObject(o)) => Some(o),
+        _ => None,
+    }
+}
+
+fn get_list<'a>(d: &'a Descriptor, k: &str) -> Option<&'a [D]> {
+    match d.get(k) {
+        Some(D::List(l)) => Some(l),
+        _ => None,
+    }
+}
+
+fn get_ref<'a>(d: &'a Descriptor, k: &str) -> Option<&'a [ReferenceItem]> {
+    match d.get(k) {
+        Some(D::Reference(r)) => Some(r),
+        _ => None,
+    }
+}
+
+/// The class of a reference's first item, trimmed (`Lyr`, `Chnl`, `AdjL`…).
+fn ref_class(r: &[ReferenceItem]) -> Option<String> {
+    Some(trimmed(match r.first()? {
+        ReferenceItem::Property { class, .. }
+        | ReferenceItem::Class(class)
+        | ReferenceItem::Enumerated { class, .. }
+        | ReferenceItem::Offset { class, .. }
+        | ReferenceItem::Identifier { class, .. }
+        | ReferenceItem::Index { class, .. }
+        | ReferenceItem::Name { class, .. } => &class.class_id,
+    }))
+}
+
+/// How a reference names its target: the ordinal (`Trgt`, `Frnt`…), a name, a property…
+enum Target {
+    Ordinal(String),
+    Name(String),
+    Property(String),
+    Class,
+    Offset(i32),
+    Other,
+}
+
+fn target(r: &[ReferenceItem]) -> Target {
+    match r.first() {
+        Some(ReferenceItem::Enumerated { value, .. }) => Target::Ordinal(trimmed(value)),
+        Some(ReferenceItem::Name { name, .. }) => Target::Name(name.to_string_lossy()),
+        Some(ReferenceItem::Property { key, .. }) => Target::Property(trimmed(key)),
+        Some(ReferenceItem::Class(_)) => Target::Class,
+        Some(ReferenceItem::Offset { offset, .. }) => Target::Offset(*offset),
+        _ => Target::Other,
+    }
+}
+
+/// `{"layer": name}` for a reference that names a layer, `{}` for the target layer, `None`
+/// for anything else (an index or id: meaningless in another document).
+fn layer_target(r: &[ReferenceItem]) -> Option<Map<String, Value>> {
+    let mut m = Map::new();
+    match target(r) {
+        Target::Ordinal(o) if o == "Trgt" => {}
+        Target::Name(n) => {
+            m.insert("layer".into(), json!(n));
+        }
+        Target::Property(p) if p == "Bckg" => {
+            m.insert("layer".into(), json!("Background"));
+        }
+        _ => return None,
+    }
+    Some(m)
+}
+
+// ------------------------------------------------------------------ descriptor building
+
+/// A Photoshop id: codes shorter than four characters are space-padded (`H   `, `Rd  `),
+/// longer names stay strings.
+fn code(s: &str) -> Id {
+    if s.len() < 4 { Id::new(&format!("{s:<4}")) } else { Id::new(s) }
+}
+
+fn class(c: &str) -> Class {
+    Class { name: UnicodeString::new_nul(""), class_id: code(c) }
+}
+
+/// The pixel and percent units of a `UntF` value.
+const PX: [u8; 4] = *b"#Pxl";
+const PCT: [u8; 4] = *b"#Prc";
+/// Points (1/72 in): what Photoshop calls "relative" units.
+const PT: [u8; 4] = *b"#Rlt";
+
+fn px(v: f64) -> D {
+    D::UnitFloat { unit: PX, value: v }
+}
+
+fn pct(v: f64) -> D {
+    D::UnitFloat { unit: *b"#Prc", value: v }
+}
+
+fn ang(v: f64) -> D {
+    D::UnitFloat { unit: *b"#Ang", value: v }
+}
+
+fn long(v: f64) -> D {
+    D::Integer(v.round().clamp(f64::from(i32::MIN), f64::from(i32::MAX)) as i32)
+}
+
+fn text(s: &str) -> D {
+    D::Text(UnicodeString::new_nul(s))
+}
+
+fn enm(ty: &str, v: &str) -> D {
+    D::Enumerated { type_id: code(ty), value: code(v) }
+}
+
+fn target_ref(cls: &str) -> D {
+    D::Reference(vec![ReferenceItem::Enumerated { class: class(cls), type_id: Id::new("Ordn"), value: Id::new("Trgt") }])
+}
+
+fn name_ref(cls: &str, name: &str) -> D {
+    D::Reference(vec![ReferenceItem::Name { class: class(cls), name: UnicodeString::new_nul(name) }])
+}
+
+fn class_ref(cls: &str) -> D {
+    D::Reference(vec![ReferenceItem::Class(class(cls))])
+}
+
+/// The `null` reference for a command's `layer` param: by name, else the target layer.
+fn layer_ref(p: &Value) -> D {
+    match p.get("layer") {
+        Some(Value::String(n)) => name_ref("Lyr ", n),
+        _ => target_ref("Lyr "),
+    }
+}
+
+fn desc(cls: &str) -> Descriptor {
+    Descriptor::new(cls)
+}
+
+// ------------------------------------------------------------------ JSON access
+
+fn jnum(p: &Value, k: &str) -> Option<f64> {
+    p.get(k).and_then(Value::as_f64).filter(|f| f.is_finite())
+}
+
+fn jbool(p: &Value, k: &str) -> Option<bool> {
+    p.get(k).and_then(Value::as_bool)
+}
+
+fn jstr<'a>(p: &'a Value, k: &str) -> Option<&'a str> {
+    p.get(k).and_then(Value::as_str)
+}
+
+// ------------------------------------------------------------------ colours and enums
+
+/// A Photoshop colour object as `#rrggbb`: `RGBC` (0..255), `HSBC`, `Grsc`.
+fn color_hex(c: &Descriptor) -> Option<String> {
+    let hex = |r: f64, g: f64, b: f64| {
+        format!("#{:02x}{:02x}{:02x}", r.round().clamp(0.0, 255.0) as u8, g.round().clamp(0.0, 255.0) as u8, b.round().clamp(0.0, 255.0) as u8)
+    };
+    if let (Some(r), Some(g), Some(b)) = (get_num(c, "Rd  "), get_num(c, "Grn "), get_num(c, "Bl  ")) {
+        return Some(hex(r, g, b));
+    }
+    if let (Some(h), Some(s), Some(v)) = (get_num(c, "H   "), get_num(c, "Strt"), get_num(c, "Brgh")) {
+        let (s, v) = ((s / 100.0).clamp(0.0, 1.0), (v / 100.0).clamp(0.0, 1.0));
+        let h = h.rem_euclid(360.0) / 60.0;
+        let i = h.floor();
+        let f = h - i;
+        let (p, q, t) = (v * (1.0 - s), v * (1.0 - s * f), v * (1.0 - s * (1.0 - f)));
+        let (r, g, b) = match i as i32 {
+            0 => (v, t, p),
+            1 => (q, v, p),
+            2 => (p, v, t),
+            3 => (p, q, v),
+            4 => (t, p, v),
+            _ => (v, p, q),
+        };
+        return Some(hex(r * 255.0, g * 255.0, b * 255.0));
+    }
+    get_num(c, "Gry ").map(|g| {
+        let v = 255.0 - g * 2.55;
+        hex(v, v, v)
+    })
+}
+
+fn color_desc(hex: &str) -> Option<Descriptor> {
+    let h = hex.strip_prefix('#')?;
+    if h.len() != 6 || !h.is_ascii() {
+        return None;
+    }
+    let ch = |i: usize| u8::from_str_radix(h.get(i..i + 2)?, 16).ok().map(f64::from);
+    Some(desc("RGBC").with("Rd  ", D::Double(ch(0)?)).with("Grn ", D::Double(ch(2)?)).with("Bl  ", D::Double(ch(4)?)))
+}
+
+/// A `Pth ` value's text: Photoshop stores `"txtu"`, a little-endian total length, a
+/// little-endian UTF-16 unit count and the units (NUL-terminated).
+fn path_text(v: &D) -> Option<String> {
+    let D::Path(b) = v else { return None };
+    if b.get(0..4)? != b"txtu" {
+        return None;
+    }
+    let n = u32::from_le_bytes(b.get(8..12)?.try_into().ok()?) as usize;
+    let units: Vec<u16> = b.get(12..12usize.checked_add(n.checked_mul(2)?)?)?.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect();
+    let text = String::from_utf16_lossy(&units);
+    let text = text.trim_end_matches('\0');
+    (!text.is_empty()).then(|| text.to_string())
+}
+
+fn path_value(text: &str) -> D {
+    let units: Vec<u16> = text.encode_utf16().chain(std::iter::once(0)).collect();
+    let mut b = b"txtu".to_vec();
+    b.extend_from_slice(&((12 + units.len() * 2) as u32).to_le_bytes());
+    b.extend_from_slice(&(units.len() as u32).to_le_bytes());
+    for u in units {
+        b.extend_from_slice(&u.to_le_bytes());
+    }
+    D::Path(b)
+}
+
+/// Photoshop's `BlnM` enumeration ↔ PhotoCraft's blend mode labels.
+const BLEND_MODES: &[(&str, &str)] = &[
+    ("Nrml", "Normal"),
+    ("Dslv", "Dissolve"),
+    ("Drkn", "Darken"),
+    ("Mltp", "Multiply"),
+    ("CBrn", "Color Burn"),
+    ("linearBurn", "Linear Burn"),
+    ("darkerColor", "Darker Color"),
+    ("Lghn", "Lighten"),
+    ("Scrn", "Screen"),
+    ("CDdg", "Color Dodge"),
+    ("linearDodge", "Linear Dodge (Add)"),
+    ("lighterColor", "Lighter Color"),
+    ("Ovrl", "Overlay"),
+    ("SftL", "Soft Light"),
+    ("HrdL", "Hard Light"),
+    ("vividLight", "Vivid Light"),
+    ("linearLight", "Linear Light"),
+    ("pinLight", "Pin Light"),
+    ("hardMix", "Hard Mix"),
+    ("Dfrn", "Difference"),
+    ("Xclu", "Exclusion"),
+    ("blendSubtraction", "Subtract"),
+    ("blendDivide", "Divide"),
+    ("H", "Hue"),
+    ("Strt", "Saturation"),
+    ("Clr", "Color"),
+    ("Lmns", "Luminosity"),
+    ("PsTh", "Pass Through"),
+];
+
+fn blend_label(ps: &str) -> Option<&'static str> {
+    BLEND_MODES.iter().find(|(k, _)| *k == ps).map(|(_, v)| *v)
+}
+
+fn blend_ps(label: &str) -> Option<&'static str> {
+    crate::commands::blend_from_str(label).and_then(|m| BLEND_MODES.iter().find(|(_, v)| crate::commands::blend_from_str(v) == Some(m))).map(|(k, _)| *k)
+}
+
+/// Photoshop ↔ PhotoCraft value tables; Photoshop codes compare without their space padding.
+fn lookup<'a>(table: &'a [(&'a str, &'a str)], key: &str) -> Option<&'a str> {
+    table.iter().find(|(k, _)| k.trim_end() == key.trim_end()).map(|(_, v)| *v)
+}
+
+fn lookup_back<'a>(table: &'a [(&'a str, &'a str)], value: &str) -> Option<&'a str> {
+    table.iter().find(|(_, v)| *v == value).map(|(k, _)| *k)
+}
+
+/// `Chnl` enumeration ↔ the per-channel keys of the adjustment commands.
+const CHANNELS: &[(&str, &str)] = &[
+    ("Rd", "red"),
+    ("Grn", "green"),
+    ("Bl", "blue"),
+    ("Gry", "gray"),
+    ("Cyn", "cyan"),
+    ("Mgnt", "magenta"),
+    ("Yllw", "yellow"),
+    ("Blck", "black"),
+    ("Lmnc", "lightness"),
+    ("A", "a"),
+    ("B", "b"),
+];
+
+/// The channel an adjustment entry's `Chnl` reference names: `None` = the composite.
+fn channel_key(d: &Descriptor) -> Option<Option<&'static str>> {
+    let r = get_ref(d, "Chnl")?;
+    Some(match target(r) {
+        Target::Ordinal(o) if o == "Trgt" || o == "Cmps" => None,
+        Target::Ordinal(o) => Some(lookup(CHANNELS, &o)?),
+        _ => return None,
+    })
+}
+
+fn channel_ref(key: Option<&str>) -> D {
+    let value = key.and_then(|k| lookup_back(CHANNELS, k));
+    D::Reference(vec![ReferenceItem::Enumerated {
+        class: class("Chnl"),
+        type_id: code(if value.is_some() { "Chnl" } else { "Ordn" }),
+        value: code(value.unwrap_or("Trgt")),
+    }])
+}
+
+// ------------------------------------------------------------------ field tables
+
+#[derive(Clone, Copy)]
+enum Kind {
+    Px,
+    Pct,
+    Ang,
+    Long,
+    Dbl,
+    Bool,
+    /// An enumeration: its type id and the Photoshop ↔ PhotoCraft value pairs.
+    Enum(&'static str, &'static [(&'static str, &'static str)]),
+    /// A blend mode (`BlnM`).
+    Blend,
+    /// A colour object ↔ `#rrggbb`.
+    Color,
+}
+
+/// One descriptor key ↔ one command param.
+struct F(&'static str, &'static str, Kind);
+
+fn fields_from(d: &Descriptor, fields: &[F]) -> Option<Map<String, Value>> {
+    let mut m = Map::new();
+    for F(key, param, kind) in fields {
+        let v = match kind {
+            Kind::Px | Kind::Pct | Kind::Ang | Kind::Long | Kind::Dbl => get_num(d, key).map(Value::from),
+            Kind::Bool => get_bool(d, key).map(Value::from),
+            Kind::Enum(_, table) => match get_enum(d, key) {
+                Some(e) => Some(Value::from(lookup(table, &e)?)),
+                None => None,
+            },
+            Kind::Blend => match get_enum(d, key) {
+                Some(e) => Some(Value::from(blend_label(&e)?)),
+                None => None,
+            },
+            Kind::Color => match get_obj(d, key) {
+                Some(c) => Some(Value::from(color_hex(c)?)),
+                None => None,
+            },
+        };
+        if let Some(v) = v {
+            m.insert((*param).into(), v);
+        }
+    }
+    Some(m)
+}
+
+fn fields_to(p: &Value, fields: &[F], mut d: Descriptor) -> Option<Descriptor> {
+    for F(key, param, kind) in fields {
+        let Some(v) = p.get(param) else { continue };
+        let out = match kind {
+            Kind::Px => px(v.as_f64()?),
+            Kind::Pct => pct(v.as_f64()?),
+            Kind::Ang => ang(v.as_f64()?),
+            Kind::Long => long(v.as_f64()?),
+            Kind::Dbl => D::Double(v.as_f64()?),
+            Kind::Bool => D::Boolean(v.as_bool()?),
+            Kind::Enum(ty, table) => enm(ty, lookup_back(table, v.as_str()?)?),
+            Kind::Blend => enm("BlnM", blend_ps(v.as_str()?)?),
+            Kind::Color => D::Descriptor(color_desc(v.as_str()?)?),
+        };
+        d = d.with(key, out);
+    }
+    Some(d)
+}
+
+// ------------------------------------------------------------------ adjustments
+
+/// The `Adjs` entries of a per-channel adjustment (Levels, Curves): `(channel key, entry)`.
+fn per_channel(d: &Descriptor) -> Option<Vec<(Option<&'static str>, &Descriptor)>> {
+    get_list(d, "Adjs")?
+        .iter()
+        .map(|v| match v {
+            D::Descriptor(e) => Some((channel_key(e)?, e)),
+            _ => None,
+        })
+        .collect()
+}
+
+fn levels_from(d: &Descriptor) -> Option<Value> {
+    if get_bool(d, "Auto") == Some(true) {
+        return None;
+    }
+    let mut out = Map::new();
+    for (chan, e) in per_channel(d)? {
+        let mut m = Map::new();
+        if let Some(i) = get_list(e, "Inpt") {
+            if let Some(v) = i.first().and_then(num) {
+                m.insert("inBlack".into(), v.into());
+            }
+            if let Some(v) = i.get(1).and_then(num) {
+                m.insert("inWhite".into(), v.into());
+            }
+        }
+        if let Some(o) = get_list(e, "Otpt") {
+            if let Some(v) = o.first().and_then(num) {
+                m.insert("outBlack".into(), v.into());
+            }
+            if let Some(v) = o.get(1).and_then(num) {
+                m.insert("outWhite".into(), v.into());
+            }
+        }
+        if let Some(g) = get_num(e, "Gmm ") {
+            m.insert("gamma".into(), g.into());
+        }
+        match chan {
+            None => out.extend(m),
+            Some(k) => {
+                out.insert(k.into(), Value::Object(m));
+            }
+        }
+    }
+    Some(Value::Object(out))
+}
+
+fn levels_entry(chan: Option<&str>, p: &Value) -> Descriptor {
+    let mut e = desc("LvlA").with("Chnl", channel_ref(chan));
+    if jnum(p, "inBlack").is_some() || jnum(p, "inWhite").is_some() {
+        e = e.with("Inpt", D::List(vec![long(jnum(p, "inBlack").unwrap_or(0.0)), long(jnum(p, "inWhite").unwrap_or(255.0))]));
+    }
+    if let Some(g) = jnum(p, "gamma") {
+        e = e.with("Gmm ", D::Double(g));
+    }
+    if jnum(p, "outBlack").is_some() || jnum(p, "outWhite").is_some() {
+        e = e.with("Otpt", D::List(vec![long(jnum(p, "outBlack").unwrap_or(0.0)), long(jnum(p, "outWhite").unwrap_or(255.0))]));
+    }
+    e
+}
+
+fn levels_to(p: &Value) -> Option<Descriptor> {
+    let mut entries = vec![D::Descriptor(levels_entry(None, p))];
+    for (_, k) in CHANNELS {
+        if let Some(c) = p.get(*k).filter(|v| v.is_object()) {
+            entries.push(D::Descriptor(levels_entry(Some(k), c)));
+        }
+    }
+    Some(desc("Lvls").with("presetKind", enm("presetKindType", "presetKindCustom")).with("Adjs", D::List(entries)))
+}
+
+fn curve_points(e: &Descriptor) -> Option<Value> {
+    let pts: Option<Vec<Value>> = get_list(e, "Crv ")?
+        .iter()
+        .map(|v| match v {
+            D::Descriptor(pt) => Some(json!([get_num(pt, "Hrzn")?, get_num(pt, "Vrtc")?])),
+            _ => None,
+        })
+        .collect();
+    pts.map(Value::Array)
+}
+
+fn curves_from(d: &Descriptor) -> Option<Value> {
+    let mut out = Map::new();
+    for (chan, e) in per_channel(d)? {
+        let pts = curve_points(e)?;
+        out.insert(chan.unwrap_or("points").into(), pts);
+    }
+    Some(Value::Object(out))
+}
+
+fn curve_entry(chan: Option<&str>, pts: &Value) -> Option<Descriptor> {
+    let list: Option<Vec<D>> = pts
+        .as_array()?
+        .iter()
+        .map(|pt| {
+            let a = pt.as_array()?;
+            Some(D::Descriptor(desc("Pnt ").with("Hrzn", D::Double(a.first()?.as_f64()?)).with("Vrtc", D::Double(a.get(1)?.as_f64()?))))
+        })
+        .collect();
+    Some(desc("CrvA").with("Chnl", channel_ref(chan)).with("Crv ", D::List(list?)))
+}
+
+fn curves_to(p: &Value) -> Option<Descriptor> {
+    let mut entries = Vec::new();
+    if let Some(pts) = p.get("points") {
+        entries.push(D::Descriptor(curve_entry(None, pts)?));
+    }
+    for (_, k) in CHANNELS {
+        if let Some(pts) = p.get(*k) {
+            entries.push(D::Descriptor(curve_entry(Some(k), pts)?));
+        }
+    }
+    Some(desc("Crvs").with("presetKind", enm("presetKindType", "presetKindCustom")).with("Adjs", D::List(entries)))
+}
+
+const HUE_RANGES: [&str; 6] = ["reds", "yellows", "greens", "cyans", "blues", "magentas"];
+
+fn hue_sat_from(d: &Descriptor) -> Option<Value> {
+    let mut out = Map::new();
+    if let Some(c) = get_bool(d, "Clrz") {
+        out.insert("colorize".into(), c.into());
+    }
+    for e in get_list(d, "Adjs").unwrap_or(&[]) {
+        let D::Descriptor(e) = e else { return None };
+        let mut m = Map::new();
+        for (key, param) in [("Hue ", "hue"), ("Strt", "saturation"), ("Lght", "lightness")] {
+            if let Some(v) = get_num(e, key) {
+                m.insert(param.into(), v.into());
+            }
+        }
+        match get_num(e, "LclR") {
+            None => out.extend(m),
+            Some(r) => {
+                let name = *HUE_RANGES.get((r as usize).checked_sub(1)?)?;
+                if let (Some(a), Some(b), Some(c), Some(dd)) = (get_num(e, "BgnR"), get_num(e, "BgnS"), get_num(e, "EndS"), get_num(e, "EndR")) {
+                    m.insert("range".into(), json!([a, b, c, dd]));
+                }
+                out.insert(name.into(), Value::Object(m));
+            }
+        }
+    }
+    Some(Value::Object(out))
+}
+
+fn hue_entry(p: &Value, range: Option<(usize, &Value)>) -> Option<Descriptor> {
+    let mut e = desc("Hst2");
+    if let Some((i, r)) = range {
+        e = e.with("LclR", long(i as f64 + 1.0));
+        if let Some(a) = r.get("range").and_then(Value::as_array)
+            && a.len() == 4
+        {
+            for (k, v) in ["BgnR", "BgnS", "EndS", "EndR"].iter().zip(a) {
+                e = e.with(k, long(v.as_f64()?));
+            }
+        }
+    }
+    for (key, param) in [("Hue ", "hue"), ("Strt", "saturation"), ("Lght", "lightness")] {
+        e = e.with(key, long(jnum(p, param).unwrap_or(0.0)));
+    }
+    Some(e)
+}
+
+fn hue_sat_to(p: &Value) -> Option<Descriptor> {
+    let mut entries = vec![D::Descriptor(hue_entry(p, None)?)];
+    for (i, name) in HUE_RANGES.iter().enumerate() {
+        if let Some(r) = p.get(*name).filter(|v| v.is_object()) {
+            entries.push(D::Descriptor(hue_entry(r, Some((i, r)))?));
+        }
+    }
+    Some(
+        desc("HStr")
+            .with("presetKind", enm("presetKindType", "presetKindCustom"))
+            .with("Clrz", D::Boolean(jbool(p, "colorize").unwrap_or(false)))
+            .with("Adjs", D::List(entries)),
+    )
+}
+
+fn triple(d: &Descriptor, k: &str) -> Option<Value> {
+    let l = get_list(d, k)?;
+    let v: Option<Vec<f64>> = l.iter().map(num).collect();
+    Some(json!(v?))
+}
+
+fn triple_to(p: &Value, k: &str) -> Option<D> {
+    Some(D::List(p.get(k)?.as_array()?.iter().map(|v| v.as_f64().map(long)).collect::<Option<Vec<_>>>()?))
+}
+
+fn color_balance_from(d: &Descriptor) -> Option<Value> {
+    let mut out = Map::new();
+    for (key, param) in [("ShdL", "shadows"), ("MdtL", "midtones"), ("HghL", "highlights")] {
+        if let Some(v) = triple(d, key) {
+            out.insert(param.into(), v);
+        }
+    }
+    if let Some(b) = get_bool(d, "PrsL") {
+        out.insert("preserveLuminosity".into(), b.into());
+    }
+    Some(Value::Object(out))
+}
+
+fn color_balance_to(p: &Value) -> Option<Descriptor> {
+    let mut d = desc("ClrB");
+    for (key, param) in [("ShdL", "shadows"), ("MdtL", "midtones"), ("HghL", "highlights")] {
+        d = d.with(key, triple_to(p, param).unwrap_or_else(|| D::List(vec![long(0.0), long(0.0), long(0.0)])));
+    }
+    Some(d.with("PrsL", D::Boolean(jbool(p, "preserveLuminosity").unwrap_or(true))))
+}
+
+const BW: &[F] = &[
+    F("Rd  ", "reds", Kind::Long),
+    F("Yllw", "yellows", Kind::Long),
+    F("Grn ", "greens", Kind::Long),
+    F("Cyn ", "cyans", Kind::Long),
+    F("Bl  ", "blues", Kind::Long),
+    F("Mgnt", "magentas", Kind::Long),
+    F("useTint", "tint", Kind::Bool),
+    F("tintColor", "tintColor", Kind::Color),
+];
+
+fn mixer_channel(e: &Descriptor) -> Option<Value> {
+    Some(json!([get_num(e, "Rd  ").unwrap_or(0.0), get_num(e, "Grn ").unwrap_or(0.0), get_num(e, "Bl  ").unwrap_or(0.0), get_num(e, "Cnst").unwrap_or(0.0)]))
+}
+
+fn channel_mixer_from(d: &Descriptor) -> Option<Value> {
+    let mut out = Map::new();
+    for (key, param) in [("Rd  ", "red"), ("Grn ", "green"), ("Bl  ", "blue"), ("Gry ", "gray")] {
+        if let Some(e) = get_obj(d, key) {
+            out.insert(param.into(), mixer_channel(e)?);
+        }
+    }
+    if let Some(m) = get_bool(d, "Mnch") {
+        out.insert("monochrome".into(), m.into());
+    }
+    Some(Value::Object(out))
+}
+
+fn channel_mixer_to(p: &Value) -> Option<Descriptor> {
+    let mut d = desc("ChnM").with("presetKind", enm("presetKindType", "presetKindCustom"));
+    for (key, param) in [("Rd  ", "red"), ("Grn ", "green"), ("Bl  ", "blue"), ("Gry ", "gray")] {
+        if let Some(a) = p.get(param).and_then(Value::as_array) {
+            let v = |i: usize| a.get(i).and_then(Value::as_f64).unwrap_or(0.0);
+            d = d.with(key, D::Descriptor(desc("ChMx").with("Rd  ", pct(v(0))).with("Grn ", pct(v(1))).with("Bl  ", pct(v(2))).with("Cnst", pct(v(3)))));
+        }
+    }
+    Some(d.with("Mnch", D::Boolean(jbool(p, "monochrome").unwrap_or(false))))
+}
+
+const SELECTIVE_RANGES: &[(&str, &str)] = &[
+    ("Rds", "reds"),
+    ("Yllw", "yellows"),
+    ("Grns", "greens"),
+    ("Cyns", "cyans"),
+    ("Bls", "blues"),
+    ("Mgnt", "magentas"),
+    ("Whts", "whites"),
+    ("Ntrl", "neutrals"),
+    ("Blks", "blacks"),
+];
+
+fn selective_from(d: &Descriptor) -> Option<Value> {
+    let mut out = Map::new();
+    if let Some(m) = get_enum(d, "Mthd") {
+        out.insert("method".into(), (if m == "Absl" { "absolute" } else { "relative" }).into());
+    }
+    for e in get_list(d, "ClrC").unwrap_or(&[]) {
+        let D::Descriptor(e) = e else { return None };
+        let name = lookup(SELECTIVE_RANGES, &get_enum(e, "Clrs")?)?;
+        let v = |k: &str| get_num(e, k).unwrap_or(0.0);
+        out.insert(name.into(), json!([v("Cyn "), v("Mgnt"), v("Yllw"), v("Blck")]));
+    }
+    Some(Value::Object(out))
+}
+
+fn selective_to(p: &Value) -> Option<Descriptor> {
+    let mut list = Vec::new();
+    for (ps, name) in SELECTIVE_RANGES {
+        if let Some(a) = p.get(*name).and_then(Value::as_array) {
+            let v = |i: usize| a.get(i).and_then(Value::as_f64).unwrap_or(0.0);
+            list.push(D::Descriptor(
+                desc("ClrC").with("Clrs", enm("Clrs", ps)).with("Cyn ", pct(v(0))).with("Mgnt", pct(v(1))).with("Yllw", pct(v(2))).with("Blck", pct(v(3))),
+            ));
+        }
+    }
+    Some(
+        desc("SlcC")
+            .with("presetKind", enm("presetKindType", "presetKindCustom"))
+            .with("Mthd", enm("CrcM", if jstr(p, "method") == Some("absolute") { "Absl" } else { "Rltv" }))
+            .with("ClrC", D::List(list)),
+    )
+}
+
+/// Gradient Map: the gradient's colour stops at 0..4096 → `stops: [[0..1, "#rrggbb"], …]`.
+fn gradient_map_from(d: &Descriptor) -> Option<Value> {
+    let grad = get_obj(d, "Grad")?;
+    let stops: Option<Vec<Value>> = get_list(grad, "Clrs")?
+        .iter()
+        .map(|v| match v {
+            D::Descriptor(stop) => Some(json!([(get_num(stop, "Lctn")? / 4096.0).clamp(0.0, 1.0), color_hex(get_obj(stop, "Clr ")?)?])),
+            _ => None,
+        })
+        .collect();
+    let mut out = json!({"stops": stops?});
+    if let Some(r) = get_bool(d, "Rvrs") {
+        out["reverse"] = json!(r);
+    }
+    if let Some(dd) = get_bool(d, "Dthr") {
+        out["dither"] = json!(dd);
+    }
+    Some(out)
+}
+
+fn gradient_map_to(p: &Value) -> Option<Descriptor> {
+    let stops: Option<Vec<D>> = p
+        .get("stops")?
+        .as_array()?
+        .iter()
+        .map(|st| {
+            let a = st.as_array()?;
+            Some(D::Descriptor(
+                desc("Clrt")
+                    .with("Clr ", D::Descriptor(color_desc(a.get(1)?.as_str()?)?))
+                    .with("Type", enm("Clry", "UsrS"))
+                    .with("Lctn", long((a.first()?.as_f64()? * 4096.0).round()))
+                    .with("Mdpn", long(50.0)),
+            ))
+        })
+        .collect();
+    let transparency = D::List(vec![
+        D::Descriptor(desc("TrnS").with("Opct", pct(100.0)).with("Lctn", long(0.0)).with("Mdpn", long(50.0))),
+        D::Descriptor(desc("TrnS").with("Opct", pct(100.0)).with("Lctn", long(4096.0)).with("Mdpn", long(50.0))),
+    ]);
+    let grad = desc("Grdn")
+        .with("Nm  ", text("Custom"))
+        .with("GrdF", enm("GrdF", "CstS"))
+        .with("Intr", D::Double(4096.0))
+        .with("Clrs", D::List(stops?))
+        .with("Trns", transparency);
+    Some(
+        desc("GdMp")
+            .with("Grad", D::Descriptor(grad))
+            .with("Rvrs", D::Boolean(jbool(p, "reverse").unwrap_or(false)))
+            .with("Dthr", D::Boolean(jbool(p, "dither").unwrap_or(false))),
+    )
+}
+
+/// An adjustment: its Photoshop class (also the direct event's code), the command suffix (`image.adjustments.<suffix>`, `layer.newAdjustmentLayer.<suffix>`), and
+/// the converters between the adjustment descriptor and the command params.
+struct Adjustment {
+    class: &'static str,
+    suffix: &'static str,
+    from: fn(&Descriptor) -> Option<Value>,
+    to: fn(&Value) -> Option<Descriptor>,
+}
+
+macro_rules! adj_fields {
+    ($class:literal, $suffix:literal, $fields:expr) => {
+        Adjustment { class: $class, suffix: $suffix, from: |d| fields_from(d, $fields).map(Value::Object), to: |p| fields_to(p, $fields, desc($class)) }
+    };
+}
+
+const ADJUSTMENTS: &[Adjustment] = &[
+    Adjustment { class: "Lvls", suffix: "levels", from: levels_from, to: levels_to },
+    Adjustment { class: "Crvs", suffix: "curves", from: curves_from, to: curves_to },
+    Adjustment { class: "HStr", suffix: "hueSaturation", from: hue_sat_from, to: hue_sat_to },
+    adj_fields!("BrgC", "brightnessContrast", &[F("Brgh", "brightness", Kind::Long), F("Cntr", "contrast", Kind::Long), F("useLegacy", "legacy", Kind::Bool)]),
+    adj_fields!("Thrs", "threshold", &[F("Lvl ", "level", Kind::Long)]),
+    adj_fields!("Pstr", "posterize", &[F("Lvls", "levels", Kind::Long)]),
+    adj_fields!("Invr", "invert", &[]),
+    Adjustment { class: "ClrB", suffix: "colorBalance", from: color_balance_from, to: color_balance_to },
+    adj_fields!("Vbrn", "vibrance", &[F("vibrance", "vibrance", Kind::Long), F("Strt", "saturation", Kind::Long)]),
+    adj_fields!("Exps", "exposure", &[F("Exps", "exposure", Kind::Dbl), F("Ofst", "offset", Kind::Dbl), F("gammaCorrection", "gamma", Kind::Dbl)]),
+    adj_fields!("PhtF", "photoFilter", &[F("Clr ", "color", Kind::Color), F("Dnst", "density", Kind::Long), F("PrsL", "preserveLuminosity", Kind::Bool)]),
+    adj_fields!("BlnW", "blackWhite", BW),
+    Adjustment { class: "ChnM", suffix: "channelMixer", from: channel_mixer_from, to: channel_mixer_to },
+    Adjustment { class: "SlcC", suffix: "selectiveColor", from: selective_from, to: selective_to },
+    Adjustment { class: "GdMp", suffix: "gradientMap", from: gradient_map_from, to: gradient_map_to },
+];
+
+fn adjustment_by_class(c: &str) -> Option<&'static Adjustment> {
+    ADJUSTMENTS.iter().find(|a| a.class.trim_end() == c.trim_end())
+}
+
+fn adjustment_by_suffix(suffix: &str) -> Option<&'static Adjustment> {
+    ADJUSTMENTS.iter().find(|a| a.suffix == suffix)
+}
+
+// ------------------------------------------------------------------ the event table
+
+/// What one Photoshop step maps to.
+enum Mapped {
+    /// One or more PhotoCraft steps (a `make` with a name becomes new layer + rename).
+    Steps(Vec<(String, Value)>),
+    /// No PhotoCraft equivalent; `harmless` steps (tool selections…) are imported switched off.
+    Unsupported { harmless: bool },
+}
+
+fn step(id: &str, params: Value) -> Mapped {
+    Mapped::Steps(vec![(id.to_string(), params)])
+}
+
+fn steps(v: Vec<(&str, Value)>) -> Mapped {
+    Mapped::Steps(v.into_iter().map(|(id, p)| (id.to_string(), p)).collect())
+}
+
+fn none(id: &str) -> Mapped {
+    step(id, json!({}))
+}
+
+/// An event: code (empty when Photoshop only has a string name), string name, the panel
+/// label, the command ids it exports (the first is the one simple events import to), and the
+/// two converters.
+struct Event {
+    code: &'static str,
+    name: &'static str,
+    label: &'static str,
+    ids: &'static [&'static str],
+    from: fn(&Descriptor) -> Mapped,
+    to: fn(&str, &Value) -> Option<Descriptor>,
+}
+
+macro_rules! ev {
+    ($code:literal, $name:literal, $label:literal, $id:literal, $fields:expr) => {
+        Event {
+            code: $code,
+            name: $name,
+            label: $label,
+            ids: &[$id],
+            from: |d| match fields_from(d, $fields) {
+                Some(m) => step($id, Value::Object(m)),
+                None => Mapped::Unsupported { harmless: false },
+            },
+            to: |_, p| fields_to(p, $fields, desc("null")),
+        }
+    };
+}
+
+const INTERPOLATION: &[(&str, &str)] = &[
+    ("Bcbc", "bicubic"),
+    ("Blnr", "bilinear"),
+    ("Nrst", "nearest"),
+    ("bicubicSharper", "bicubicSharper"),
+    ("bicubicSmoother", "bicubicSmoother"),
+    ("bicubicAutomatic", "bicubicAutomatic"),
+    ("automaticInterpolation", "automatic"),
+    ("preserveDetailsUpscale", "preserveDetails"),
+    ("deepUpscale", "preserveDetails"),
+];
+const NOISE: &[(&str, &str)] = &[("Unfr", "uniform"), ("Gsn ", "gaussian")];
+const OFFSET_FILL: &[(&str, &str)] = &[("Wrp ", "wrap"), ("Rpt ", "repeat"), ("Bckg", "transparent")];
+const TRIM: &[(&str, &str)] = &[("Trns", "transparent"), ("topLeftPixelColor", "topLeft"), ("bottomRightPixelColor", "bottomRight")];
+const EXTENSION: &[(&str, &str)] = &[("Bckg", "background"), ("Frgd", "foreground"), ("Wht ", "white"), ("Blck", "black"), ("Trns", "transparent")];
+const FILL_CONTENTS: &[(&str, &str)] = &[
+    ("FrgC", "foreground"),
+    ("BckC", "background"),
+    ("Wht ", "white"),
+    ("Blck", "black"),
+    ("Gry ", "gray"),
+    ("Clr ", "color"),
+    ("HstS", "history"),
+    ("contentAware", "contentAware"),
+];
+const STROKE_LOCATION: &[(&str, &str)] = &[("Insd", "inside"), ("Cntr", "center"), ("OtsF", "outside")];
+const INTENT: &[(&str, &str)] = &[("Img ", "perceptual"), ("Clrm", "relative"), ("Grp ", "saturation"), ("AbsC", "absolute")];
+const PROFILES: &[(&str, &str)] =
+    &[("sRGB IEC61966-2.1", "srgb"), ("Display P3", "display-p3"), ("Adobe RGB (1998)", "adobe-rgb-compat"), ("ProPhoto RGB", "prophoto-compat")];
+const SMART_BLUR_QUALITY: &[(&str, &str)] = &[("Hgh ", "high"), ("Mdm ", "medium"), ("Low ", "low")];
+const SMART_BLUR_MODE: &[(&str, &str)] = &[("SBMN", "normal"), ("SBME", "edgeOnly"), ("SBMO", "overlayEdge")];
+const RADIAL_METHOD: &[(&str, &str)] = &[("Spn ", "spin"), ("Zm  ", "zoom")];
+const RADIAL_QUALITY: &[(&str, &str)] = &[("Drft", "draft"), ("Gd  ", "good"), ("Bst ", "best")];
+const LABEL_COLORS: &[(&str, &str)] =
+    &[("None", "none"), ("Rd", "red"), ("Orng", "orange"), ("Ylw", "yellow"), ("Grn", "green"), ("Bl", "blue"), ("Vlt", "violet"), ("Gry", "gray")];
+const ALIGN: &[(&str, &str)] =
+    &[("AdLf", "leftEdges"), ("AdCH", "horizontalCenters"), ("AdRg", "rightEdges"), ("AdTp", "topEdges"), ("AdCV", "verticalCenters"), ("AdBt", "bottomEdges")];
+const PURGE: &[(&str, &str)] = &[("Al", "all"), ("Clpb", "clipboard"), ("Hsty", "histories"), ("Undo", "undo")];
+const MODES: &[(&str, &str)] = &[("RGBM", "rgb"), ("Grys", "grayscale"), ("CMYM", "cmyk"), ("LbCM", "lab"), ("Mltc", "multichannel")];
+
+// Events whose target depends on the descriptor (`make`, `set`, `select`…): custom converters.
+
+fn adjustment_steps(a: &Adjustment, prefix: &str, type_desc: Option<&Descriptor>) -> Mapped {
+    let params = match type_desc {
+        Some(t) if get_enum(t, "presetKind").as_deref() != Some("presetKindDefault") => match (a.from)(t) {
+            Some(p) => p,
+            None => return Mapped::Unsupported { harmless: false },
+        },
+        _ => json!({}),
+    };
+    step(&format!("{prefix}{}", a.suffix), params)
+}
+
+/// A `patternLayer` descriptor's pattern, scale, angle and link as the params of
+/// `layer.newFillLayer.pattern` / `layer.fill.pattern.set`. The pattern goes by name: ids differ
+/// between Photoshop's library and one rebuilt from the same `.pat` file. None for a pattern
+/// recorded without a name or id.
+fn pattern_params(t: &Descriptor) -> Option<Map<String, Value>> {
+    let mut p = Map::new();
+    if let Some(ptrn) = get_obj(t, "Ptrn") {
+        let key = get_text(ptrn, "Nm  ").filter(|n| !n.is_empty()).or_else(|| get_text(ptrn, "Idnt").filter(|i| !i.is_empty()))?;
+        p.insert("pattern".into(), key.into());
+    }
+    if let Some(s) = get_num(t, "Scl ") {
+        p.insert("scale".into(), s.into());
+    }
+    if let Some(a) = get_num(t, "Angl") {
+        p.insert("angle".into(), a.into());
+    }
+    if let Some(l) = get_bool(t, "Algn") {
+        p.insert("link".into(), l.into());
+    }
+    Some(p)
+}
+
+/// The `patternLayer` descriptor for [`pattern_params`]' params.
+fn pattern_desc(p: &Value) -> Option<Descriptor> {
+    let mut t = desc("patternLayer");
+    if let Some(n) = jstr(p, "pattern") {
+        t = t.with("Ptrn", D::Descriptor(desc("Ptrn").with("Nm  ", text(n))));
+    }
+    if let Some(s) = jnum(p, "scale") {
+        t = t.with("Scl ", pct(s));
+    }
+    if let Some(a) = jnum(p, "angle") {
+        t = t.with("Angl", ang(a));
+    }
+    if let Some(l) = jbool(p, "link") {
+        t = t.with("Algn", D::Boolean(l));
+    }
+    if p.get("phase").is_some() {
+        return None;
+    }
+    Some(t)
+}
+
+fn make_from(d: &Descriptor) -> Mapped {
+    if let Some(nw) = get_obj(d, "Nw  ") {
+        // Layer via Copy / Cut (`Usng` = the selection), or a new document.
+        if get_enum(d, "Usng").as_deref() == Some("Slct") {
+            let id = if get_bool(d, "Cpy ") == Some(true) { "layer.new.layerViaCopy" } else { "layer.new.layerViaCut" };
+            let mut v = vec![(id, json!({}))];
+            if let Some(n) = get_text(nw, "Nm  ") {
+                v.push(("layer.renameLayer", json!({"name": n})));
+            }
+            return steps(v);
+        }
+        if get_text(nw, "preset").is_some() {
+            return none("file.newFromClipboard");
+        }
+        if let (Some(w), Some(h)) = (get_num(nw, "Wdth"), get_num(nw, "Hght")) {
+            let res = get_num(nw, "Rslt").unwrap_or(72.0);
+            // Dimensions are in points (`#Rlt`) unless given in pixels.
+            let to_px = |k: &str, v: f64| match nw.get(k) {
+                Some(D::UnitFloat { unit: PX, .. }) => v,
+                _ => v * res / 72.0,
+            };
+            let mut p = json!({"width": to_px("Wdth", w).round(), "height": to_px("Hght", h).round(), "resolution": res});
+            if let Some(n) = get_text(nw, "Nm  ") {
+                p["name"] = json!(n);
+            }
+            if let Some(D::Class(c)) = nw.get("Md  ")
+                && let Some(m) = lookup(MODES, &trimmed(&c.class_id))
+            {
+                p["mode"] = json!(m);
+            }
+            if let Some(depth) = get_num(nw, "Dpth") {
+                p["depth"] = json!(depth);
+            }
+            if let Some(f) = get_enum(nw, "Fl  ") {
+                p["background"] = json!(match f.as_str() {
+                    "Wht" => "white",
+                    "BckC" => "backgroundColor",
+                    "Trns" => "transparent",
+                    _ => "white",
+                });
+            }
+            return step("file.new", p);
+        }
+        return Mapped::Unsupported { harmless: false };
+    }
+    let Some(r) = get_ref(d, "null") else { return Mapped::Unsupported { harmless: false } };
+    let using = get_obj(d, "Usng");
+    let type_desc = using.and_then(|u| get_obj(u, "Type"));
+    match ref_class(r).as_deref() {
+        Some("Lyr") => {
+            let mut p = Map::new();
+            if let Some(u) = using {
+                if let Some(n) = get_text(u, "Nm  ") {
+                    p.insert("name".into(), n.into());
+                }
+                if let Some(o) = get_num(u, "Opct") {
+                    p.insert("opacity".into(), (o / 100.0).into());
+                }
+                if let Some(m) = get_enum(u, "Md  ").and_then(|m| blend_label(&m)) {
+                    p.insert("mode".into(), m.into());
+                }
+            }
+            step("layer.new.layer", Value::Object(p))
+        }
+        Some("AdjL") => match type_desc.and_then(|t| adjustment_by_class(&trimmed(&t.class_id))) {
+            Some(a) => adjustment_steps(a, "layer.newAdjustmentLayer.", type_desc),
+            None => Mapped::Unsupported { harmless: false },
+        },
+        Some("contentLayer") => match type_desc {
+            Some(t) if t.class_id.is("solidColorLayer") => match get_obj(t, "Clr ").and_then(color_hex) {
+                Some(c) => step("layer.newFillLayer.solidColor", json!({"color": c})),
+                None => none("layer.newFillLayer.solidColor"),
+            },
+            Some(t) if t.class_id.is("patternLayer") => match pattern_params(t) {
+                Some(p) => step("layer.newFillLayer.pattern", Value::Object(p)),
+                None => Mapped::Unsupported { harmless: false },
+            },
+            _ => Mapped::Unsupported { harmless: false },
+        },
+        Some("layerSection") => {
+            let mut p = Map::new();
+            if let Some(n) = using.and_then(|u| get_text(u, "Nm  ")) {
+                p.insert("name".into(), n.into());
+            }
+            let id = if get_ref(d, "From").is_some() { "layer.groupLayers" } else { "layer.new.group" };
+            step(id, Value::Object(p))
+        }
+        _ => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn make_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let with_name = |cls: &str| {
+        let mut u = desc(cls);
+        if let Some(n) = jstr(p, "name") {
+            u = u.with("Nm  ", text(n));
+        }
+        u
+    };
+    Some(match id {
+        "layer.new.layer" => {
+            let mut u = with_name("Lyr ");
+            if let Some(o) = jnum(p, "opacity") {
+                u = u.with("Opct", pct(o * 100.0));
+            }
+            if let Some(m) = jstr(p, "mode").and_then(blend_ps) {
+                u = u.with("Md  ", enm("BlnM", m));
+            }
+            desc("null").with("null", class_ref("Lyr ")).with("Usng", D::Descriptor(u))
+        }
+        "layer.new.group" => desc("null").with("null", class_ref("layerSection")).with("Usng", D::Descriptor(with_name("layerSection"))),
+        "layer.groupLayers" => {
+            desc("null").with("null", class_ref("layerSection")).with("From", target_ref("Lyr ")).with("Usng", D::Descriptor(with_name("layerSection")))
+        }
+        "layer.new.layerViaCopy" | "layer.new.layerViaCut" => {
+            let mut d = desc("null").with("Nw  ", D::Descriptor(desc("Lyr "))).with("Usng", enm("ArSl", "Slct"));
+            if id == "layer.new.layerViaCopy" {
+                d = d.with("Cpy ", D::Boolean(true));
+            }
+            d
+        }
+        "layer.newFillLayer.solidColor" => {
+            let mut t = desc("solidColorLayer");
+            if let Some(c) = jstr(p, "color").and_then(color_desc) {
+                t = t.with("Clr ", D::Descriptor(c));
+            }
+            desc("null").with("null", class_ref("contentLayer")).with("Usng", D::Descriptor(desc("contentLayer").with("Type", D::Descriptor(t))))
+        }
+        "layer.newFillLayer.pattern" => {
+            if p.get("path").is_some() {
+                return None;
+            }
+            let t = pattern_desc(p)?;
+            desc("null").with("null", class_ref("contentLayer")).with("Usng", D::Descriptor(desc("contentLayer").with("Type", D::Descriptor(t))))
+        }
+        "file.newFromClipboard" => desc("null").with("Nw  ", D::Descriptor(desc("Dcmn").with("preset", text("Clipboard")))),
+        "file.new" => {
+            let mut n = desc("Dcmn");
+            if let Some(name) = jstr(p, "name") {
+                n = n.with("Nm  ", text(name));
+            }
+            if let Some(m) = jstr(p, "mode").and_then(|m| lookup_back(MODES, if m == "gray" { "grayscale" } else { m })) {
+                n = n.with("Md  ", D::Class(class(m)));
+            }
+            n = n.with("Wdth", px(jnum(p, "width").unwrap_or(1920.0))).with("Hght", px(jnum(p, "height").unwrap_or(1080.0)));
+            n = n.with("Rslt", D::UnitFloat { unit: *b"#Rsl", value: jnum(p, "resolution").unwrap_or(72.0) });
+            let fill = match jstr(p, "background") {
+                Some("transparent") => "Trns",
+                Some("backgroundColor") => "BckC",
+                _ => "Wht ",
+            };
+            n = n.with("Fl  ", enm("Fl  ", fill)).with("Dpth", long(jnum(p, "depth").unwrap_or(8.0)));
+            desc("null").with("Nw  ", D::Descriptor(n))
+        }
+        _ => {
+            let suffix = id.strip_prefix("layer.newAdjustmentLayer.")?;
+            let a = adjustment_by_suffix(suffix)?;
+            let t = if p.as_object().is_some_and(|o| o.is_empty()) {
+                desc(a.class).with("presetKind", enm("presetKindType", "presetKindDefault"))
+            } else {
+                (a.to)(p)?
+            };
+            desc("null").with("null", class_ref("AdjL")).with("Usng", D::Descriptor(desc("AdjL").with("Type", D::Descriptor(t))))
+        }
+    })
+}
+
+fn set_from(d: &Descriptor) -> Mapped {
+    let Some(r) = get_ref(d, "null") else { return Mapped::Unsupported { harmless: false } };
+    let unsupported = Mapped::Unsupported { harmless: false };
+    match (ref_class(r).as_deref(), target(r)) {
+        (Some("Chnl"), Target::Property(p)) if p == "fsel" => match d.get("T   ") {
+            Some(D::Enumerated { value, .. }) => match trimmed(value).as_str() {
+                "Al" => none("select.all"),
+                "None" => none("select.deselect"),
+                "Prvs" => none("select.reselect"),
+                _ => unsupported,
+            },
+            Some(D::Reference(t)) => match (ref_class(t).as_deref(), target(t)) {
+                (Some("Chnl"), Target::Ordinal(o)) if o == "Trsp" => step("select.loadSelection", json!({"channel": "transparency"})),
+                // ⌘-click on the targeted channel (a layer mask after `select` of `Msk`).
+                (Some("Chnl"), Target::Ordinal(o)) if o == "Trgt" => step("select.loadSelection", json!({"channel": "targeted"})),
+                (Some("Chnl"), Target::Name(n)) => step("select.loadSelection", json!({"channel": n})),
+                _ => unsupported,
+            },
+            Some(D::Descriptor(t)) if t.class_id.is("Plgn") => {
+                let pts: Option<Vec<Value>> = get_list(t, "Pts ")
+                    .unwrap_or(&[])
+                    .iter()
+                    .map(|v| match v {
+                        D::Descriptor(pt) => Some(json!([get_num(pt, "Hrzn")?, get_num(pt, "Vrtc")?])),
+                        _ => None,
+                    })
+                    .collect();
+                match pts {
+                    Some(pts) if pts.len() >= 3 => step("select.lasso", json!({"points": pts})),
+                    _ => unsupported,
+                }
+            }
+            Some(D::Descriptor(t)) if t.class_id.is("Rctn") || t.class_id.is("Elps") => {
+                let (Some(top), Some(left), Some(bottom), Some(right)) = (get_num(t, "Top "), get_num(t, "Left"), get_num(t, "Btom"), get_num(t, "Rght"))
+                else {
+                    return unsupported;
+                };
+                let mut p = json!({"x": left.round(), "y": top.round(), "width": (right - left).round().max(0.0), "height": (bottom - top).round().max(0.0)});
+                if t.class_id.is("Elps") {
+                    p["ellipse"] = json!(true);
+                }
+                step("select.rect", p)
+            }
+            _ => unsupported,
+        },
+        // Quick Mask mode on (`set` of the document's quick-mask property); `clearEvent` turns it off.
+        (Some("Prpr"), Target::Property(p)) if p == "QucM" => step("select.editInQuickMaskMode", json!({"on": true})),
+        // Layer › New › Layer From Background (Photoshop records the New Layer dialog's values
+        // as a `set` of the Background); values other than the defaults then apply to the layer.
+        (Some("Lyr"), Target::Property(p)) if p == "Bckg" => {
+            // On an image that opened as a normal layer there is no Background to convert;
+            // Photoshop stops there, but the step's purpose (an editable layer) is met.
+            // Photoshop's `set` of another layer doesn't target it: the selected layer stays.
+            let mut v = vec![("layer.new.layerFromBackground", json!({"ifPresent": true, "select": false}))];
+            let mut props = Map::new();
+            props.insert("layer".into(), "Layer 0".into());
+            if let Some(t) = get_obj(d, "T   ") {
+                if let Some(n) = get_text(t, "Nm  ") {
+                    props.insert("name".into(), n.into());
+                }
+                if let Some(o) = get_num(t, "Opct").filter(|o| (o - 100.0).abs() > 1e-9) {
+                    props.insert("opacity".into(), (o / 100.0).into());
+                }
+                match get_enum(t, "Md  ").as_deref() {
+                    None | Some("Nrml") => {}
+                    Some(m) => match blend_label(m) {
+                        Some(label) => {
+                            props.insert("blend".into(), label.into());
+                        }
+                        None => return unsupported,
+                    },
+                }
+            }
+            if props.len() > 1 {
+                v.push(("layer.setProps", Value::Object(props)));
+            }
+            steps(v)
+        }
+        (Some("Lyr"), _) => {
+            let Some(mut p) = layer_target(r) else { return unsupported };
+            let Some(t) = get_obj(d, "T   ") else { return unsupported };
+            let mut v = Vec::new();
+            if let Some(c) = get_enum(t, "Clr ").and_then(|c| lookup(LABEL_COLORS, &c)) {
+                let mut lp = p.clone();
+                lp.insert("color".into(), c.into());
+                v.push(("layer.setLabelColor", Value::Object(lp)));
+            }
+            if let Some(n) = get_text(t, "Nm  ") {
+                p.insert("name".into(), n.into());
+            }
+            if let Some(o) = get_num(t, "Opct") {
+                p.insert("opacity".into(), (o / 100.0).into());
+            }
+            if let Some(f) = get_num(t, "fillOpacity") {
+                p.insert("fill".into(), (f / 100.0).into());
+            }
+            if let Some(m) = get_enum(t, "Md  ") {
+                let Some(label) = blend_label(&m) else { return unsupported };
+                p.insert("blend".into(), label.into());
+            }
+            if let Some(vis) = get_bool(t, "Vsbl") {
+                p.insert("visible".into(), vis.into());
+            }
+            if p.keys().any(|k| k != "layer") {
+                v.push(("layer.setProps", Value::Object(p)));
+            }
+            if v.is_empty() { unsupported } else { steps(v) }
+        }
+        // A Pattern Fill layer's pattern (double-click its thumbnail).
+        (Some("contentLayer"), Target::Ordinal(o)) if o == "Trgt" => match get_obj(d, "T   ") {
+            Some(t) if t.class_id.is("patternLayer") => match pattern_params(t) {
+                Some(p) if !p.is_empty() => step("layer.fill.pattern.set", Value::Object(p)),
+                _ => unsupported,
+            },
+            _ => unsupported,
+        },
+        (Some("AdjL"), Target::Ordinal(o)) if o == "Trgt" => {
+            match get_obj(d, "T   ").and_then(|t| adjustment_by_class(&trimmed(&t.class_id)).map(|a| (a, t))) {
+                Some((a, t)) => match (a.from)(t) {
+                    Some(p) => step("layer.setAdjustment", p),
+                    None => unsupported,
+                },
+                None => unsupported,
+            }
+        }
+        _ => unsupported,
+    }
+}
+
+fn set_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let fsel = D::Reference(vec![ReferenceItem::Property { class: class("Chnl"), key: Id::new("fsel") }]);
+    let sel = |t: D| desc("null").with("null", fsel.clone()).with("T   ", t);
+    Some(match id {
+        "select.all" => sel(enm("Ordn", "Al  ")),
+        "select.deselect" => sel(enm("Ordn", "None")),
+        "select.reselect" => sel(enm("Ordn", "Prvs")),
+        "select.loadSelection" => match jstr(p, "channel")? {
+            "transparency" => sel(D::Reference(vec![ReferenceItem::Enumerated { class: class("Chnl"), type_id: Id::new("Chnl"), value: Id::new("Trsp") }])),
+            "targeted" => sel(D::Reference(vec![ReferenceItem::Enumerated { class: class("Chnl"), type_id: Id::new("Ordn"), value: Id::new("Trgt") }])),
+            name => sel(name_ref("Chnl", name)),
+        },
+        "select.lasso" => {
+            let pts: Option<Vec<D>> = p
+                .get("points")?
+                .as_array()?
+                .iter()
+                .map(|pt| {
+                    let a = pt.as_array()?;
+                    Some(D::Descriptor(desc("Pnt ").with("Hrzn", px(a.first()?.as_f64()?)).with("Vrtc", px(a.get(1)?.as_f64()?))))
+                })
+                .collect();
+            sel(D::Descriptor(desc("Plgn").with("Pts ", D::List(pts?))))
+        }
+        "select.editInQuickMaskMode" => {
+            if jbool(p, "on") != Some(true) {
+                return None;
+            }
+            desc("null").with("null", quick_mask_ref())
+        }
+        "select.rect" => {
+            let (x, y, w, h) = (jnum(p, "x")?, jnum(p, "y")?, jnum(p, "width")?, jnum(p, "height")?);
+            let cls = if jbool(p, "ellipse") == Some(true) { "Elps" } else { "Rctn" };
+            sel(D::Descriptor(desc(cls).with("Top ", px(y)).with("Left", px(x)).with("Btom", px(y + h)).with("Rght", px(x + w))))
+        }
+        "layer.setProps" | "layer.renameLayer" | "layer.setLabelColor" => {
+            let mut t = desc("Lyr ");
+            if let Some(n) = jstr(p, "name") {
+                t = t.with("Nm  ", text(n));
+            }
+            if let Some(o) = jnum(p, "opacity") {
+                t = t.with("Opct", pct(o * 100.0));
+            }
+            if let Some(f) = jnum(p, "fill") {
+                t = t.with("fillOpacity", pct(f * 100.0));
+            }
+            if let Some(m) = jstr(p, "blend") {
+                t = t.with("Md  ", enm("BlnM", blend_ps(m)?));
+            }
+            if let Some(v) = jbool(p, "visible") {
+                t = t.with("Vsbl", D::Boolean(v));
+            }
+            if let Some(c) = jstr(p, "color") {
+                t = t.with("Clr ", enm("Clr ", lookup_back(LABEL_COLORS, c)?));
+            }
+            if t.items.is_empty() {
+                return None;
+            }
+            desc("null").with("null", layer_ref(p)).with("T   ", D::Descriptor(t))
+        }
+        "layer.new.layerFromBackground" => {
+            let bckg = D::Reference(vec![ReferenceItem::Property { class: class("Lyr "), key: Id::new("Bckg") }]);
+            desc("null").with("null", bckg).with("T   ", D::Descriptor(desc("Lyr ").with("Opct", pct(100.0)).with("Md  ", enm("BlnM", "Nrml"))))
+        }
+        "layer.fill.pattern.set" => {
+            if p.get("layer").is_some() || p.get("document").is_some() {
+                return None;
+            }
+            desc("null").with("null", target_ref("contentLayer")).with("T   ", D::Descriptor(pattern_desc(p)?))
+        }
+        "layer.setAdjustment" => {
+            // The adjustment kind isn't in the params: Photoshop needs it, so only steps that
+            // name one (`kind`) export.
+            let a = adjustment_by_suffix(jstr(p, "kind")?)?;
+            desc("null").with("null", target_ref("AdjL")).with("T   ", D::Descriptor((a.to)(p)?))
+        }
+        _ => return None,
+    })
+}
+
+/// Tool classes Photoshop records when an action switches tools: no document effect.
+fn is_tool_class(c: &str) -> bool {
+    c.ends_with("Tl") || c.ends_with("Tool")
+}
+
+fn select_from(d: &Descriptor) -> Mapped {
+    let Some(r) = get_ref(d, "null") else { return Mapped::Unsupported { harmless: false } };
+    match (ref_class(r).as_deref(), target(r)) {
+        (Some("Lyr"), Target::Name(n)) => {
+            let mut p = json!({"layer": n});
+            match get_enum(d, "selectionModifier").as_deref() {
+                Some("addToSelection") => p["mode"] = json!("add"),
+                Some("removeFromSelection") => p["mode"] = json!("remove"),
+                _ => {}
+            }
+            step("layer.select", p)
+        }
+        // The Channels panel: the active layer's mask, or back to the composite (`RGB`, `CMYK`…).
+        (Some("Chnl"), Target::Ordinal(o)) => match o.as_str() {
+            "Msk" => step("channel.target", json!({"channel": "mask"})),
+            "RGB" | "CMYK" | "Lab" | "Gry" => step("channel.target", json!({"channel": "composite"})),
+            // Re-selecting the channel that is already targeted changes nothing.
+            "Trgt" => Mapped::Unsupported { harmless: true },
+            _ => Mapped::Unsupported { harmless: false },
+        },
+        // History › Step Backward / Step Forward.
+        (Some("HstS"), Target::Ordinal(o)) if o == "Prvs" => none("edit.undo"),
+        (Some("HstS"), Target::Ordinal(o)) if o == "Nxt" => none("edit.redo"),
+        (Some("Lyr"), Target::Ordinal(o)) => {
+            // Shift+Alt+[ / ] add the next layer to the selection instead of replacing it.
+            let add = get_enum(d, "selectionModifier").as_deref() == Some("addToSelection");
+            match (o.as_str(), add) {
+                ("Frwr", false) => none("layer.selectAbove"),
+                ("Frwr", true) => none("layer.addAboveToSelection"),
+                ("Bckw", false) => none("layer.selectBelow"),
+                ("Bckw", true) => none("layer.addBelowToSelection"),
+                ("Frnt", _) => none("layer.selectTop"),
+                ("Back", _) => none("layer.selectBottom"),
+                _ => Mapped::Unsupported { harmless: false },
+            }
+        }
+        (Some(c), Target::Class) if is_tool_class(c) => Mapped::Unsupported { harmless: true },
+        _ => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn select_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let ord = |o: &str| D::Reference(vec![ReferenceItem::Enumerated { class: class("Lyr "), type_id: code("Ordn"), value: code(o) }]);
+    let enumerated = |cls: &str, ty: &str, v: &str| D::Reference(vec![ReferenceItem::Enumerated { class: class(cls), type_id: code(ty), value: code(v) }]);
+    Some(match id {
+        "layer.select" => {
+            let mut d = desc("null").with("null", name_ref("Lyr ", jstr(p, "layer")?));
+            match jstr(p, "mode") {
+                None | Some("replace") => {}
+                Some("add") => d = d.with("selectionModifier", enm("selectionModifierType", "addToSelection")),
+                Some("remove") => d = d.with("selectionModifier", enm("selectionModifierType", "removeFromSelection")),
+                Some(_) => return None,
+            }
+            d.with("MkVs", D::Boolean(false))
+        }
+        "channel.target" => {
+            let v = match jstr(p, "channel") {
+                Some("mask") => "Msk ",
+                None | Some("composite") => "RGB ",
+                Some(_) => return None,
+            };
+            desc("null").with("null", enumerated("Chnl", "Chnl", v)).with("MkVs", D::Boolean(false))
+        }
+        "edit.undo" => desc("null").with("null", enumerated("HstS", "Ordn", "Prvs")),
+        "edit.redo" => desc("null").with("null", enumerated("HstS", "Ordn", "Nxt ")),
+        "layer.selectAbove" => desc("null").with("null", ord("Frwr")),
+        "layer.selectBelow" => desc("null").with("null", ord("Bckw")),
+        "layer.addAboveToSelection" => desc("null").with("null", ord("Frwr")).with("selectionModifier", enm("selectionModifierType", "addToSelection")),
+        "layer.addBelowToSelection" => desc("null").with("null", ord("Bckw")).with("selectionModifier", enm("selectionModifierType", "addToSelection")),
+        "layer.selectTop" => desc("null").with("null", ord("Frnt")),
+        "layer.selectBottom" => desc("null").with("null", ord("Back")),
+        _ => return None,
+    })
+}
+
+fn delete_from(d: &Descriptor) -> Mapped {
+    match get_ref(d, "null") {
+        None => none("edit.clear"),
+        Some(r) if ref_class(r).as_deref() == Some("Lyr") => match layer_target(r) {
+            Some(p) => step("layer.delete", Value::Object(p)),
+            None => Mapped::Unsupported { harmless: false },
+        },
+        // The targeted channel of a layer is its mask (what Photoshop records after making an
+        // adjustment layer over a selection and discarding the mask).
+        Some(r) if ref_class(r).as_deref() == Some("Chnl") && matches!(target(r), Target::Ordinal(o) if o == "Trgt") => none("layer.layerMask.delete"),
+        Some(_) => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn quick_mask_ref() -> D {
+    D::Reference(vec![
+        ReferenceItem::Property { class: class("Prpr"), key: code("QucM") },
+        ReferenceItem::Enumerated { class: class("Dcmn"), type_id: code("Ordn"), value: code("Trgt") },
+    ])
+}
+
+fn clear_from(d: &Descriptor) -> Mapped {
+    match get_ref(d, "null").map(target) {
+        Some(Target::Property(p)) if p == "QucM" => step("select.editInQuickMaskMode", json!({"on": false})),
+        None => none("edit.clear"),
+        _ => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn clear_to(id: &str, p: &Value) -> Option<Descriptor> {
+    match id {
+        "select.editInQuickMaskMode" if jbool(p, "on") == Some(false) => Some(desc("null").with("null", quick_mask_ref())),
+        _ => None,
+    }
+}
+
+/// `placeEvent`: File › Place Embedded / Linked, with the file and the recorded scale.
+fn place_from(d: &Descriptor) -> Mapped {
+    let Some(path) = d.get("null").and_then(path_text) else { return Mapped::Unsupported { harmless: false } };
+    let mut p = json!({"path": path});
+    if let Some(w) = get_num(d, "Wdth") {
+        p["scale"] = json!(w);
+    }
+    step(if get_bool(d, "Lnkd") == Some(true) { "file.placeLinked" } else { "file.placeEmbedded" }, p)
+}
+
+fn place_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let mut d = desc("null").with("null", path_value(jstr(p, "path")?)).with("FTcs", enm("QCSt", "Qcsa"));
+    if let Some(s) = jnum(p, "scale") {
+        d = d.with("Wdth", pct(s)).with("Hght", pct(s));
+    }
+    Some(d.with("Lnkd", D::Boolean(id == "file.placeLinked")).with("Antl", D::Boolean(true)))
+}
+
+/// `open`: File › Open of a recorded path.
+fn open_from(d: &Descriptor) -> Mapped {
+    match d.get("null").and_then(path_text) {
+        Some(path) => step("file.openAs", json!({"path": path})),
+        None => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn open_to(_: &str, p: &Value) -> Option<Descriptor> {
+    Some(desc("null").with("null", path_value(jstr(p, "path")?)))
+}
+
+/// Photoshop's four-character condition codes that differ from the string ids.
+const CONDITION_CODES: &[(&str, &str)] = &[("Lyrs", "hasLayers")];
+
+/// `conditional`: Insert Conditional, with its Then and Else actions by name.
+fn conditional_from(d: &Descriptor) -> Mapped {
+    let Some(c) = get_enum(d, "null") else { return Mapped::Unsupported { harmless: false } };
+    let condition = lookup(CONDITION_CODES, &c).unwrap_or(c.as_str());
+    if !crate::actions_edit_cmds::CONDITIONS.contains(&condition) {
+        return Mapped::Unsupported { harmless: false };
+    }
+    let branch = |key: &str| match get_ref(d, key).map(target) {
+        Some(Target::Name(n)) => Some(n),
+        _ => None,
+    };
+    step("actions.conditional", json!({"if": condition, "then": branch("then"), "else": branch("else")}))
+}
+
+fn conditional_to(_: &str, p: &Value) -> Option<Descriptor> {
+    let condition = jstr(p, "if")?;
+    let code = lookup_back(CONDITION_CODES, condition).unwrap_or(condition);
+    let mut d = desc("null").with("null", enm("Cndt", code));
+    for key in ["then", "else"] {
+        if let Some(name) = jstr(p, key) {
+            let mut items = vec![ReferenceItem::Name { class: class("Actn"), name: UnicodeString::new_nul(name) }];
+            if let Some(set) = jstr(p, "set") {
+                items.push(ReferenceItem::Name { class: class("ASet"), name: UnicodeString::new_nul(set) });
+            }
+            d = d.with(key, D::Reference(items));
+        }
+    }
+    Some(d)
+}
+
+/// `close`: Photoshop's Save prompt answer becomes a Save step before the Close.
+fn close_from(d: &Descriptor) -> Mapped {
+    if get_enum(d, "Svng").as_deref() == Some("Ys") { steps(vec![("file.save", json!({})), ("file.close", json!({}))]) } else { none("file.close") }
+}
+
+fn close_to(_: &str, _: &Value) -> Option<Descriptor> {
+    Some(desc("null").with("Svng", enm("YsN ", "N   ")))
+}
+
+/// `transform`: Photoshop records a Free Transform relative to the frame (offset of its centre,
+/// width/height in percent, angle). A layer moved only becomes `layer.translate`; anything
+/// else is `edit.transform`'s relative form; the selection's frame is `select.transformSelection`.
+fn transform_from(d: &Descriptor) -> Mapped {
+    let Some(r) = get_ref(d, "null") else { return Mapped::Unsupported { harmless: false } };
+    let unsupported = Mapped::Unsupported { harmless: false };
+    let mut p = Map::new();
+    if let Some(o) = get_obj(d, "Ofst") {
+        let in_px = |k: &str| matches!(o.get(k), Some(D::UnitFloat { unit: PX, .. }));
+        if !in_px("Hrzn") || !in_px("Vrtc") {
+            return unsupported;
+        }
+        if let Some(x) = get_num(o, "Hrzn") {
+            p.insert("dx".into(), x.into());
+        }
+        if let Some(y) = get_num(o, "Vrtc") {
+            p.insert("dy".into(), y.into());
+        }
+    }
+    for (key, param) in [("Wdth", "scaleX"), ("Hght", "scaleY"), ("Angl", "rotate")] {
+        if let Some(v) = get_num(d, key) {
+            p.insert(param.into(), v.into());
+        }
+    }
+    if d.get("Skew").is_some() || d.get("Usng").is_some() {
+        return unsupported;
+    }
+    let geometry_only = p.keys().all(|k| k == "dx" || k == "dy");
+    match (ref_class(r).as_deref(), target(r)) {
+        (Some("Chnl"), Target::Property(prop)) if prop == "fsel" => step("select.transformSelection", Value::Object(p)),
+        (Some("Lyr"), _) => {
+            let Some(mut lp) = layer_target(r) else { return unsupported };
+            if geometry_only {
+                lp.insert("dx".into(), p.get("dx").and_then(Value::as_f64).unwrap_or(0.0).round().into());
+                lp.insert("dy".into(), p.get("dy").and_then(Value::as_f64).unwrap_or(0.0).round().into());
+                return step("layer.translate", Value::Object(lp));
+            }
+            lp.extend(p);
+            if let Some(i) = get_enum(d, "Intr").and_then(|i| lookup(INTERPOLATION, &i)).filter(|i| matches!(*i, "bicubic" | "bilinear" | "nearest")) {
+                lp.insert("interpolation".into(), i.into());
+            }
+            step("edit.transform", Value::Object(lp))
+        }
+        _ => unsupported,
+    }
+}
+
+fn transform_to(id: &str, p: &Value) -> Option<Descriptor> {
+    if p.get("quad").is_some() || p.get("matrix").is_some() || p.get("rect").is_some() {
+        return None;
+    }
+    let target = match id {
+        "edit.transform" => layer_ref(p),
+        "select.transformSelection" => D::Reference(vec![ReferenceItem::Property { class: class("Chnl"), key: code("fsel") }]),
+        _ => return None,
+    };
+    let mut d = desc("null").with("null", target).with("FTcs", enm("QCSt", "Qcsa"));
+    d = d.with("Ofst", D::Descriptor(desc("Ofst").with("Hrzn", px(jnum(p, "dx").unwrap_or(0.0))).with("Vrtc", px(jnum(p, "dy").unwrap_or(0.0)))));
+    for (key, param) in [("Wdth", "scaleX"), ("Hght", "scaleY")] {
+        if let Some(v) = jnum(p, param) {
+            d = d.with(key, pct(v));
+        }
+    }
+    if let Some(a) = jnum(p, "rotate") {
+        d = d.with("Angl", ang(a));
+    }
+    if let Some(i) = jstr(p, "interpolation").and_then(|i| lookup_back(INTERPOLATION, i)) {
+        d = d.with("Intr", enm("Intp", i));
+    }
+    Some(d)
+}
+
+/// `Clcn` (Apply Image / Calculations blending) ↔ `image.applyImage`'s `blending`.
+const CALC_BLEND: &[(&str, &str)] = &[
+    ("Nrml", "normal"),
+    ("Mltp", "multiply"),
+    ("Scrn", "screen"),
+    ("Ovrl", "overlay"),
+    ("SftL", "softLight"),
+    ("HrdL", "hardLight"),
+    ("CDdg", "colorDodge"),
+    ("CBrn", "colorBurn"),
+    ("Drkn", "darken"),
+    ("Lghn", "lighten"),
+    ("Dfrn", "difference"),
+    ("Xclu", "exclusion"),
+    ("linearBurn", "linearBurn"),
+    ("linearDodge", "linearDodge"),
+    ("Add ", "add"),
+    ("Sbtr", "subtract"),
+];
+const SOURCE_CHANNELS: &[(&str, &str)] =
+    &[("RGB", "composite"), ("CMYK", "composite"), ("Lab", "composite"), ("Trsp", "transparency"), ("Msk", "mask"), ("fsel", "selection")];
+
+fn apply_image_from(d: &Descriptor) -> Mapped {
+    let unsupported = Mapped::Unsupported { harmless: false };
+    let Some(with) = get_obj(d, "With") else { return unsupported };
+    let Some(r) = get_ref(with, "T   ") else { return unsupported };
+    let mut source = Map::new();
+    for item in r {
+        match item {
+            ReferenceItem::Enumerated { class, value, .. } if class.class_id.is("Chnl") => {
+                let v = trimmed(value);
+                let Some(channel) = lookup(SOURCE_CHANNELS, &v).or_else(|| lookup(CHANNELS, &v)) else { return unsupported };
+                source.insert("channel".into(), channel.into());
+            }
+            ReferenceItem::Name { class, name } if class.class_id.is("Lyr ") => {
+                source.insert("layer".into(), name.to_string_lossy().into());
+            }
+            ReferenceItem::Enumerated { class, value, .. } if class.class_id.is("Lyr ") && trimmed(value) == "Mrgd" => {
+                source.insert("layer".into(), "merged".into());
+            }
+            _ => return unsupported,
+        }
+    }
+    if let Some(i) = get_bool(with, "Invr") {
+        source.insert("invert".into(), i.into());
+    }
+    let mut p = json!({"source": source});
+    if let Some(c) = get_enum(with, "Clcl") {
+        match lookup(CALC_BLEND, &c) {
+            Some(b) => p["blending"] = json!(b),
+            None => return unsupported,
+        }
+    }
+    for (key, param) in [("Scl ", "scale"), ("Ofst", "offset"), ("Opct", "opacity")] {
+        if let Some(v) = get_num(with, key) {
+            p[param] = json!(v);
+        }
+    }
+    if let Some(t) = get_bool(with, "PrsT") {
+        p["preserveTransparency"] = json!(t);
+    }
+    step("image.applyImage", p)
+}
+
+fn apply_image_to(_: &str, p: &Value) -> Option<Descriptor> {
+    let source = p.get("source").cloned().unwrap_or(json!({}));
+    let channel = jstr(&source, "channel").unwrap_or("composite");
+    let chan = lookup_back(SOURCE_CHANNELS, channel).or_else(|| lookup_back(CHANNELS, channel))?;
+    let mut items = vec![ReferenceItem::Enumerated { class: class("Chnl"), type_id: code("Chnl"), value: code(chan) }];
+    match jstr(&source, "layer") {
+        Some("merged") | None => items.push(ReferenceItem::Enumerated { class: class("Lyr "), type_id: code("Ordn"), value: code("Mrgd") }),
+        Some(name) => items.push(ReferenceItem::Name { class: class("Lyr "), name: UnicodeString::new_nul(name) }),
+    }
+    let mut with = desc("null").with("T   ", D::Reference(items));
+    if let Some(i) = jbool(&source, "invert") {
+        with = with.with("Invr", D::Boolean(i));
+    }
+    with = with.with("Clcl", enm("Clcn", lookup_back(CALC_BLEND, jstr(p, "blending").unwrap_or("multiply"))?));
+    if let Some(v) = jnum(p, "opacity") {
+        with = with.with("Opct", pct(v));
+    }
+    if let Some(v) = jnum(p, "scale") {
+        with = with.with("Scl ", D::Double(v));
+    }
+    if let Some(v) = jnum(p, "offset") {
+        with = with.with("Ofst", D::Double(v));
+    }
+    if let Some(t) = jbool(p, "preserveTransparency") {
+        with = with.with("PrsT", D::Boolean(t));
+    }
+    Some(desc("null").with("With", D::Descriptor(with)))
+}
+
+const WEB_FORMATS: &[(&str, &str)] = &[("PN24", "png24"), ("PN8", "png8"), ("JPEG", "jpeg"), ("GIFf", "gif"), ("WBMP", "wbmp")];
+
+/// `export` (Save for Web): needs the destination path (`In`), as the command writes a file.
+fn export_from(d: &Descriptor) -> Mapped {
+    let unsupported = Mapped::Unsupported { harmless: false };
+    let Some(u) = get_obj(d, "Usng") else { return unsupported };
+    let Some(path) = d.get("In  ").and_then(path_text) else { return unsupported };
+    let mut p = json!({"path": path});
+    if let Some(f) = get_enum(u, "Fmt ") {
+        match lookup(WEB_FORMATS, &f) {
+            Some(f) => p["format"] = json!(f),
+            None => return unsupported,
+        }
+    }
+    for (key, param) in [("Intr", "interlaced"), ("Trns", "transparency"), ("EICC", "embedIcc"), ("Prgr", "progressive"), ("Optm", "optimized")] {
+        if let Some(b) = get_bool(u, key) {
+            p[param] = json!(b);
+        }
+    }
+    for (key, param) in [("Qlty", "quality"), ("NCol", "colors")] {
+        if let Some(v) = get_num(u, key) {
+            p[param] = json!(v);
+        }
+    }
+    if get_bool(u, "Mtt ") == Some(false) {
+        p["matte"] = json!("none");
+    } else if let (Some(r), Some(g), Some(b)) = (get_num(u, "MttR"), get_num(u, "MttG"), get_num(u, "MttB")) {
+        p["matte"] =
+            json!(format!("#{:02x}{:02x}{:02x}", r.round().clamp(0.0, 255.0) as u8, g.round().clamp(0.0, 255.0) as u8, b.round().clamp(0.0, 255.0) as u8));
+    }
+    step("file.export.saveForWebLegacy", p)
+}
+
+fn export_to(_: &str, p: &Value) -> Option<Descriptor> {
+    let path = jstr(p, "path")?;
+    let mut u = desc("SaveForWeb").with("Op  ", enm("SWOp", "OpSa")).with("Fmt ", enm("IRFm", lookup_back(WEB_FORMATS, jstr(p, "format").unwrap_or("png24"))?));
+    for (key, param, default) in [
+        ("Intr", "interlaced", false),
+        ("Trns", "transparency", true),
+        ("EICC", "embedIcc", false),
+        ("Prgr", "progressive", false),
+        ("Optm", "optimized", true),
+    ] {
+        u = u.with(key, D::Boolean(jbool(p, param).unwrap_or(default)));
+    }
+    if let Some(q) = jnum(p, "quality") {
+        u = u.with("Qlty", long(q));
+    }
+    if let Some(c) = jnum(p, "colors") {
+        u = u.with("NCol", long(c));
+    }
+    match jstr(p, "matte") {
+        Some("none") => u = u.with("Mtt ", D::Boolean(false)),
+        matte => {
+            let c = color_desc(matte.unwrap_or("#ffffff"))?;
+            u = u
+                .with("Mtt ", D::Boolean(true))
+                .with("MttR", get_num(&c, "Rd  ").map(long)?)
+                .with("MttG", get_num(&c, "Grn ").map(long)?)
+                .with("MttB", get_num(&c, "Bl  ").map(long)?);
+        }
+    }
+    Some(desc("null").with("Usng", D::Descriptor(u)).with("In  ", path_value(path)))
+}
+
+fn delete_to(id: &str, p: &Value) -> Option<Descriptor> {
+    Some(match id {
+        "edit.clear" => desc("null"),
+        "layer.delete" => desc("null").with("null", layer_ref(p)),
+        "layer.layerMask.delete" => desc("null").with("null", target_ref("Chnl")),
+        _ => return None,
+    })
+}
+
+/// `hide` / `show` take a list of references (or one).
+fn visibility_from(d: &Descriptor, id: &str) -> Mapped {
+    let refs: Vec<&[ReferenceItem]> = match d.get("null") {
+        Some(D::List(l)) => l.iter().filter_map(|v| if let D::Reference(r) = v { Some(r.as_slice()) } else { None }).collect(),
+        Some(D::Reference(r)) => vec![r.as_slice()],
+        _ => return Mapped::Unsupported { harmless: false },
+    };
+    let mut v = Vec::new();
+    for r in refs {
+        match layer_target(r) {
+            Some(p) => v.push((id, Value::Object(p))),
+            None => return Mapped::Unsupported { harmless: false },
+        }
+    }
+    if v.is_empty() { Mapped::Unsupported { harmless: false } } else { steps(v) }
+}
+
+fn visibility_to(_: &str, p: &Value) -> Option<Descriptor> {
+    Some(desc("null").with("null", D::List(vec![layer_ref(p)])))
+}
+
+fn move_from(d: &Descriptor) -> Mapped {
+    let Some(r) = get_ref(d, "null") else { return Mapped::Unsupported { harmless: false } };
+    if ref_class(r).as_deref() != Some("Lyr") {
+        return Mapped::Unsupported { harmless: false };
+    }
+    let Some(mut p) = layer_target(r) else { return Mapped::Unsupported { harmless: false } };
+    match d.get("T   ") {
+        Some(D::Descriptor(t)) => {
+            let unit = |k: &str| match t.get(k) {
+                Some(D::UnitFloat { unit, .. }) => Some(*unit),
+                _ => None,
+            };
+            let (Some(dx), Some(dy)) = (get_num(t, "Hrzn"), get_num(t, "Vrtc")) else { return Mapped::Unsupported { harmless: false } };
+            match (unit("Hrzn"), unit("Vrtc")) {
+                (Some(PX), Some(PX)) => {
+                    p.insert("dx".into(), dx.round().into());
+                    p.insert("dy".into(), dy.round().into());
+                }
+                // A nudge recorded with the rulers in other units: points, converted to pixels
+                // at the resolution of the document the action plays on.
+                (Some(PT), Some(PT)) => {
+                    p.insert("dx".into(), dx.into());
+                    p.insert("dy".into(), dy.into());
+                    p.insert("units".into(), "pt".into());
+                }
+                _ => return Mapped::Unsupported { harmless: false },
+            }
+            step("layer.translate", Value::Object(p))
+        }
+        Some(D::Reference(t)) => {
+            let id = match target(t) {
+                Target::Ordinal(o) if o == "Frnt" => "layer.arrange.bringToFront",
+                Target::Ordinal(o) if o == "Back" => "layer.arrange.sendToBack",
+                Target::Ordinal(o) if o == "Nxt" => "layer.arrange.bringForward",
+                Target::Ordinal(o) if o == "Prvs" => "layer.arrange.sendBackward",
+                Target::Offset(1) => "layer.arrange.bringForward",
+                Target::Offset(-1) => "layer.arrange.sendBackward",
+                _ => return Mapped::Unsupported { harmless: false },
+            };
+            step(id, Value::Object(p))
+        }
+        _ => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn move_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let ord = |o: &str| D::Reference(vec![ReferenceItem::Enumerated { class: class("Lyr "), type_id: code("Ordn"), value: code(o) }]);
+    let t = match id {
+        "layer.translate" => {
+            let unit = match jstr(p, "units") {
+                None | Some("px") => PX,
+                Some("pt") => PT,
+                Some(_) => return None,
+            };
+            let v = |k: &str| D::UnitFloat { unit, value: jnum(p, k).unwrap_or(0.0) };
+            D::Descriptor(desc("Ofst").with("Hrzn", v("dx")).with("Vrtc", v("dy")))
+        }
+        "layer.arrange.bringToFront" => ord("Frnt"),
+        "layer.arrange.sendToBack" => ord("Back"),
+        "layer.arrange.bringForward" => ord("Nxt "),
+        "layer.arrange.sendBackward" => ord("Prvs"),
+        _ => return None,
+    };
+    Some(desc("null").with("null", layer_ref(p)).with("T   ", t))
+}
+
+fn duplicate_from(d: &Descriptor) -> Mapped {
+    let Some(r) = get_ref(d, "null") else { return Mapped::Unsupported { harmless: false } };
+    match ref_class(r).as_deref() {
+        Some("Lyr") => {
+            let Some(mut p) = layer_target(r) else { return Mapped::Unsupported { harmless: false } };
+            if let Some(n) = get_text(d, "Nm  ") {
+                p.insert("name".into(), n.into());
+            }
+            step("layer.duplicate", Value::Object(p))
+        }
+        Some("Dcmn") => {
+            let mut p = Map::new();
+            if let Some(n) = get_text(d, "Nm  ") {
+                p.insert("name".into(), n.into());
+            }
+            if let Some(m) = get_bool(d, "Mrgd") {
+                p.insert("mergedOnly".into(), m.into());
+            }
+            step("image.duplicate", Value::Object(p))
+        }
+        _ => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn duplicate_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let mut d = match id {
+        "layer.duplicate" => desc("null").with("null", layer_ref(p)),
+        "image.duplicate" => {
+            desc("null").with("null", D::Reference(vec![ReferenceItem::Enumerated { class: class("Dcmn"), type_id: Id::new("Ordn"), value: Id::new("Frst") }]))
+        }
+        _ => return None,
+    };
+    if let Some(n) = jstr(p, "name") {
+        d = d.with("Nm  ", text(n));
+    }
+    if let Some(m) = jbool(p, "mergedOnly") {
+        d = d.with("Mrgd", D::Boolean(m));
+    }
+    Some(d)
+}
+
+fn play_from(d: &Descriptor) -> Mapped {
+    match get_ref(d, "null").map(target) {
+        Some(Target::Name(n)) => step("actions.play", json!({"action": n})),
+        _ => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn play_to(_: &str, p: &Value) -> Option<Descriptor> {
+    let name = jstr(p, "action")?;
+    let mut items = vec![ReferenceItem::Name { class: class("Actn"), name: UnicodeString::new_nul(name) }];
+    if let Some(set) = jstr(p, "set") {
+        items.push(ReferenceItem::Name { class: class("ASet"), name: UnicodeString::new_nul(set) });
+    }
+    Some(desc("null").with("null", D::Reference(items)))
+}
+
+fn fill_from(d: &Descriptor) -> Mapped {
+    if let Some(from) = get_obj(d, "From") {
+        // The Paint Bucket tool's click: its point is in pixels, or in percent of the canvas
+        // (not replayable without the document size).
+        let in_px = |k: &str| matches!(from.get(k), Some(D::UnitFloat { unit: PX, .. }));
+        let (Some(x), Some(y)) = (get_num(from, "Hrzn"), get_num(from, "Vrtc")) else { return Mapped::Unsupported { harmless: false } };
+        if !in_px("Hrzn") || !in_px("Vrtc") {
+            return Mapped::Unsupported { harmless: false };
+        }
+        let mut p = json!({"x": x.round(), "y": y.round()});
+        match get_enum(d, "Usng").as_deref() {
+            Some("FrgC") | None => {}
+            Some("Pttn") => p["contents"] = json!("pattern"),
+            Some(_) => return Mapped::Unsupported { harmless: false },
+        }
+        if let Some(t) = get_num(d, "Tlrn") {
+            p["tolerance"] = json!(t);
+        }
+        if let Some(c) = get_bool(d, "Cntg") {
+            p["contiguous"] = json!(c);
+        }
+        if let Some(a) = get_bool(d, "AntA") {
+            p["antiAlias"] = json!(a);
+        }
+        if let Some(m) = get_bool(d, "Mrgd") {
+            p["sampleAllLayers"] = json!(m);
+        }
+        if let Some(o) = get_num(d, "Opct") {
+            p["opacity"] = json!(o);
+        }
+        return step("paint.bucket", p);
+    }
+    let Some(contents) = get_enum(d, "Usng").and_then(|u| lookup(FILL_CONTENTS, &u)) else { return Mapped::Unsupported { harmless: false } };
+    let mut p = json!({"contents": contents});
+    if contents == "color" {
+        match get_obj(d, "Clr ").and_then(color_hex) {
+            Some(c) => p["color"] = json!(c),
+            None => return Mapped::Unsupported { harmless: false },
+        }
+    }
+    if let Some(o) = get_num(d, "Opct") {
+        p["opacity"] = json!(o);
+    }
+    if let Some(m) = get_enum(d, "Md  ") {
+        match blend_label(&m) {
+            Some(l) => p["mode"] = json!(l),
+            None => return Mapped::Unsupported { harmless: false },
+        }
+    }
+    if let Some(t) = get_bool(d, "PrsT") {
+        p["preserveTransparency"] = json!(t);
+    }
+    step("edit.fill", p)
+}
+
+fn fill_to(id: &str, p: &Value) -> Option<Descriptor> {
+    if id == "paint.bucket" {
+        let mut d = desc("null").with("From", D::Descriptor(desc("Pnt ").with("Hrzn", px(jnum(p, "x")?)).with("Vrtc", px(jnum(p, "y")?))));
+        d = d.with("Tlrn", long(jnum(p, "tolerance").unwrap_or(32.0))).with("AntA", D::Boolean(jbool(p, "antiAlias").unwrap_or(true)));
+        d = d.with("Usng", enm("FlCn", if jstr(p, "contents") == Some("pattern") { "Pttn" } else { "FrgC" }));
+        if let Some(o) = jnum(p, "opacity") {
+            d = d.with("Opct", pct(o));
+        }
+        d = d.with("Cntg", D::Boolean(jbool(p, "contiguous").unwrap_or(true)));
+        if let Some(m) = jbool(p, "sampleAllLayers") {
+            d = d.with("Mrgd", D::Boolean(m));
+        }
+        return Some(d);
+    }
+    let contents = jstr(p, "contents").unwrap_or("color");
+    let mut d = desc("null").with("Usng", enm("FlCn", lookup_back(FILL_CONTENTS, contents)?));
+    if contents == "color" {
+        d = d.with("Clr ", D::Descriptor(color_desc(jstr(p, "color")?)?));
+    }
+    d = d.with("Opct", pct(jnum(p, "opacity").unwrap_or(100.0))).with("Md  ", enm("BlnM", blend_ps(jstr(p, "mode").unwrap_or("Normal"))?));
+    if let Some(t) = jbool(p, "preserveTransparency") {
+        d = d.with("PrsT", D::Boolean(t));
+    }
+    Some(d)
+}
+
+const STROKE: &[F] = &[
+    F("Wdth", "width", Kind::Long),
+    F("Lctn", "location", Kind::Enum("StrL", STROKE_LOCATION)),
+    F("Opct", "opacity", Kind::Pct),
+    F("Md  ", "mode", Kind::Blend),
+    F("Clr ", "color", Kind::Color),
+    F("PrsT", "preserveTransparency", Kind::Bool),
+];
+
+/// Whether an event's `null` reference targets a layer (Edit › Transform) rather than the
+/// document (Image › Image Rotation).
+fn targets_layer(d: &Descriptor) -> bool {
+    get_ref(d, "null").and_then(ref_class).as_deref() == Some("Lyr")
+}
+
+fn rotate_from(d: &Descriptor) -> Mapped {
+    let Some(angle) = get_num(d, "Angl") else { return Mapped::Unsupported { harmless: false } };
+    let a = angle.rem_euclid(360.0);
+    let (layer, doc) = if (a - 90.0).abs() < 1e-6 {
+        ("edit.transform.rotate90Cw", "image.imageRotation.90cw")
+    } else if (a - 270.0).abs() < 1e-6 {
+        ("edit.transform.rotate90Ccw", "image.imageRotation.90ccw")
+    } else if (a - 180.0).abs() < 1e-6 {
+        ("edit.transform.rotate180", "image.imageRotation.180")
+    } else if targets_layer(d) {
+        return Mapped::Unsupported { harmless: false };
+    } else {
+        return step("image.rotation.arbitrary", json!({"angle": angle.abs(), "direction": if angle < 0.0 { "ccw" } else { "cw" }}));
+    };
+    none(if targets_layer(d) { layer } else { doc })
+}
+
+fn rotate_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let (angle, layer) = match id {
+        "edit.transform.rotate90Cw" => (90.0, true),
+        "edit.transform.rotate90Ccw" => (-90.0, true),
+        "edit.transform.rotate180" => (180.0, true),
+        "image.imageRotation.90cw" => (90.0, false),
+        "image.imageRotation.90ccw" => (-90.0, false),
+        "image.imageRotation.180" => (180.0, false),
+        "image.rotation.arbitrary" => (jnum(p, "angle")? * if jstr(p, "direction") == Some("ccw") { -1.0 } else { 1.0 }, false),
+        _ => return None,
+    };
+    let mut d = desc("null");
+    if layer {
+        d = d.with("null", target_ref("Lyr "));
+    }
+    Some(d.with("Angl", ang(angle)))
+}
+
+fn flip_from(d: &Descriptor) -> Mapped {
+    let Some(axis) = get_enum(d, "Axis") else { return Mapped::Unsupported { harmless: false } };
+    let horizontal = axis == "Hrzn";
+    none(match (targets_layer(d), horizontal) {
+        (true, true) => "edit.transform.flipHorizontal",
+        (true, false) => "edit.transform.flipVertical",
+        (false, true) => "image.imageRotation.flipCanvasHorizontal",
+        (false, false) => "image.imageRotation.flipCanvasVertical",
+    })
+}
+
+fn flip_to(id: &str, _: &Value) -> Option<Descriptor> {
+    let (layer, axis) = match id {
+        "edit.transform.flipHorizontal" => (true, "Hrzn"),
+        "edit.transform.flipVertical" => (true, "Vrtc"),
+        "image.imageRotation.flipCanvasHorizontal" => (false, "Hrzn"),
+        "image.imageRotation.flipCanvasVertical" => (false, "Vrtc"),
+        _ => return None,
+    };
+    let mut d = desc("null");
+    if layer {
+        d = d.with("null", target_ref("Lyr "));
+    }
+    Some(d.with("Axis", enm("Ornt", axis)))
+}
+
+fn convert_mode_from(d: &Descriptor) -> Mapped {
+    if let Some(depth) = get_num(d, "Dpth") {
+        return match depth as i64 {
+            8 => none("image.mode.bits8"),
+            16 => none("image.mode.bits16"),
+            32 => none("image.mode.bits32"),
+            _ => Mapped::Unsupported { harmless: false },
+        };
+    }
+    // The mode as an enumeration (`ClrS.Grys`), a class (`Grys`), or an object of the mode's
+    // class holding its options (`BtmM {Rslt, Mthd}`, `Grys {Rt}` from Bitmap).
+    let (mode, options) = match d.get("T   ") {
+        Some(D::Enumerated { value, .. }) => (trimmed(value), None),
+        Some(D::Class(c)) => (trimmed(&c.class_id), None),
+        Some(D::Descriptor(o)) => (trimmed(&o.class_id), Some(o)),
+        _ => return Mapped::Unsupported { harmless: false },
+    };
+    if mode == "BtmM" {
+        return bitmap_from(options);
+    }
+    // Bitmap to Grayscale records a size ratio; only 1 keeps the pixels as they are.
+    if options.and_then(|o| get_num(o, "Rt  ")).is_some_and(|r| (r - 1.0).abs() > 1e-9) {
+        return Mapped::Unsupported { harmless: false };
+    }
+    match lookup(MODES, &mode) {
+        Some(m) => none(&format!("image.mode.{m}")),
+        None => Mapped::Unsupported { harmless: false },
+    }
+}
+
+const BITMAP_METHOD: &[(&str, &str)] = &[("Thrh", "threshold"), ("PtnD", "pattern"), ("DfnD", "diffusion")];
+
+/// Image › Mode › Bitmap. Its Output resolution resamples the image, keeping the print size,
+/// before the conversion; at the document's own resolution that is a no-op. Halftone screens
+/// and custom patterns stay unsupported.
+fn bitmap_from(options: Option<&Descriptor>) -> Mapped {
+    let Some(o) = options else { return none("image.mode.bitmap") };
+    let method = match get_enum(o, "Mthd") {
+        None => "diffusion",
+        Some(m) => match lookup(BITMAP_METHOD, &m) {
+            Some(m) => m,
+            None => return Mapped::Unsupported { harmless: false },
+        },
+    };
+    let convert = ("image.mode.bitmap", json!({"method": method}));
+    match get_num(o, "Rslt") {
+        Some(r) => steps(vec![("image.imageSize", json!({"resolution": r, "resample": "bicubic", "keepPrintSize": true})), convert]),
+        None => steps(vec![convert]),
+    }
+}
+
+fn bitmap_to(p: &Value) -> Option<Descriptor> {
+    let method = lookup_back(BITMAP_METHOD, jstr(p, "method").unwrap_or("diffusion"))?;
+    Some(desc("null").with("T   ", D::Descriptor(desc("BtmM").with("Mthd", enm("Mthd", method)))))
+}
+
+fn convert_mode_to(id: &str, p: &Value) -> Option<Descriptor> {
+    Some(match id {
+        "image.mode.bits8" => desc("null").with("Dpth", long(8.0)),
+        "image.mode.bits16" => desc("null").with("Dpth", long(16.0)),
+        "image.mode.bits32" => desc("null").with("Dpth", long(32.0)),
+        "image.mode.bitmap" => bitmap_to(p)?,
+        _ => desc("null").with("T   ", enm("ClrS", lookup_back(MODES, id.strip_prefix("image.mode.")?)?)),
+    })
+}
+
+fn canvas_size_from(d: &Descriptor) -> Mapped {
+    let mut p = Map::new();
+    for (k, param) in [("Wdth", "width"), ("Hght", "height")] {
+        match d.get(k) {
+            Some(D::UnitFloat { unit: PX, value }) => {
+                p.insert(param.into(), value.round().into());
+            }
+            Some(_) => return Mapped::Unsupported { harmless: false },
+            None => {}
+        }
+    }
+    if let Some(r) = get_bool(d, "Rltv") {
+        p.insert("relative".into(), r.into());
+    }
+    let v = get_enum(d, "Vrtc").unwrap_or_else(|| "Cntr".into());
+    let h = get_enum(d, "Hrzn").unwrap_or_else(|| "Cntr".into());
+    let anchor = match (v.as_str(), h.as_str()) {
+        ("Top", "Left") => "topLeft",
+        ("Top", "Cntr") => "top",
+        ("Top", "Rght") => "topRight",
+        ("Cntr", "Left") => "left",
+        ("Cntr", "Cntr") => "center",
+        ("Cntr", "Rght") => "right",
+        ("Bttm", "Left") => "bottomLeft",
+        ("Bttm", "Cntr") => "bottom",
+        ("Bttm", "Rght") => "bottomRight",
+        _ => return Mapped::Unsupported { harmless: false },
+    };
+    p.insert("anchor".into(), anchor.into());
+    if let Some(c) = get_enum(d, "canvasExtensionColorType") {
+        match lookup(EXTENSION, &c) {
+            Some(c) => {
+                p.insert("extensionColor".into(), c.into());
+            }
+            None => match get_obj(d, "canvasExtensionColor").and_then(color_hex) {
+                Some(hex) => {
+                    p.insert("extensionColor".into(), hex.into());
+                }
+                None => return Mapped::Unsupported { harmless: false },
+            },
+        }
+    }
+    step("image.canvasSize", Value::Object(p))
+}
+
+fn canvas_size_to(_: &str, p: &Value) -> Option<Descriptor> {
+    let anchor = jstr(p, "anchor").unwrap_or("center");
+    let v = if anchor.starts_with("top") {
+        "Top "
+    } else if anchor.starts_with("bottom") {
+        "Bttm"
+    } else {
+        "Cntr"
+    };
+    let h = if anchor.to_ascii_lowercase().ends_with("left") {
+        "Left"
+    } else if anchor.to_ascii_lowercase().ends_with("right") {
+        "Rght"
+    } else {
+        "Cntr"
+    };
+    let mut d = desc("null");
+    if let Some(r) = jbool(p, "relative") {
+        d = d.with("Rltv", D::Boolean(r));
+    }
+    if let Some(w) = jnum(p, "width") {
+        d = d.with("Wdth", px(w));
+    }
+    if let Some(hh) = jnum(p, "height") {
+        d = d.with("Hght", px(hh));
+    }
+    d = d.with("Hrzn", enm("HrzL", h)).with("Vrtc", enm("VrtL", v));
+    if let Some(c) = jstr(p, "extensionColor") {
+        d = match lookup_back(EXTENSION, c) {
+            Some(e) => d.with("canvasExtensionColorType", enm("canvasExtensionColorType", e)),
+            None => d.with("canvasExtensionColorType", enm("canvasExtensionColorType", "Othr")).with("canvasExtensionColor", D::Descriptor(color_desc(c)?)),
+        };
+    }
+    Some(d)
+}
+
+fn image_size_from(d: &Descriptor) -> Mapped {
+    let mut p = Map::new();
+    let mut percent: Option<f64> = None;
+    for (k, param) in [("Wdth", "width"), ("Hght", "height")] {
+        match d.get(k) {
+            Some(D::UnitFloat { unit: PX, value }) => {
+                p.insert(param.into(), value.round().into());
+            }
+            // Percent scales both sides at playback; two different percentages, or physical
+            // units, need the document's size and resolution and stay unsupported.
+            Some(D::UnitFloat { unit: PCT, value }) => match percent {
+                Some(other) if (other - value).abs() > 1e-9 => return Mapped::Unsupported { harmless: false },
+                _ => percent = Some(*value),
+            },
+            Some(_) => return Mapped::Unsupported { harmless: false },
+            None => {}
+        }
+    }
+    if let Some(pc) = percent {
+        p.insert("percent".into(), pc.into());
+    }
+    if let Some(r) = get_num(d, "Rslt") {
+        p.insert("resolution".into(), r.into());
+    }
+    if let Some(i) = get_enum(d, "Intr") {
+        match lookup(INTERPOLATION, &i) {
+            Some(i) => {
+                p.insert("resample".into(), i.into());
+                // Resample on with only the resolution changed: Photoshop keeps the print size.
+                if p.contains_key("resolution") && !p.contains_key("width") && !p.contains_key("height") && !p.contains_key("percent") {
+                    p.insert("keepPrintSize".into(), true.into());
+                }
+            }
+            None => return Mapped::Unsupported { harmless: false },
+        }
+    } else if p.contains_key("resolution") && !p.contains_key("width") && !p.contains_key("height") && !p.contains_key("percent") {
+        p.insert("resample".into(), "none".into());
+    }
+    if p.is_empty() {
+        return Mapped::Unsupported { harmless: false };
+    }
+    step("image.imageSize", Value::Object(p))
+}
+
+fn image_size_to(_: &str, p: &Value) -> Option<Descriptor> {
+    let mut d = desc("null");
+    if let Some(pc) = jnum(p, "percent") {
+        d = d.with("Wdth", pct(pc)).with("Hght", pct(pc)).with("CnsP", D::Boolean(true));
+    }
+    if let Some(w) = jnum(p, "width") {
+        d = d.with("Wdth", px(w));
+    }
+    if let Some(h) = jnum(p, "height") {
+        d = d.with("Hght", px(h));
+    }
+    if let Some(r) = jnum(p, "resolution") {
+        d = d.with("Rslt", D::UnitFloat { unit: *b"#Rsl", value: r });
+    }
+    if let Some(i) = jstr(p, "resample").filter(|r| *r != "none") {
+        d = d.with("Intr", enm("Intp", lookup_back(INTERPOLATION, i)?));
+    }
+    Some(d)
+}
+
+fn crop_from(d: &Descriptor) -> Mapped {
+    let mut p = Map::new();
+    if let Some(t) = get_obj(d, "To  ") {
+        let (Some(top), Some(left), Some(bottom), Some(right)) = (get_num(t, "Top "), get_num(t, "Left"), get_num(t, "Btom"), get_num(t, "Rght")) else {
+            return Mapped::Unsupported { harmless: false };
+        };
+        p.insert("x".into(), left.round().into());
+        p.insert("y".into(), top.round().into());
+        p.insert("width".into(), (right - left).round().into());
+        p.insert("height".into(), (bottom - top).round().into());
+    }
+    if let Some(a) = get_num(d, "Angl") {
+        p.insert("angle".into(), a.into());
+    }
+    if let Some(del) = get_bool(d, "Dlt ") {
+        p.insert("deleteCroppedPixels".into(), del.into());
+    }
+    step("image.crop", Value::Object(p))
+}
+
+fn crop_to(_: &str, p: &Value) -> Option<Descriptor> {
+    let mut d = desc("null");
+    if let (Some(x), Some(y), Some(w), Some(h)) = (jnum(p, "x"), jnum(p, "y"), jnum(p, "width"), jnum(p, "height")) {
+        d = d.with("To  ", D::Descriptor(desc("Rctn").with("Top ", px(y)).with("Left", px(x)).with("Btom", px(y + h)).with("Rght", px(x + w))));
+    }
+    if let Some(a) = jnum(p, "angle") {
+        d = d.with("Angl", ang(a));
+    }
+    Some(d.with("Dlt ", D::Boolean(jbool(p, "deleteCroppedPixels").unwrap_or(true))))
+}
+
+fn stop_from(d: &Descriptor) -> Mapped {
+    step(STOP_MESSAGE, json!({"message": get_text(d, "Msge").unwrap_or_default(), "allowContinue": get_bool(d, "Cntn").unwrap_or(false)}))
+}
+
+fn stop_to(_: &str, p: &Value) -> Option<Descriptor> {
+    Some(desc("null").with("Msge", text(jstr(p, "message").unwrap_or(""))).with("Cntn", D::Boolean(jbool(p, "allowContinue").unwrap_or(false))))
+}
+
+fn paste_from(d: &Descriptor) -> Mapped {
+    none(if get_bool(d, "inPlace") == Some(true) { "edit.pasteSpecial.pasteInPlace" } else { "edit.paste" })
+}
+
+fn paste_to(id: &str, _: &Value) -> Option<Descriptor> {
+    let mut d = desc("null");
+    if id == "edit.pasteSpecial.pasteInPlace" {
+        d = d.with("inPlace", D::Boolean(true));
+    }
+    Some(d.with("AntA", enm("Annt", "Anno")))
+}
+
+fn merge_visible_from(d: &Descriptor) -> Mapped {
+    none(if get_bool(d, "Dplc") == Some(true) { "layer.stampVisible" } else { "layer.mergeVisible" })
+}
+
+fn merge_visible_to(id: &str, _: &Value) -> Option<Descriptor> {
+    Some(if id == "layer.stampVisible" { desc("null").with("Dplc", D::Boolean(true)) } else { desc("null") })
+}
+
+fn align_from(d: &Descriptor) -> Mapped {
+    match get_enum(d, "Usng").and_then(|u| lookup(ALIGN, &u)) {
+        Some(a) => step(&format!("layer.align.{a}"), if get_bool(d, "alignToCanvas") == Some(true) { json!({"to": "canvas"}) } else { json!({}) }),
+        None => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn align_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let a = lookup_back(ALIGN, id.strip_prefix("layer.align.")?)?;
+    Some(desc("null").with("null", target_ref("Lyr ")).with("Usng", enm("ADSt", a)).with("alignToCanvas", D::Boolean(jstr(p, "to") == Some("canvas"))))
+}
+
+fn purge_from(d: &Descriptor) -> Mapped {
+    match get_enum(d, "null").and_then(|u| lookup(PURGE, &u)) {
+        Some(p) => none(&format!("edit.purge.{p}")),
+        None => Mapped::Unsupported { harmless: true },
+    }
+}
+
+fn purge_to(id: &str, _: &Value) -> Option<Descriptor> {
+    Some(desc("null").with("null", enm("PrgI", lookup_back(PURGE, id.strip_prefix("edit.purge.")?)?)))
+}
+
+fn reset_from(d: &Descriptor) -> Mapped {
+    match get_ref(d, "null").map(target) {
+        Some(Target::Property(p)) if p == "Clrs" => none("tools.defaultColors"),
+        _ => Mapped::Unsupported { harmless: true },
+    }
+}
+
+fn reset_to(_: &str, _: &Value) -> Option<Descriptor> {
+    Some(desc("null").with("null", D::Reference(vec![ReferenceItem::Property { class: class("Clr "), key: Id::new("Clrs") }])))
+}
+
+fn profile_from(d: &Descriptor, id: &str) -> Mapped {
+    let name = get_text(d, "T   ").or_else(|| get_text(d, "profile"));
+    let Some(profile) = name.as_deref().and_then(|n| lookup(PROFILES, n)) else { return Mapped::Unsupported { harmless: false } };
+    let mut p = json!({"profile": profile});
+    if id == "edit.convertToProfile" {
+        if let Some(i) = get_enum(d, "Inte").and_then(|i| lookup(INTENT, &i)) {
+            p["intent"] = json!(i);
+        }
+        if let Some(b) = get_bool(d, "MpBl") {
+            p["bpc"] = json!(b);
+        }
+    }
+    step(id, p)
+}
+
+fn profile_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let name = lookup_back(PROFILES, jstr(p, "profile")?)?;
+    let mut d = desc("null").with("null", target_ref("Dcmn"));
+    if id == "edit.convertToProfile" {
+        d = d
+            .with("T   ", text(name))
+            .with("Inte", enm("Inte", lookup_back(INTENT, jstr(p, "intent").unwrap_or("relative"))?))
+            .with("MpBl", D::Boolean(jbool(p, "bpc").unwrap_or(true)));
+    } else {
+        d = d.with("profile", text(name));
+    }
+    Some(d)
+}
+
+fn levels_event_from(d: &Descriptor) -> Mapped {
+    if get_bool(d, "Auto") == Some(true) {
+        return none("image.autoTone");
+    }
+    if get_bool(d, "AuCo") == Some(true) {
+        return none("image.autoContrast");
+    }
+    match levels_from(d) {
+        Some(p) => step("image.adjustments.levels", p),
+        None => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn levels_event_to(id: &str, p: &Value) -> Option<Descriptor> {
+    Some(match id {
+        "image.autoTone" => desc("null").with("Auto", D::Boolean(true)),
+        "image.autoContrast" => desc("null").with("AuCo", D::Boolean(true)),
+        _ => levels_to(p)?,
+    })
+}
+
+/// A direct adjustment event (Image › Adjustments › …).
+macro_rules! adjustment_event {
+    ($code:literal, $class:literal, $name:literal, $label:literal) => {
+        Event {
+            code: $code,
+            name: $name,
+            label: $label,
+            ids: &[concat!("image.adjustments.", $name)],
+            from: |d| match adjustment_by_class($class) {
+                Some(a) => adjustment_steps(a, "image.adjustments.", Some(d)),
+                None => Mapped::Unsupported { harmless: false },
+            },
+            to: |_, p| adjustment_by_class($class).and_then(|a| (a.to)(p)),
+        }
+    };
+}
+
+const RIPPLE_SIZE: &[(&str, &str)] = &[("Sml", "small"), ("Mdm", "medium"), ("Lrg", "large")];
+
+/// Select and Mask (`refineSelectionEdge`). Smart Radius, decontamination and the output follow
+/// Photoshop's; the edge itself is PhotoCraft's own matting, so results differ in detail.
+const REFINE_EDGE: &[F] = &[
+    F("refineEdgeBorderRadius", "radius", Kind::Px),
+    F("refineEdgeAutoRadius", "smartRadius", Kind::Bool),
+    F("refineEdgeSmooth", "smooth", Kind::Long),
+    F("refineEdgeFeatherRadius", "feather", Kind::Px),
+    F("refineEdgeBorderContrast", "contrast", Kind::Pct),
+    F("refineEdgeChoke", "shiftEdge", Kind::Pct),
+    F("refineEdgeDecontaminate", "decontaminate", Kind::Bool),
+    F("refineEdgeDeconAmount", "amount", Kind::Pct),
+    F("refineEdgeOutput", "output", Kind::Enum("refineEdgeOutput", REFINE_OUTPUT)),
+];
+const REFINE_OUTPUT: &[(&str, &str)] = &[
+    ("refineEdgeOutputSelection", "selection"),
+    ("refineEdgeOutputUserMask", "layerMask"),
+    ("refineEdgeOutputNewLayer", "newLayer"),
+    ("refineEdgeOutputNewLayerWithMask", "newLayerWithMask"),
+    ("refineEdgeOutputNewDocument", "newDocument"),
+    ("refineEdgeOutputNewDocumentWithMask", "newDocumentWithMask"),
+];
+
+/// Filter Gallery effects (`GEfc` with the effect in `GEfk`): Photoshop's effect code, the
+/// command, and its fields. A stack of several effects stays unsupported.
+const GALLERY: &[(&str, &str, &[F])] = &[("Spt", "filter.gallery.spatter", &[F("SprR", "sprayRadius", Kind::Long), F("Smth", "smoothness", Kind::Long)])];
+const GALLERY_IDS: &[&str] = &["filter.gallery.spatter"];
+
+fn gallery_from(d: &Descriptor) -> Mapped {
+    let Some(effect) = get_enum(d, "GEfk") else { return Mapped::Unsupported { harmless: false } };
+    match GALLERY.iter().find(|(code, _, _)| *code == effect).and_then(|(_, id, fields)| Some((*id, fields_from(d, fields)?))) {
+        Some((id, p)) => step(id, Value::Object(p)),
+        None => Mapped::Unsupported { harmless: false },
+    }
+}
+
+fn gallery_to(id: &str, p: &Value) -> Option<Descriptor> {
+    let (code, _, fields) = GALLERY.iter().find(|(_, cmd, _)| *cmd == id)?;
+    fields_to(p, fields, desc("null").with("GEfk", enm("GEft", code)))
+}
+
+/// Every Photoshop event PhotoCraft maps. The order matters only for the panel label.
+const EVENTS: &[Event] = &[
+    // Filters.
+    ev!("GsnB", "gaussianBlur", "Gaussian Blur", "filter.blur.gaussianBlur", &[F("Rds ", "radius", Kind::Px)]),
+    ev!(
+        "UnsM",
+        "unsharpMask",
+        "Unsharp Mask",
+        "filter.sharpen.unsharpMask",
+        &[F("Amnt", "amount", Kind::Pct), F("Rds ", "radius", Kind::Px), F("Thsh", "threshold", Kind::Long)]
+    ),
+    ev!(
+        "AdNs",
+        "addNoise",
+        "Add Noise",
+        "filter.noise.addNoise",
+        &[
+            F("Dstr", "distribution", Kind::Enum("Dstr", NOISE)),
+            F("Nose", "amount", Kind::Pct),
+            F("Mnch", "monochromatic", Kind::Bool),
+            F("FlRs", "seed", Kind::Long)
+        ]
+    ),
+    ev!("Mdn ", "median", "Median", "filter.noise.median", &[F("Rds ", "radius", Kind::Px)]),
+    ev!("DstS", "dustAndScratches", "Dust & Scratches", "filter.noise.dustAndScratches", &[F("Rds ", "radius", Kind::Px), F("Thsh", "threshold", Kind::Long)]),
+    ev!("Dspc", "despeckle", "Despeckle", "filter.noise.despeckle", &[]),
+    ev!("MtnB", "motionBlur", "Motion Blur", "filter.blur.motionBlur", &[F("Angl", "angle", Kind::Ang), F("Dstn", "distance", Kind::Px)]),
+    ev!("BoxB", "boxblur", "Box Blur", "filter.blur.boxBlur", &[F("Rds ", "radius", Kind::Px)]),
+    ev!("SrfB", "surfaceBlur", "Surface Blur", "filter.blur.surfaceBlur", &[F("Rds ", "radius", Kind::Px), F("Thsh", "threshold", Kind::Long)]),
+    ev!(
+        "SmrB",
+        "smartBlur",
+        "Smart Blur",
+        "filter.blur.smartBlur",
+        &[
+            F("Rds ", "radius", Kind::Dbl),
+            F("Thsh", "threshold", Kind::Dbl),
+            F("SmBQ", "quality", Kind::Enum("SmBQ", SMART_BLUR_QUALITY)),
+            F("SmBM", "mode", Kind::Enum("SmBM", SMART_BLUR_MODE))
+        ]
+    ),
+    ev!(
+        "RdlB",
+        "radialBlur",
+        "Radial Blur",
+        "filter.blur.radialBlur",
+        &[F("Amnt", "amount", Kind::Long), F("BlrM", "method", Kind::Enum("BlrM", RADIAL_METHOD)), F("BlrQ", "quality", Kind::Enum("BlrQ", RADIAL_QUALITY))]
+    ),
+    ev!("Blr ", "blur", "Blur", "filter.blur.blur", &[]),
+    ev!("BlrM", "blurMore", "Blur More", "filter.blur.blurMore", &[]),
+    ev!("Shrp", "sharpen", "Sharpen", "filter.sharpen.sharpen", &[]),
+    ev!("ShrM", "sharpenMore", "Sharpen More", "filter.sharpen.sharpenMore", &[]),
+    ev!("ShrE", "sharpenEdges", "Sharpen Edges", "filter.sharpen.sharpenEdges", &[]),
+    ev!("HghP", "highPass", "High Pass", "filter.other.highPass", &[F("Rds ", "radius", Kind::Px)]),
+    ev!("Mnm ", "minimum", "Minimum", "filter.other.minimum", &[F("Rds ", "radius", Kind::Px)]),
+    ev!("Mxm ", "maximum", "Maximum", "filter.other.maximum", &[F("Rds ", "radius", Kind::Px)]),
+    ev!(
+        "Ofst",
+        "offset",
+        "Offset",
+        "filter.other.offset",
+        &[F("Hrzn", "horizontal", Kind::Long), F("Vrtc", "vertical", Kind::Long), F("Fl  ", "undefinedAreas", Kind::Enum("FlMd", OFFSET_FILL))]
+    ),
+    ev!("Rple", "ripple", "Ripple", "filter.distort.ripple", &[F("Amnt", "amount", Kind::Long), F("RplS", "size", Kind::Enum("RplS", RIPPLE_SIZE))]),
+    ev!("Crst", "crystallize", "Crystallize", "filter.pixelate.crystallize", &[F("ClSz", "cellSize", Kind::Long)]),
+    Event { code: "GEfc", name: "filterGallery", label: "Filter Gallery", ids: GALLERY_IDS, from: gallery_from, to: gallery_to },
+    // Adjustments (Image › Adjustments).
+    Event {
+        code: "Lvls",
+        name: "levels",
+        label: "Levels",
+        ids: &["image.adjustments.levels", "image.autoTone", "image.autoContrast"],
+        from: levels_event_from,
+        to: levels_event_to,
+    },
+    adjustment_event!("Crvs", "Crvs", "curves", "Curves"),
+    adjustment_event!("HStr", "HStr", "hueSaturation", "Hue/Saturation"),
+    Event {
+        code: "BrgC",
+        name: "brightnessEvent",
+        label: "Brightness/Contrast",
+        ids: &["image.adjustments.brightnessContrast"],
+        from: |d| match adjustment_by_class("BrgC") {
+            Some(a) => adjustment_steps(a, "image.adjustments.", Some(d)),
+            None => Mapped::Unsupported { harmless: false },
+        },
+        to: |_, p| adjustment_by_class("BrgC").and_then(|a| (a.to)(p)),
+    },
+    adjustment_event!("Thrs", "Thrs", "threshold", "Threshold"),
+    adjustment_event!("Pstr", "Pstr", "posterize", "Posterize"),
+    adjustment_event!("Invr", "Invr", "invert", "Invert"),
+    adjustment_event!("ClrB", "ClrB", "colorBalance", "Color Balance"),
+    adjustment_event!("Vbrn", "Vbrn", "vibrance", "Vibrance"),
+    adjustment_event!("Exps", "Exps", "exposure", "Exposure"),
+    adjustment_event!("PhtF", "PhtF", "photoFilter", "Photo Filter"),
+    Event {
+        code: "BlnW",
+        name: "blackAndWhite",
+        label: "Black & White",
+        ids: &["image.adjustments.blackWhite"],
+        from: |d| match adjustment_by_class("BlnW") {
+            Some(a) => adjustment_steps(a, "image.adjustments.", Some(d)),
+            None => Mapped::Unsupported { harmless: false },
+        },
+        to: |_, p| adjustment_by_class("BlnW").and_then(|a| (a.to)(p)),
+    },
+    adjustment_event!("ChnM", "ChnM", "channelMixer", "Channel Mixer"),
+    Event {
+        code: "GdMp",
+        name: "gradientMapEvent",
+        label: "Gradient Map",
+        ids: &["image.adjustments.gradientMap"],
+        from: |d| match adjustment_by_class("GdMp") {
+            Some(a) => adjustment_steps(a, "image.adjustments.", Some(d)),
+            None => Mapped::Unsupported { harmless: false },
+        },
+        to: |_, p| adjustment_by_class("GdMp").and_then(|a| (a.to)(p)),
+    },
+    adjustment_event!("SlcC", "SlcC", "selectiveColor", "Selective Color"),
+    ev!("Dstt", "desaturate", "Desaturate", "image.adjustments.desaturate", &[]),
+    ev!("Eqlz", "equalize", "Equalize", "image.adjustments.equalize", &[]),
+    ev!("", "autoColor", "Auto Color", "image.autoColor", &[]),
+    // Image.
+    Event { code: "ImgS", name: "imageSize", label: "Image Size", ids: &["image.imageSize"], from: image_size_from, to: image_size_to },
+    Event { code: "CnvS", name: "canvasSize", label: "Canvas Size", ids: &["image.canvasSize"], from: canvas_size_from, to: canvas_size_to },
+    Event {
+        code: "Rtte",
+        name: "rotateEventEnum",
+        label: "Rotate",
+        ids: &[
+            "image.imageRotation.90cw",
+            "image.imageRotation.90ccw",
+            "image.imageRotation.180",
+            "image.rotation.arbitrary",
+            "edit.transform.rotate90Cw",
+            "edit.transform.rotate90Ccw",
+            "edit.transform.rotate180",
+        ],
+        from: rotate_from,
+        to: rotate_to,
+    },
+    Event {
+        code: "Flip",
+        name: "flip",
+        label: "Flip",
+        ids: &[
+            "image.imageRotation.flipCanvasHorizontal",
+            "image.imageRotation.flipCanvasVertical",
+            "edit.transform.flipHorizontal",
+            "edit.transform.flipVertical",
+        ],
+        from: flip_from,
+        to: flip_to,
+    },
+    Event { code: "Crop", name: "crop", label: "Crop", ids: &["image.crop"], from: crop_from, to: crop_to },
+    ev!(
+        "",
+        "trim",
+        "Trim",
+        "image.trim",
+        &[
+            F("trimBasedOn", "basedOn", Kind::Enum("trimBasedOn", TRIM)),
+            F("Top ", "top", Kind::Bool),
+            F("Btom", "bottom", Kind::Bool),
+            F("Left", "left", Kind::Bool),
+            F("Rght", "right", Kind::Bool)
+        ]
+    ),
+    ev!("RvlA", "revealAll", "Reveal All", "image.revealAll", &[]),
+    Event {
+        code: "CnvM",
+        name: "convertMode",
+        label: "Convert Mode",
+        ids: &[
+            "image.mode.rgb",
+            "image.mode.grayscale",
+            "image.mode.cmyk",
+            "image.mode.lab",
+            "image.mode.multichannel",
+            "image.mode.bits8",
+            "image.mode.bits16",
+            "image.mode.bits32",
+            "image.mode.bitmap",
+        ],
+        from: convert_mode_from,
+        to: convert_mode_to,
+    },
+    Event { code: "Dplc", name: "duplicate", label: "Duplicate", ids: &["layer.duplicate", "image.duplicate"], from: duplicate_from, to: duplicate_to },
+    // Layers.
+    Event {
+        code: "Mk  ",
+        name: "make",
+        label: "Make",
+        ids: &[
+            "layer.new.layer",
+            "layer.new.group",
+            "layer.groupLayers",
+            "layer.new.layerViaCopy",
+            "layer.new.layerViaCut",
+            "layer.newFillLayer.solidColor",
+            "layer.newFillLayer.pattern",
+            "layer.newAdjustmentLayer.levels",
+            "layer.newAdjustmentLayer.curves",
+            "layer.newAdjustmentLayer.hueSaturation",
+            "layer.newAdjustmentLayer.brightnessContrast",
+            "layer.newAdjustmentLayer.threshold",
+            "layer.newAdjustmentLayer.posterize",
+            "layer.newAdjustmentLayer.invert",
+            "layer.newAdjustmentLayer.colorBalance",
+            "layer.newAdjustmentLayer.vibrance",
+            "layer.newAdjustmentLayer.exposure",
+            "layer.newAdjustmentLayer.photoFilter",
+            "layer.newAdjustmentLayer.blackWhite",
+            "layer.newAdjustmentLayer.channelMixer",
+            "layer.newAdjustmentLayer.selectiveColor",
+            "layer.newAdjustmentLayer.gradientMap",
+            "file.new",
+            "file.newFromClipboard",
+        ],
+        from: make_from,
+        to: make_to,
+    },
+    Event {
+        code: "setd",
+        name: "set",
+        label: "Set",
+        ids: &[
+            "select.all",
+            "select.deselect",
+            "select.reselect",
+            "select.loadSelection",
+            "select.rect",
+            "select.lasso",
+            "select.editInQuickMaskMode",
+            "layer.setProps",
+            "layer.renameLayer",
+            "layer.setLabelColor",
+            "layer.setAdjustment",
+            "layer.fill.pattern.set",
+            "layer.new.layerFromBackground",
+        ],
+        from: set_from,
+        to: set_to,
+    },
+    Event {
+        code: "slct",
+        name: "select",
+        label: "Select",
+        ids: &[
+            "layer.select",
+            "layer.selectAbove",
+            "layer.selectBelow",
+            "layer.addAboveToSelection",
+            "layer.addBelowToSelection",
+            "layer.selectTop",
+            "layer.selectBottom",
+            "channel.target",
+            "edit.undo",
+            "edit.redo",
+        ],
+        from: select_from,
+        to: select_to,
+    },
+    Event { code: "Dlt ", name: "delete", label: "Delete", ids: &["layer.delete", "edit.clear", "layer.layerMask.delete"], from: delete_from, to: delete_to },
+    Event { code: "", name: "clearEvent", label: "Clear", ids: &["select.editInQuickMaskMode"], from: clear_from, to: clear_to },
+    Event {
+        code: "Trnf",
+        name: "transform",
+        label: "Transform",
+        ids: &["edit.transform", "select.transformSelection"],
+        from: transform_from,
+        to: transform_to,
+    },
+    Event { code: "AppI", name: "applyImageEvent", label: "Apply Image", ids: &["image.applyImage"], from: apply_image_from, to: apply_image_to },
+    ev!("", "newPlacedLayer", "Convert to Smart Object", "layer.smartObjects.convertToSmartObject", &[]),
+    ev!("", "placedLayerEditContents", "Edit Contents", "layer.smartObjects.editContents", &[]),
+    ev!("", "updatePlacedLayer", "Update Smart Objects", "layer.smartObjects.updateModifiedContent", &[]),
+    Event { code: "Hd  ", name: "hide", label: "Hide", ids: &["layer.hideLayers"], from: |d| visibility_from(d, "layer.hideLayers"), to: visibility_to },
+    Event { code: "Shw ", name: "show", label: "Show", ids: &["layer.showLayers"], from: |d| visibility_from(d, "layer.showLayers"), to: visibility_to },
+    Event {
+        code: "move",
+        name: "move",
+        label: "Move",
+        ids: &["layer.translate", "layer.arrange.bringToFront", "layer.arrange.sendToBack", "layer.arrange.bringForward", "layer.arrange.sendBackward"],
+        from: move_from,
+        to: move_to,
+    },
+    ev!("Fltn", "flattenImage", "Flatten Image", "layer.flattenImage", &[]),
+    Event {
+        code: "MrgV",
+        name: "mergeVisible",
+        label: "Merge Visible",
+        ids: &["layer.mergeVisible", "layer.stampVisible"],
+        from: merge_visible_from,
+        to: merge_visible_to,
+    },
+    ev!("Mrg2", "mergeLayersNew", "Merge Layers", "layer.mergeLayers", &[]),
+    ev!("CpTL", "copyToLayer", "Layer Via Copy", "layer.new.layerViaCopy", &[]),
+    ev!("CtTL", "cutToLayer", "Layer Via Cut", "layer.new.layerViaCut", &[]),
+    ev!("", "rasterizeLayer", "Rasterize", "layer.rasterize.layer", &[]),
+    ev!("", "selectAllLayers", "Select All Layers", "select.allLayers", &[]),
+    ev!("", "selectNoLayers", "Deselect Layers", "select.deselectLayers", &[]),
+    ev!("Dfrg", "defringe", "Defringe", "layer.matting.defringe", &[F("Wdth", "width", Kind::Px)]),
+    Event {
+        code: "Algn",
+        name: "align",
+        label: "Align",
+        ids: &[
+            "layer.align.leftEdges",
+            "layer.align.horizontalCenters",
+            "layer.align.rightEdges",
+            "layer.align.topEdges",
+            "layer.align.verticalCenters",
+            "layer.align.bottomEdges",
+        ],
+        from: align_from,
+        to: align_to,
+    },
+    // Selection.
+    ev!("Invs", "inverse", "Inverse", "select.inverse", &[]),
+    ev!("Fthr", "feather", "Feather", "select.modify.feather", &[F("Rds ", "radius", Kind::Px)]),
+    ev!("Expn", "expand", "Expand", "select.modify.expand", &[F("By  ", "radius", Kind::Px)]),
+    ev!("Cntc", "contract", "Contract", "select.modify.contract", &[F("By  ", "radius", Kind::Px)]),
+    ev!("Smth", "smoothness", "Smooth", "select.modify.smooth", &[F("Rds ", "radius", Kind::Px)]),
+    ev!("Brdr", "border", "Border", "select.modify.border", &[F("Wdth", "radius", Kind::Px)]),
+    ev!("Grow", "grow", "Grow", "select.grow", &[F("Tlrn", "tolerance", Kind::Long)]),
+    ev!("Smlr", "similar", "Similar", "select.similar", &[F("Tlrn", "tolerance", Kind::Long)]),
+    ev!("", "refineSelectionEdge", "Select and Mask", "select.refineEdge", REFINE_EDGE),
+    // Edit.
+    Event { code: "Fl  ", name: "fill", label: "Fill", ids: &["edit.fill", "paint.bucket"], from: fill_from, to: fill_to },
+    ev!("Strk", "stroke", "Stroke", "edit.stroke", STROKE),
+    ev!("copy", "copyEvent", "Copy", "edit.copy", &[]),
+    ev!("CpyM", "copyMerged", "Copy Merged", "edit.copyMerged", &[]),
+    ev!("cut ", "cut", "Cut", "edit.cut", &[]),
+    Event { code: "past", name: "paste", label: "Paste", ids: &["edit.paste", "edit.pasteSpecial.pasteInPlace"], from: paste_from, to: paste_to },
+    Event {
+        code: "Prge",
+        name: "purge",
+        label: "Purge",
+        ids: &["edit.purge.all", "edit.purge.clipboard", "edit.purge.histories", "edit.purge.undo"],
+        from: purge_from,
+        to: purge_to,
+    },
+    Event { code: "Rset", name: "reset", label: "Reset", ids: &["tools.defaultColors"], from: reset_from, to: reset_to },
+    ev!("Exch", "exchange", "Exchange", "tools.swapColors", &[]),
+    Event {
+        code: "",
+        name: "assignProfile",
+        label: "Assign Profile",
+        ids: &["edit.assignProfile"],
+        from: |d| profile_from(d, "edit.assignProfile"),
+        to: profile_to,
+    },
+    Event {
+        code: "",
+        name: "convertToProfile",
+        label: "Convert to Profile",
+        ids: &["edit.convertToProfile"],
+        from: |d| profile_from(d, "edit.convertToProfile"),
+        to: profile_to,
+    },
+    // File and actions.
+    Event { code: "Cls ", name: "close", label: "Close", ids: &["file.close"], from: close_from, to: close_to },
+    Event { code: "Expr", name: "export", label: "Export", ids: &["file.export.saveForWebLegacy"], from: export_from, to: export_to },
+    Event { code: "Plc ", name: "placeEvent", label: "Place", ids: &["file.placeEmbedded", "file.placeLinked"], from: place_from, to: place_to },
+    Event { code: "Opn ", name: "open", label: "Open", ids: &["file.openAs"], from: open_from, to: open_to },
+    Event { code: "", name: "conditional", label: "If", ids: &["actions.conditional"], from: conditional_from, to: conditional_to },
+    ev!("save", "save", "Save", "file.save", &[]),
+    ev!("Rvrt", "revert", "Revert", "file.revert", &[]),
+    Event { code: "Ply ", name: "play", label: "Play", ids: &["actions.play"], from: play_from, to: play_to },
+    Event { code: "Stop", name: "stop", label: "Stop", ids: &[STOP_MESSAGE], from: stop_from, to: stop_to },
+];
+
+fn event_for(item: &AtnEvent) -> Option<&'static Event> {
+    let id = item.id();
+    EVENTS.iter().find(|e| (!e.code.is_empty() && e.code.trim_end() == id.trim_end()) || e.name == id)
+}
+
+/// The event `id` exports as: the first event listing it whose converter accepts the params
+/// (Quick Mask on is a `set`, off a `clearEvent`).
+fn event_and_descriptor(id: &str, params: &Value) -> Option<(&'static Event, Descriptor)> {
+    EVENTS.iter().filter(|e| e.ids.contains(&id)).find_map(|e| (e.to)(id, params).map(|d| (e, d)))
+}
+
+// ------------------------------------------------------------------ import
+
+/// A step with no PhotoCraft equivalent.
+#[derive(Clone, Debug, PartialEq, serde::Serialize)]
+pub struct Unsupported {
+    pub action: String,
+    pub step: usize,
+    pub event: String,
+    pub name: String,
+}
+
+/// What a `.atn` file imports to.
+#[derive(Clone, Debug, Default)]
+pub struct Imported {
+    pub set: String,
+    pub actions: Vec<Action>,
+    /// Function keys the file assigns, as `(action name, key)`.
+    pub function_keys: Vec<(String, String)>,
+    pub unsupported: Vec<Unsupported>,
+    pub warnings: Vec<String>,
+}
+
+fn photoshop_step(item: &AtnItem) -> (String, Value) {
+    let descriptor = item.descriptor.as_ref().map(|d| photocraft_paint::tile::b64_encode(&d.to_bytes()));
+    (PHOTOSHOP_STEP.into(), json!({"event": item.event.id(), "name": item.dictionary, "descriptor": descriptor}))
+}
+
+/// Integral floats become integers (`2.0` → `2`), as the commands' own docs and recordings
+/// use, so an imported step reads and compares like a recorded one.
+fn normalise(v: &mut Value) {
+    match v {
+        Value::Number(n) => {
+            if let Some(f) = n.as_f64()
+                && f.fract() == 0.0
+                && f.abs() < 9.0e15
+                && n.as_i64().is_none()
+            {
+                *v = Value::from(f as i64);
+            }
+        }
+        Value::Array(a) => a.iter_mut().for_each(normalise),
+        Value::Object(o) => o.values_mut().for_each(normalise),
+        _ => {}
+    }
+}
+
+fn convert_action(a: &AtnAction, set: &str, unsupported: &mut Vec<Unsupported>) -> Action {
+    let name = a.name.to_string_lossy();
+    let mut action = Action::new(name.clone(), Vec::new());
+    action.set = Some(set.to_string());
+    for (i, item) in a.items.iter().enumerate() {
+        let mapped = match (event_for(&item.event), &item.descriptor) {
+            (Some(e), Some(d)) => (e.from)(d),
+            (Some(e), None) => (e.from)(&Descriptor::default()),
+            (None, _) => Mapped::Unsupported { harmless: false },
+        };
+        let (new_steps, enabled) = match mapped {
+            Mapped::Steps(s) => (s, item.enabled),
+            Mapped::Unsupported { harmless } => {
+                unsupported.push(Unsupported { action: name.clone(), step: i, event: item.event.id(), name: item.dictionary.clone() });
+                (vec![photoshop_step(item)], item.enabled && !harmless)
+            }
+        };
+        for mut s in new_steps {
+            normalise(&mut s.1);
+            let idx = action.steps.len();
+            action.steps.push(s);
+            if !enabled {
+                action.disabled.insert(idx);
+            }
+            if item.with_dialog {
+                action.dialogs.insert(idx);
+            }
+        }
+    }
+    action
+}
+
+/// Convert a `.atn` file. Fails only when the file is unreadable: every step imports, as a
+/// command or as a kept Photoshop step.
+pub fn import(bytes: &[u8]) -> std::result::Result<Imported, String> {
+    let file = atn::parse(bytes).map_err(|e| e.to_string())?;
+    let set = file.name.to_string_lossy();
+    let set = if set.trim().is_empty() { DEFAULT_SET.to_string() } else { set };
+    let mut out = Imported { set: set.clone(), warnings: file.warnings.clone(), ..Default::default() };
+    for a in &file.actions {
+        let action = convert_action(a, &set, &mut out.unsupported);
+        if a.function_key > 0 && !a.shift && !a.command {
+            out.function_keys.push((action.name.clone(), format!("F{}", a.function_key)));
+        }
+        out.actions.push(action);
+    }
+    Ok(out)
+}
+
+// ------------------------------------------------------------------ export
+
+/// A step Save Actions could not express as a Photoshop event.
+#[derive(Clone, Debug, PartialEq, serde::Serialize)]
+pub struct Skipped {
+    pub action: String,
+    pub step: usize,
+    pub id: String,
+}
+
+fn export_item(id: &str, params: &Value, set: &str) -> Option<AtnItem> {
+    if id == PHOTOSHOP_STEP {
+        let event = jstr(params, "event")?;
+        let event = match event.as_bytes() {
+            [a, b, c, d] => AtnEvent::Code([*a, *b, *c, *d]),
+            _ => AtnEvent::Name(event.to_string()),
+        };
+        let descriptor = match jstr(params, "descriptor") {
+            Some(b64) => Some(Descriptor::from_bytes(&photocraft_paint::tile::b64_decode(b64)?).ok()?),
+            None => None,
+        };
+        return Some(AtnItem { event, dictionary: jstr(params, "name").unwrap_or("").to_string(), descriptor, ..Default::default() });
+    }
+    let mut params = params.clone();
+    if (id == "actions.play" || id == "actions.conditional") && params.get("set").is_none() {
+        params["set"] = json!(set);
+    }
+    let (e, descriptor) = event_and_descriptor(id, &params)?;
+    let event = if e.code.is_empty() { AtnEvent::Name(e.name.to_string()) } else { AtnEvent::Code(e.code.as_bytes().try_into().ok()?) };
+    Some(AtnItem { event, dictionary: e.label.to_string(), descriptor: Some(descriptor), ..Default::default() })
+}
+
+/// The `.atn` bytes of `actions` as the set `set`. `function_keys` gives each action's key
+/// (`F1`…`F15`). Steps with no Photoshop equivalent are an error unless `skip_unsupported`.
+pub fn export(
+    set: &str,
+    actions: &[&Action],
+    function_keys: &[(String, String)],
+    skip_unsupported: bool,
+) -> std::result::Result<(Vec<u8>, Vec<Skipped>), String> {
+    let mut skipped = Vec::new();
+    let mut file = AtnFile { name: UnicodeString::new_nul(set), expanded: true, actions: Vec::new(), warnings: Vec::new() };
+    for a in actions {
+        let mut out = AtnAction { name: UnicodeString::new_nul(&a.name), expanded: false, ..Default::default() };
+        if let Some((_, key)) = function_keys.iter().find(|(n, _)| n == &a.name)
+            && let Some(n) = key.strip_prefix('F').and_then(|n| n.parse::<u16>().ok())
+            && (1..=15).contains(&n)
+        {
+            out.function_key = n;
+        }
+        for (i, (id, params)) in a.steps.iter().enumerate() {
+            let Some(mut item) = export_item(id, params, set) else {
+                if skip_unsupported {
+                    skipped.push(Skipped { action: a.name.clone(), step: i, id: id.clone() });
+                    continue;
+                }
+                return Err(format!("step {} of `{}` (`{id}`) has no Photoshop equivalent; pass \"skipUnsupported\": true to leave it out", i + 1, a.name));
+            };
+            item.enabled = a.step_enabled(i);
+            item.with_dialog = a.dialogs.contains(&i);
+            item.dialog_options = if item.with_dialog { 2 } else { 0 };
+            out.items.push(item);
+        }
+        file.actions.push(out);
+    }
+    let bytes = atn::write(&file).map_err(|e| e.to_string())?;
+    Ok((bytes, skipped))
+}
+
+// ------------------------------------------------------------------ commands
+
+/// A name not used by any action in `taken`: `name`, `name 2`, `name 3`…
+fn unique(name: &str, taken: &[String]) -> String {
+    if !taken.iter().any(|t| t == name) {
+        return name.to_string();
+    }
+    (2..).map(|i| format!("{name} {i}")).find(|n| !taken.contains(n)).unwrap_or_else(|| name.to_string())
+}
+
+fn load(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "actions.load";
+    if s.actions.recording.is_some() || s.actions.playing > 0 {
+        return Err(bad(cmd, "stop recording or playing before loading actions"));
+    }
+    let (bytes, _) = crate::preset_import_cmds::file_bytes(p, cmd, ".atn file")?;
+    let mut imp = import(&bytes).map_err(|e| bad(cmd, e))?;
+    match p.get("set") {
+        None | Some(Value::Null) => {}
+        Some(Value::String(n)) if !n.trim().is_empty() => {
+            imp.set = n.trim().to_string();
+            for a in &mut imp.actions {
+                a.set = Some(imp.set.clone());
+            }
+        }
+        Some(_) => return Err(bad(cmd, "`set` must be a non-empty string")),
+    }
+    let replace = match p.get("replace") {
+        None | Some(Value::Null) => true,
+        Some(Value::Bool(b)) => *b,
+        Some(_) => return Err(bad(cmd, "`replace` must be true or false")),
+    };
+    if replace {
+        s.actions.list.retain(|a| a.set.as_deref() != Some(imp.set.as_str()));
+    }
+    let mut taken: Vec<String> = s.actions.list.iter().map(|a| a.name.clone()).collect();
+    let mut names = Vec::with_capacity(imp.actions.len());
+    let mut renamed = Vec::new();
+    let mut steps = 0usize;
+    for mut a in imp.actions {
+        let name = unique(&a.name, &taken);
+        if name != a.name {
+            renamed.push((a.name.clone(), name.clone()));
+        }
+        a.name = name.clone();
+        taken.push(name.clone());
+        steps = steps.saturating_add(a.steps.len());
+        names.push(name);
+        s.actions.list.push(a);
+    }
+    // A Play step calls its action by name: follow renames within the set.
+    for (from, to) in &renamed {
+        for a in s.actions.list.iter_mut().filter(|a| a.set.as_deref() == Some(imp.set.as_str())) {
+            for (id, params) in &mut a.steps {
+                if id == "actions.play" && params.get("action").and_then(Value::as_str) == Some(from) {
+                    params["action"] = json!(to);
+                }
+            }
+        }
+    }
+    let keys: Vec<(String, String)> =
+        imp.function_keys.into_iter().map(|(n, k)| (renamed.iter().find(|(f, _)| f == &n).map_or(n, |(_, t)| t.clone()), k)).collect();
+    if !keys.is_empty() {
+        s.edit_prefs(|prefs| {
+            for (name, key) in &keys {
+                // A function key belongs to one action.
+                prefs.shortcuts.retain(|k, v| !(k.starts_with(crate::actions_cmds::PLAY_SHORTCUT_PREFIX) && v == key));
+                prefs.shortcuts.insert(format!("{}{name}", crate::actions_cmds::PLAY_SHORTCUT_PREFIX), key.clone());
+            }
+        });
+    }
+    s.actions.touch();
+    Ok(json!({
+        "set": imp.set,
+        "actions": names,
+        "steps": steps,
+        "unsupported": imp.unsupported,
+        "functionKeys": keys.iter().map(|(n, k)| json!({"action": n, "key": k})).collect::<Vec<_>>(),
+        "warnings": imp.warnings,
+    }))
+}
+
+fn save(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "actions.save";
+    let skip = match p.get("skipUnsupported") {
+        None | Some(Value::Null) => false,
+        Some(Value::Bool(b)) => *b,
+        Some(_) => return Err(bad(cmd, "`skipUnsupported` must be true or false")),
+    };
+    let set_param = match p.get("set") {
+        None | Some(Value::Null) => None,
+        Some(Value::String(n)) if !n.trim().is_empty() => Some(n.trim().to_string()),
+        Some(_) => return Err(bad(cmd, "`set` must be a non-empty string")),
+    };
+    let (set, actions): (String, Vec<&Action>) = if p.get("action").is_some() {
+        let idx = crate::actions_cmds::resolve(&s.actions.list, p, cmd)?;
+        let a = &s.actions.list[idx];
+        (set_param.or_else(|| a.set.clone()).unwrap_or_else(|| a.name.clone()), vec![a])
+    } else if let Some(set) = set_param {
+        let list: Vec<&Action> = s.actions.list.iter().filter(|a| a.set.as_deref() == Some(set.as_str())).collect();
+        if list.is_empty() {
+            return Err(bad(cmd, format!("no actions in a set named `{set}`")));
+        }
+        (set, list)
+    } else {
+        (DEFAULT_SET.to_string(), s.actions.list.iter().collect())
+    };
+    if actions.is_empty() {
+        return Err(bad(cmd, "there are no actions to save"));
+    }
+    let names: Vec<String> = actions.iter().map(|a| a.name.clone()).collect();
+    let keys: Vec<(String, String)> =
+        s.prefs().shortcuts.iter().filter_map(|(k, v)| k.strip_prefix(crate::actions_cmds::PLAY_SHORTCUT_PREFIX).map(|n| (n.to_string(), v.clone()))).collect();
+    let (bytes, skipped) = export(&set, &actions, &keys, skip).map_err(|e| bad(cmd, e))?;
+    let steps: usize = actions.iter().map(|a| a.steps.len()).sum::<usize>().saturating_sub(skipped.len());
+    let mut out = json!({"set": set, "actions": names, "steps": steps, "bytes": bytes.len(), "skipped": skipped});
+    match p.get("path") {
+        None | Some(Value::Null) => {
+            out["data"] = json!(photocraft_paint::tile::b64_encode(&bytes));
+        }
+        Some(Value::String(path)) if !path.trim().is_empty() => {
+            write_file(path, &bytes).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+            out["path"] = json!(path);
+        }
+        Some(_) => return Err(bad(cmd, "`path` must be a non-empty string")),
+    }
+    Ok(out)
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn write_file(path: &str, bytes: &[u8]) -> std::io::Result<()> {
+    std::fs::write(path, bytes)
+}
+
+#[cfg(target_arch = "wasm32")]
+fn write_file(path: &str, _bytes: &[u8]) -> std::io::Result<()> {
+    Err(std::io::Error::other(format!("cannot write paths on the web ({path}); omit `path` to get the bytes back as `data`")))
+}
+
+fn stop_message(_: &mut Session, p: &Value) -> Result<Value> {
+    let message = jstr(p, "message").unwrap_or("Stop").to_string();
+    if jbool(p, "allowContinue").unwrap_or(false) {
+        Ok(json!({"message": message, "continued": true}))
+    } else {
+        Err(EngineError::Other(format!("stopped by the action: {message}")))
+    }
+}
+
+fn photoshop_step_run(_: &mut Session, p: &Value) -> Result<Value> {
+    let name = jstr(p, "name").filter(|n| !n.is_empty()).unwrap_or("this step");
+    let event = jstr(p, "event").unwrap_or("?");
+    Err(EngineError::Other(format!("Photoshop step \"{name}\" ({event}) has no PhotoCraft equivalent yet; switch it off in the Actions panel to skip it")))
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec {
+            id: "actions.load",
+            label: "Load Actions…",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"path":".atn file"?,"data":base64 bytes?,"set":name? (override the file's set name),"replace":bool=true (replace the actions of a set of the same name)} → {set, actions:[names], steps, unsupported:[{action, step, event, name}], functionKeys:[{action, key}], warnings}. Photoshop steps PhotoCraft cannot play become actions.photoshopStep steps (kept for Save Actions; they fail at playback with the step's name); tool selections and other steps with no document effect are imported switched off. Layer references by name replay in any document."##,
+            enabled: always,
+            run: load,
+            journal: false,
+        },
+        CommandSpec {
+            id: "actions.save",
+            label: "Save Actions…",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"path":".atn file"? (else the bytes come back as base64 `data`),"set":name? (that set's actions; default: every action, as the set "PhotoCraft Actions"),"action":name|index? (one action),"skipUnsupported":bool=false (leave out steps with no Photoshop equivalent instead of failing)} → {set, actions:[names], steps, bytes, skipped:[{action, step, id}], path|data}"##,
+            enabled: always,
+            run: save,
+            journal: false,
+        },
+        CommandSpec {
+            id: STOP_MESSAGE,
+            label: "Stop",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"message":str,"allowContinue":bool=false} (Photoshop's Insert Stop: a step that shows the message; headless playback continues when allowContinue is set and otherwise stops the action with the message)"##,
+            enabled: always,
+            run: stop_message,
+            journal: true,
+        },
+        CommandSpec {
+            id: PHOTOSHOP_STEP,
+            label: "Photoshop Step",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"event":id,"name":str,"descriptor":base64?} (a step from a .atn file PhotoCraft has no command for: fails at playback, written back by actions.save)"##,
+            enabled: always,
+            run: photoshop_step_run,
+            journal: true,
+        },
+    ]
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/engine/src/atn_cmds/tests.rs b/crates/engine/src/atn_cmds/tests.rs
new file mode 100644
index 0000000000..bdb839fa30
--- /dev/null
+++ b/crates/engine/src/atn_cmds/tests.rs
@@ -0,0 +1,941 @@
+use super::*;
+use photocraft_psd::atn::{AtnAction, AtnEvent, AtnFile, AtnItem};
+use photocraft_psd::descriptor::{Descriptor, Id, ReferenceItem, UnicodeString, Value as D};
+use serde_json::json;
+
+fn item(event: &str, label: &str, d: Option<Descriptor>) -> AtnItem {
+    let event = match event.as_bytes() {
+        [a, b, c, dd] => AtnEvent::Code([*a, *b, *c, *dd]),
+        _ => AtnEvent::Name(event.into()),
+    };
+    AtnItem { event, dictionary: label.into(), descriptor: d, ..Default::default() }
+}
+
+fn b64(bytes: &[u8]) -> String {
+    photocraft_paint::tile::b64_encode(bytes)
+}
+
+/// A set with a mapped filter, an adjustment layer, selection steps, a layer by name, a Stop,
+/// a Play, a tool selection (no document effect) and an event PhotoCraft has no command for.
+fn sample() -> AtnFile {
+    let levels = desc("Lvls").with(
+        "Adjs",
+        D::List(vec![D::Descriptor(
+            desc("LvlA")
+                .with("Chnl", channel_ref(None))
+                .with("Inpt", D::List(vec![long(10.0), long(240.0)]))
+                .with("Gmm ", D::Double(1.2))
+                .with("Otpt", D::List(vec![long(0.0), long(250.0)])),
+        )]),
+    );
+    let make_levels = desc("null").with("null", class_ref("AdjL")).with("Usng", D::Descriptor(desc("AdjL").with("Type", D::Descriptor(levels))));
+    let select_all =
+        desc("null").with("null", D::Reference(vec![ReferenceItem::Property { class: class("Chnl"), key: Id::new("fsel") }])).with("T   ", enm("Ordn", "Al  "));
+    let select_layer = desc("null").with("null", name_ref("Lyr ", "Shadow")).with("MkVs", D::Boolean(false));
+    let tool = desc("null").with("null", class_ref("MvTl"));
+    let play = desc("null").with("null", D::Reference(vec![ReferenceItem::Name { class: class("Actn"), name: UnicodeString::new_nul("Finish") }]));
+    let stop = desc("null").with("Msge", text("Check the result")).with("Cntn", D::Boolean(true));
+    let fancy = desc("null").with("prompt", text("a cat")).with("DocI", long(5.0));
+    let mut blur = item("GsnB", "Gaussian Blur", Some(desc("null").with("Rds ", px(2.5))));
+    blur.with_dialog = true;
+    let mut off = item("Fltn", "Flatten Image", None);
+    off.enabled = false;
+    AtnFile {
+        name: UnicodeString::new_nul("Test Set"),
+        expanded: true,
+        actions: vec![
+            AtnAction {
+                name: UnicodeString::new_nul("Soften"),
+                function_key: 3,
+                items: vec![
+                    blur,
+                    item("make", "Make", Some(make_levels)),
+                    item("setd", "Set", Some(select_all)),
+                    item("select", "Select", Some(select_layer)),
+                    item("slct", "Select", Some(tool)),
+                    item("stop", "Stop", Some(stop)),
+                    item("syntheticFill", "Generative Fill", Some(fancy)),
+                    item("play", "Play", Some(play)),
+                    off,
+                ],
+                ..Default::default()
+            },
+            AtnAction { name: UnicodeString::new_nul("Finish"), items: vec![item("Invs", "Inverse", None)], ..Default::default() },
+        ],
+        warnings: Vec::new(),
+    }
+}
+
+#[test]
+fn load_maps_events_keeps_flags_and_plays() {
+    let mut s = Session::new();
+    let bytes = atn::write(&sample()).unwrap();
+    let r = s.execute("actions.load", json!({"data": b64(&bytes)})).unwrap();
+    assert_eq!(r["set"], "Test Set");
+    assert_eq!(r["actions"], json!(["Soften", "Finish"]));
+    assert_eq!(r["steps"], 10);
+    assert_eq!(r["functionKeys"], json!([{"action": "Soften", "key": "F3"}]));
+    assert_eq!(s.prefs().shortcuts.get("actions.play:Soften").map(String::as_str), Some("F3"));
+    let unsupported: Vec<(String, String)> =
+        r["unsupported"].as_array().unwrap().iter().map(|u| (u["event"].as_str().unwrap().into(), u["name"].as_str().unwrap().into())).collect();
+    assert_eq!(unsupported, [("slct".to_string(), "Select".to_string()), ("syntheticFill".to_string(), "Generative Fill".to_string())]);
+
+    let a = &s.actions.list[0];
+    assert_eq!(a.set.as_deref(), Some("Test Set"));
+    let ids: Vec<&str> = a.steps.iter().map(|(id, _)| id.as_str()).collect();
+    assert_eq!(
+        ids,
+        [
+            "filter.blur.gaussianBlur",
+            "layer.newAdjustmentLayer.levels",
+            "select.all",
+            "layer.select",
+            PHOTOSHOP_STEP,
+            STOP_MESSAGE,
+            PHOTOSHOP_STEP,
+            "actions.play",
+            "layer.flattenImage"
+        ]
+    );
+    assert_eq!(a.steps[0].1, json!({"radius": 2.5}));
+    assert_eq!(a.steps[1].1, json!({"inBlack": 10, "inWhite": 240, "gamma": 1.2, "outBlack": 0, "outWhite": 250}));
+    assert_eq!(a.steps[3].1, json!({"layer": "Shadow"}));
+    assert_eq!(a.steps[5].1, json!({"message": "Check the result", "allowContinue": true}));
+    assert_eq!(a.steps[6].1["event"], "syntheticFill");
+    assert_eq!(a.steps[7].1, json!({"action": "Finish"}));
+    assert_eq!(a.dialogs.iter().copied().collect::<Vec<_>>(), [0], "the dialog toggle is kept");
+    assert_eq!(a.disabled.iter().copied().collect::<Vec<_>>(), [4, 8], "tool selections are switched off, as is the step the file had off");
+    assert_eq!(s.actions.list[1].steps, [("select.inverse".to_string(), json!({}))]);
+
+    // Playback: the mapped steps run, the layer is found by name, and the kept Photoshop step
+    // stops the action with its name.
+    s.execute("file.new", json!({"width": 16, "height": 16})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "Shadow"})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "Top"})).unwrap();
+    let played = s.execute("actions.play", json!({"action": "Soften"})).unwrap();
+    assert_eq!(played["ran"], 5, "{played}");
+    assert_eq!(played["failed"]["step"], 6);
+    assert!(played["failed"]["error"].as_str().unwrap().contains("Generative Fill"), "{played}");
+    let d = s.active().unwrap();
+    assert_eq!(d.doc.layer(d.active_layer.unwrap()).unwrap().name, "Shadow");
+    assert!(d.doc.walk().iter().any(|(_, _, l)| l.name.starts_with("Levels")));
+
+    // Loading the same set again replaces it; a different set with the same action names
+    // gets unique names and its Play steps follow.
+    s.execute("actions.load", json!({"data": b64(&bytes)})).unwrap();
+    assert_eq!(s.actions.list.len(), 2);
+    let r = s.execute("actions.load", json!({"data": b64(&bytes), "set": "Other"})).unwrap();
+    assert_eq!(r["actions"], json!(["Soften 2", "Finish 2"]));
+    assert_eq!(s.actions.list[2].steps[7].1, json!({"action": "Finish 2"}));
+    assert_eq!(s.actions.list[2].set.as_deref(), Some("Other"));
+}
+
+#[test]
+fn save_round_trips_through_photoshop_events() {
+    let mut s = Session::new();
+    let bytes = atn::write(&sample()).unwrap();
+    s.execute("actions.load", json!({"data": b64(&bytes)})).unwrap();
+    let first = s.actions.list.clone();
+    let r = s.execute("actions.save", json!({"set": "Test Set"})).unwrap();
+    assert_eq!(r["actions"], json!(["Soften", "Finish"]));
+    assert_eq!(r["skipped"], json!([]));
+    let saved = photocraft_paint::tile::b64_decode(r["data"].as_str().unwrap()).unwrap();
+    let file = atn::parse(&saved).unwrap();
+    assert_eq!(file.name.to_string_lossy(), "Test Set");
+    assert_eq!(file.actions[0].function_key, 3);
+    let events: Vec<String> = file.actions[0].items.iter().map(|i| i.event.id()).collect();
+    assert_eq!(events, ["GsnB", "Mk  ", "setd", "slct", "slct", "Stop", "syntheticFill", "Ply ", "Fltn"]);
+    assert!(file.actions[0].items[0].with_dialog);
+    assert!(!file.actions[0].items[8].enabled);
+    // The kept Photoshop step is written back byte for byte.
+    assert_eq!(file.actions[0].items[6].descriptor, sample().actions[0].items[6].descriptor);
+    // Play names the set too, as Photoshop does.
+    assert_eq!(get_ref(file.actions[0].items[7].descriptor.as_ref().unwrap(), "null").unwrap().len(), 2);
+
+    // Loading what was saved gives the same actions.
+    let mut t = Session::new();
+    t.execute("actions.load", json!({"data": b64(&saved)})).unwrap();
+    assert_eq!(t.actions.list, first);
+
+    // A step with no Photoshop equivalent fails unless skipped.
+    s.actions.list.push(Action::new("Ours", vec![("filter.render.clouds".into(), json!({}))]));
+    let e = s.execute("actions.save", json!({"action": "Ours"})).unwrap_err().to_string();
+    assert!(e.contains("filter.render.clouds"), "{e}");
+    let r = s.execute("actions.save", json!({"action": "Ours", "skipUnsupported": true})).unwrap();
+    assert_eq!(r["skipped"], json!([{"action": "Ours", "step": 0, "id": "filter.render.clouds"}]));
+    assert_eq!(r["set"], "Ours");
+}
+
+#[test]
+fn every_mapped_command_exports_and_imports_back() {
+    let cases: Vec<(&str, Value)> = vec![
+        ("filter.blur.gaussianBlur", json!({"radius": 3.5})),
+        ("filter.sharpen.unsharpMask", json!({"amount": 120, "radius": 1.5, "threshold": 3})),
+        ("filter.noise.addNoise", json!({"amount": 12.5, "distribution": "gaussian", "monochromatic": true, "seed": 7})),
+        ("filter.noise.median", json!({"radius": 2})),
+        ("filter.blur.motionBlur", json!({"angle": 45, "distance": 20})),
+        ("filter.other.offset", json!({"horizontal": 10, "vertical": -5, "undefinedAreas": "wrap"})),
+        ("filter.blur.blur", json!({})),
+        (
+            "image.adjustments.levels",
+            json!({"inBlack": 5, "inWhite": 250, "gamma": 0.9, "outBlack": 0, "outWhite": 255, "red": {"inBlack": 2, "inWhite": 255, "gamma": 1, "outBlack": 0, "outWhite": 255}}),
+        ),
+        ("image.adjustments.curves", json!({"points": [[0, 0], [128, 140], [255, 255]], "blue": [[0, 10], [255, 245]]})),
+        (
+            "image.adjustments.hueSaturation",
+            json!({"colorize": false, "hue": 10, "saturation": -20, "lightness": 0, "reds": {"hue": 5, "saturation": 0, "lightness": 0, "range": [315, 345, 15, 45]}}),
+        ),
+        ("image.adjustments.brightnessContrast", json!({"brightness": 10, "contrast": -5, "legacy": false})),
+        ("image.adjustments.threshold", json!({"level": 100})),
+        ("image.adjustments.posterize", json!({"levels": 4})),
+        ("image.adjustments.invert", json!({})),
+        ("image.adjustments.colorBalance", json!({"shadows": [1, 2, 3], "midtones": [0, 0, 0], "highlights": [-5, 0, 5], "preserveLuminosity": true})),
+        ("image.adjustments.vibrance", json!({"vibrance": 30, "saturation": 5})),
+        ("image.adjustments.exposure", json!({"exposure": 0.5, "offset": 0.01, "gamma": 1.1})),
+        ("image.adjustments.photoFilter", json!({"color": "#ec8a00", "density": 25, "preserveLuminosity": true})),
+        (
+            "image.adjustments.blackWhite",
+            json!({"reds": 40, "yellows": 60, "greens": 40, "cyans": 60, "blues": 20, "magentas": 80, "tint": true, "tintColor": "#e4d5b0"}),
+        ),
+        ("image.adjustments.channelMixer", json!({"red": [100, 0, 0, 0], "green": [0, 90, 10, 0], "blue": [0, 0, 100, 5], "monochrome": false})),
+        ("image.adjustments.selectiveColor", json!({"method": "absolute", "reds": [10, 0, -5, 0], "neutrals": [0, 0, 0, 3]})),
+        ("image.adjustments.desaturate", json!({})),
+        ("image.autoTone", json!({})),
+        ("image.imageSize", json!({"width": 800, "height": 600, "resolution": 72, "resample": "bicubicSharper"})),
+        ("image.canvasSize", json!({"width": 100, "height": 50, "relative": true, "anchor": "topLeft", "extensionColor": "white"})),
+        ("image.imageRotation.90cw", json!({})),
+        ("image.rotation.arbitrary", json!({"angle": 12.5, "direction": "ccw"})),
+        ("edit.transform.flipHorizontal", json!({})),
+        ("image.imageRotation.flipCanvasVertical", json!({})),
+        ("image.crop", json!({"x": 10, "y": 20, "width": 100, "height": 50, "deleteCroppedPixels": true})),
+        ("image.trim", json!({"basedOn": "transparent", "top": true, "bottom": true, "left": false, "right": true})),
+        ("image.mode.grayscale", json!({})),
+        ("image.mode.bits16", json!({})),
+        ("layer.duplicate", json!({"name": "copy"})),
+        ("image.duplicate", json!({"mergedOnly": true})),
+        ("layer.new.layer", json!({"name": "Ink", "opacity": 0.5, "mode": "Multiply"})),
+        ("layer.new.group", json!({"name": "G"})),
+        ("layer.groupLayers", json!({})),
+        ("layer.new.layerViaCopy", json!({})),
+        ("layer.newFillLayer.solidColor", json!({"color": "#336699"})),
+        ("layer.newAdjustmentLayer.hueSaturation", json!({})),
+        ("layer.newAdjustmentLayer.threshold", json!({"level": 77})),
+        ("file.new", json!({"width": 640, "height": 480, "resolution": 72, "mode": "rgb", "depth": 8, "background": "transparent", "name": "Doc"})),
+        ("select.all", json!({})),
+        ("select.deselect", json!({})),
+        ("select.loadSelection", json!({"channel": "transparency"})),
+        ("select.loadSelection", json!({"channel": "Alpha 1"})),
+        ("select.rect", json!({"x": 1, "y": 2, "width": 30, "height": 40})),
+        ("select.rect", json!({"x": 1, "y": 2, "width": 30, "height": 40, "ellipse": true})),
+        ("layer.setProps", json!({"name": "Renamed", "opacity": 0.4, "blend": "Linear Light"})),
+        ("layer.setProps", json!({"layer": "Shadow", "visible": false})),
+        ("layer.setLabelColor", json!({"color": "red"})),
+        ("layer.select", json!({"layer": "Shadow", "mode": "add"})),
+        ("layer.selectTop", json!({})),
+        ("layer.selectBelow", json!({})),
+        ("layer.addBelowToSelection", json!({})),
+        ("layer.addAboveToSelection", json!({})),
+        ("layer.delete", json!({})),
+        ("edit.clear", json!({})),
+        ("layer.hideLayers", json!({"layer": "Background"})),
+        ("layer.showLayers", json!({})),
+        ("layer.translate", json!({"dx": 3, "dy": -4})),
+        ("layer.arrange.sendToBack", json!({})),
+        ("layer.flattenImage", json!({})),
+        ("layer.stampVisible", json!({})),
+        ("layer.mergeVisible", json!({})),
+        ("layer.matting.defringe", json!({"width": 2})),
+        ("layer.align.leftEdges", json!({"to": "canvas"})),
+        ("select.inverse", json!({})),
+        ("select.modify.feather", json!({"radius": 4})),
+        ("select.modify.contract", json!({"radius": 1})),
+        ("edit.fill", json!({"contents": "color", "color": "#ff0080", "opacity": 50, "mode": "Multiply", "preserveTransparency": true})),
+        ("edit.fill", json!({"contents": "foreground", "opacity": 100, "mode": "Normal"})),
+        ("edit.stroke", json!({"width": 3, "location": "outside", "opacity": 100, "mode": "Normal", "color": "#000000", "preserveTransparency": false})),
+        ("edit.copyMerged", json!({})),
+        ("edit.pasteSpecial.pasteInPlace", json!({})),
+        ("edit.paste", json!({})),
+        ("edit.purge.histories", json!({})),
+        ("tools.defaultColors", json!({})),
+        ("edit.convertToProfile", json!({"profile": "display-p3", "intent": "perceptual", "bpc": false})),
+        ("edit.assignProfile", json!({"profile": "srgb"})),
+        ("file.close", json!({})),
+        ("file.save", json!({})),
+        ("layer.layerMask.delete", json!({})),
+        ("select.lasso", json!({"points": [[1, 2], [30, 2], [15, 40]]})),
+        ("select.editInQuickMaskMode", json!({"on": true})),
+        ("select.editInQuickMaskMode", json!({"on": false})),
+        ("edit.transform", json!({"dx": 10, "dy": -5, "scaleX": 50, "scaleY": 75, "rotate": 12.5, "interpolation": "bicubic"})),
+        ("edit.transform", json!({"layer": "Shadow", "dx": 0, "dy": 0, "scaleX": 200})),
+        ("select.transformSelection", json!({"dx": 3, "dy": 4, "scaleX": 110, "scaleY": 110, "rotate": -30})),
+        (
+            "image.applyImage",
+            json!({"source": {"channel": "composite", "layer": "High-Frequency"}, "blending": "subtract", "scale": 2, "offset": 128, "preserveTransparency": true}),
+        ),
+        ("image.applyImage", json!({"source": {"channel": "red", "layer": "merged", "invert": true}, "blending": "multiply", "opacity": 50})),
+        (
+            "file.export.saveForWebLegacy",
+            json!({"path": "/tmp/out/banner.png", "format": "png24", "interlaced": false, "transparency": true, "embedIcc": false, "progressive": false, "optimized": true, "matte": "#ffffff"}),
+        ),
+        (
+            "file.export.saveForWebLegacy",
+            json!({"path": "C:\\shots\\a.jpg", "format": "jpeg", "interlaced": false, "transparency": false, "embedIcc": true, "progressive": true, "optimized": true, "quality": 80, "matte": "none"}),
+        ),
+        ("image.adjustments.gradientMap", json!({"stops": [[0, "#000000"], [0.5, "#ff8000"], [1, "#ffffff"]], "reverse": true, "dither": false})),
+        ("layer.newAdjustmentLayer.gradientMap", json!({"stops": [[0, "#102030"], [1, "#f0e0d0"]], "reverse": false, "dither": true})),
+        ("layer.smartObjects.convertToSmartObject", json!({})),
+        ("layer.smartObjects.editContents", json!({})),
+        ("layer.smartObjects.updateModifiedContent", json!({})),
+        ("paint.bucket", json!({"x": 10, "y": 20, "tolerance": 32, "antiAlias": true, "contiguous": false, "opacity": 100})),
+        ("image.imageSize", json!({"percent": 200, "resample": "bicubicAutomatic"})),
+        ("file.placeEmbedded", json!({"path": "/tmp/logo.png", "scale": 50})),
+        ("file.placeLinked", json!({"path": "/tmp/logo.png"})),
+        ("file.openAs", json!({"path": "/tmp/a.psd"})),
+        ("actions.conditional", json!({"if": "hasLayers", "then": "FS8-Layers", "else": "FS8-No-Layers", "set": "S"})),
+        ("actions.conditional", json!({"if": "landscape", "then": "Wide", "else": null, "set": "S"})),
+        ("actions.play", json!({"action": "Other", "set": "S"})),
+        (STOP_MESSAGE, json!({"message": "Hi", "allowContinue": false})),
+        // The TrueGrit Texture Supply sets (Debaser, Distress Press, Halftone Zine Machine).
+        ("filter.distort.ripple", json!({"amount": 50, "size": "medium"})),
+        ("filter.pixelate.crystallize", json!({"cellSize": 5})),
+        ("filter.gallery.spatter", json!({"sprayRadius": 7, "smoothness": 15})),
+        (
+            "select.refineEdge",
+            json!({"radius": 0, "smartRadius": false, "smooth": 2, "feather": 0.5, "contrast": 15, "shiftEdge": -100, "decontaminate": false, "output": "layerMask"}),
+        ),
+        ("channel.target", json!({"channel": "mask"})),
+        ("channel.target", json!({"channel": "composite"})),
+        ("edit.undo", json!({})),
+        ("edit.redo", json!({})),
+        ("layer.select", json!({"layer": "YELLOW", "mode": "remove"})),
+        ("layer.translate", json!({"dx": 0.36, "dy": -1.08, "units": "pt"})),
+        ("select.loadSelection", json!({"channel": "targeted"})),
+        ("layer.newFillLayer.pattern", json!({"pattern": "Debaser-Distressed-Dark", "scale": 50, "angle": 0, "link": true})),
+        ("layer.fill.pattern.set", json!({"pattern": "1 -R2.jpg"})),
+        ("image.mode.bitmap", json!({"method": "threshold"})),
+        ("image.imageSize", json!({"resolution": 1200, "resample": "preserveDetails", "keepPrintSize": true})),
+        ("layer.new.layerFromBackground", json!({"ifPresent": true, "select": false})),
+    ];
+    for (id, params) in &cases {
+        let item = export_item(id, params, "S").unwrap_or_else(|| panic!("{id} does not export"));
+        if *id == "file.close" {
+            // Close exports "don't save" and imports as a plain close; the Save answer is tested below.
+            assert_eq!(item.event.id(), "Cls ");
+            continue;
+        }
+        let e = event_for(&item.event).unwrap_or_else(|| panic!("{id} exported as an unknown event {}", item.event.id()));
+        match (e.from)(item.descriptor.as_ref().unwrap()) {
+            Mapped::Steps(steps) => {
+                assert_eq!(steps.len(), 1, "{id}: {steps:?}");
+                assert_eq!(steps[0].0, *id, "{id} came back as another command");
+                let mut back = steps[0].1.clone();
+                normalise(&mut back);
+                if *id == "actions.play" || *id == "actions.conditional" {
+                    back["set"] = json!("S");
+                }
+                assert_eq!(back, *params, "{id}");
+            }
+            Mapped::Unsupported { .. } => panic!("{id} does not import back"),
+        }
+    }
+    // Every command the table claims to export has a case above.
+    let covered: std::collections::BTreeSet<&str> = cases.iter().map(|(id, _)| *id).collect();
+    let mut missing: Vec<&str> = EVENTS.iter().flat_map(|e| e.ids.iter().copied()).filter(|id| !covered.contains(id)).collect();
+    missing.sort_unstable();
+    let allowed = [
+        "edit.transform.flipVertical",
+        "edit.transform.rotate180",
+        "edit.transform.rotate90Ccw",
+        "edit.transform.rotate90Cw",
+        "image.autoColor",
+        "image.autoContrast",
+        "image.imageRotation.180",
+        "image.imageRotation.90ccw",
+        "image.imageRotation.flipCanvasHorizontal",
+        "image.mode.bits32",
+        "image.mode.bits8",
+        "image.mode.cmyk",
+        "image.mode.lab",
+        "image.mode.multichannel",
+        "image.mode.rgb",
+        "layer.align.bottomEdges",
+        "layer.align.horizontalCenters",
+        "layer.align.rightEdges",
+        "layer.align.topEdges",
+        "layer.align.verticalCenters",
+        "layer.arrange.bringForward",
+        "layer.arrange.bringToFront",
+        "layer.arrange.sendBackward",
+        "layer.mergeLayers",
+        "layer.new.layerViaCut",
+        "layer.newAdjustmentLayer.blackWhite",
+        "layer.newAdjustmentLayer.brightnessContrast",
+        "layer.newAdjustmentLayer.channelMixer",
+        "layer.newAdjustmentLayer.colorBalance",
+        "layer.newAdjustmentLayer.curves",
+        "layer.newAdjustmentLayer.exposure",
+        "layer.newAdjustmentLayer.invert",
+        "layer.newAdjustmentLayer.levels",
+        "layer.newAdjustmentLayer.photoFilter",
+        "layer.newAdjustmentLayer.posterize",
+        "layer.newAdjustmentLayer.selectiveColor",
+        "layer.newAdjustmentLayer.vibrance",
+        "layer.rasterize.layer",
+        "layer.renameLayer",
+        "layer.selectAbove",
+        "layer.selectBottom",
+        "layer.setAdjustment",
+        "select.allLayers",
+        "select.deselectLayers",
+        "select.grow",
+        "select.modify.border",
+        "select.modify.expand",
+        "select.modify.smooth",
+        "select.reselect",
+        "select.similar",
+        "tools.swapColors",
+        "edit.cut",
+        "edit.copy",
+        "edit.purge.all",
+        "edit.purge.clipboard",
+        "edit.purge.undo",
+        "file.newFromClipboard",
+        "file.revert",
+        "image.adjustments.equalize",
+        "image.revealAll",
+        "filter.blur.blurMore",
+        "filter.blur.boxBlur",
+        "filter.blur.radialBlur",
+        "filter.blur.smartBlur",
+        "filter.blur.surfaceBlur",
+        "filter.noise.despeckle",
+        "filter.noise.dustAndScratches",
+        "filter.other.highPass",
+        "filter.other.maximum",
+        "filter.other.minimum",
+        "filter.sharpen.sharpen",
+        "filter.sharpen.sharpenEdges",
+        "filter.sharpen.sharpenMore",
+    ];
+    let unexpected: Vec<&str> = missing.iter().copied().filter(|id| !allowed.contains(id)).collect();
+    assert!(unexpected.is_empty(), "add round-trip cases for {unexpected:?}");
+    // Every command the table names exists.
+    // (Save is the desktop shell's: recorded by it, replayed by it, written by Batch.)
+    for id in EVENTS.iter().flat_map(|e| e.ids.iter()) {
+        assert!(crate::commands::find(id).is_some() || crate::actions_cmds::shell_save_command(id), "the .atn table names an unknown command `{id}`");
+    }
+}
+
+#[test]
+fn unsupported_shapes_become_photoshop_steps_not_errors() {
+    // Image size in two different percentages, a Paint Bucket click in percent of the canvas, a
+    // move in percent, an unknown adjustment class.
+    let items = vec![
+        item("ImgS", "Image Size", Some(desc("null").with("Wdth", pct(200.0)).with("Hght", pct(150.0)))),
+        item(
+            "Fl  ",
+            "Fill",
+            Some(desc("null").with("From", D::Descriptor(desc("Pnt ").with("Hrzn", pct(0.0)).with("Vrtc", pct(0.0)))).with("Usng", enm("FlCn", "FrgC"))),
+        ),
+        item(
+            "move",
+            "Move",
+            Some(desc("null").with("null", target_ref("Lyr ")).with("T   ", D::Descriptor(desc("Ofst").with("Hrzn", pct(3.0)).with("Vrtc", pct(1.0))))),
+        ),
+        item(
+            "make",
+            "Make",
+            Some(desc("null").with("null", class_ref("AdjL")).with("Usng", D::Descriptor(desc("AdjL").with("Type", D::Descriptor(desc("GdMp")))))),
+        ),
+        item("GsnB", "Gaussian Blur", None),
+    ];
+    let file = AtnFile {
+        name: UnicodeString::new_nul("Odd"),
+        expanded: false,
+        actions: vec![AtnAction { name: UnicodeString::new_nul("A"), items, ..Default::default() }],
+        warnings: vec![],
+    };
+    let imp = import(&atn::write(&file).unwrap()).unwrap();
+    let ids: Vec<&str> = imp.actions[0].steps.iter().map(|(id, _)| id.as_str()).collect();
+    assert_eq!(ids, [PHOTOSHOP_STEP, PHOTOSHOP_STEP, PHOTOSHOP_STEP, PHOTOSHOP_STEP, "filter.blur.gaussianBlur"]);
+    assert_eq!(imp.unsupported.len(), 4);
+    assert!(imp.actions[0].disabled.is_empty(), "steps with a document effect stay on so playback reports them");
+}
+
+#[test]
+fn step_commands_and_bad_params_fail_gracefully() {
+    let mut s = Session::new();
+    for p in [
+        json!({}),
+        json!({"path": ""}),
+        json!({"path": "/nonexistent/set.atn"}),
+        json!({"data": 42}),
+        json!({"data": "%%%"}),
+        json!({"data": b64(b"")}),
+        json!({"data": b64(&[0, 0, 0, 12, 0, 0, 0, 0])}),
+        json!({"data": b64(&atn::write(&sample()).unwrap()[..40])}),
+        json!({"data": b64(&atn::write(&sample()).unwrap()), "set": ""}),
+        json!({"data": b64(&atn::write(&sample()).unwrap()), "set": 3}),
+        json!({"data": b64(&atn::write(&sample()).unwrap()), "replace": "yes"}),
+    ] {
+        assert!(s.execute("actions.load", p.clone()).is_err(), "{p}");
+    }
+    assert!(s.actions.list.is_empty());
+    for p in [json!({}), json!({"set": "Nope"}), json!({"action": 3}), json!({"path": 7}), json!({"skipUnsupported": "no"}), json!({"set": ""})] {
+        assert!(s.execute("actions.save", p.clone()).is_err(), "{p}");
+    }
+    s.actions.list.push(Action::new("One", vec![("select.all".into(), json!({}))]));
+    assert!(s.execute("actions.save", json!({"path": ""})).is_err());
+    assert!(s.execute("actions.save", json!({})).unwrap()["data"].is_string());
+
+    assert!(s.execute(STOP_MESSAGE, json!({"message": "halt"})).unwrap_err().to_string().contains("halt"));
+    assert_eq!(s.execute(STOP_MESSAGE, json!({"message": "go on", "allowContinue": true})).unwrap()["continued"], true);
+    assert!(s.execute(STOP_MESSAGE, json!({"message": 5, "allowContinue": "x"})).is_err());
+    for p in [json!({}), json!({"event": 1}), json!({"event": "GsnB", "name": "Gaussian Blur", "descriptor": "not base64"})] {
+        assert!(s.execute(PHOTOSHOP_STEP, p.clone()).is_err(), "{p}");
+    }
+    // A Photoshop step with a damaged descriptor is left out of a save rather than crashing it.
+    s.actions.list.push(Action::new("Broken", vec![(PHOTOSHOP_STEP.into(), json!({"event": "GsnB", "name": "Blur", "descriptor": b64(b"\x00\x00\x00")}))]));
+    assert!(s.execute("actions.save", json!({"action": "Broken"})).is_err());
+    assert_eq!(s.execute("actions.save", json!({"action": "Broken", "skipUnsupported": true})).unwrap()["skipped"].as_array().unwrap().len(), 1);
+}
+
+#[test]
+fn save_writes_the_file_and_the_set_of_the_selected_action() {
+    let mut s = Session::new();
+    s.execute("actions.load", json!({"data": b64(&atn::write(&sample()).unwrap())})).unwrap();
+    s.actions.list.push(Action::new("Loose", vec![("select.all".into(), json!({}))]));
+    let dir = std::env::temp_dir().join(format!("pc-atn-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("Saved.atn");
+    let r = s.execute("actions.save", json!({"action": "Finish", "path": path.to_string_lossy()})).unwrap();
+    assert_eq!((r["set"].as_str(), r["actions"].as_array().map(Vec::len)), (Some("Test Set"), Some(1)));
+    let file = atn::parse(&std::fs::read(&path).unwrap()).unwrap();
+    assert_eq!(file.actions.len(), 1);
+    assert_eq!(file.actions[0].name.to_string_lossy(), "Finish");
+    // Without a set, everything goes out under the default name.
+    let r = s.execute("actions.save", json!({})).unwrap();
+    assert_eq!((r["set"].as_str(), r["actions"].as_array().map(Vec::len)), (Some(DEFAULT_SET), Some(3)));
+    std::fs::remove_dir_all(&dir).ok();
+}
+
+#[test]
+fn layer_param_accepts_a_name() {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "A"})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "B"})).unwrap();
+    s.execute("layer.select", json!({"layer": "A"})).unwrap();
+    let d = s.active().unwrap();
+    assert_eq!(d.doc.layer(d.active_layer.unwrap()).unwrap().name, "A");
+    assert!(s.execute("layer.select", json!({"layer": "Nope"})).is_err());
+    assert!(s.execute("layer.select", json!({"layer": true})).is_err());
+    assert!(s.execute("layer.select", json!({"layer": -1})).is_err());
+}
+
+#[test]
+fn colours_convert_both_ways() {
+    assert_eq!(color_hex(&desc("RGBC").with("Rd  ", D::Double(255.0)).with("Grn ", D::Double(127.6)).with("Bl  ", D::Double(0.0))).as_deref(), Some("#ff8000"));
+    assert_eq!(color_hex(&desc("HSBC").with("H   ", ang(0.0)).with("Strt", D::Double(0.0)).with("Brgh", D::Double(100.0))).as_deref(), Some("#ffffff"));
+    assert_eq!(color_hex(&desc("HSBC").with("H   ", ang(120.0)).with("Strt", D::Double(100.0)).with("Brgh", D::Double(100.0))).as_deref(), Some("#00ff00"));
+    assert_eq!(color_hex(&desc("Grsc").with("Gry ", D::Double(100.0))).as_deref(), Some("#000000"));
+    assert_eq!(color_hex(&desc("CMYC")), None);
+    assert_eq!(color_desc("#12ab9F").map(|d| color_hex(&d)), Some(Some("#12ab9f".into())));
+    assert_eq!(color_desc("12ab9f"), None);
+    assert_eq!(color_desc("#12ab9"), None);
+    assert_eq!(color_desc("#ééééé"), None);
+}
+
+#[test]
+fn remaining_events_import_in_their_photoshop_shapes() {
+    // Close with the Save answer becomes Save then Close.
+    let close_yes = item("Cls ", "Close", Some(desc("null").with("Svng", enm("YsN ", "Ys  "))));
+    let close_no = item("close", "Close", Some(desc("null").with("Svng", enm("YsN ", "N   "))));
+    // A layer only moved is a translation; scaled, it is the relative Free Transform; the
+    // selection's frame goes to Transform Selection; points (not pixels) stay unsupported.
+    let moved = desc("null")
+        .with("null", target_ref("Lyr "))
+        .with("FTcs", enm("QCSt", "Qcsa"))
+        .with("Ofst", D::Descriptor(desc("Ofst").with("Hrzn", px(-57.4)).with("Vrtc", px(12.0))))
+        .with("Intr", enm("Intp", "Bcbc"));
+    let scaled = desc("null")
+        .with("null", target_ref("Lyr "))
+        .with("FTcs", enm("QCSt", "Qcsa"))
+        .with("Ofst", D::Descriptor(desc("Ofst").with("Hrzn", px(10.0)).with("Vrtc", px(0.0))))
+        .with("Wdth", pct(50.0))
+        .with("Hght", pct(50.0))
+        .with("Lnkd", D::Boolean(true))
+        .with("Intr", enm("Intp", "Bcbc"));
+    let sel = desc("null")
+        .with("null", D::Reference(vec![ReferenceItem::Property { class: class("Chnl"), key: Id::new("fsel") }]))
+        .with("FTcs", enm("QCSt", "Qcs0"))
+        .with("Ofst", D::Descriptor(desc("Ofst").with("Hrzn", px(1014.0)).with("Vrtc", px(0.0))));
+    let points = desc("null").with("null", target_ref("Lyr ")).with(
+        "Ofst",
+        D::Descriptor(desc("Ofst").with("Hrzn", D::UnitFloat { unit: *b"#Rlt", value: 3.0 }).with("Vrtc", D::UnitFloat { unit: *b"#Rlt", value: 1.0 })),
+    );
+    // Apply Image as recorded by the frequency-separation action.
+    let apply = desc("null").with(
+        "With",
+        D::Descriptor(
+            desc("null")
+                .with(
+                    "T   ",
+                    D::Reference(vec![
+                        ReferenceItem::Enumerated { class: class("Chnl"), type_id: Id::new("Chnl"), value: Id::new("RGB ") },
+                        ReferenceItem::Name { class: class("Lyr "), name: UnicodeString::new_nul("High-Frequency") },
+                    ]),
+                )
+                .with("Clcl", enm("Clcn", "Sbtr"))
+                .with("Scl ", D::Double(2.0))
+                .with("Ofst", D::Double(128.0))
+                .with("PrsT", D::Boolean(true)),
+        ),
+    );
+    // Save for Web with and without a destination.
+    let web = desc("null")
+        .with(
+            "Usng",
+            D::Descriptor(
+                desc("SaveForWeb")
+                    .with("Fmt ", enm("IRFm", "PN24"))
+                    .with("Intr", D::Boolean(false))
+                    .with("Trns", D::Boolean(true))
+                    .with("Mtt ", D::Boolean(true))
+                    .with("MttR", long(255.0))
+                    .with("MttG", long(255.0))
+                    .with("MttB", long(255.0))
+                    .with("EICC", D::Boolean(false)),
+            ),
+        )
+        .with("In  ", path_value("/Users/me/Desktop/out.png"));
+    let web_nowhere = desc("null").with("Usng", D::Descriptor(desc("SaveForWeb").with("Fmt ", enm("IRFm", "PN24"))));
+    // Quick Mask on/off, a polygon selection, the mask of the target layer deleted.
+    let qm_on = desc("null").with("null", quick_mask_ref());
+    let polygon = desc("null").with("null", D::Reference(vec![ReferenceItem::Property { class: class("Chnl"), key: Id::new("fsel") }])).with(
+        "T   ",
+        D::Descriptor(desc("Plgn").with(
+            "Pts ",
+            D::List(vec![
+                D::Descriptor(desc("Pnt ").with("Hrzn", px(1.0)).with("Vrtc", px(2.0))),
+                D::Descriptor(desc("Pnt ").with("Hrzn", px(30.0)).with("Vrtc", px(2.0))),
+                D::Descriptor(desc("Pnt ").with("Hrzn", px(15.0)).with("Vrtc", px(40.0))),
+            ]),
+        )),
+    );
+    let mask_delete = desc("null").with("null", target_ref("Chnl"));
+    let items = vec![
+        item("GsnB", "Gaussian Blur", Some(desc("null").with("Rds ", px(1.0)))),
+        close_yes,
+        close_no,
+        item("transform", "Transform", Some(moved)),
+        item("Trnf", "Transform", Some(scaled)),
+        item("transform", "Transform", Some(sel)),
+        item("transform", "Transform", Some(points)),
+        item("applyImageEvent", "Apply Image", Some(apply)),
+        item("export", "Export", Some(web)),
+        item("export", "Export", Some(web_nowhere)),
+        item("setd", "Set", Some(qm_on.clone())),
+        item("clearEvent", "Clear", Some(qm_on.clone())),
+        item("set", "Set", Some(polygon)),
+        item("delete", "Delete", Some(mask_delete)),
+        item("newPlacedLayer", "Convert to Smart Object", None),
+        item("placedLayerEditContents", "Edit Contents", None),
+        item("updatePlacedLayer", "Update Smart Objects", None),
+    ];
+    let file = AtnFile {
+        name: UnicodeString::new_nul("More"),
+        expanded: false,
+        actions: vec![AtnAction { name: UnicodeString::new_nul("A"), items, ..Default::default() }],
+        warnings: vec![],
+    };
+    let imp = import(&atn::write(&file).unwrap()).unwrap();
+    let steps = &imp.actions[0].steps;
+    let ids: Vec<&str> = steps.iter().map(|(id, _)| id.as_str()).collect();
+    assert_eq!(
+        ids,
+        [
+            "filter.blur.gaussianBlur",
+            "file.save",
+            "file.close",
+            "file.close",
+            "layer.translate",
+            "edit.transform",
+            "select.transformSelection",
+            PHOTOSHOP_STEP,
+            "image.applyImage",
+            "file.export.saveForWebLegacy",
+            PHOTOSHOP_STEP,
+            "select.editInQuickMaskMode",
+            "select.editInQuickMaskMode",
+            "select.lasso",
+            "layer.layerMask.delete",
+            "layer.smartObjects.convertToSmartObject",
+            "layer.smartObjects.editContents",
+            "layer.smartObjects.updateModifiedContent",
+        ]
+    );
+    assert_eq!(steps[4].1, json!({"dx": -57, "dy": 12}));
+    assert_eq!(steps[5].1, json!({"dx": 10, "dy": 0, "scaleX": 50, "scaleY": 50, "interpolation": "bicubic"}));
+    assert_eq!(steps[6].1, json!({"dx": 1014, "dy": 0}));
+    assert_eq!(
+        steps[8].1,
+        json!({"source": {"channel": "composite", "layer": "High-Frequency"}, "blending": "subtract", "scale": 2, "offset": 128, "preserveTransparency": true})
+    );
+    assert_eq!(
+        steps[9].1,
+        json!({"path": "/Users/me/Desktop/out.png", "format": "png24", "interlaced": false, "transparency": true, "embedIcc": false, "matte": "#ffffff"})
+    );
+    assert_eq!(steps[11].1, json!({"on": true}));
+    assert_eq!(steps[12].1, json!({"on": false}));
+    assert_eq!(steps[13].1, json!({"points": [[1, 2], [30, 2], [15, 40]]}));
+    assert_eq!(imp.unsupported.len(), 2);
+
+    // The frequency-separation set's own conditional, a percent Image Size, a Paint Bucket
+    // click in pixels (percent stays unsupported) and a Place.
+    let cond = desc("null")
+        .with("null", enm("Cndt", "Lyrs"))
+        .with(
+            "then",
+            D::Reference(vec![
+                ReferenceItem::Name { class: class("Actn"), name: UnicodeString::new_nul("FS8-Layers") },
+                ReferenceItem::Name { class: class("ASet"), name: UnicodeString::new_nul("FS") },
+            ]),
+        )
+        .with("else", D::Reference(vec![ReferenceItem::Name { class: class("Actn"), name: UnicodeString::new_nul("FS8-No-Layers") }]));
+    let size = desc("null")
+        .with("Wdth", pct(200.0))
+        .with("scaleStyles", D::Boolean(true))
+        .with("CnsP", D::Boolean(true))
+        .with("Intr", enm("Intp", "bicubicAutomatic"));
+    let bucket_px = desc("null")
+        .with("From", D::Descriptor(desc("Pnt ").with("Hrzn", px(0.0)).with("Vrtc", px(0.0))))
+        .with("Tlrn", long(32.0))
+        .with("Usng", enm("FlCn", "FrgC"))
+        .with("Cntg", D::Boolean(false));
+    let bucket_pct = desc("null")
+        .with("From", D::Descriptor(desc("Pnt ").with("Hrzn", pct(0.0)).with("Vrtc", pct(0.0))))
+        .with("Tlrn", long(32.0))
+        .with("Usng", enm("FlCn", "FrgC"));
+    let place = desc("null")
+        .with("null", path_value("/Users/me/logo.png"))
+        .with("FTcs", enm("QCSt", "Qcsa"))
+        .with("Wdth", pct(50.0))
+        .with("Hght", pct(50.0))
+        .with("Lnkd", D::Boolean(false));
+    let items = vec![
+        item("conditional", "If", Some(cond)),
+        item("imageSize", "Image Size", Some(size)),
+        item("fill", "Fill", Some(bucket_px)),
+        item("fill", "Fill", Some(bucket_pct)),
+        item("placeEvent", "Place", Some(place)),
+        item("Opn ", "Open", Some(desc("null").with("null", path_value("/Users/me/in.psd")))),
+    ];
+    let file = AtnFile {
+        name: UnicodeString::new_nul("Rest"),
+        expanded: false,
+        actions: vec![AtnAction { name: UnicodeString::new_nul("A"), items, ..Default::default() }],
+        warnings: vec![],
+    };
+    let rest = import(&atn::write(&file).unwrap()).unwrap();
+    let rest_steps = &rest.actions[0].steps;
+    let rest_ids: Vec<&str> = rest_steps.iter().map(|(id, _)| id.as_str()).collect();
+    assert_eq!(rest_ids, ["actions.conditional", "image.imageSize", "paint.bucket", PHOTOSHOP_STEP, "file.placeEmbedded", "file.openAs"]);
+    assert_eq!(rest_steps[0].1, json!({"if": "hasLayers", "then": "FS8-Layers", "else": "FS8-No-Layers"}));
+    assert_eq!(rest_steps[1].1, json!({"percent": 200, "resample": "bicubicAutomatic"}));
+    assert_eq!(rest_steps[2].1, json!({"x": 0, "y": 0, "tolerance": 32, "contiguous": false}));
+    assert_eq!(rest_steps[4].1, json!({"path": "/Users/me/logo.png", "scale": 50}));
+    assert_eq!(rest_steps[5].1, json!({"path": "/Users/me/in.psd"}));
+
+    // The Photoshop path record round-trips and rejects other shapes.
+    assert_eq!(path_text(&path_value("/a/b c.png")).as_deref(), Some("/a/b c.png"));
+    assert_eq!(path_text(&D::Path(b"txtu".to_vec())), None);
+    assert_eq!(path_text(&D::Path(vec![])), None);
+    assert_eq!(path_text(&D::Text(UnicodeString::new("x"))), None);
+    assert_eq!(path_text(&path_value("")), None);
+
+    // Apply Image by layer name runs on a document; a missing name is a clear error.
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "High-Frequency"})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "Top"})).unwrap();
+    s.execute("image.applyImage", steps[8].1.clone()).unwrap();
+    let e = s.execute("image.applyImage", json!({"source": {"layer": "Nope"}})).unwrap_err().to_string();
+    assert!(e.contains("Nope"), "{e}");
+}
+
+fn channel_ord(value: &str) -> D {
+    D::Reference(vec![ReferenceItem::Enumerated { class: class("Chnl"), type_id: Id::new("Chnl"), value: code(value) }])
+}
+
+fn fsel(t: D) -> Descriptor {
+    desc("null").with("null", D::Reference(vec![ReferenceItem::Property { class: class("Chnl"), key: Id::new("fsel") }])).with("T   ", t)
+}
+
+fn set_of(name: &str, actions: Vec<(&str, Vec<AtnItem>)>) -> String {
+    let file = AtnFile {
+        name: UnicodeString::new_nul(name),
+        expanded: false,
+        actions: actions.into_iter().map(|(n, items)| AtnAction { name: UnicodeString::new_nul(n), items, ..Default::default() }).collect(),
+        warnings: vec![],
+    };
+    b64(&atn::write(&file).unwrap())
+}
+
+/// The step shapes of the TrueGrit Texture Supply sets (Distress Press, Debaser, Transparency,
+/// Halftone Zine Machine), rebuilt here as Photoshop records them, import and play: the
+/// distressing filters land on the targeted layer mask, Remove White leaves the white
+/// transparent, nudges in points follow the resolution, and Step Backward undoes a step.
+#[test]
+fn distressing_and_remove_white_shapes_import_and_play() {
+    let ord = |cls: &str, ty: &str, v: &str| D::Reference(vec![ReferenceItem::Enumerated { class: class(cls), type_id: Id::new(ty), value: code(v) }]);
+    let black = D::Descriptor(desc("RGBC").with("Rd  ", D::Double(0.0)).with("Grn ", D::Double(0.0)).with("Bl  ", D::Double(0.0)));
+    let fill = desc("null")
+        .with("null", class_ref("contentLayer"))
+        .with("Usng", D::Descriptor(desc("contentLayer").with("Type", D::Descriptor(desc("solidColorLayer").with("Clr ", black)))));
+    let refine = desc("null")
+        .with("refineEdgeBorderRadius", px(0.0))
+        .with("refineEdgeBorderContrast", pct(100.0))
+        .with("refineEdgeSmooth", long(2.0))
+        .with("refineEdgeFeatherRadius", px(0.0))
+        .with("refineEdgeChoke", pct(0.0))
+        .with("refineEdgeAutoRadius", D::Boolean(false))
+        .with("refineEdgeDecontaminate", D::Boolean(false))
+        .with("refineEdgeOutput", enm("refineEdgeOutput", "refineEdgeOutputUserMask"));
+    let distress = vec![
+        item("setd", "Set", Some(fsel(channel_ord("Trsp")))),
+        item("Hd  ", "Hide", Some(desc("null").with("null", D::List(vec![target_ref("Lyr ")])))),
+        item("Mk  ", "Make", Some(fill)),
+        item("slct", "Select", Some(desc("null").with("null", channel_ord("Msk")).with("MkVs", D::Boolean(false)))),
+        item("refineSelectionEdge", "Select and Mask", Some(refine)),
+        item("Rple", "Ripple", Some(desc("null").with("Amnt", long(50.0)).with("RplS", enm("RplS", "Sml")))),
+        item("Crst", "Crystallize", Some(desc("null").with("ClSz", long(3.0)))),
+        item("GEfc", "Filter Gallery", Some(desc("null").with("GEfk", enm("GEft", "Spt")).with("SprR", long(7.0)).with("Smth", long(15.0)))),
+        item("slct", "Select", Some(desc("null").with("null", ord("Chnl", "Ordn", "Trgt")).with("MkVs", D::Boolean(false)))),
+        item("setd", "Set", Some(fsel(ord("Chnl", "Ordn", "Trgt")))),
+    ];
+    let bckg = D::Reference(vec![ReferenceItem::Property { class: class("Lyr "), key: Id::new("Bckg") }]);
+    let remove_white = vec![
+        item("CnvM", "Convert Mode", Some(desc("null").with("T   ", D::Class(class("Grys"))))),
+        item(
+            "setd",
+            "Set",
+            Some(desc("null").with("null", bckg).with("T   ", D::Descriptor(desc("Lyr ").with("Opct", pct(100.0)).with("Md  ", enm("BlnM", "Nrml"))))),
+        ),
+        item("setd", "Set", Some(fsel(ord("Chnl", "Ordn", "Trgt")))),
+        item("Dlt ", "Delete", None),
+        item("setd", "Set", Some(fsel(enm("Ordn", "None")))),
+    ];
+    let pt = |v: f64| D::UnitFloat { unit: PT, value: v };
+    let nudge = vec![item(
+        "move",
+        "Move",
+        Some(desc("null").with("null", target_ref("Lyr ")).with("T   ", D::Descriptor(desc("Ofst").with("Hrzn", pt(0.36)).with("Vrtc", pt(-0.36))))),
+    )];
+    let undo = vec![item("Invs", "Inverse", None), item("slct", "Select", Some(desc("null").with("null", ord("HstS", "Ordn", "Prvs"))))];
+    let data = set_of("TrueGrit", vec![("Distress", distress), ("Remove White", remove_white), ("Nudge", nudge), ("Undo", undo)]);
+
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 120, "height": 80, "resolution": 200})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "Ink"})).unwrap();
+    s.execute("select.rect", json!({"x": 20, "y": 20, "width": 80, "height": 40})).unwrap();
+    s.execute("edit.fill", json!({"contents": "color", "color": "#000000"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    let r = s.execute("actions.load", json!({"data": data})).unwrap();
+    // Only the re-selection of the targeted channel stays a Photoshop step, switched off.
+    let unsupported: Vec<&str> = r["unsupported"].as_array().unwrap().iter().map(|u| u["action"].as_str().unwrap()).collect();
+    assert_eq!(unsupported, ["Distress"], "{r}");
+
+    let r = s.execute("actions.play", json!({"action": "Distress"})).unwrap();
+    assert!(r.get("failed").is_none(), "{r}");
+    let st = s.active().unwrap();
+    let fill = st.doc.layer(st.active_layer.unwrap()).unwrap();
+    let mask = &fill.mask.as_ref().expect("the fill layer is masked by the ink").surface;
+    // The rectangle's straight top edge is roughened: pixels along it differ.
+    let edge: Vec<f32> = (20..100).map(|x| mask.sample_channel(x, 20, 0)).collect();
+    assert!(edge.iter().any(|v| *v < 0.5) && edge.iter().any(|v| *v > 0.5), "{edge:?}");
+    assert!(mask.sample_channel(60, 40, 0) > 0.9 && mask.sample_channel(5, 5, 0) < 0.1);
+    assert!(st.doc.selection.is_some(), "the targeted mask loads as the selection");
+    assert_eq!(st.channel_view.target, crate::channel_cmds::ChannelTarget::LayerMask);
+
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 40, "height": 30})).unwrap();
+    s.execute("select.rect", json!({"x": 10, "y": 10, "width": 20, "height": 10})).unwrap();
+    s.execute("edit.fill", json!({"contents": "color", "color": "#202020"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    s.execute("actions.load", json!({"data": data})).unwrap();
+    let r = s.execute("actions.play", json!({"action": "Remove White"})).unwrap();
+    assert!(r.get("failed").is_none(), "{r}");
+    let d = &s.active().unwrap().doc;
+    assert_eq!(d.mode, photocraft_color::ColorMode::Grayscale);
+    let l = d.layers.last().unwrap();
+    assert!(!d.is_background(l.id), "Layer From Background");
+    let surf = l.surface().unwrap();
+    assert!(surf.sample_channel(2, 2, 1) < 0.01, "white is cleared");
+    // #202020 is about 22 in the default (Dot Gain 20 %-compatible) working gray.
+    let ink = surf.sample_channel(20, 15, 1);
+    assert!((ink - (1.0 - 22.0 / 255.0)).abs() < 0.02, "the ink keeps its darkness as opacity: {ink}");
+    // An image that opened as a normal layer has no Background: the step leaves it as it is.
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 40, "height": 30, "background": "transparent"})).unwrap();
+    s.execute("edit.fill", json!({"contents": "white"})).unwrap();
+    s.execute("actions.load", json!({"data": data})).unwrap();
+    let r = s.execute("actions.play", json!({"action": "Remove White"})).unwrap();
+    assert!(r.get("failed").is_none(), "{r}");
+    let surf = s.active().unwrap().doc.layers.last().unwrap().surface().unwrap().clone();
+    assert!(surf.sample_channel(2, 2, 1) < 0.01, "white is cleared without a Background");
+
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 40, "height": 30, "resolution": 200})).unwrap();
+    s.execute("layer.new.layer", json!({})).unwrap();
+    s.execute("select.rect", json!({"x": 10, "y": 10, "width": 5, "height": 5})).unwrap();
+    s.execute("edit.fill", json!({"contents": "color", "color": "#ff0000"})).unwrap();
+    s.execute("actions.load", json!({"data": data})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    assert!(s.execute("actions.play", json!({"action": "Nudge"})).unwrap().get("failed").is_none());
+    let st = s.active().unwrap();
+    let b = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().content_bounds();
+    assert_eq!((b.x0, b.y0), (11, 9), "0.36 pt is 1 px at 200 ppi");
+    s.execute("select.rect", json!({"x": 0, "y": 0, "width": 5, "height": 5})).unwrap();
+    let before = s.active().unwrap().doc.selection.clone();
+    assert!(s.execute("actions.play", json!({"action": "Undo"})).unwrap().get("failed").is_none());
+    assert_eq!(s.active().unwrap().doc.selection, before, "Step Backward undid the Inverse");
+}
+
+/// Remove White on art in its own layer above a white Background: the Background becomes a
+/// normal layer, but the art layer stays targeted, so the white is cleared from the art.
+#[test]
+fn remove_white_clears_the_targeted_layer_not_the_converted_background() {
+    let ord = |cls: &str, ty: &str, v: &str| D::Reference(vec![ReferenceItem::Enumerated { class: class(cls), type_id: Id::new(ty), value: code(v) }]);
+    let bckg = D::Reference(vec![ReferenceItem::Property { class: class("Lyr "), key: Id::new("Bckg") }]);
+    let steps = vec![
+        item("CnvM", "Convert Mode", Some(desc("null").with("T   ", D::Class(class("Grys"))))),
+        item(
+            "setd",
+            "Set",
+            Some(desc("null").with("null", bckg).with("T   ", D::Descriptor(desc("Lyr ").with("Opct", pct(100.0)).with("Md  ", enm("BlnM", "Nrml"))))),
+        ),
+        item("setd", "Set", Some(fsel(ord("Chnl", "Ordn", "Trgt")))),
+        item("Dlt ", "Delete", None),
+        item("setd", "Set", Some(fsel(enm("Ordn", "None")))),
+    ];
+    let data = set_of("TrueGrit", vec![("Remove White", steps)]);
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 40, "height": 30})).unwrap();
+    let art = s.execute("layer.new.layer", json!({"name": "Art"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("edit.fill", json!({"contents": "white"})).unwrap();
+    s.execute("select.rect", json!({"x": 10, "y": 10, "width": 20, "height": 10})).unwrap();
+    s.execute("edit.fill", json!({"contents": "color", "color": "#000000"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    s.execute("actions.load", json!({"data": data})).unwrap();
+    let r = s.execute("actions.play", json!({"action": "Remove White"})).unwrap();
+    assert!(r.get("failed").is_none(), "{r}");
+    let st = s.active().unwrap();
+    assert_eq!(st.active_layer.map(|l| l.0), Some(art), "the art layer stays targeted");
+    let art = st.doc.layer(photocraft_doc::LayerId(art)).unwrap().surface().unwrap();
+    assert!(art.sample_channel(2, 2, 1) < 0.01, "the art's white is cleared");
+    assert!(art.sample_channel(20, 15, 1) > 0.99, "the black stays");
+    let bottom = st.doc.layers.first().unwrap();
+    assert!(!st.doc.is_background(bottom.id), "the Background became a normal layer");
+    assert!(bottom.surface().unwrap().sample_channel(2, 2, 1) > 0.99, "and kept its pixels");
+}
diff --git a/crates/engine/src/automate_cmds.rs b/crates/engine/src/automate_cmds.rs
index b8f827d125..6a98ee3c4f 100644
--- a/crates/engine/src/automate_cmds.rs
+++ b/crates/engine/src/automate_cmds.rs
@@ -391,23 +391,8 @@ fn statistics(s: &mut Session, p: &Value) -> Result<Value> {
         .ok_or_else(|| bad(cmd, format!("unknown stack mode `{mode}`")))?;
     let input = p.get("input").or_else(|| p.get("paths")).cloned().ok_or_else(|| bad(cmd, "missing \"input\" (files or a folder)"))?;
     let align = p.get("align").and_then(Value::as_bool).unwrap_or(false);
-    let r = s.execute("file.scripts.loadFilesIntoStack", json!({"paths": input, "createSmartObject": !align}))?;
+    let r = s.execute("file.scripts.loadFilesIntoStack", json!({"paths": input, "align": align, "createSmartObject": true}))?;
     let n = r["layers"].as_u64().unwrap_or(0);
-    if align && n > 1 {
-        s.execute("select.allLayers", json!({}))?;
-        s.execute("edit.autoAlignLayers", json!({"projection": "auto"}))?;
-        let name = s.active().map(|d| d.doc.name.clone()).unwrap_or_default();
-        s.edit("Convert to Smart Object", |doc, active| {
-            let layers = std::mem::take(&mut doc.layers);
-            let smart = crate::smart_cmds::layers_to_smart(doc, &name, layers)?;
-            *active = Some(smart.id);
-            doc.layers = vec![smart];
-            Ok(())
-        })?;
-        if let Some(st) = s.active_mut() {
-            st.selected_layers = st.active_layer.into_iter().collect();
-        }
-    }
     let id = s.active().and_then(|d| d.doc.layers.first().map(|l| l.id)).ok_or(EngineError::NoDocument)?;
     s.select_layer(id)?;
     s.execute(&format!("layer.smartObjects.stackMode.{}", sm.id()), json!({"layer": id.0}))?;
diff --git a/crates/engine/src/automate_cmds/tests.rs b/crates/engine/src/automate_cmds/tests.rs
index d4e0a6379b..b60dc2940e 100644
--- a/crates/engine/src/automate_cmds/tests.rs
+++ b/crates/engine/src/automate_cmds/tests.rs
@@ -340,8 +340,18 @@ fn a_failed_step_inside_a_called_action_fails_scripts_and_batch() {
     images(&dir, 1, 8, 4);
     let mut s = Session::new();
     s.execute("file.new", json!({"width": 8, "height": 6})).unwrap();
-    s.actions.list.push(Action { name: "Rotate".into(), steps: vec![("image.imageRotation.90cw".into(), json!({}))], disabled: Default::default() });
-    s.actions.list.push(Action { name: "Bad".into(), steps: vec![("layer.delete".into(), json!({"layer": 999_999}))], disabled: Default::default() });
+    s.actions.list.push(Action {
+        name: "Rotate".into(),
+        steps: vec![("image.imageRotation.90cw".into(), json!({}))],
+        disabled: Default::default(),
+        ..Default::default()
+    });
+    s.actions.list.push(Action {
+        name: "Bad".into(),
+        steps: vec![("layer.delete".into(), json!({"layer": 999_999}))],
+        disabled: Default::default(),
+        ..Default::default()
+    });
     // A script stops at the failed call and reports it.
     let r = s.execute("file.scripts.browse", json!({"steps": [["actions.play", {"action": "Bad"}], ["image.imageRotation.90cw", {}]]})).unwrap();
     assert_eq!(r["ok"], false, "{r}");
@@ -358,6 +368,48 @@ fn a_failed_step_inside_a_called_action_fails_scripts_and_batch() {
     assert!(r["errors"][0]["error"].as_str().unwrap().contains("no such layer"), "{r}");
     // An action that batches itself stops as a recursive call instead of overflowing the stack.
     let inner = json!({"steps": [["actions.play", {"action": "Loop"}]], "input": dir.clone(), "output": format!("{dir}/inner"), "format": "png"});
-    s.actions.list.push(Action { name: "Loop".into(), steps: vec![("file.automate.batch".into(), inner)], disabled: Default::default() });
+    s.actions.list.push(Action { name: "Loop".into(), steps: vec![("file.automate.batch".into(), inner)], disabled: Default::default(), ..Default::default() });
     batch(&mut s, "Loop");
 }
+
+/// #4671: Load Files into Stack's Attempt to Automatically Align Source Images runs Auto-Align
+/// Layers on the loaded layers, then (with Create Smart Object) puts them in one smart object;
+/// without the smart object they stay loose layers, selected.
+#[test]
+fn load_files_into_stack_aligns_before_the_smart_object() {
+    let dir = tmp("stack-align");
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 96, "height": 72, "background": "#606060"})).unwrap();
+    s.edit("texture", |doc, active| {
+        let surf = doc.layer_mut(active.ok_or(EngineError::NoDocument)?).and_then(Layer::surface_mut).ok_or(EngineError::NoDocument)?;
+        for k in 0..40 {
+            let (x, y, v) = ((k * 37) % 88, (k * 23) % 66, (k % 7) as f32 / 6.0);
+            surf.fill_rect(photocraft_geom::Rect::new(x, y, x + 3 + k % 5, y + 2 + k % 4), &[v, 1.0 - v, 0.5, 1.0]);
+        }
+        Ok(())
+    })
+    .unwrap();
+    let files: Vec<String> = (0..2)
+        .map(|i| {
+            let path = format!("{dir}/img{i}.png");
+            crate::file_cmds::save_doc(&s.active().unwrap().doc, &path, None).unwrap();
+            path
+        })
+        .collect();
+    let mut s = Session::new();
+    let r = s.execute("file.scripts.loadFilesIntoStack", json!({"paths": files, "align": true})).unwrap();
+    assert_eq!(r["layers"], 2);
+    let st = s.active().unwrap();
+    assert_eq!(st.doc.layers.len(), 2, "loose layers");
+    assert!(st.doc.layers.iter().all(|l| matches!(l.content, LayerContent::Raster(_))));
+    assert_eq!(st.selected_layers().len(), 2, "Auto-Align ran on them all");
+    let mut s = Session::new();
+    s.execute("file.scripts.loadFilesIntoStack", json!({"paths": files, "align": true, "createSmartObject": true})).unwrap();
+    let d = &s.active().unwrap().doc;
+    assert_eq!(d.layers.len(), 1);
+    let LayerContent::Smart(_) = &d.layers[0].content else { panic!("not a smart object") };
+    // A single file has nothing to align with: it just loads.
+    let mut s = Session::new();
+    s.execute("file.scripts.loadFilesIntoStack", json!({"paths": [files[0].clone()], "align": true})).unwrap();
+    assert_eq!(s.active().unwrap().doc.layers.len(), 1);
+}
diff --git a/crates/engine/src/background_cmds.rs b/crates/engine/src/background_cmds.rs
index 1da5ebc92b..81c47501d3 100644
--- a/crates/engine/src/background_cmds.rs
+++ b/crates/engine/src/background_cmds.rs
@@ -10,14 +10,13 @@ use photocraft_doc::{Document, Layer, LayerContent, LayerId};
 use serde_json::{Value, json};
 
 use crate::commands::CommandSpec;
-use crate::extra_cmds::is_background;
 use crate::{EngineError, Result, Session};
 
 const CMD: &str = "layer.new.backgroundFromLayer";
 
 /// The document's Background layer, if it has one (always the bottom layer).
 pub(crate) fn background_id(doc: &Document) -> Option<LayerId> {
-    doc.layers.first().filter(|l| is_background(l)).map(|l| l.id)
+    doc.background().map(|l| l.id)
 }
 
 /// Refuses an edit that moved the Background `bg` (taken before the edit) off the bottom of the
@@ -155,7 +154,7 @@ mod tests {
             assert_eq!(s.execute(CMD, json!({})).unwrap()["layer"], a.0);
             assert_eq!(order(&s), [a, l0, b], "{depth}: drops to the bottom");
             let l = &doc(&s).layers[0];
-            assert!(is_background(l) && l.name == "Background", "{depth}");
+            assert!(doc(&s).is_background(l.id) && l.name == "Background", "{depth}");
             assert_eq!(s.active().unwrap().active_layer, Some(a));
             // Its pixels stay; transparency takes the background colour (blue).
             let red = pixel(&s, 3, 3);
@@ -170,10 +169,10 @@ mod tests {
             assert!(s.undo());
             assert_eq!(order(&s), [l0, a, b], "{depth}");
             let l = doc(&s).layer(a).unwrap();
-            assert!(!is_background(l) && l.name == "A");
+            assert!(!doc(&s).is_background(l.id) && l.name == "A");
             assert!(s.redo());
             assert_eq!(order(&s), [a, l0, b], "{depth}");
-            assert!(is_background(&doc(&s).layers[0]));
+            assert!(doc(&s).is_background(doc(&s).layers[0].id));
         }
     }
 
@@ -191,7 +190,7 @@ mod tests {
         assert_eq!(d.layers[1].id, l0);
         assert_eq!(d.layers[2].id, a);
         let bg = &d.layers[0];
-        assert!(is_background(bg) && !bg.visible, "visibility is kept");
+        assert!(d.is_background(bg.id) && !bg.visible, "visibility is kept");
         assert_eq!(bg.opacity, 1.0);
     }
 
@@ -211,7 +210,7 @@ mod tests {
         for p in [json!({"layer": "A"}), json!({"layer": -1}), json!({"layer": 1.5}), json!({"layer": 99999}), json!({"layer": [a.0]})] {
             assert!(s.execute(CMD, p.clone()).is_err(), "{p}");
         }
-        assert!(!doc(&s).layers.iter().any(is_background));
+        assert!(doc(&s).background().is_none());
         // A group or an adjustment layer can't become the Background.
         s.execute("layer.select", json!({"layer": a.0})).unwrap();
         s.execute("layer.groupLayers", json!({})).unwrap();
@@ -220,7 +219,7 @@ mod tests {
         s.execute("layer.newAdjustmentLayer.invert", json!({})).unwrap();
         assert!(!s.is_enabled(CMD));
         assert!(s.execute(CMD, json!({})).is_err());
-        assert!(!doc(&s).layers.iter().any(is_background));
+        assert!(doc(&s).background().is_none());
     }
 
     #[test]
diff --git a/crates/engine/src/brush_cmds.rs b/crates/engine/src/brush_cmds.rs
index 2167cb1a0d..370b6fcc78 100644
--- a/crates/engine/src/brush_cmds.rs
+++ b/crates/engine/src/brush_cmds.rs
@@ -10,7 +10,10 @@ use photocraft_doc::LayerContent;
 use photocraft_geom::Rect;
 use photocraft_paint::mixer::{MixerSettings, apply_mixer_stroke};
 use photocraft_paint::replace::{Limits, ReplaceMode, ReplaceSettings, Sampling, apply_color_replacement, color_replacement_effect};
-use photocraft_paint::{BrushPreset, BrushSettings, GrayTile, Stroke, StrokePoint, StrokeRenderer, TipShape, render_stroke};
+use photocraft_paint::tile::PREVIEW_SIDE;
+use photocraft_paint::{
+    BrushPreset, BrushSettings, GrayTile, Pattern, PresetCaptures, StoredTile, Stroke, StrokePoint, StrokeRenderer, TipShape, render_stroke,
+};
 use photocraft_raster::Surface;
 use serde_json::{Value, json};
 
@@ -177,7 +180,7 @@ fn find_preset<'a>(s: &'a Session, name: &str, cmd: &str) -> Result<&'a BrushPre
 pub fn resolve_brush(s: &Session, p: &Value, cmd: &str) -> Result<BrushSettings> {
     let mut b = s.tools.brush.clone();
     if let Some(name) = p.get("preset").and_then(Value::as_str) {
-        b = find_preset(s, name, cmd)?.brush.clone().picked_over(&s.tools.brush);
+        b = find_preset(s, name, cmd)?.picked_over(&s.tools.brush);
     }
     if let Some(patch) = p.get("brush").filter(|v| v.is_object()) {
         b = merge_brush(&b, patch, cmd)?;
@@ -200,9 +203,11 @@ pub fn resolve_brush(s: &Session, p: &Value, cmd: &str) -> Result<BrushSettings>
         b.spacing = v.clamp(0.01, 10.0);
     }
     if let Some(v) = num(p, "smoothing") {
+        b.smoothing.enabled = true;
         b.smoothing.amount = v.clamp(0.0, 1.0);
     }
     b.color = color(p.get("color"), s.tools.foreground);
+    b.color_cmyk = s.tools.picked_cmyk([b.color[0], b.color[1], b.color[2]]).map(|k| ([b.color[0], b.color[1], b.color[2]], k));
     b.background = s.tools.background;
     b.erase = flag(p, "erase", false);
     b.seed = match p.get("seed").and_then(Value::as_u64) {
@@ -248,7 +253,7 @@ fn erase_locked(brush: &mut BrushSettings, lock: bool, bg: [f32; 4]) {
 /// The document's own CMYK profile (absent, built-in or not a CMYK document: `None`, the
 /// default conversions), which the stroke's colour conversions must honour — the compositors
 /// and composite exports enter the same scope.
-fn doc_cmyk_space(s: &Session) -> Option<std::sync::Arc<photocraft_color::convert::CmykSpace>> {
+pub(crate) fn doc_cmyk_space(s: &Session) -> Option<std::sync::Arc<photocraft_color::convert::CmykSpace>> {
     photocraft_color::convert::CmykSpace::for_profile(s.active().and_then(|d| d.doc.icc_profile.as_ref()))
 }
 
@@ -366,6 +371,7 @@ fn block_brush(b: BrushSettings, p: &Value) -> Result<BrushSettings> {
         pressure_opacity: false,
         spacing: 0.25,
         color: b.color,
+        color_cmyk: b.color_cmyk,
         background: b.background,
         erase: b.erase,
         smoothing: b.smoothing,
@@ -415,8 +421,9 @@ pub struct LiveStroke {
     symmetry: Option<crate::symmetry_cmds::PaintingSymmetry>,
     mirrors: Vec<StrokeRenderer>,
     mirror_distinct: Vec<bool>,
-    /// Restore passes separately; their union may span an otherwise untouched document.
-    symmetry_regions: Vec<Rect>,
+    /// What the symmetric preview drew last, once a mirror differs from the stroke, and how many
+    /// passes it merged (a mirror joining redraws every tile).
+    union_live: Option<(photocraft_paint::UnionLive, usize)>,
     pre: Surface,
     sel: Option<Surface>,
     lock: bool,
@@ -433,17 +440,19 @@ pub struct LiveStroke {
     base: (photocraft_doc::DocId, u64),
 }
 
-/// A finished live stroke offered to its own commit ([`Session::offer_live_stroke`]): when the
-/// committing `paint.stroke` / `paint.pencil` matches it (same command, document revision, params,
-/// seed and points), the command takes these pixels instead of rendering the stroke again.
+/// A finished live stroke offered to its own commit ([`Session::offer_live_stroke`],
+/// [`Session::offer_live_retouch`]): when the committing command matches it (same command,
+/// document revision, params, seed and points), it takes these pixels instead of rendering the
+/// stroke again.
 pub struct LiveCommit {
-    cmd: String,
-    base: (photocraft_doc::DocId, u64),
-    params: Value,
-    seed: u64,
-    points: Vec<StrokePoint>,
-    surface: Surface,
-    bounds: Rect,
+    pub(crate) cmd: String,
+    pub(crate) base: (photocraft_doc::DocId, u64),
+    pub(crate) params: Value,
+    /// The Brush's and Pencil's seed; the retouching tools have none.
+    pub(crate) seed: Option<u64>,
+    pub(crate) points: Vec<StrokePoint>,
+    pub(crate) surface: Surface,
+    pub(crate) bounds: Rect,
 }
 
 impl LiveCommit {
@@ -457,11 +466,11 @@ impl LiveCommit {
         p
     }
 
-    fn matches(&self, s: &Session, cmd: &str, p: &Value, pts: &[StrokePoint]) -> bool {
+    pub(crate) fn matches(&self, s: &Session, cmd: &str, p: &Value, pts: &[StrokePoint]) -> bool {
         let base = s.active().map(|st| (st.doc.id, st.revision));
         self.cmd == cmd
             && base == Some(self.base)
-            && p.get("seed").and_then(Value::as_u64) == Some(self.seed)
+            && p.get("seed").and_then(Value::as_u64) == self.seed
             && self.points == pts
             && Self::settings(p) == Self::settings(&self.params)
     }
@@ -508,7 +517,7 @@ impl LiveStroke {
             symmetry,
             mirrors,
             mirror_distinct,
-            symmetry_regions: Vec::new(),
+            union_live: None,
             pre,
             sel,
             lock,
@@ -527,7 +536,7 @@ impl LiveStroke {
     pub fn into_commit(mut self) -> Result<LiveCommit> {
         let bounds = self.bounds();
         let (surf, _) = crate::channel_cmds::target_surface(std::sync::Arc::make_mut(&mut self.doc), self.layer, &self.params)?;
-        Ok(LiveCommit { cmd: self.cmd, base: self.base, params: self.params, seed: self.seed, points: self.points, surface: surf.clone(), bounds })
+        Ok(LiveCommit { cmd: self.cmd, base: self.base, params: self.params, seed: Some(self.seed), points: self.points, surface: surf.clone(), bounds })
     }
 
     /// Everything the stroke has touched so far.
@@ -567,33 +576,27 @@ impl LiveStroke {
             }
             let (surf, _) = crate::channel_cmds::target_surface(std::sync::Arc::make_mut(&mut self.doc), self.layer, &self.params)?;
             if self.mirror_distinct.iter().any(|d| *d) {
-                // Merge every finished pass once, both here and on commit, including shared axes.
+                // The stroke and its distinct mirrors composite as one stroke, as the commit
+                // merges them; only the tiles that changed are redrawn.
                 let old = self.tail;
-                let mut original_preview = self.renderer.clone();
-                original_preview.finish();
-                let copies: Vec<_> = self
-                    .mirrors
-                    .iter()
-                    .zip(&self.mirror_distinct)
-                    .filter(|(_, d)| **d)
-                    .map(|(r, _)| {
-                        let mut r = r.clone();
-                        r.finish();
-                        r
-                    })
+                let passes = 1 + self.mirror_distinct.iter().filter(|d| **d).count();
+                let (mut live, full, mut dmg) = match self.union_live.take() {
+                    Some((live, merged)) => (live, merged != passes, Rect::EMPTY),
+                    None => {
+                        // Leaving the single-pass preview: take its smoothing tail back first.
+                        if !old.is_empty() {
+                            surf.write_region(old, &self.pre.read_region(old));
+                        }
+                        (photocraft_paint::UnionLive::default(), true, old)
+                    }
+                };
+                let mut renderers: Vec<&mut StrokeRenderer> = std::iter::once(&mut self.renderer)
+                    .chain(self.mirrors.iter_mut().zip(&self.mirror_distinct).filter(|(_, d)| **d).map(|(r, _)| r))
                     .collect();
-                let bounds = copies.iter().fold(original_preview.bounds().union(&old), |b, r| b.union(&r.bounds()));
-                if self.symmetry_regions.is_empty() && !old.is_empty() {
-                    surf.write_region(old, &self.pre.read_region(old));
-                }
-                for region in &self.symmetry_regions {
-                    surf.write_region(*region, &self.pre.read_region(*region));
-                }
-                self.symmetry_regions =
-                    std::iter::once(original_preview.bounds()).chain(copies.iter().map(StrokeRenderer::bounds)).filter(|r| !r.is_empty()).collect();
-                let damage = original_preview.composite_union_many(&copies, &self.pre, surf, self.sel.as_ref(), self.lock);
-                self.tail = bounds;
-                return Ok(damage.union(&bounds));
+                dmg = dmg.union(&StrokeRenderer::composite_union_live(&mut renderers, &mut live, full, &self.pre, surf, self.sel.as_ref(), self.lock));
+                self.tail = old.union(&live.bounds());
+                self.union_live = Some((live, passes));
+                return Ok(dmg);
             }
             let mut dmg = Rect::EMPTY;
             let old = std::mem::replace(&mut self.tail, Rect::EMPTY);
@@ -761,13 +764,19 @@ fn upsert(s: &mut Session, preset: BrushPreset) {
 fn presets_save(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "brush.presets.save";
     let name = name_param(p, cmd)?;
-    let brush = match p.get("brush").filter(|v| v.is_object()) {
+    let mut brush = match p.get("brush").filter(|v| v.is_object()) {
         Some(patch) => merge_brush(&s.tools.brush, patch, cmd)?,
         None => s.tools.brush.clone(),
     };
-    upsert(s, BrushPreset { name: name.clone(), brush, builtin: false, group: String::new(), folder: Vec::new() });
+    // The New Brush Preset dialog's boxes; without them the preset captures what it always did.
+    let captures = PresetCaptures { size: flag(p, "captureSize", true), tool_settings: flag(p, "toolSettings", true), color: flag(p, "color", false) };
+    if captures.color {
+        brush.color = s.tools.foreground;
+    }
+    upsert(s, BrushPreset { name: name.clone(), brush, builtin: false, group: String::new(), folder: Vec::new(), captures });
     // The saved brush is the current brush now (Photoshop selects the brush it just saved).
     s.tools.current_preset = Some(name.clone());
+    s.tools.brush_changed();
     Ok(json!({ "name": name, "count": s.tools.presets.len() }))
 }
 
@@ -781,6 +790,8 @@ fn presets_delete(s: &mut Session, p: &Value) -> Result<Value> {
     }
     if s.tools.current_preset.as_ref().is_some_and(|c| c.eq_ignore_ascii_case(&name)) {
         s.tools.current_preset = None;
+        // The remembered brush names the preset it was picked from: the name went away.
+        s.tools.brush_changed();
     }
     s.brush_presets_changed();
     Ok(json!({ "count": s.tools.presets.len() }))
@@ -818,6 +829,7 @@ fn presets_set_current(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad(cmd, format!("no brush preset named `{name}`")));
     }
     s.tools.current_preset = Some(name.clone());
+    s.tools.brush_changed();
     Ok(json!({ "name": name }))
 }
 
@@ -881,9 +893,10 @@ fn define_from_selection(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let tip = GrayTile::from_f32(tw, th, &data);
     let brush = BrushSettings { tip: TipShape::Sampled(tip), size: tw.max(th) as f32, spacing: 0.25, pressure_size: false, ..BrushSettings::default() };
-    upsert(s, BrushPreset { name: name.clone(), brush: brush.clone(), builtin: false, group: String::new(), folder: Vec::new() });
+    upsert(s, BrushPreset { name: name.clone(), brush: brush.clone(), builtin: false, group: String::new(), folder: Vec::new(), captures: Default::default() });
     s.tools.brush = brush;
     s.tools.current_preset = Some(name.clone());
+    s.tools.brush_changed();
     Ok(json!({ "name": name, "width": tw, "height": th }))
 }
 
@@ -891,8 +904,11 @@ pub(crate) fn set_brush(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "tools.setBrush";
     let mut b = s.tools.brush.clone();
     let mut picked = None;
+    let mut picked_color = None;
     if let Some(name) = p.get("preset").and_then(Value::as_str) {
-        b = find_preset(s, name, cmd)?.brush.clone().picked_over(&s.tools.brush);
+        let preset = find_preset(s, name, cmd)?;
+        b = preset.picked_over(&s.tools.brush);
+        picked_color = preset.captures.color.then_some(preset.brush.color);
         picked = Some(name.to_string());
     }
     let reset = flag(p, "reset", false);
@@ -921,6 +937,10 @@ pub(crate) fn set_brush(s: &mut Session, p: &Value) -> Result<Value> {
         s.tools.current_preset = None;
     } else if let Some(name) = picked {
         s.tools.current_preset = Some(name);
+        // A preset saved with Include Color brings its colour as the foreground (Photoshop).
+        if let Some(c) = picked_color {
+            s.tools.foreground = c;
+        }
     }
     // The tool's brush always paints with full tips: load a library preset's from the store.
     s.load_brush_tips(&mut b).map_err(|e| bad(cmd, e))?;
@@ -936,9 +956,70 @@ pub(crate) fn set_brush(s: &mut Session, p: &Value) -> Result<Value> {
         Some(k) => s.tools.brush_gesture = Some((k.to_string(), before)),
         None => s.tools.brush_gesture = None,
     }
+    // The one accepted brush change everyone (UI sliders, control channel, presets) lands here.
+    s.tools.brush_changed();
     Ok(brush_json(&s.tools.brush))
 }
 
+/// Remember the current brush in `Preferences::last_brush` (see [`remembered_brush`]). Called
+/// every frame while the pointer is up, so it is change-driven: `ToolState::brush_rev` is compared
+/// with the revision already saved and an unchanged brush clones and serialises nothing.
+pub fn remember_brush(s: &mut Session) {
+    if s.tools.brush_rev == s.tools.brush_saved_rev {
+        return;
+    }
+    let Some(now) = remembered_brush(s) else { return };
+    if s.prefs().last_brush != now {
+        s.prefs.edit(|p| p.last_brush = now);
+    }
+    s.tools.brush_saved_rev = s.tools.brush_rev;
+}
+
+/// The current brush as JSON for `Preferences::last_brush`: settings plus tip references, no full
+/// bitmap. `None` while a sampled bitmap too big to embed is current (only before the store
+/// externalizes it; see [`ref_tip`]), so the previous remembered brush stands.
+fn remembered_brush(s: &Session) -> Option<Value> {
+    let b = &s.tools.brush;
+    let (tip, dual, pattern) = (ref_tip(&b.tip)?, ref_tip(&b.dual_brush.tip)?, ref_pattern(&b.texture.pattern)?);
+    let mut c = b.clone();
+    (c.tip, c.dual_brush.tip, c.texture.pattern) = (tip, dual, pattern);
+    Some(json!({ "preset": s.tools.current_preset.clone(), "brush": serde_json::to_value(&c).ok()? }))
+}
+
+/// Restore `Preferences::last_brush` into the session at launch (a missing or malformed value
+/// keeps the default brush). Stored tips load when the preset store attaches.
+pub fn restore_brush(s: &mut Session) {
+    let v = s.prefs().last_brush.clone();
+    let Some(patch) = v.get("brush").filter(|b| b.is_object()) else { return };
+    let Ok(mut b) = merge_brush(&BrushSettings::default(), patch, "brush.restore") else { return };
+    if validate_brush(&b, "brush.restore").is_err() {
+        return;
+    }
+    let _ = s.load_brush_tips(&mut b);
+    s.tools.brush = b;
+    s.tools.current_preset = v.get("preset").and_then(Value::as_str).map(str::to_string);
+    // What was just restored is exactly what the preferences hold: nothing new to write.
+    s.tools.brush_saved_rev = s.tools.brush_rev;
+}
+
+/// A tip for remembering: a loaded stored tip drops its full bitmap (it serialises as a reference
+/// then); a sampled bitmap bigger than a preview would enter the prefs document whole.
+fn ref_tip(t: &TipShape) -> Option<TipShape> {
+    match t {
+        TipShape::Stored(r) if r.full.is_some() => Some(TipShape::Stored(StoredTile { full: None, ..r.clone() })),
+        TipShape::Sampled(g) if g.width > PREVIEW_SIDE || g.height > PREVIEW_SIDE => None,
+        t => Some(t.clone()),
+    }
+}
+
+fn ref_pattern(p: &Pattern) -> Option<Pattern> {
+    match p {
+        Pattern::Stored(r) if r.full.is_some() => Some(Pattern::Stored(StoredTile { full: None, ..r.clone() })),
+        Pattern::Tile(g) if g.width > PREVIEW_SIDE || g.height > PREVIEW_SIDE => None,
+        p => Some(p.clone()),
+    }
+}
+
 /// The brush as JSON with the bitmaps (sampled tips, pattern tiles) that `skip` names replaced by
 /// placeholders: they can be megabytes of base64, and skipped ones are equal on both sides.
 fn light_json(b: &BrushSettings, skip: (bool, bool, bool)) -> Value {
@@ -1041,7 +1122,14 @@ pub fn specs() -> Vec<CommandSpec> {
             true
         ),
         spec!("brush.presets.list", "List Brush Presets", r##"{"full":bool=false}"##, always, presets_list, false),
-        spec!("brush.presets.save", "Save Brush Preset", r##"{"name":string,"brush":{…BrushSettings}?=current brush}"##, always, presets_save, true),
+        spec!(
+            "brush.presets.save",
+            "Save Brush Preset",
+            r##"{"name":string,"brush":{…BrushSettings}?=current brush,"captureSize":bool=true (false: picking it keeps the tool's size),"toolSettings":bool=true (false: picking it keeps the tool's mode, opacity, flow and pressure buttons),"color":bool=false (picking it sets the foreground to the current foreground)}"##,
+            always,
+            presets_save,
+            true
+        ),
         spec!(
             "brush.presets.update",
             "Update Brush Preset",
diff --git a/crates/engine/src/brush_cmds/tests.rs b/crates/engine/src/brush_cmds/tests.rs
index 3a04a470fb..d91e9ec4d7 100644
--- a/crates/engine/src/brush_cmds/tests.rs
+++ b/crates/engine/src/brush_cmds/tests.rs
@@ -191,7 +191,7 @@ fn live_color_replacement_matches_the_commit() {
                 }
             }
             assert!(b.rgba(10, 20)[1] > 0.5 || sampling == "backgroundSwatch", "{depth}-bit {sampling}: recoloured");
-            assert!(worst <= 2.0 / 255.0, "{depth}-bit {sampling}: live and commit differ by {worst}");
+            assert!(worst <= 2.0 / 255.0 + 1e-6, "{depth}-bit {sampling}: live and commit differ by {worst}");
         }
     }
 }
@@ -237,6 +237,45 @@ fn presets_save_load_delete_round_trip() {
     assert!(s.execute("brush.presets.save", json!({})).is_err());
 }
 
+/// The New Brush Preset dialog's boxes (#4490): a preset saved without Capture Brush Size or
+/// Include Tool Settings leaves the tool's size, mode, opacity, flow and pressure buttons as they
+/// are when picked; one saved with Include Color brings its colour back as the foreground. A preset
+/// saved without the boxes picks as it always did.
+#[test]
+fn presets_save_captures_size_tool_settings_and_color_as_asked() {
+    let mut s = session(10, 10);
+    s.execute("tools.setBrush", json!({"size": 40, "opacity": 0.5, "flow": 0.25, "mode": "Multiply", "pressureSize": false})).unwrap();
+    s.tools.foreground = [1.0, 0.0, 0.0, 1.0];
+    s.execute("brush.presets.save", json!({"name": "Legacy"})).unwrap();
+    s.execute("brush.presets.save", json!({"name": "Bare", "captureSize": false, "toolSettings": false})).unwrap();
+    s.execute("brush.presets.save", json!({"name": "Red", "color": true})).unwrap();
+    let caps = |n: &str| s.tools.presets.iter().find(|p| p.name == n).unwrap().captures.clone();
+    assert!(caps("Legacy").is_default(), "no boxes, the captures of any other preset");
+    assert_eq!(caps("Bare"), PresetCaptures { size: false, tool_settings: false, color: false });
+    assert!(caps("Red").color);
+
+    // Change the tool, then pick each.
+    let other = json!({"size": 9, "opacity": 1.0, "flow": 1.0, "mode": "Normal", "pressureSize": true});
+    s.execute("tools.setBrush", other.clone()).unwrap();
+    s.tools.foreground = [0.0, 0.0, 1.0, 1.0];
+    s.execute("tools.setBrush", json!({"preset": "Legacy"})).unwrap();
+    let b = &s.tools.brush;
+    assert_eq!((b.size, b.opacity, b.flow, b.mode, b.pressure_size), (40.0, 0.5, 0.25, photocraft_color::BlendMode::Multiply, false), "everything it saved");
+    assert_eq!(s.tools.foreground, [0.0, 0.0, 1.0, 1.0], "a preset without Include Color leaves the foreground");
+
+    s.execute("tools.setBrush", other.clone()).unwrap();
+    s.execute("tools.setBrush", json!({"preset": "Bare"})).unwrap();
+    let b = &s.tools.brush;
+    assert_eq!((b.size, b.opacity, b.flow, b.mode, b.pressure_size), (9.0, 1.0, 1.0, photocraft_color::BlendMode::Normal, true), "the tool's own");
+    assert_eq!(s.tools.current_preset.as_deref(), Some("Bare"));
+
+    s.execute("tools.setBrush", json!({"preset": "Red"})).unwrap();
+    assert_eq!(s.tools.foreground, [1.0, 0.0, 0.0, 1.0], "Include Color sets the foreground");
+    // A stroke naming the preset takes the same brush.
+    let r = resolve_brush(&s, &json!({"preset": "Bare"}), "paint.brush").unwrap();
+    assert_eq!(r.size, s.tools.brush.size);
+}
+
 #[test]
 fn presets_save_appends_at_the_end_and_update_overwrites_in_place() {
     let mut s = session(10, 10);
@@ -744,10 +783,11 @@ fn out_of_range_scatter_is_rejected_and_the_maximum_still_paints() {
         let d: Vec<i64> = r["damage"].as_array().unwrap().iter().map(|v| v.as_i64().unwrap()).collect();
         assert!(d[0].abs() < 1000 && d[1].abs() < 1000 && d[2] > 0 && d[3] > 0, "{r}");
     }
-    // Control: 200 % scatter paints where it did before the cap.
+    // Control: 200 % scatter paints where it did before the cap (the soft default tip reaches a
+    // little past its radius).
     let mut s = new();
     s.execute("tools.setBrush", json!({ "brush": scatter(2.0) })).unwrap();
-    assert_eq!(s.execute("paint.stroke", stroke).unwrap(), json!({"damage": [17, 14, 23, 23]}));
+    assert_eq!(s.execute("paint.stroke", stroke).unwrap(), json!({"damage": [15, 12, 27, 27]}));
 }
 
 #[test]
@@ -870,6 +910,82 @@ fn an_offer_that_does_not_match_the_commit_is_ignored() {
     assert!(r.get("fromLive").is_none());
 }
 
+#[test]
+fn last_brush_is_remembered_when_the_revision_moves_only() {
+    let mut s = session(8, 8);
+    restore_brush(&mut s);
+    // A restore is already in the preferences: nothing to write, no clone or serialise.
+    s.prefs.edit(|p| p.last_brush = json!("sentinel"));
+    remember_brush(&mut s);
+    assert_eq!(s.prefs().last_brush, json!("sentinel"), "an unchanged brush must not serialise");
+    s.execute("tools.setBrush", json!({"size": 23})).unwrap();
+    assert!(s.tools.brush_rev > s.tools.brush_saved_rev);
+    remember_brush(&mut s);
+    assert_eq!(s.prefs().last_brush["brush"]["size"].as_f64(), Some(23.0));
+    assert_eq!(s.tools.brush_saved_rev, s.tools.brush_rev, "the revision is marked saved");
+    // Revision unchanged: even a hand-written value stays (the gate is a counter compare).
+    s.prefs.edit(|p| p.last_brush = json!("sentinel"));
+    remember_brush(&mut s);
+    assert_eq!(s.prefs().last_brush, json!("sentinel"));
+}
+
+#[test]
+fn rejected_brush_changes_do_not_move_the_revision() {
+    let mut s = session(8, 8);
+    let rev = s.tools.brush_rev;
+    assert!(s.execute("tools.setBrush", json!({"size": "big"})).is_err());
+    assert_eq!(s.tools.brush_rev, rev, "a rejected brush leaves no change behind");
+    s.execute("tools.setBrush", json!({"size": 31})).unwrap();
+    assert!(s.tools.brush_rev > rev);
+}
+
+#[test]
+fn the_revision_tracks_the_picked_preset_too() {
+    let mut s = session(8, 8);
+    s.execute("tools.setBrush", json!({"preset": "Hard Round"})).unwrap();
+    let rev = s.tools.brush_rev;
+    s.execute("brush.presets.setCurrent", json!({"name": "Soft Round"})).unwrap();
+    assert!(s.tools.brush_rev > rev, "the remembered preset name follows the picked preset");
+    remember_brush(&mut s);
+    assert_eq!(s.prefs().last_brush["preset"].as_str(), Some("Soft Round"));
+}
+
+#[test]
+fn the_remembered_brush_restores_at_launch() {
+    let mut s = session(8, 8);
+    s.execute("tools.setBrush", json!({"preset": "Hard Round", "size": 44, "hardness": 0.3})).unwrap();
+    remember_brush(&mut s);
+    let stored = s.prefs().last_brush.clone();
+    assert_eq!(stored["preset"].as_str(), Some("Hard Round"));
+    let mut t = Session::new();
+    assert_ne!(t.tools.brush.size, 44.0, "a fresh session starts on the default brush");
+    t.prefs.edit(|p| p.last_brush = stored);
+    restore_brush(&mut t);
+    assert_eq!(t.tools.brush.size, 44.0);
+    assert_eq!(t.tools.brush.hardness, 0.3);
+    assert_eq!(t.tools.current_preset.as_deref(), Some("Hard Round"));
+    assert_eq!(t.tools.brush_saved_rev, t.tools.brush_rev, "the restored value is already stored");
+    // A malformed remembered brush keeps the default (never an error, never a panic).
+    let mut bad = Session::new();
+    bad.prefs.edit(|p| p.last_brush = json!({"brush": {"size": "huge"}}));
+    restore_brush(&mut bad);
+    assert_eq!(bad.tools.brush.size, Session::new().tools.brush.size);
+}
+
+#[test]
+fn remembered_brushes_never_embed_large_bitmaps() {
+    use std::sync::Arc;
+    let big = GrayTile::from_fn(PREVIEW_SIDE + 1, 8, |_, _| 1.0);
+    assert!(ref_tip(&TipShape::Sampled(big)).is_none(), "a big sampled tip cannot be embedded");
+    let small = GrayTile::from_fn(8, 8, |_, _| 1.0);
+    assert!(ref_tip(&TipShape::Sampled(small.clone())).is_some(), "small tiles embed");
+    let stored =
+        StoredTile { key: "k".into(), width: 300, height: 200, preview: Arc::new(small), full: Some(Arc::new(GrayTile::from_fn(300, 200, |_, _| 1.0))) };
+    let t = ref_tip(&TipShape::Stored(stored)).expect("stored tips are remembered as references");
+    assert!(matches!(t, TipShape::Stored(r) if r.full.is_none()), "a loaded full bitmap is dropped");
+    assert!(ref_pattern(&Pattern::Tile(GrayTile::from_fn(PREVIEW_SIDE + 1, 4, |_, _| 1.0))).is_none());
+}
+
 /// Photoshop's Clear painting mode (#3439): a Brush or Pencil stroke in `"mode": "clear"` erases
 /// with that brush, and History still names the tool rather than the Eraser.
 #[test]
@@ -883,3 +999,21 @@ fn clear_mode_erases_with_the_brush_or_pencil() {
         assert_eq!(s.active().unwrap().history.undo_label(), Some(label), "{cmd}");
     }
 }
+
+/// #4344: a foreground picked as CMYK 100/0/0/0 is painted into a CMYK document as those inks by
+/// the Brush and the Pencil, not as whatever its sRGB stand-in converts back to (100/28/0/17).
+#[test]
+fn brush_and_pencil_paint_a_cmyk_pick_with_the_picked_inks() {
+    let cyan = [1.0f32, 0.0, 0.0, 0.0];
+    for cmd in ["paint.stroke", "paint.pencil"] {
+        let mut s = session(16, 16);
+        s.execute("image.mode.cmyk", json!({})).unwrap();
+        let rgb = photocraft_color::convert::cmyk_to_rgb(cyan).map(|c| c.clamp(0.0, 1.0));
+        s.execute("tools.setColors", json!({"foreground": rgb, "foregroundCmyk": cyan})).unwrap();
+        s.execute(cmd, json!({"points": [[8.0, 8.0]], "size": 6.0, "hardness": 1.0})).unwrap();
+        let st = s.active().unwrap();
+        let surf = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap();
+        let got: Vec<f32> = surf.read_region(Rect::new(8, 8, 9, 9)).into_iter().take(4).collect();
+        assert!(got.iter().zip(cyan).all(|(a, b)| (a - b).abs() < 0.02), "{cmd}: {got:?}");
+    }
+}
diff --git a/crates/engine/src/brush_key_cmds.rs b/crates/engine/src/brush_key_cmds.rs
index e4887bee39..56663b400a 100644
--- a/crates/engine/src/brush_key_cmds.rs
+++ b/crates/engine/src/brush_key_cmds.rs
@@ -2,11 +2,15 @@
 //! has no menu item for them but lists them in Edit › Keyboard Shortcuts › Tools ("Decrease Brush
 //! Size"…); here they are ordinary commands with default shortcuts, so they can be rebound,
 //! recorded and driven by agents. Each one is a `tools.setBrush` on the session brush.
+//!
+//! `tools.rotateBrush` turns the tip: Photoshop's ← / → while painting (1°, ⇧ 15°). Arrows mean
+//! other things with other tools, so the shell gives them to it only for the painting tools
+//! (`move_mods::arrow_keys`).
 
 use serde_json::{Value, json};
 
 use crate::commands::{CommandSpec, always};
-use crate::{Result, Session};
+use crate::{EngineError, Result, Session};
 
 /// Photoshop's largest brush diameter, in pixels.
 pub const MAX_SIZE: f32 = 5000.0;
@@ -35,6 +39,23 @@ fn hardness(s: &mut Session, up: bool) -> Result<Value> {
     crate::brush_cmds::set_brush(s, &json!({ "brush": { "hardness": hardness } }))
 }
 
+/// The brush angle turned by `degrees` (positive is anticlockwise, as the angle field counts),
+/// wrapped into Photoshop's -180..=180.
+fn turned(angle: f32, degrees: f32) -> f32 {
+    let a = (angle + degrees).rem_euclid(360.0);
+    if a > 180.0 { a - 360.0 } else { a }
+}
+
+fn rotate(s: &mut Session, p: &Value) -> Result<Value> {
+    let by = p
+        .get("degrees")
+        .and_then(Value::as_f64)
+        .filter(|d| d.is_finite() && d.abs() <= 360.0)
+        .ok_or_else(|| EngineError::BadParams { cmd: "tools.rotateBrush".into(), msg: "`degrees` must be a number from -360 to 360".into() })?;
+    let angle = turned(s.tools.brush.angle, by as f32);
+    crate::brush_cmds::set_brush(s, &json!({ "brush": { "angle": angle } }))
+}
+
 macro_rules! key_cmd {
     ($id:literal, $label:literal, $sc:literal, $run:expr) => {
         CommandSpec { id: $id, label: $label, menu: &[], shortcut: Some($sc), params: "{}", enabled: always, run: $run, journal: true }
@@ -47,6 +68,16 @@ pub fn specs() -> Vec<CommandSpec> {
         key_cmd!("tools.increaseBrushSize", "Increase Brush Size", "]", |s, _| size(s, true)),
         key_cmd!("tools.decreaseBrushHardness", "Decrease Brush Hardness", "Shift+[", |s, _| hardness(s, false)),
         key_cmd!("tools.increaseBrushHardness", "Increase Brush Hardness", "Shift+]", |s, _| hardness(s, true)),
+        CommandSpec {
+            id: "tools.rotateBrush",
+            label: "Rotate Brush Tip",
+            menu: &[],
+            shortcut: None,
+            params: r##"{"degrees":-360..360 (positive anticlockwise; ← / → while painting send 1, ⇧ 15)}"##,
+            enabled: always,
+            run: rotate,
+            journal: true,
+        },
     ]
 }
 
@@ -74,6 +105,21 @@ mod tests {
         assert_eq!(hardness_step(0.0, false), 0.0);
     }
 
+    #[test]
+    fn rotate_brush_turns_the_tip_and_wraps_at_180() {
+        assert_eq!(turned(0.0, 1.0), 1.0);
+        assert_eq!(turned(179.0, 15.0), -166.0);
+        assert_eq!(turned(-175.0, -15.0), 170.0);
+        assert_eq!(turned(180.0, 0.0), 180.0);
+        let mut s = Session::new();
+        s.execute("tools.rotateBrush", json!({"degrees": -15})).unwrap();
+        assert_eq!(s.tools.brush.angle, -15.0);
+        for bad in [json!({}), json!({"degrees": "x"}), json!({"degrees": 1e9}), json!(null)] {
+            assert!(s.execute("tools.rotateBrush", bad.clone()).is_err(), "{bad}");
+        }
+        assert_eq!(s.tools.brush.angle, -15.0);
+    }
+
     #[test]
     fn commands_step_the_session_brush_and_journal() {
         let mut s = Session::new();
diff --git a/crates/engine/src/brush_preset_cmds.rs b/crates/engine/src/brush_preset_cmds.rs
index 614127f297..46331126ac 100644
--- a/crates/engine/src/brush_preset_cmds.rs
+++ b/crates/engine/src/brush_preset_cmds.rs
@@ -4,7 +4,9 @@
 //! Groups are the panel's top-level folders ([`BrushPreset::group`]); a group can hold nested
 //! folders ([`BrushPreset::folder`], a path inside the group, e.g. the folders of an imported
 //! `.abr` file). The group commands take an optional `folder` path to act on a nested folder
-//! instead of the whole group. A folder exists while a preset is in it (or below it).
+//! instead of the whole group, and `moveGroup` can move a group or folder `into` another folder
+//! or group, or out to the top level (dragging a folder onto a folder in Photoshop's panel). A
+//! folder exists while a preset is in it (or below it).
 //!
 //! The library order is the panel order: groups appear in order of their first preset, and a
 //! group's folders and presets in order of their first preset too. Every
@@ -117,6 +119,7 @@ fn rename(s: &mut Session, p: &Value) -> Result<Value> {
         pr.builtin = false;
         if was_current {
             s.tools.current_preset = Some(new.clone());
+            s.tools.brush_changed();
         }
         s.brush_presets_changed();
     }
@@ -247,9 +250,116 @@ fn move_folder(s: &mut Session, p: &Value, g: String, f: Vec<String>, cmd: &str)
     Ok(json!({ "group": g, "folder": f, "index": at }))
 }
 
+/// Where `into` puts a folder: `Some(None)` = the top level (it becomes a group), `Some(Some((group,
+/// folder)))` = inside that folder of that group (`[]`: directly in the group). `None` without `into`.
+type Dest = Option<(String, Vec<String>)>;
+
+fn into_param(s: &Session, p: &Value, cmd: &str) -> Result<Option<Dest>> {
+    let into = match p.get("into") {
+        None | Some(Value::Null) => return Ok(None),
+        Some(v @ Value::Object(_)) => v,
+        Some(_) => return Err(bad(cmd, "`into` must be an object {group?, folder?}")),
+    };
+    let Some(g) = group_param(into, "group", cmd)? else {
+        if folder_param(into, cmd)?.is_some_and(|f| !f.is_empty()) {
+            return Err(bad(cmd, "`into.folder` needs `into.group`"));
+        }
+        return Ok(Some(None));
+    };
+    group_block(s, &g, cmd)?;
+    let f = folder_param(into, cmd)?.unwrap_or_default();
+    if !s.tools.presets.iter().any(|x| in_folder(x, &g, &f)) {
+        return Err(bad(cmd, format!("no folder `{}` in brush preset group `{g}`", f.join("/"))));
+    }
+    Ok(Some(Some((g, f))))
+}
+
+/// Move folder `f` of group `g` (the whole group when `f` is empty) into `dest`, keeping its
+/// content and the order of its presets: Photoshop's drag of a folder onto another folder. It
+/// lands at the end of the destination, or before the sibling folder (group at the top level)
+/// named by `before`.
+fn move_into(s: &mut Session, p: &Value, g: String, f: Vec<String>, dest: Dest, cmd: &str) -> Result<Value> {
+    if p.get("index").is_some_and(|v| !v.is_null()) {
+        return Err(bad(cmd, "`index` can't be combined with `into` (use `before`)"));
+    }
+    let leaf = match f.last() {
+        Some(l) => l.clone(),
+        None if g.is_empty() => return Err(bad(cmd, "the ungrouped presets are not a folder that can be moved")),
+        None => g.clone(),
+    };
+    let moving = |x: &BrushPreset| in_folder(x, &g, &f);
+    let rest_of = |x: &BrushPreset| x.folder.get(f.len()..).unwrap_or_default().to_vec();
+    let before = match p.get("before") {
+        None | Some(Value::Null) => None,
+        Some(Value::String(b)) => Some(b.trim().to_string()),
+        Some(_) => return Err(bad(cmd, "`before` must be a folder name")),
+    };
+    // The destination's own folders and groups, without the one being moved.
+    let others: Vec<BrushPreset> = s.tools.presets.iter().filter(|x| !moving(x)).cloned().collect();
+    let (new_group, new_prefix, siblings) = match &dest {
+        None => {
+            if f.is_empty() {
+                return Err(bad(cmd, "`into`: the group is already at the top level"));
+            }
+            (leaf.clone(), Vec::new(), group_order(&others))
+        }
+        Some((dg, df)) => {
+            if *dg == g && df.starts_with(&f) {
+                return Err(bad(cmd, "`into` names the folder being moved or one of its own folders"));
+            }
+            let mut prefix = df.clone();
+            prefix.push(leaf.clone());
+            (dg.clone(), prefix, subfolder_order(&others, dg, df))
+        }
+    };
+    if siblings.contains(&leaf) {
+        return Err(bad(cmd, format!("a folder named `{leaf}` already exists there")));
+    }
+    if let Some(b) = &before
+        && !siblings.contains(b)
+    {
+        return Err(bad(cmd, format!("`before`: no folder named `{b}` there")));
+    }
+    let deepest = s.tools.presets.iter().filter(|x| moving(x)).map(|x| new_prefix.len() + rest_of(x).len()).max().unwrap_or(0);
+    if deepest > MAX_FOLDER_DEPTH {
+        return Err(bad(cmd, format!("folders can be nested at most {MAX_FOLDER_DEPTH} deep")));
+    }
+    let lib = std::mem::take(&mut s.tools.presets);
+    let (mut block, mut rest): (Vec<BrushPreset>, Vec<BrushPreset>) = lib.into_iter().partition(|x| in_folder(x, &g, &f));
+    for x in &mut block {
+        let tail = rest_of(x);
+        x.group.clone_from(&new_group);
+        x.folder = new_prefix.iter().cloned().chain(tail).collect();
+        x.builtin = false;
+    }
+    let pos = match (&dest, &before) {
+        (None, Some(b)) => rest.iter().position(|x| x.group == *b),
+        (None, None) => None,
+        (Some((dg, df)), Some(b)) => {
+            let sib: Vec<String> = df.iter().cloned().chain(std::iter::once(b.clone())).collect();
+            rest.iter().position(|x| in_folder(x, dg, &sib))
+        }
+        (Some((dg, df)), None) => rest.iter().rposition(|x| in_folder(x, dg, df)).map(|k| k + 1),
+    };
+    let tail = rest.split_off(pos.unwrap_or(rest.len()).min(rest.len()));
+    rest.extend(block);
+    rest.extend(tail);
+    s.tools.presets = rest;
+    s.brush_presets_changed();
+    let folder = new_prefix.get(..new_prefix.len().saturating_sub(1)).unwrap_or_default();
+    let at = match &dest {
+        None => group_order(&s.tools.presets).iter().position(|x| *x == new_group),
+        Some(_) => subfolder_order(&s.tools.presets, &new_group, folder).iter().position(|x| *x == leaf),
+    };
+    Ok(json!({ "group": new_group, "folder": new_prefix, "index": at.unwrap_or(0) }))
+}
+
 fn move_group(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "brush.presets.moveGroup";
     let (g, f) = target_folder(s, p, cmd)?;
+    if let Some(dest) = into_param(s, p, cmd)? {
+        return move_into(s, p, g, f, dest, cmd);
+    }
     if !f.is_empty() {
         return move_folder(s, p, g, f, cmd);
     }
@@ -324,6 +434,7 @@ fn delete_group(s: &mut Session, p: &Value) -> Result<Value> {
     s.tools.presets.retain(|x| !in_folder(x, &g, &f));
     if s.tools.current_preset.as_ref().is_some_and(|c| !s.tools.presets.iter().any(|x| x.name.eq_ignore_ascii_case(c))) {
         s.tools.current_preset = None;
+        s.tools.brush_changed();
     }
     s.brush_presets_changed();
     Ok(json!({ "deleted": before - s.tools.presets.len(), "count": s.tools.presets.len() }))
@@ -348,7 +459,7 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!(
             "brush.presets.moveGroup",
             "Move Brush Group",
-            r##"{"group":string,"folder":[name]? (move this nested folder among its sibling folders instead),"before":group? (or sibling folder name) | "index":n? (group or sibling folder position)=end} → {group, folder?, index}"##,
+            r##"{"group":string,"folder":[name]? (move this nested folder instead),"into":{"group":string?,"folder":[name]?}? (move it inside that folder of that group, [] = directly in the group; no group = out to the top level as a group of its own; the folder keeps its content),"before":group? (or sibling folder name, in its new place with `into`) | "index":n? (group or sibling folder position, without `into`)=end} → {group, folder?, index}"##,
             move_group
         ),
         spec!(
@@ -377,7 +488,14 @@ mod tests {
     fn with_groups() -> Session {
         let mut s = Session::new();
         for (n, g) in [("A1", "Alpha"), ("A2", "Alpha"), ("A3", "Alpha"), ("B1", "Beta"), ("B2", "Beta")] {
-            s.tools.presets.push(BrushPreset { name: n.into(), brush: Default::default(), builtin: false, group: g.into(), folder: Vec::new() });
+            s.tools.presets.push(BrushPreset {
+                name: n.into(),
+                brush: Default::default(),
+                builtin: false,
+                group: g.into(),
+                folder: Vec::new(),
+                captures: Default::default(),
+            });
         }
         s
     }
@@ -482,7 +600,14 @@ mod tests {
         let mut s = Session::new();
         for (n, f) in [("S0", &[][..]), ("I1", &["Ink"][..]), ("F1", &["Ink", "Fine"][..]), ("I2", &["Ink"][..]), ("D1", &["Dry"][..])] {
             let folder = f.iter().map(|x| x.to_string()).collect();
-            s.tools.presets.push(BrushPreset { name: n.into(), brush: Default::default(), builtin: false, group: "Set".into(), folder });
+            s.tools.presets.push(BrushPreset {
+                name: n.into(),
+                brush: Default::default(),
+                builtin: false,
+                group: "Set".into(),
+                folder,
+                captures: Default::default(),
+            });
         }
         s
     }
@@ -572,4 +697,112 @@ mod tests {
         assert_eq!(s.tools.presets, before);
         s.execute("brush.presets.moveGroup", json!({"group": "Set", "folder": ["Ink", "Fine"], "index": u64::MAX})).unwrap();
     }
+
+    fn paths(s: &Session) -> Vec<String> {
+        s.tools.presets.iter().filter(|x| !x.builtin).map(|x| format!("{}:{}:{}", x.group, x.folder.join("/"), x.name)).collect()
+    }
+
+    /// `with_folders` plus group "Other" holding O1, and folder Box (B1) in it.
+    fn with_two_groups() -> Session {
+        let mut s = with_folders();
+        for (n, f) in [("O1", &[][..]), ("B1", &["Box"][..])] {
+            let folder = f.iter().map(|x| x.to_string()).collect();
+            s.tools.presets.push(BrushPreset {
+                name: n.into(),
+                brush: Default::default(),
+                builtin: false,
+                group: "Other".into(),
+                folder,
+                captures: Default::default(),
+            });
+        }
+        s
+    }
+
+    #[test]
+    fn folders_move_into_folders_and_groups() {
+        let mut s = with_two_groups();
+        // A nested folder into a sibling folder: its subtree follows, order kept.
+        let r = s.execute("brush.presets.moveGroup", json!({"group": "Set", "folder": ["Dry"], "into": {"group": "Set", "folder": ["Ink", "Fine"]}})).unwrap();
+        assert_eq!(r, json!({"group": "Set", "folder": ["Ink", "Fine", "Dry"], "index": 0}));
+        assert_eq!(folder_of(&s, "D1"), ["Ink", "Fine", "Dry"]);
+        // Into another group, before one of its folders.
+        let r = s.execute("brush.presets.moveGroup", json!({"group": "Set", "folder": ["Ink"], "into": {"group": "Other"}, "before": "Box"})).unwrap();
+        assert_eq!(r["folder"], json!(["Ink"]));
+        assert_eq!(paths(&s), ["Set::S0", "Other::O1", "Other:Ink:I1", "Other:Ink/Fine:F1", "Other:Ink/Fine/Dry:D1", "Other:Ink:I2", "Other:Box:B1"]);
+        // Out to the top level: the folder becomes a group of its own.
+        let r = s.execute("brush.presets.moveGroup", json!({"group": "Other", "folder": ["Ink", "Fine"], "into": {}})).unwrap();
+        assert_eq!(r["group"], "Fine");
+        assert_eq!(folder_of(&s, "D1"), ["Dry"]);
+        assert_eq!(photocraft_paint::presets::find(&s.tools.presets, "F1").unwrap().group, "Fine");
+        // A whole group into another group's folder.
+        s.execute("brush.presets.moveGroup", json!({"group": "Fine", "into": {"group": "Set"}})).unwrap();
+        assert!(names(&s, "Fine").is_empty());
+        assert_eq!(folder_of(&s, "D1"), ["Fine", "Dry"]);
+        assert_eq!(subfolder_order(&s.tools.presets, "Set", &[]), ["Fine"]);
+    }
+
+    #[test]
+    fn bad_moves_into_folders_fail_without_changes() {
+        let mut s = with_two_groups();
+        // A chain 31 deep under Set/Deep.
+        let deep: Vec<String> = std::iter::once("Deep".to_string()).chain((0..30).map(|i| format!("d{i}"))).collect();
+        s.tools.presets.push(BrushPreset {
+            name: "Z".into(),
+            brush: Default::default(),
+            builtin: false,
+            group: "Set".into(),
+            folder: deep.clone(),
+            captures: Default::default(),
+        });
+        s.tools.presets.push(BrushPreset {
+            name: "Y".into(),
+            brush: Default::default(),
+            builtin: false,
+            group: "Other".into(),
+            folder: vec!["Dry".into()],
+            captures: Default::default(),
+        });
+        let before = s.tools.presets.clone();
+        let deep_json = json!(deep);
+        for p in [
+            // Into itself or its own descendant.
+            json!({"group": "Set", "folder": ["Ink"], "into": {"group": "Set", "folder": ["Ink"]}}),
+            json!({"group": "Set", "folder": ["Ink"], "into": {"group": "Set", "folder": ["Ink", "Fine"]}}),
+            json!({"group": "Set", "into": {"group": "Set", "folder": ["Dry"]}}),
+            json!({"group": "Set", "into": {"group": "Set"}}),
+            // A group already at the top level; the ungrouped presets.
+            json!({"group": "Set", "into": {}}),
+            // A name clash at the destination.
+            json!({"group": "Set", "folder": ["Dry"], "into": {"group": "Other"}}),
+            json!({"group": "Other", "folder": ["Box"], "into": {"group": "Set", "folder": ["Ink"]}, "before": "Nope"}),
+            json!({"group": "Set", "folder": ["Dry"], "into": {"group": "Set", "folder": ["Ink"]}, "index": 0}),
+            // Missing destinations and bad shapes.
+            json!({"group": "Set", "folder": ["Dry"], "into": {"group": "Nope"}}),
+            json!({"group": "Set", "folder": ["Dry"], "into": {"group": "Other", "folder": ["Nope"]}}),
+            json!({"group": "Set", "folder": ["Dry"], "into": {"folder": ["Box"]}}),
+            json!({"group": "Set", "folder": ["Dry"], "into": "Other"}),
+            json!({"group": "Set", "folder": ["Dry"], "into": {"group": 5}}),
+            json!({"group": "Set", "folder": ["Dry"], "into": {"group": "Other"}, "before": 3}),
+            // Deeper than MAX_FOLDER_DEPTH once moved (Ink/Fine is 2 deep: 2 + 31 > 32).
+            json!({"group": "Set", "folder": ["Deep"], "into": {"group": "Set", "folder": ["Ink", "Fine"]}}),
+            json!({"group": "Set", "folder": ["Ink"], "into": {"group": "Set", "folder": deep_json}}),
+        ] {
+            assert!(s.execute("brush.presets.moveGroup", p.clone()).is_err(), "{p}");
+        }
+        assert_eq!(s.tools.presets, before);
+        // Ink/Fine into Set itself: a clash with nothing, so it moves up a level.
+        s.execute("brush.presets.moveGroup", json!({"group": "Set", "folder": ["Ink", "Fine"], "into": {"group": "Set"}})).unwrap();
+        assert_eq!(folder_of(&s, "F1"), ["Fine"]);
+        // An ungrouped preset's group can't move.
+        s.tools.presets.push(BrushPreset {
+            name: "U".into(),
+            brush: Default::default(),
+            builtin: false,
+            group: String::new(),
+            folder: Vec::new(),
+            captures: Default::default(),
+        });
+        assert!(s.execute("brush.presets.moveGroup", json!({"group": "", "into": {"group": "Set"}})).is_err());
+    }
 }
diff --git a/crates/engine/src/channel_clip.rs b/crates/engine/src/channel_clip.rs
index 8b1739d161..fc52cf0a43 100644
--- a/crates/engine/src/channel_clip.rs
+++ b/crates/engine/src/channel_clip.rs
@@ -73,7 +73,7 @@ pub(crate) fn copy(s: &mut Session) -> Result<Option<Value>> {
     if bounds.is_empty() {
         return Err(EngineError::Other("Could not copy: the selected area is empty".into()));
     }
-    s.clipboard = Some(Clip { surface, bounds, layers: None });
+    s.clipboard = Some(Clip { surface, bounds, layers: None, resolution: Some(doc.resolution_dpi) });
     Ok(Some(json!({"bounds": [bounds.x0, bounds.y0, bounds.width(), bounds.height()], "channel": k})))
 }
 
diff --git a/crates/engine/src/channel_clip/tests.rs b/crates/engine/src/channel_clip/tests.rs
index e6fa57333a..39cb029b3d 100644
--- a/crates/engine/src/channel_clip/tests.rs
+++ b/crates/engine/src/channel_clip/tests.rs
@@ -147,3 +147,19 @@ fn cut_a_colour_channel_clears_only_that_channel() {
     s.undo();
     assert!(near(&px(&s, 5, 5), &left), "one undoable step");
 }
+
+#[test]
+fn clearing_a_channel_reports_allocation_failure_without_editing() {
+    for depth in [8, 16, 32] {
+        let mut s = session(depth);
+        let id = s.active().unwrap().active_layer.unwrap();
+        let before = s.active().unwrap().doc.clone();
+        let history = s.active().unwrap().history.entries();
+        crate::allocation::fail_next_for_test();
+        let result = s.edit("Clear", |doc, _| crate::channel_cmds::clear_color_channel(doc, id, 0, [1.0; 4]));
+        let _ = crate::allocation::capacity::<u8>(0, "reset failpoint");
+        assert!(result.is_err());
+        assert_eq!(*s.active().unwrap().doc, *before);
+        assert_eq!(s.active().unwrap().history.entries(), history);
+    }
+}
diff --git a/crates/engine/src/channel_cmds.rs b/crates/engine/src/channel_cmds.rs
index 5fd7e5c97e..00f3ec4e31 100644
--- a/crates/engine/src/channel_cmds.rs
+++ b/crates/engine/src/channel_cmds.rs
@@ -152,6 +152,7 @@ pub(crate) fn fix_view(st: &mut DocState) {
 fn touch(st: &mut DocState) {
     let clean = st.saved_revision == st.revision;
     st.revision += 1;
+    st.view_revision += 1;
     if clean {
         st.saved_revision = st.revision;
     }
@@ -194,8 +195,8 @@ pub fn channel_format(doc: &Document) -> PixelFormat {
     PixelFormat::new(ColorMode::Grayscale, doc.depth, false)
 }
 
-/// Next free "Alpha N" name.
-fn next_alpha_name(doc: &Document, base: &str) -> String {
+/// Next free "`base` N" name (Alpha 1, Spot Color 2, …).
+pub fn next_alpha_name(doc: &Document, base: &str) -> String {
     // `channels.len() + 1` candidates always include a free one.
     (1..=doc.channels.len() + 1).map(|n| format!("{base} {n}")).find(|n| !doc.channels.iter().any(|c| &c.name == n)).unwrap_or_else(|| base.to_string())
 }
@@ -328,9 +329,20 @@ fn native_pixels(doc: &Document, layer: Option<LayerId>) -> Result<(Vec<f32>, us
     }
 }
 
-/// `"layer"` param of a source: a layer id, or `"merged"` (default).
-fn source_layer(p: &Value) -> Option<LayerId> {
-    p.get("layer").and_then(Value::as_u64).map(LayerId)
+/// `"layer"` param of a source: a layer id, a layer name (the topmost of that name, as a loaded
+/// Photoshop action refers to it), or `"merged"` (default). An unknown name is an error.
+fn source_layer(doc: &Document, p: &Value, cmd: &str) -> Result<Option<LayerId>> {
+    match p.get("layer") {
+        Some(Value::Number(n)) => Ok(n.as_u64().map(LayerId)),
+        Some(Value::String(name)) if !name.is_empty() && name != "merged" => doc
+            .walk()
+            .into_iter()
+            .rev()
+            .find(|(_, _, l)| l.name == *name)
+            .map(|(_, _, l)| Some(l.id))
+            .ok_or_else(|| bad(cmd, format!("no source layer named \"{name}\""))),
+        _ => Ok(None),
+    }
 }
 
 /// Planes of channel `r` from document `doc` (`layer` = None: merged). A composite gives one
@@ -425,7 +437,7 @@ fn source(s: &Session, p: &Value, cmd: &str, gray: bool) -> Result<Vec<Vec<f32>>
         return Err(bad(cmd, format!("source document \"{}\" is {}×{}; it must match the target size", st.doc.name, st.doc.size.width, st.doc.size.height)));
     }
     let r = p.get("channel").map_or(Some(ChanRef::Composite), |v| parse_ref(v, &st.doc)).ok_or_else(|| bad(cmd, "unknown `channel`"))?;
-    let layer = source_layer(p);
+    let layer = source_layer(&st.doc, p, cmd)?;
     let mut planes = if gray { vec![gray_plane(&st.doc, layer, st.active_layer, r)?] } else { ref_planes(&st.doc, layer, st.active_layer, r)? };
     // Guard every caller (`.remove(0)` / `src[0]`) against an empty source.
     if planes.is_empty() {
@@ -608,7 +620,8 @@ pub(crate) fn mask_target_enabled(s: &Session, id: &str, p: &Value) -> Option<st
 /// (filters, adjustments, paint and fill commands); the shell adds its mask target to these.
 pub fn follows_target(id: &str) -> bool {
     // Moving the selected pixels (⌘-drag, Move tool) moves the targeted mask's, not the layer's.
-    routed(id) || id == "select.float"
+    // Moving a layer with its unlinked mask targeted moves the mask alone (`layer.translate`).
+    routed(id) || id == "select.float" || id == "layer.translate"
 }
 
 /// Commands whose target follows the Channels panel.
@@ -734,15 +747,16 @@ pub(crate) fn clear_color_channel(doc: &mut Document, id: LayerId, k: usize, bac
     if area.is_empty() {
         return Ok(());
     }
-    let cover = sel.map(|m| (m.read_region(area), m.format().channels().max(1)));
-    let mut px = surf.read_region(area);
+    let cover =
+        sel.as_ref().map(|m| crate::allocation::read_region(m, area, "clearing a channel selection").map(|v| (v, m.format().channels().max(1)))).transpose()?;
+    let mut px = crate::allocation::read_region(surf, area, "clearing a channel")?;
     for (i, p) in px.chunks_exact_mut(n).enumerate() {
         let w = cover.as_ref().map_or(1.0, |(m, mk)| m.get(i * mk).copied().unwrap_or(0.0));
         if let Some(c) = p.get_mut(k) {
             *c += (v - *c) * w.clamp(0.0, 1.0);
         }
     }
-    surf.write_region(area, &px);
+    surf.try_write_region(area, &px)?;
     surf.prune();
     Ok(())
 }
@@ -885,6 +899,20 @@ fn load_selection(s: &mut Session, p: &Value) -> Result<Value> {
     if p.get("channel").is_none() {
         return Err(bad(cmd, "missing `channel`"));
     }
+    // `"targeted"`: the Channels panel's target, as a Photoshop action's "load the target
+    // channel" step records it.
+    let mut targeted = p.clone();
+    if p.get("channel").and_then(Value::as_str) == Some("targeted") {
+        let st = s.active().ok_or(EngineError::NoDocument)?;
+        targeted["channel"] = match st.channel_view.target {
+            ChannelTarget::Composite => json!("composite"),
+            ChannelTarget::Color(k) => json!({ "color": k }),
+            ChannelTarget::Alpha(i) => json!(i),
+            ChannelTarget::LayerMask => json!("mask"),
+            ChannelTarget::VectorMask => json!("vectorMask"),
+        };
+    }
+    let p = &targeted;
     // Composite and colour channels load their luminosity / values, as ⌘-clicking them does.
     let plane = source(s, p, cmd, true)?.into_iter().next().ok_or_else(|| bad(cmd, "the channel has no pixels"))?;
     let doc = &s.active().ok_or(EngineError::NoDocument)?.doc;
@@ -1125,11 +1153,15 @@ fn delete_channel(s: &mut Session, p: &Value) -> Result<Value> {
             _ => return Err(bad(cmd, "missing `channel`")),
         },
     };
+    // `edit` validates the view against the shorter channel list before we can remap it.
+    // Keep the original indices and eyes so a surviving final channel is not discarded.
+    let view = s.active().ok_or(EngineError::NoDocument)?.channel_view.clone();
     s.edit("Delete Channel", |doc, _| {
         doc.channels.remove(i);
         Ok(())
     })?;
     if let Some(st) = s.active_mut() {
+        st.channel_view = view;
         let v = &mut st.channel_view;
         if i < v.alpha_visible.len() {
             v.alpha_visible.remove(i);
@@ -1210,7 +1242,12 @@ fn target(s: &mut Session, t: ChannelTarget) {
         let v = &mut st.channel_view;
         v.target = t;
         match t {
-            ChannelTarget::Composite | ChannelTarget::LayerMask | ChannelTarget::VectorMask => v.color_hidden.clear(),
+            // Like clicking RGB in Photoshop: the alpha overlays go away with their eyes.
+            ChannelTarget::Composite => {
+                v.color_hidden.clear();
+                v.alpha_visible.clear();
+            }
+            ChannelTarget::LayerMask | ChannelTarget::VectorMask => v.color_hidden.clear(),
             ChannelTarget::Color(k) => {
                 v.color_hidden = (0..colors).map(|c| c != k).collect();
                 v.alpha_visible.clear();
@@ -1701,7 +1738,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Load Selection…",
             ["Select"],
             None,
-            r##"{"channel":index|name|"composite"|"red|green|blue|…"|"transparency"|"mask"|"vectorMask"|"quickMask"|"selection","layer":id?,"document":index?,"invert":bool=false,"operation":"new|add|subtract|intersect"="new"}"##,
+            r##"{"channel":index|name|"composite"|"red|green|blue|…"|"transparency"|"mask"|"vectorMask"|"quickMask"|"selection"|"targeted" (the Channels panel's target),"layer":id?,"document":index?,"invert":bool=false,"operation":"new|add|subtract|intersect"="new"}"##,
             has_doc,
             load_selection
         ),
@@ -1711,7 +1748,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Apply Image…",
             ["Image"],
             None,
-            r##"{"source":{"document":index?,"layer":id|"merged"="merged","channel":"composite"|"red|…"|index|"selection"|"transparency"|"mask"="composite","invert":bool=false},"blending":"normal|multiply|screen|overlay|softLight|hardLight|colorDodge|colorBurn|darken|lighten|difference|exclusion|linearBurn|linearDodge|add|subtract|…"="multiply","opacity":0..100=100,"scale":1..2=1,"offset":-255..255=0,"preserveTransparency":bool=false,"mask":{"document","layer","channel","invert"}?,"sourceChannel|sourceDocument|sourceLayer|sourceInvert|maskChannel|…":flat form of source/mask?}"##,
+            r##"{"source":{"document":index?,"layer":id|name|"merged"="merged","channel":"composite"|"red|…"|index|"selection"|"transparency"|"mask"="composite","invert":bool=false},"blending":"normal|multiply|screen|overlay|softLight|hardLight|colorDodge|colorBurn|darken|lighten|difference|exclusion|linearBurn|linearDodge|add|subtract|…"="multiply","opacity":0..100=100,"scale":1..2=1,"offset":-255..255=0,"preserveTransparency":bool=false,"mask":{"document","layer","channel","invert"}?,"sourceChannel|sourceDocument|sourceLayer|sourceInvert|maskChannel|…":flat form of source/mask?}"##,
             has_apply_target,
             apply_image
         ),
@@ -1803,6 +1840,16 @@ pub fn specs() -> Vec<CommandSpec> {
             journal: false,
         },
         spec!("channel.target.composite", "Target Composite Channel", [], Some("Cmd+2"), "{}", has_doc, |s, _| target_slot(s, 2)),
+        // ⌘\ targets the active layer's mask, as clicking its thumbnail does.
+        spec!("channel.target.layerMask", "Target Layer Mask", [], Some("Cmd+\\"), "{}", has_layer_mask, |s, _| target_cmd(
+            s,
+            &serde_json::json!({"channel": "mask"})
+        )),
+        // ⌘⌥2 loads the image's luminosity as a selection (⌘-click on the composite channel).
+        spec!("select.loadLuminosity", "Load Luminosity", [], Some("Cmd+Alt+2"), "{}", has_doc, |s, _| load_selection(
+            s,
+            &serde_json::json!({"channel": "composite"})
+        )),
         spec!("channel.target.slot3", "Target Channel 3", [], Some("Cmd+3"), "{}", slot_ok::<3>, |s, _| target_slot(s, 3)),
         spec!("channel.target.slot4", "Target Channel 4", [], Some("Cmd+4"), "{}", slot_ok::<4>, |s, _| target_slot(s, 4)),
         spec!("channel.target.slot5", "Target Channel 5", [], Some("Cmd+5"), "{}", slot_ok::<5>, |s, _| target_slot(s, 5)),
@@ -1813,6 +1860,13 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
+/// Target Layer Mask: the active layer has a mask.
+fn has_layer_mask(s: &Session) -> std::result::Result<(), String> {
+    let st = s.active().ok_or("no document open")?;
+    let layer = st.active_layer.and_then(|id| st.doc.layer(id)).ok_or("no active layer")?;
+    layer.mask.as_ref().map(|_| ()).ok_or_else(|| "the active layer has no layer mask".to_string())
+}
+
 fn slot_ok<const N: usize>(s: &Session) -> std::result::Result<(), String> {
     let d = s.active().ok_or("no document open")?;
     let colors = color_count(&d.doc);
diff --git a/crates/engine/src/channel_cmds/tests.rs b/crates/engine/src/channel_cmds/tests.rs
index 1223c0589b..1d721ee5c5 100644
--- a/crates/engine/src/channel_cmds/tests.rs
+++ b/crates/engine/src/channel_cmds/tests.rs
@@ -168,6 +168,70 @@ fn channel_management_and_view_state() {
     assert_eq!(doc(&s).channels.len(), 3);
 }
 
+#[test]
+fn deleting_an_earlier_channel_keeps_the_last_channel_targeted() {
+    for depth in [8, 16, 32] {
+        let mut s = session_depth(depth);
+        s.execute("channel.new", json!({"name": "Remove", "fill": "black"})).unwrap();
+        s.execute("channel.new", json!({"name": "Keep", "fill": "white"})).unwrap();
+        let layer_before = px(&s, 5, 5);
+        s.execute("channel.delete", json!({"channel": "Remove"})).unwrap();
+        assert_eq!(doc(&s).channels[0].name, "Keep");
+        let view = &s.active().unwrap().channel_view;
+        assert_eq!(view.target, ChannelTarget::Alpha(0), "the surviving target follows its new index");
+        assert!(view.alpha_shown(0));
+        assert_eq!(view.visible_colors(3), 0, "keep the channel-only view");
+
+        s.execute("image.adjustments.invert", json!({})).unwrap();
+        assert_eq!(chan(&s, 0, 5, 5), 0.0, "implicit pixel edits still target Keep");
+        assert_eq!(px(&s, 5, 5), layer_before, "the layer must not be edited instead");
+        assert!(s.undo());
+        assert_eq!(chan(&s, 0, 5, 5), 1.0);
+        assert_eq!(px(&s, 5, 5), layer_before);
+        assert!(s.redo());
+        assert_eq!(chan(&s, 0, 5, 5), 0.0);
+        assert_eq!(px(&s, 5, 5), layer_before);
+    }
+}
+
+#[test]
+fn deleting_a_channel_remaps_all_surviving_eyes_and_targets() {
+    for target_index in 0..3 {
+        let mut s = session();
+        for name in ["First", "Middle", "Last"] {
+            s.execute("channel.new", json!({"name": name})).unwrap();
+        }
+        s.execute("channel.target", json!({"channel": target_index})).unwrap();
+        for (channel, visible) in [false, false, true].into_iter().enumerate() {
+            s.execute("channel.setVisible", json!({"channel": channel, "visible": visible})).unwrap();
+        }
+        s.execute("channel.delete", json!({"channel": "Middle"})).unwrap();
+        let view = &s.active().unwrap().channel_view;
+        let expected = match target_index {
+            0 => ChannelTarget::Alpha(0),
+            1 => ChannelTarget::Composite,
+            _ => ChannelTarget::Alpha(1),
+        };
+        assert_eq!(view.target, expected, "old target {target_index}");
+        assert!(!view.alpha_shown(0));
+        assert!(view.alpha_shown(1), "Last keeps its eye when Middle is removed");
+    }
+}
+
+#[test]
+fn targeting_the_composite_hides_the_alpha_overlay() {
+    for (cmd, params) in [("channel.target", json!({"channel": "composite"})), ("channel.target.composite", json!({}))] {
+        let mut s = session();
+        s.execute("channel.new", json!({})).unwrap();
+        assert!(s.active().unwrap().channel_view.alpha_shown(0));
+        s.execute(cmd, params).unwrap();
+        let st = s.active().unwrap();
+        assert_eq!(st.channel_view.visible_colors(3), 3, "{cmd}");
+        assert!(!st.channel_view.alpha_shown(0), "{cmd}: the alpha eye turns off");
+        assert!(st.channel_view.is_plain(&st.doc), "{cmd}: no overlay left on the image (#4538)");
+    }
+}
+
 #[test]
 fn every_colour_channel_can_hide_while_alpha_stays() {
     let mut s = session();
@@ -483,6 +547,18 @@ fn apply_image_hand_computed() {
     assert!(s.execute("image.applyImage", json!({"blending": "hue"})).is_err());
 }
 
+#[test]
+fn apply_image_subtract_layer_from_itself_is_mid_grey() {
+    // Frequency separation: Subtract, Scale 2, Offset 128, in the flat form the dialog sends.
+    let mut s = session();
+    s.execute("edit.fill", json!({"color": "#c08040"})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "High"})).unwrap();
+    s.execute("edit.fill", json!({"color": "#406080"})).unwrap();
+    s.execute("image.applyImage", json!({"sourceLayer": "High", "blending": "subtract", "scale": 2.0, "offset": 128})).unwrap();
+    let p = px(&s, 3, 3);
+    assert!(p[..3].iter().all(|v| (v - 128.0 / 255.0).abs() < 0.003), "{p:?}");
+}
+
 #[test]
 fn apply_image_onto_transparent_layer() {
     for depth in [8, 16, 32] {
@@ -741,6 +817,33 @@ fn clear_with_an_alpha_channel_or_quick_mask_targeted_fills_it_not_the_layer() {
     assert_eq!(px(&s, 5, 5), layer, "the layer is untouched in Quick Mask mode");
 }
 
+#[test]
+fn command_backslash_targets_the_layer_mask_and_command_2_the_composite() {
+    let mut s = session();
+    s.execute("layer.new.layer", json!({})).unwrap();
+    assert!(!s.is_enabled("channel.target.layerMask"), "no mask yet");
+    assert!(s.execute("channel.target.layerMask", json!({})).is_err());
+    s.execute("layer.layerMask.revealAll", json!({})).unwrap();
+    s.execute("channel.target.composite", json!({})).unwrap();
+    assert_eq!(crate::commands::find("channel.target.layerMask").and_then(|c| c.shortcut), Some("Cmd+\\"));
+    s.execute("channel.target.layerMask", json!({})).unwrap();
+    assert_eq!(s.active().unwrap().channel_view.target, ChannelTarget::LayerMask);
+    s.execute("channel.target.composite", json!({})).unwrap();
+    assert_eq!(s.active().unwrap().channel_view.target, ChannelTarget::Composite);
+}
+
+#[test]
+fn command_alt_2_loads_the_images_luminosity() {
+    let mut s = session();
+    rect(&mut s, 0, 0, 20, 20, "replace");
+    s.execute("edit.fill", json!({"contents": "black"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    assert_eq!(crate::commands::find("select.loadLuminosity").and_then(|c| c.shortcut), Some("Cmd+Alt+2"));
+    s.execute("select.loadLuminosity", json!({})).unwrap();
+    assert!(sel_at(&s, 5, 5) < 0.01, "black: unselected");
+    assert!(sel_at(&s, 30, 5) > 0.99, "white: selected");
+}
+
 #[test]
 fn thumbnail_selection_shape_without_pixel_cache_uses_its_transparency() {
     for depth in [8, 16, 32] {
diff --git a/crates/engine/src/color_cmds.rs b/crates/engine/src/color_cmds.rs
index f6d4b1b18c..d3a6d36931 100644
--- a/crates/engine/src/color_cmds.rs
+++ b/crates/engine/src/color_cmds.rs
@@ -133,7 +133,8 @@ impl Default for ColorSettings {
         Self {
             working_rgb: Builtin::Srgb.id().into(),
             working_cmyk: Builtin::CoatedCmyk.id().into(),
-            working_gray: Builtin::SGray.id().into(),
+            // Photoshop's default working gray is Dot Gain 20 %.
+            working_gray: Builtin::DotGain20Compat.id().into(),
             policy_rgb: Policy::Preserve,
             policy_cmyk: Policy::Preserve,
             policy_gray: Policy::Preserve,
@@ -172,13 +173,18 @@ impl ColorSettings {
     }
 }
 
-/// Check that each working space resolves to a profile of the right colour space.
+/// Check that each working space resolves to the right colour space and RGB can be both a
+/// source and editing destination for the configured rendering intent.
 pub fn validate_settings(c: &ColorSettings) -> std::result::Result<(), String> {
     for (space, spec) in [(ColorSpace::Rgb, &c.working_rgb), (ColorSpace::Cmyk, &c.working_cmyk), (ColorSpace::Gray, &c.working_gray)] {
         let p = resolve_profile(spec, None, space_mode(space)).map_err(|e| e.to_string())?;
         if p.color_space != space {
             return Err(format!("working space `{spec}` is {:?}, not {space:?}", p.color_space));
         }
+        if space == ColorSpace::Rgb {
+            p.pcs_to_device(c.intent()).map_err(|e| format!("working RGB space `{spec}` cannot be a destination for {}: {e}", c.intent().id()))?;
+            p.device_to_pcs(c.intent()).map_err(|e| format!("working RGB space `{spec}` cannot be a source for {}: {e}", c.intent().id()))?;
+        }
     }
     let m = c.monitor_profile.as_str();
     if !(m.is_empty() || m == "auto") {
@@ -215,13 +221,16 @@ pub struct ColorState {
 
 impl ColorState {
     /// The working profile of a mode from Color Settings (the built-in default when the
-    /// setting does not resolve).
+    /// setting does not resolve or cannot be both an RGB source and editing destination).
     pub fn working(&self, mode: ColorMode) -> Arc<Profile> {
         let space = mode_space(mode);
         self.settings
             .working_spec(space)
             .and_then(|spec| resolve_profile(spec, None, Some(mode)).ok())
-            .filter(|p| p.color_space == space)
+            .filter(|p| {
+                p.color_space == space
+                    && (space != ColorSpace::Rgb || (p.pcs_to_device(self.settings.intent()).is_ok() && p.device_to_pcs(self.settings.intent()).is_ok()))
+            })
             .unwrap_or_else(|| working_profile(mode))
     }
 
@@ -276,18 +285,22 @@ impl ColorState {
                 if !mismatch || linear_hdr {
                     return merge(base, json!({"action": "kept"}));
                 }
+                // An input-only profile can't be the document's space: nothing could be
+                // composited into it (#3876). Preserve converts it to the working space instead.
+                let input_only = !emb.can_be_destination();
                 let action = match policy {
-                    Policy::Preserve => "kept",
+                    Policy::Preserve if !input_only => "kept",
                     Policy::Off => {
                         doc.icc_profile = None;
                         "discarded"
                     }
-                    Policy::Convert => match convert_document(doc, &working, self.settings.intent(), self.settings.bpc) {
+                    Policy::Preserve | Policy::Convert => match convert_document(doc, &working, self.settings.intent(), self.settings.bpc) {
                         Ok(()) => "converted",
                         Err(_) => "kept",
                     },
                 };
-                merge(base, json!({"action": action, "ask": self.settings.ask_on_mismatch}))
+                let report = merge(base, json!({"action": action, "ask": self.settings.ask_on_mismatch}));
+                if input_only { merge(report, json!({"inputOnly": true})) } else { report }
             }
             None => {
                 // Untagged files are assumed to be in the working space; tag them when it is not
@@ -302,6 +315,60 @@ impl ColorState {
         }
     }
 
+    /// Whether opening `doc` asks about its profile first (Ask When Opening, for a mismatched or
+    /// missing profile), and if so what the prompt shows: the report [`Self::open_policy`]
+    /// would give, with `ask: true` and `action` the answer the policy suggests. Nothing is
+    /// changed: the answer is applied with [`Self::resolve_open`] before the document opens.
+    pub fn open_question(&self, doc: &Document) -> Option<Value> {
+        let space = mode_space(doc.mode);
+        if !matches!(space, ColorSpace::Rgb | ColorSpace::Cmyk | ColorSpace::Gray) {
+            return None;
+        }
+        let working = self.working(doc.mode);
+        let policy = self.settings.policy(doc.mode);
+        let embedded = doc.icc_profile.as_ref().and_then(|b| profile_from_bytes(b).ok()).filter(|p| p.color_space == space);
+        match embedded {
+            Some(emb) => {
+                let linear_hdr =
+                    doc.depth == SampleType::F32 && (emb.same_colors(Builtin::LinearSrgb.profile()) || emb.same_colors(photocraft_cms::builtin::linear_gray()));
+                if !self.settings.ask_on_mismatch || emb.same_colors(&working) || linear_hdr {
+                    return None;
+                }
+                let action = match policy {
+                    Policy::Preserve => "preserve",
+                    Policy::Off => "discard",
+                    Policy::Convert => "convert",
+                };
+                Some(
+                    json!({"embedded": emb.description, "working": working.description, "mismatch": true, "policy": policy.id(), "action": action, "ask": true}),
+                )
+            }
+            None if self.settings.ask_on_missing => {
+                Some(json!({"working": working.description, "policy": policy.id(), "missing": true, "action": "preserve", "ask": true}))
+            }
+            None => None,
+        }
+    }
+
+    /// Applies the answer to an [`Self::open_question`] to a document not opened yet:
+    /// `preserve` (keep the embedded profile, or leave an untagged file as is), `convert` to the
+    /// working space, `discard` the embedded profile, or `assignWorking` (untagged files).
+    pub fn resolve_open(&self, doc: &mut Document, action: &str) -> Result<()> {
+        match action {
+            "preserve" | "useEmbedded" => Ok(()),
+            "convert" | "convertToWorking" => convert_document(doc, &self.working(doc.mode), self.settings.intent(), self.settings.bpc),
+            "discard" | "off" => {
+                doc.icc_profile = None;
+                Ok(())
+            }
+            "assignWorking" => {
+                doc.icc_profile = Some(self.working(doc.mode).to_bytes());
+                Ok(())
+            }
+            other => Err(EngineError::Other(format!("unknown answer `{other}` (preserve|convert|discard|assignWorking)"))),
+        }
+    }
+
     /// Proofing state of a document (defaults: coated CMYK, relative colorimetric + BPC, off).
     pub fn proof(&self, doc: DocId) -> ProofView {
         self.proofs.get(&doc).cloned().unwrap_or_else(|| ProofView { gamut_threshold: photocraft_cms::gamut::DEFAULT_THRESHOLD, ..Default::default() })
@@ -558,20 +625,41 @@ pub fn convert_surface(s: &Surface, from: ColorMode, to: PixelFormat, t: &Transf
     let mut dpo = vec![0.0f32; ds];
     t.convert_f32(&dp, ss, &mut dpo, ds, true);
     let mut out = Surface::with_default(to, &dpo);
-    // Convert all tiles in one parallel pass into a staging buffer, then store them.
-    let tiles: Vec<_> = s.tiles().map(|(c, t)| (*c, t.clone())).collect();
+    // Convert every distinct tile once, in one parallel pass into a staging buffer, then store
+    // them. Coordinates that share a tile (a filled background) share the converted one (#4531).
+    let mut distinct: Vec<std::sync::Arc<photocraft_raster::Tile>> = Vec::new();
+    let mut slot: std::collections::HashMap<*const photocraft_raster::Tile, usize> = std::collections::HashMap::new();
+    let tiles: Vec<(photocraft_geom::TileCoord, usize)> = s
+        .tiles()
+        .map(|(c, tile)| {
+            let i = *slot.entry(std::sync::Arc::as_ptr(tile)).or_insert_with(|| {
+                distinct.push(tile.clone());
+                distinct.len() - 1
+            });
+            (*c, i)
+        })
+        .collect();
     let tile_px = (photocraft_geom::TILE_SIZE * photocraft_geom::TILE_SIZE) as usize;
     let dst_len = tile_px * to.bytes_per_pixel();
-    let mut staging = vec![0u8; dst_len * tiles.len()];
-    let jobs: Vec<(&[u8], &mut [u8])> = tiles.iter().map(|(_, t)| t.bytes()).zip(staging.chunks_mut(dst_len.max(1))).collect();
+    let mut staging = vec![0u8; dst_len * distinct.len()];
+    let jobs: Vec<(&[u8], &mut [u8])> = distinct.iter().map(|t| t.bytes()).zip(staging.chunks_mut(dst_len.max(1))).collect();
     let kind = match sf.sample {
         SampleType::U8 => SampleKind::U8,
         SampleType::U16 => SampleKind::U16,
         SampleType::F32 => SampleKind::F32,
     };
     t.convert_bytes_many(kind, jobs, ss, ds, true);
-    for ((c, _), bytes) in tiles.iter().zip(staging.chunks(dst_len.max(1))) {
-        out.tile_mut(*c).bytes_mut().copy_from_slice(bytes);
+    let mut converted: Vec<Option<std::sync::Arc<photocraft_raster::Tile>>> = vec![None; distinct.len()];
+    for (c, i) in tiles {
+        if let Some(Some(tile)) = converted.get(i) {
+            out.put_tiles([(c, tile.clone())]);
+            continue;
+        }
+        let Some(bytes) = staging.chunks(dst_len.max(1)).nth(i) else { continue };
+        out.tile_mut(c).bytes_mut().copy_from_slice(bytes);
+        if let Some(slot) = converted.get_mut(i) {
+            *slot = out.tile(c).cloned();
+        }
     }
     out
 }
@@ -1050,7 +1138,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "edit.assignProfile",
             "Assign Profile…",
             ["Edit"],
-            r##"{"profile":"working|srgb|display-p3|adobe-rgb-compat|prophoto-compat|linear-srgb|rec2020|gray-gamma-2.2|sgray|lab-d50|coated-cmyk|none" (or a path to an .icc file)}"##,
+            r##"{"profile":"working|srgb|display-p3|adobe-rgb-compat|prophoto-compat|linear-srgb|rec2020|gray-gamma-2.2|sgray|dot-gain-20-compat|lab-d50|coated-cmyk|none" (or a path to an .icc file)}"##,
             has_doc,
             assign_profile,
             true
@@ -1068,7 +1156,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "edit.colorSettings",
             "Color Settings…",
             ["Edit"],
-            r##"{"workingRgb":"srgb|display-p3|adobe-rgb-compat|prophoto-compat|linear-srgb|rec2020","workingCmyk":"coated-cmyk","workingGray":"sgray|gray-gamma-2.2","policyRgb":"preserve|convert|off","policyCmyk":"preserve|convert|off","policyGray":"preserve|convert|off","askOnMismatch":bool=true,"askOnPaste":bool=true,"askOnMissing":bool=false,"intent":"relative|perceptual|saturation|absolute","blendTextGamma":1.0..2.2|bool=1.45,"bpc":bool=true,"dither":bool=true,"monitorProfile":"auto|srgb|display-p3|adobe-rgb-compat|prophoto-compat|rec2020","reset":bool=false} (working spaces and the monitor profile also accept .icc paths; monitor `auto` = the main display's profile when the platform provides it, else sRGB; the reply's `monitorStatus` says which profile is in use and why: source auto|manual|fallback, reason)"##,
+            r##"{"workingRgb":"srgb|display-p3|adobe-rgb-compat|prophoto-compat|linear-srgb|rec2020","workingCmyk":"coated-cmyk","workingGray":"dot-gain-20-compat|sgray|gray-gamma-2.2","policyRgb":"preserve|convert|off","policyCmyk":"preserve|convert|off","policyGray":"preserve|convert|off","askOnMismatch":bool=true,"askOnPaste":bool=true,"askOnMissing":bool=false,"intent":"relative|perceptual|saturation|absolute","blendTextGamma":1.0..2.2|bool=1.45,"bpc":bool=true,"dither":bool=true,"monitorProfile":"auto|srgb|display-p3|adobe-rgb-compat|prophoto-compat|rec2020","reset":bool=false} (working spaces and the monitor profile also accept .icc paths; monitor `auto` = the main display's profile when the platform provides it, else sRGB; the reply's `monitorStatus` says which profile is in use and why: source auto|manual|fallback, reason)"##,
             always,
             color_settings,
             true,
@@ -1112,6 +1200,29 @@ mod tests {
     use super::*;
     use photocraft_geom::Rect;
 
+    /// Image › Mode to CMYK keeps a filled background's shared tile shared (#4531): one
+    /// converted tile for the whole grid, the same colour everywhere.
+    #[test]
+    fn mode_conversion_keeps_shared_tiles_shared() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 2048, "height": 1024, "background": "white"})).unwrap();
+        let distinct = |s: &Session| {
+            let doc = &s.active().unwrap().doc;
+            let surf = doc.layers[0].surface().unwrap();
+            let mut seen: Vec<_> = surf.tiles().map(|(_, t)| std::sync::Arc::as_ptr(t)).collect();
+            seen.sort();
+            seen.dedup();
+            (seen.len(), surf.tile_count())
+        };
+        let (before, count) = distinct(&s);
+        s.execute("image.mode.cmyk", json!({})).unwrap();
+        let (after, count_after) = distinct(&s);
+        assert_eq!((after, count_after), (before, count), "{before} distinct of {count} before");
+        let doc = &s.active().unwrap().doc;
+        let surf = doc.layers[0].surface().unwrap();
+        assert_eq!(surf.pixel(5, 5), surf.pixel(2000, 1000), "the same converted white everywhere");
+    }
+
     fn session(mode: &str, depth: u32) -> Session {
         let mut s = Session::new();
         s.execute("file.new", json!({"width": 64, "height": 32, "mode": mode, "depth": depth})).unwrap();
@@ -1268,7 +1379,10 @@ mod tests {
         let t = s.color.display_transform(doc(&s)).unwrap();
         let mut o = [0.0f32; 3];
         t.eval(&[0.5, 0.5, 0.5], &mut o);
-        assert!(o.iter().all(|v| (v - 0.5).abs() < 2e-3), "sGray displays as sRGB gray: {o:?}");
+        // The default working gray (Dot Gain 20 %-compatible, gamma 1.732) shows gray 0.5 as the
+        // sRGB value of linear 0.5^1.732, as Photoshop does: lighter than sGray's 0.5.
+        let want = photocraft_color::convert::linear_to_srgb(0.5f32.powf(1.732));
+        assert!(o.iter().all(|v| (v - want).abs() < 2e-3), "Dot Gain 20 % gray displays as {want}: {o:?}");
         let s = session("cmyk", 8);
         assert_eq!(composite_profile(doc(&s)).description, "sRGB IEC61966-2.1");
     }
@@ -1338,6 +1452,35 @@ mod settings_tests {
     // The Blend Text Colors Using Gamma test is `tests/text_gamma.rs`: it changes the
     // process-wide text gamma, which would race every unit test here that composites type.
 
+    #[test]
+    fn open_question_asks_only_when_set_and_resolve_open_applies_each_answer() {
+        let mut s = Session::new();
+        // Ask When Opening off: nothing to ask, mismatched or missing.
+        s.execute("edit.colorSettings", json!({"askOnMismatch": false, "askOnMissing": false})).unwrap();
+        assert!(s.color.open_question(&tagged("adobe-rgb-compat")).is_none());
+        let mut untagged = tagged("srgb");
+        untagged.icc_profile = None;
+        assert!(s.color.open_question(&untagged).is_none());
+        // On: a mismatch asks, suggesting the policy's answer; a matching profile never asks.
+        s.execute("edit.colorSettings", json!({"askOnMismatch": true, "askOnMissing": true, "policyRgb": "convert"})).unwrap();
+        let q = s.color.open_question(&tagged("adobe-rgb-compat")).unwrap();
+        assert_eq!((q["mismatch"].as_bool(), q["action"].as_str()), (Some(true), Some("convert")));
+        assert!(q["embedded"].as_str().unwrap().starts_with("Adobe RGB"));
+        assert!(s.color.open_question(&tagged("srgb")).is_none());
+        assert_eq!(s.color.open_question(&untagged).unwrap()["missing"], true);
+        // Asking changes nothing; the answer is applied to the document.
+        let mut d = tagged("adobe-rgb-compat");
+        s.color.resolve_open(&mut d, "preserve").unwrap();
+        assert!(desc(&d).unwrap().starts_with("Adobe RGB"));
+        s.color.resolve_open(&mut d, "convert").unwrap();
+        assert_eq!(desc(&d).as_deref(), Some("sRGB IEC61966-2.1"));
+        s.color.resolve_open(&mut d, "discard").unwrap();
+        assert_eq!(desc(&d), None);
+        s.color.resolve_open(&mut d, "assignWorking").unwrap();
+        assert_eq!(desc(&d).as_deref(), Some("sRGB IEC61966-2.1"));
+        assert!(s.color.resolve_open(&mut d, "explode").is_err());
+    }
+
     #[test]
     fn open_policies() {
         let mut s = Session::new();
@@ -1397,6 +1540,58 @@ mod settings_tests {
         assert_eq!(desc(&s.active().unwrap().doc).as_deref(), Some("Display P3"));
     }
 
+    /// Display P3 as an input profile with only an AToB table, like Apple's Wide Color Sharing
+    /// Profile embedded in iPhone photos.
+    fn input_only_p3() -> Profile {
+        let p3 = Builtin::DisplayP3.profile();
+        let t = Transform::new(p3, Builtin::LabD50.profile(), Intent::RelativeColorimetric, false).unwrap();
+        let clut = photocraft_cms::Clut::sample(vec![9; 3], 3, |inp, out| t.eval(inp, out));
+        let ident = || photocraft_cms::pipeline::Stage::Curves(vec![photocraft_cms::Curve::Identity; 3]);
+        let lut = photocraft_cms::profile::Lut {
+            kind: photocraft_cms::profile::LutKind::Ab,
+            inputs: 3,
+            outputs: 3,
+            stages: vec![ident(), photocraft_cms::pipeline::Stage::Clut(clut), ident()],
+        };
+        let mut p = p3.clone();
+        p.class = photocraft_cms::ProfileClass::Input;
+        p.pcs = photocraft_cms::Pcs::Lab;
+        p.description = "Input-only P3".into();
+        (p.matrix, p.trc) = (None, None);
+        p.a2b = [Some(lut), None, None];
+        p.b2a = [None, None, None];
+        p.with_encoded_bytes()
+    }
+
+    #[test]
+    fn input_only_profiles_are_converted_on_open() {
+        // #3876: an iPhone photo's input-only profile was kept as the document's space, so
+        // compositing anything into it failed with "RGB profile without matrix/TRC or BToA tags".
+        let input = input_only_p3();
+        assert!(Builtin::DisplayP3.profile().can_be_destination());
+        assert!(!input.can_be_destination());
+        let mut s = Session::new();
+        let mut d = tagged("srgb");
+        d.icc_profile = Some(input.to_bytes());
+        let (photo, r) = s.open_document(d, None);
+        assert_eq!((r["action"].as_str(), r["inputOnly"].as_bool(), r["ask"].as_bool()), (Some("converted"), Some(true), Some(true)));
+        let doc = &s.active().unwrap().doc;
+        assert!(desc(doc).unwrap().starts_with("sRGB"));
+        // Converted from P3, not reinterpreted as sRGB.
+        assert!((doc.layers[0].surface().unwrap().pixel(1, 1)[0] - 0.2).abs() > 0.01);
+        let (other, _) = s.open_document(tagged("srgb"), None);
+        s.execute("layer.copyToDocument", json!({"document": photo, "source": other})).unwrap();
+        // Off still discards the profile, and profiles that can be a destination are still kept.
+        s.execute("edit.colorSettings", json!({"policyRgb": "off"})).unwrap();
+        let mut d = tagged("srgb");
+        d.icc_profile = Some(input.to_bytes());
+        let (_, r) = s.open_document(d, None);
+        assert_eq!((r["action"].as_str(), r["inputOnly"].as_bool()), (Some("discarded"), Some(true)));
+        s.execute("edit.colorSettings", json!({"policyRgb": "preserve"})).unwrap();
+        let (_, r) = s.open_document(tagged("display-p3"), None);
+        assert_eq!((r["action"].as_str(), r.get("inputOnly")), (Some("kept"), None));
+    }
+
     /// A little-endian EXIF block whose Exif IFD holds ColorSpace = `space`.
     fn exif_color_space(space: u16) -> Vec<u8> {
         let mut b = b"Exif\0\0II\x2a\0\x08\0\0\0".to_vec();
diff --git a/crates/engine/src/color_to_alpha_cmds.rs b/crates/engine/src/color_to_alpha_cmds.rs
index c3120f4ad8..a6208e8246 100644
--- a/crates/engine/src/color_to_alpha_cmds.rs
+++ b/crates/engine/src/color_to_alpha_cmds.rs
@@ -92,7 +92,7 @@ fn enabled(s: &Session) -> std::result::Result<(), String> {
     if locks.pixels || locks.all {
         return Err(format!("the layer \"{}\" is locked", l.name));
     }
-    if locks.transparency && !crate::extra_cmds::is_background(l) {
+    if locks.transparency && !d.doc.is_background(l.id) {
         return Err(format!("the transparency of layer \"{}\" is locked", l.name));
     }
     Ok(())
@@ -217,7 +217,7 @@ mod tests {
         s.execute("edit.undo", json!({})).unwrap();
         assert_eq!(name(&s), "Background");
         let d = s.active().unwrap();
-        assert!(crate::extra_cmds::is_background(d.doc.layer(d.active_layer.unwrap()).unwrap()));
+        assert!(d.doc.is_background(d.active_layer.unwrap()));
     }
 
     #[test]
diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs
index f12e017c40..a32c5feb8d 100644
--- a/crates/engine/src/commands.rs
+++ b/crates/engine/src/commands.rs
@@ -136,6 +136,19 @@ pub fn command_specs() -> &'static [CommandSpec] {
     &registry().specs
 }
 
+/// One `command.list` / `engine.commands` row for `c`, given why it can't run now (`None` = it can).
+/// `disabledReason` is that message; `needsDocument` is true when the reason is that no document is
+/// open (#3664), so an agent can tell "open or create a document first" from a precondition that a
+/// document alone won't meet (a selection, an empty clipboard).
+pub fn list_entry(s: &Session, c: &CommandSpec, reason: Option<String>) -> Value {
+    let needs_document =
+        s.active().is_none() && reason.as_deref().is_some_and(|r| ["no document", "no active document", "no open document"].iter().any(|p| r.starts_with(p)));
+    json!({
+        "id": c.id, "label": c.label, "menu": c.menu, "shortcut": c.shortcut, "params": c.params,
+        "enabled": reason.is_none(), "disabledReason": reason, "needsDocument": needs_document,
+    })
+}
+
 pub fn find(id: &str) -> Option<&'static CommandSpec> {
     let registry = registry();
     registry.by_id.get(id).and_then(|&index| registry.specs.get(index))
@@ -241,9 +254,33 @@ fn set_clipped(s: &mut Session, p: &Value, clip: bool) -> Result<Value> {
     Ok(json!({"layers": ids.iter().map(|id| id.0).collect::<Vec<_>>()}))
 }
 
+/// The layer a command's `"layer"` param names: an id, or a name (the topmost layer of that
+/// name, as Photoshop's "select layer by name" action step finds it, so a loaded action replays
+/// in another document). `None` when the param is absent.
+pub(crate) fn explicit_layer(s: &Session, p: &Value) -> Result<Option<LayerId>> {
+    match p.get("layer") {
+        Some(Value::Number(n)) => {
+            n.as_u64().map(|id| Some(LayerId(id))).ok_or_else(|| EngineError::Other(format!("layer id {n} is not a non-negative integer")))
+        }
+        Some(Value::String(name)) => {
+            let d = s.active().ok_or(EngineError::NoDocument)?;
+            d.doc
+                .walk()
+                .into_iter()
+                .rev()
+                .find(|(_, _, l)| l.name == *name)
+                .map(|(_, _, l)| Some(l.id))
+                .ok_or_else(|| EngineError::Other(format!("no layer named \"{name}\"")))
+        }
+        Some(Value::Null) | None => Ok(None),
+        Some(other) => Err(EngineError::Other(format!("`layer` must be an id or a name, not {other}"))),
+    }
+}
+
+/// The layer a command targets: [`explicit_layer`], else the active layer.
 pub(crate) fn layer_param(s: &Session, p: &Value) -> Result<LayerId> {
-    match p.get("layer").and_then(Value::as_u64) {
-        Some(id) => Ok(LayerId(id)),
+    match explicit_layer(s, p)? {
+        Some(id) => Ok(id),
         None => s.active().and_then(|d| d.active_layer).ok_or(EngineError::Other("no active layer".into())),
     }
 }
@@ -536,7 +573,7 @@ fn build() -> Vec<CommandSpec> {
             "Layer…",
             ["Layer", "New"],
             Some("Cmd+Shift+N"),
-            r##"{"name":str?,"clipToPrevious":bool=false (Use Previous Layer to Create Clipping Mask; inside a clip group the layer joins it anyway),"color":"none|red|orange|yellow|green|seafoam|blue|indigo|magenta|fuchsia|violet|gray"="none","mode":"Normal|Multiply|…"="Normal","opacity":0..1=1,"fillNeutral":bool=false (fill with the mode's neutral color: modes without one are an error)}"##,
+            r##"{"name":str?,"clipToPrevious":bool=false (Use Previous Layer to Create Clipping Mask; inside a clip group the layer joins it anyway),"color":"none|red|orange|yellow|green|seafoam|blue|indigo|magenta|fuchsia|violet|gray"="none","mode":"Normal|Multiply|…"="Normal","opacity":0..1=1,"fillNeutral":bool=false (fill with the mode's neutral color: modes without one are an error),"position":"above|below"="above" (below: the Layers panel's Cmd/Ctrl-click; never under the Background)}"##,
             has_doc,
             crate::new_layer::run
         ),
@@ -564,9 +601,25 @@ fn build() -> Vec<CommandSpec> {
             "Duplicate Layer…",
             ["Layer"],
             None,
-            r##"{"layer":id?,"inPlace":bool=false (artboards: keep the copy on the original instead of beside it),"name":str? (one layer: the copy's name)} (no layer: every selected layer)"##,
+            r##"{"layer":id?,"inPlace":bool=false (artboards: keep the copy on the original instead of beside it),"name":str? (one layer: the copy's name),"document":index|"new"=same document (Photoshop's Destination: "new" makes a new document the size of this canvas holding just the copies),"documentName":str? (the new document's name)} (no layer: every selected layer)"##,
             has_layer,
             |s, p| {
+                if let Some(d) = p.get("document") {
+                    if d.as_str() == Some("new") {
+                        return crate::layer_copy_cmds::duplicate_to_new_document(s, p);
+                    }
+                    let same = d.as_u64().is_some_and(|i| s.active_index().is_some_and(|a| i == a as u64));
+                    if !same {
+                        return Err(EngineError::BadParams {
+                            cmd: "layer.duplicate".into(),
+                            msg: if d.as_u64().is_some() {
+                                "the destination is another open document (use layer.copyToDocument)".into()
+                            } else {
+                                "`document` must be a document index or \"new\"".into()
+                            },
+                        });
+                    }
+                }
                 let in_place = p.get("inPlace").and_then(Value::as_bool).unwrap_or(false);
                 let name = p.get("name").and_then(Value::as_str).filter(|n| !n.is_empty()).map(str::to_string);
                 if crate::layer_multi_cmds::multi(s, p) {
@@ -615,7 +668,7 @@ fn build() -> Vec<CommandSpec> {
             "Select Layer",
             [],
             None,
-            r##"{"layer":id,"mode":"replace|toggle|range|add"="replace"} (toggle = ⌘-click, range = ⇧-click)"##,
+            r##"{"layer":id,"mode":"replace|toggle|range|add|remove"="replace"} (toggle = ⌘-click, range = ⇧-click, remove = deselect it, keeping at least one)"##,
             has_doc,
             crate::layer_multi_cmds::select
         ),
@@ -664,13 +717,8 @@ fn build() -> Vec<CommandSpec> {
                     if let Some(Value::Object(m)) = p.get("locks") {
                         for (k, v) in m {
                             let v = v.as_bool().unwrap_or(false);
-                            match k.as_str() {
-                                "transparency" => l.locks.transparency = v,
-                                "pixels" => l.locks.pixels = v,
-                                "position" => l.locks.position = v,
-                                "artboard" => l.locks.artboard = v,
-                                "all" => l.locks.all = v,
-                                other => return Err(bad("layer.setProps", format!("unknown lock `{other}`"))),
+                            if !l.locks.set(k, v) {
+                                return Err(bad("layer.setProps", format!("unknown lock `{k}`")));
                             }
                         }
                     }
@@ -761,7 +809,7 @@ fn build() -> Vec<CommandSpec> {
                 below.push(idx - 1);
                 let lower = doc.layer_at(&below).ok_or(EngineError::NoLayer(id))?.clone();
                 let upper = doc.layer(id).ok_or(EngineError::NoLayer(id))?.clone();
-                let merged = pixels::merge_down(doc.bounds(), &lower, &upper, doc.pixel_format());
+                let merged = pixels::merge_down(doc, &lower, &upper);
                 doc.remove(id);
                 *doc.layer_at_mut(&below).ok_or(EngineError::NoLayer(lower.id))? = merged;
                 *active = Some(lower.id);
@@ -769,6 +817,13 @@ fn build() -> Vec<CommandSpec> {
             })?;
             Ok(Value::Null)
         }),
+        cmd!("layer.mergeGroup", "Merge Group", ["Layer"], None, r##"{"layer":id?}"##, has_layer, |s, p| {
+            let id = layer_param(s, p)?;
+            if !s.active().and_then(|d| d.doc.layer(id)).is_some_and(|l| matches!(l.content, LayerContent::Group(_))) {
+                return Err(EngineError::Other("Merge Group needs a group".into()));
+            }
+            merge_group(s, id)
+        }),
         cmd!("layer.flattenImage", "Flatten Image", ["Layer"], None, "{}", has_doc, |s, _| {
             s.edit("Flatten Image", |doc, active| {
                 let fmt = doc.pixel_format();
@@ -878,7 +933,7 @@ fn build() -> Vec<CommandSpec> {
             "Move Layer",
             [],
             None,
-            r##"{"layer":id?,"dx":i32,"dy":i32} (no layer: every selected layer; linked layers follow)"##,
+            r##"{"layer":id?,"dx":i32,"dy":i32,"units":"px"|"pt"="px" (pt: points, whole pixels at the document's resolution),"target":"pixels"|"mask"="pixels"} (no layer: every selected layer; linked layers follow; target mask: a layer whose mask is unlinked moves that mask alone, a linked mask moves with the layer)"##,
             has_layer,
             crate::layer_multi_cmds::translate
         ),
@@ -922,11 +977,39 @@ fn build() -> Vec<CommandSpec> {
             has_paintable,
             crate::brush_cmds::paint_stroke
         ),
-        cmd!("tools.setColors", "Set Colors", [], None, r##"{"foreground":"#rrggbb"?,"background":"#rrggbb"?}"##, always, |s, p| {
-            s.tools.foreground = color_param(p, "foreground", s.tools.foreground);
-            s.tools.background = color_param(p, "background", s.tools.background);
-            Ok(Value::Null)
-        }),
+        cmd!(
+            "tools.setColors",
+            "Set Colors",
+            [],
+            None,
+            r##"{"foreground":"#rrggbb"|[r,g,b,a?]?,"background":same?,"foregroundCmyk":[c,m,y,k]? (inks 0..1 the foreground was picked as: a CMYK document is filled with exactly these),"backgroundCmyk":same?}"##,
+            always,
+            |s, p| {
+                let cmyk = |key: &str| -> Result<Option<[f32; 4]>> {
+                    let Some(v) = p.get(key).filter(|v| !v.is_null()) else { return Ok(None) };
+                    let inks: Option<Vec<f32>> = v
+                        .as_array()
+                        .filter(|a| a.len() == 4)
+                        .and_then(|a| a.iter().map(|x| x.as_f64().filter(|x| x.is_finite()).map(|x| x.clamp(0.0, 1.0) as f32)).collect());
+                    match inks.as_deref() {
+                        Some(&[c, m, y, k]) => Ok(Some([c, m, y, k])),
+                        _ => Err(bad("tools.setColors", format!("`{key}` must be [c, m, y, k] numbers 0..1"))),
+                    }
+                };
+                let (fg_cmyk, bg_cmyk) = (cmyk("foregroundCmyk")?, cmyk("backgroundCmyk")?);
+                s.tools.foreground = color_param(p, "foreground", s.tools.foreground);
+                s.tools.background = color_param(p, "background", s.tools.background);
+                if let Some(k) = fg_cmyk {
+                    let [r, g, b, _] = s.tools.foreground;
+                    s.tools.remember_cmyk([r, g, b], k);
+                }
+                if let Some(k) = bg_cmyk {
+                    let [r, g, b, _] = s.tools.background;
+                    s.tools.remember_cmyk([r, g, b], k);
+                }
+                Ok(Value::Null)
+            }
+        ),
         cmd!("tools.swapColors", "Switch Foreground and Background Colors", [], Some("X"), "{}", always, |s, _| {
             std::mem::swap(&mut s.tools.foreground, &mut s.tools.background);
             Ok(Value::Null)
@@ -1014,18 +1097,7 @@ fn build() -> Vec<CommandSpec> {
             shortcut: None,
             params: "{}",
             enabled: always,
-            run: |s, _| {
-                Ok(Value::Array(
-                    command_specs()
-                        .iter()
-                        .map(|c| {
-                            json!({
-                                "id": c.id, "label": c.label, "menu": c.menu, "shortcut": c.shortcut, "params": c.params, "enabled": (c.enabled)(s).is_ok(),
-                            })
-                        })
-                        .collect(),
-                ))
-            },
+            run: |s, _| Ok(Value::Array(command_specs().iter().map(|c| list_entry(s, c, (c.enabled)(s).err())).collect())),
             journal: false,
         },
         CommandSpec {
@@ -1191,6 +1263,8 @@ fn build() -> Vec<CommandSpec> {
     v.extend(crate::brush_preset_cmds::specs());
     v.extend(crate::eraser_cmds::specs());
     v.extend(crate::preset_import_cmds::specs());
+    v.extend(crate::atn_cmds::specs());
+    v.extend(crate::actions_edit_cmds::specs());
     v.extend(crate::swatch_cmds::specs());
     v.extend(crate::retouch_cmds::specs());
     v.extend(crate::redeye_cmds::specs());
@@ -1236,6 +1310,7 @@ fn build() -> Vec<CommandSpec> {
     v.extend(crate::analysis_cmds::specs());
     v.extend(crate::notes_cmds::specs());
     v.extend(crate::history_cmds::specs());
+    v.extend(crate::history_select_cmds::specs());
     v.extend(crate::proof_sim::specs());
     v.extend(crate::presets::specs());
     v.extend(crate::document_preset_cmds::specs());
@@ -1416,7 +1491,7 @@ pub(crate) fn translate_layer(doc: &Document, l: &mut Layer, dx: i32, dy: i32) {
 pub(crate) fn layer_copy(doc: &Document, id: LayerId) -> Result<Layer> {
     let src = doc.layer(id).ok_or(EngineError::NoLayer(id))?;
     // A copy of the Background layer is an ordinary, unlocked layer (Photoshop).
-    let from_background = src.name == "Background" && src.locks.transparency && doc.layers.first().is_some_and(|b| b.id == id);
+    let from_background = doc.is_background(id);
     let mut dup = src.duplicate();
     dup.name = doc.copy_name(&dup.name);
     if from_background {
@@ -1425,6 +1500,37 @@ pub(crate) fn layer_copy(doc: &Document, id: LayerId) -> Result<Layer> {
     Ok(dup)
 }
 
+/// Layer › Merge Group (⌘E with a group selected, #3832): the group's visible contents, as they
+/// show, become one pixel layer in its place, named after it. Like Photoshop, the layer keeps the
+/// group's opacity, blend mode (Pass Through becomes Normal), clipping and locks; the group's mask
+/// and style are applied to the pixels.
+fn merge_group(s: &mut Session, id: LayerId) -> Result<Value> {
+    s.edit("Merge Group", |doc, active| {
+        let group = doc.layer(id).ok_or(EngineError::NoLayer(id))?.clone();
+        if !group.visible {
+            return Err(EngineError::Other("the group is hidden".into()));
+        }
+        let fmt = doc.pixel_format();
+        let fmt = photocraft_color::PixelFormat::new(fmt.mode, fmt.sample, true);
+        let mut solo = group.clone();
+        solo.opacity = 1.0;
+        solo.blend = photocraft_doc::BlendMode::Normal;
+        solo.clipped = false;
+        let mut tmp = doc.clone();
+        tmp.layers = vec![solo];
+        let mut merged = Layer::new(group.name.clone(), LayerContent::Raster(pixels::composite_layers(&tmp, fmt, None)));
+        merged.id = group.id;
+        merged.opacity = group.opacity;
+        merged.blend = if group.blend == photocraft_doc::BlendMode::PassThrough { photocraft_doc::BlendMode::Normal } else { group.blend };
+        merged.clipped = group.clipped;
+        merged.locks = group.locks;
+        *doc.layer_mut(id).ok_or(EngineError::NoLayer(id))? = merged;
+        *active = Some(id);
+        Ok(())
+    })?;
+    Ok(json!({ "layer": id.0 }))
+}
+
 #[cfg(test)]
 mod registry_tests {
     use super::*;
diff --git a/crates/engine/src/comps_cmds.rs b/crates/engine/src/comps_cmds.rs
index 58f92f84ea..fe5708387c 100644
--- a/crates/engine/src/comps_cmds.rs
+++ b/crates/engine/src/comps_cmds.rs
@@ -319,13 +319,21 @@ fn restore_last(s: &mut Session) -> Result<Value> {
 }
 
 /// Comps that refer to deleted layers (Photoshop's warning triangle). `"clear": true` drops
-/// those stale states (Clear Layer Comp Warning) as one history step.
+/// those stale states as one history step: from `"comp"` only when given (Clear Layer Comp
+/// Warning), else from every comp (Clear All Layer Comp Warnings). `"comp"` also limits the
+/// report to that comp; an unknown comp is an error and changes nothing.
 fn update_warnings(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "layerComp.updateWarnings";
     let d = s.active().ok_or(EngineError::NoDocument)?;
+    let only = match p.get("comp") {
+        None | Some(Value::Null) => None,
+        Some(_) => Some(comp_param(&d.doc, p, cmd)?),
+    };
     let warnings: Vec<Value> = d
         .doc
         .layer_comps
         .iter()
+        .filter(|c| only.is_none_or(|id| c.id == id))
         .filter_map(|c| {
             let missing = c.missing_layers(&d.doc);
             (!missing.is_empty()).then(|| json!({"comp": c.id, "name": c.name, "missingLayers": missing.iter().map(|l| l.0).collect::<Vec<_>>()}))
@@ -333,9 +341,10 @@ fn update_warnings(s: &mut Session, p: &Value) -> Result<Value> {
         .collect();
     let n = warnings.len();
     if flag(p, "clear", false) && n > 0 {
-        s.edit("Clear Layer Comp Warnings", |doc, _| {
+        let label = if only.is_some() { "Clear Layer Comp Warning" } else { "Clear All Layer Comp Warnings" };
+        s.edit(label, |doc, _| {
             let live: std::collections::HashSet<LayerId> = doc.walk().into_iter().map(|(_, _, l)| l.id).collect();
-            for c in &mut doc.layer_comps {
+            for c in doc.layer_comps.iter_mut().filter(|c| only.is_none_or(|id| c.id == id)) {
                 c.states.retain(|st| live.contains(&st.layer));
             }
             Ok(())
@@ -434,7 +443,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "layerComp.updateWarnings",
             "Layer Comp Warnings",
             &[],
-            r##"{"clear":bool=false (drop states of deleted layers)} → {warnings:[{comp,name,missingLayers}],count}"##,
+            r##"{"comp":id|name? (default: every comp; limits the report and the clear to that comp),"clear":bool=false (drop states of deleted layers)} → {warnings:[{comp,name,missingLayers}],count}"##,
             has_doc,
             update_warnings
         ),
diff --git a/crates/engine/src/comps_cmds/tests.rs b/crates/engine/src/comps_cmds/tests.rs
index 22ef1a4697..5458523bcf 100644
--- a/crates/engine/src/comps_cmds/tests.rs
+++ b/crates/engine/src/comps_cmds/tests.rs
@@ -304,3 +304,46 @@ fn unreachable_comp_positions_leave_the_layer_in_place() {
         assert_eq!(pos(&s, b), Some((31, 22)));
     }
 }
+
+#[test]
+fn clearing_one_comps_warning_leaves_the_others() {
+    // Regression for #4197: the per-comp warning icon cleared every comp's warnings.
+    let (mut s, a, _) = session(8);
+    let c1 = s.execute("layerComp.new", json!({"name": "One"})).unwrap()["comp"].as_u64().unwrap();
+    let c2 = s.execute("layerComp.new", json!({"name": "Two"})).unwrap()["comp"].as_u64().unwrap();
+    s.edit("del", |d, _| {
+        d.remove(a);
+        Ok(())
+    })
+    .unwrap();
+    // Reporting can be limited to one comp too.
+    let w = s.execute("layerComp.updateWarnings", json!({"comp": c2})).unwrap();
+    assert_eq!(w["count"], 1);
+    assert_eq!(w["warnings"][0]["comp"], c2);
+    s.execute("layerComp.updateWarnings", json!({"clear": true, "comp": c1})).unwrap();
+    assert!(doc(&s).comp(c1 as u32).unwrap().missing_layers(doc(&s)).is_empty());
+    assert_eq!(doc(&s).comp(c2 as u32).unwrap().missing_layers(doc(&s)), vec![a]);
+    let w = s.execute("layerComp.updateWarnings", json!({})).unwrap();
+    assert_eq!(w["count"], 1);
+    assert_eq!(w["warnings"][0]["comp"], c2);
+    // Without "comp" every comp is cleared (Clear All Layer Comp Warnings).
+    s.execute("layerComp.updateWarnings", json!({"clear": true})).unwrap();
+    assert_eq!(s.execute("layerComp.updateWarnings", json!({})).unwrap()["count"], 0);
+}
+
+#[test]
+fn clearing_warnings_of_an_unknown_comp_is_an_error() {
+    let (mut s, a, _) = session(8);
+    let c1 = s.execute("layerComp.new", json!({})).unwrap()["comp"].as_u64().unwrap();
+    s.edit("del", |d, _| {
+        d.remove(a);
+        Ok(())
+    })
+    .unwrap();
+    let before = doc(&s).layer_comps.clone();
+    for bad in [json!(c1 + 99), json!("nope"), json!(-1), json!(1.5), json!(true), json!([c1])] {
+        assert!(s.execute("layerComp.updateWarnings", json!({"clear": true, "comp": bad})).is_err(), "{bad}");
+    }
+    assert_eq!(doc(&s).layer_comps, before);
+    assert_eq!(s.execute("layerComp.updateWarnings", json!({})).unwrap()["count"], 1);
+}
diff --git a/crates/engine/src/cutout_cmds.rs b/crates/engine/src/cutout_cmds.rs
index 762830ee83..d5cc734668 100644
--- a/crates/engine/src/cutout_cmds.rs
+++ b/crates/engine/src/cutout_cmds.rs
@@ -45,8 +45,12 @@ fn run(s: &mut Session, p: &Value) -> Result<Value> {
         s,
         "Remove Background",
         move |doc, _, ctx| {
-            ctx.progress(0.1, "Finding subject");
-            let found = with_doc_sampler(doc, Some(id), sample_all, |smp, d| subject::select_subject(smp, d.bounds()));
+            // Cancel reaches the min cuts inside Select Subject, so Esc doesn't wait for them.
+            let found = ctx
+                .stage(0.1, 0.6, "Finding subject", |ctl| {
+                    with_doc_sampler(doc, Some(id), sample_all, |smp, d| subject::select_subject_with(smp, d.bounds(), ctl))
+                })
+                .map_err(|_| EngineError::Cancelled)?;
             let mut region = found.ok_or_else(|| EngineError::Other("no subject found".into()))?;
             if ctx.cancelled() {
                 return Err(EngineError::Cancelled);
@@ -200,6 +204,24 @@ mod tests {
         assert!(l.mask.is_some());
     }
 
+    #[test]
+    fn remove_background_cancelled_while_finding_the_subject_changes_nothing() {
+        let (mut s, _) = disc(8);
+        let id = active_id(&s);
+        let before = s.active().unwrap().revision;
+        // The job's cancel reaches Select Subject, which stops at its first check.
+        let ctx = crate::jobs::JobCtx::new();
+        ctx.cancel();
+        s.set_inline_job_ctx(Some(ctx.clone()));
+        assert!(matches!(s.execute(CMD, json!({})), Err(EngineError::Cancelled)));
+        assert_eq!(ctx.message(), "Finding subject");
+        assert_eq!(s.active().unwrap().revision, before);
+        assert!(layer(&s, id).mask.is_none());
+        s.set_inline_job_ctx(None);
+        s.execute(CMD, json!({})).unwrap();
+        assert!(layer(&s, id).mask.is_some());
+    }
+
     #[test]
     fn remove_background_without_a_subject_leaves_the_document() {
         let mut s = session_with(32, 32, 8, |_, _| [0.5, 0.5, 0.5]);
@@ -233,8 +255,11 @@ mod tests {
         let (mut s, _) = disc(8);
         let before = s.active().unwrap().revision;
         assert!(s.execute(CMD, json!({"layer": 999_999})).is_err());
-        // Wrong types fall back to the defaults (the active layer, layer-only sampling, refined).
-        assert!(s.execute(CMD, json!({"layer": "x", "sampleAllLayers": 3, "refine": "no"})).is_ok());
+        // A `layer` string names a layer; one that isn't there is an error, not the active layer.
+        assert!(s.execute(CMD, json!({"layer": "x"})).is_err());
+        assert_eq!(s.active().unwrap().revision, before);
+        // Wrong types for the options fall back to the defaults (layer-only sampling, refined).
+        assert!(s.execute(CMD, json!({"sampleAllLayers": 3, "refine": "no"})).is_ok());
         assert!(s.active().unwrap().revision > before);
     }
 
diff --git a/crates/engine/src/display_color.rs b/crates/engine/src/display_color.rs
index 06490dbade..1e4aafc909 100644
--- a/crates/engine/src/display_color.rs
+++ b/crates/engine/src/display_color.rs
@@ -76,14 +76,15 @@ impl CanvasDisplay {
         if !self.encode_srgb {
             return Cow::Borrowed(buf);
         }
-        let mut b = buf.clone();
-        for p in &mut b.px {
-            for v in &mut p[..3] {
+        let mut px = vec![[0.0f32; 4]; buf.px.len()];
+        par_pixels(&mut px, &buf.px, |out, src| {
+            for (o, p) in out.iter_mut().zip(src) {
                 // Capped at the largest half float; NaN is dropped by the texel conversion.
-                *v = photocraft_color::convert::linear_to_srgb(v.clamp(0.0, 65504.0));
+                let enc = |v: f32| photocraft_color::convert::linear_to_srgb(v.clamp(0.0, 65504.0));
+                *o = [enc(p[0]), enc(p[1]), enc(p[2]), p[3]];
             }
-        }
-        Cow::Owned(b)
+        });
+        Cow::Owned(Buffer { rect: buf.rect, px })
     }
 }
 
@@ -97,12 +98,29 @@ fn encode_rgba8(buf: &Buffer) -> Rgba8Image {
     let t = encode_table();
     let mut img = Rgba8Image::new(buf.rect.width(), buf.rect.height());
     let code = |v: f32| t.get((v.clamp(0.0, 1.0) * 65535.0 + 0.5) as usize).copied().unwrap_or(255);
-    for (o, p) in img.pixels.as_chunks_mut::<4>().0.iter_mut().zip(&buf.px) {
-        *o = [code(p[0]), code(p[1]), code(p[2]), (p[3].clamp(0.0, 1.0) * 255.0 + 0.5) as u8];
-    }
+    par_pixels(img.pixels.as_chunks_mut::<4>().0, &buf.px, |out, src| {
+        for (o, p) in out.iter_mut().zip(src) {
+            *o = [code(p[0]), code(p[1]), code(p[2]), (p[3].clamp(0.0, 1.0) * 255.0 + 0.5) as u8];
+        }
+    });
     img
 }
 
+/// Pixels per piece [`par_pixels`] hands to one thread.
+const PAR_PIXELS: usize = 16 * 1024;
+
+/// `f` over matching pieces of `dst` and `src`, in parallel off wasm. The display encodes run on
+/// every canvas upload and preview, and a 24 MP linear document took 350 ms on one core.
+fn par_pixels<D: Send, S: Sync>(dst: &mut [D], src: &[S], f: impl Fn(&mut [D], &[S]) + Sync) {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        use rayon::prelude::*;
+        dst.par_chunks_mut(PAR_PIXELS).zip(src.par_chunks(PAR_PIXELS)).for_each(|(d, s)| f(d, s));
+    }
+    #[cfg(target_arch = "wasm32")]
+    f(dst, src);
+}
+
 /// In-place 8-bit RGBA transform (alpha kept), in blocks so the scratch copy stays small.
 fn apply_u8(t: &Transform, px: &mut [u8]) {
     const BLOCK: usize = 1 << 20;
diff --git a/crates/engine/src/display_color_tests.rs b/crates/engine/src/display_color_tests.rs
index 2ce0e0cfb1..1270a2418f 100644
--- a/crates/engine/src/display_color_tests.rs
+++ b/crates/engine/src/display_color_tests.rs
@@ -80,8 +80,11 @@ fn srgb_is_the_identity_fast_path() {
         assert!(s.color.canvas_lut(&d, 9).unwrap().is_none(), "no GPU LUT either");
         assert!(close(shown(&s, &d), [204.0, 127.5, 76.5], 0.6));
     }
-    // Untagged gray (sGray), CMYK (shown in sRGB) and Lab composites are sRGB too.
-    let g = Document::with_background("g", Size::new(4, 4), ColorMode::Grayscale, SampleType::U8, Color::gray(0.3));
+    // sGray-tagged gray and CMYK (shown in sRGB) composites are sRGB too; untagged gray takes the
+    // default working gray (Dot Gain 20 %-compatible), which is not.
+    let mut g = Document::with_background("g", Size::new(4, 4), ColorMode::Grayscale, SampleType::U8, Color::gray(0.3));
+    assert!(!s.color.canvas_display(&g).unwrap().is_identity());
+    g.icc_profile = Some(Builtin::SGray.profile().to_bytes());
     assert!(s.color.canvas_display(&g).unwrap().is_identity());
     assert!(s.color.canvas_display(&cmyk_doc(None, [0.1, 0.5, 0.5, 0.0])).unwrap().is_identity());
     // Cached: the same Arc for the same profiles.
@@ -195,7 +198,8 @@ fn gray_exr_round_trip_is_linear() {
     let mut s = Session::new();
     // An sGray document exported to EXR is linearised (#2386); re-opened it is tagged linear gray
     // and displays as before.
-    let d = Document::with_background("t", Size::new(8, 8), ColorMode::Grayscale, SampleType::U8, Color::gray(128.0 / 255.0));
+    let mut d = Document::with_background("t", Size::new(8, 8), ColorMode::Grayscale, SampleType::U8, Color::gray(128.0 / 255.0));
+    d.icc_profile = Some(Builtin::SGray.profile().to_bytes());
     let r = photocraft_io::export(&d, "x.exr", &photocraft_io::ExportOptions::default()).unwrap();
     let back = photocraft_io::import("x.exr", &r.bytes).unwrap().document;
     let icc = back.icc_profile.clone().expect("tagged");
@@ -393,3 +397,61 @@ fn proof_colors_still_apply_on_top() {
     s.execute("view.gamutWarning", json!({"on": true})).unwrap();
     assert_ne!(sig, s.color.display_signature(&d));
 }
+
+#[test]
+fn parallel_linear_encodes_match_the_scalar_curve() {
+    // Several parallel pieces, a ragged last one, and HDR, negative and NaN values.
+    let n: usize = 3 * 16 * 1024 + 77;
+    let px: Vec<[f32; 4]> = (0..n)
+        .map(|i| {
+            let v = match i % 9 {
+                0 => f32::NAN,
+                1 => -0.5,
+                2 => 3.25,
+                _ => (i % 1001) as f32 / 1000.0,
+            };
+            [v, (i % 257) as f32 / 256.0, 1.0 - (i % 113) as f32 / 112.0, (i % 5) as f32 / 4.0]
+        })
+        .collect();
+    let buf = photocraft_compose::Buffer { rect: Rect::new(-4, 2, -4 + n as i32, 3), px };
+    let mut doc = Document::new("t", Size::new(1, 1), ColorMode::Rgb, SampleType::F32);
+    doc.icc_profile = Some(Builtin::LinearSrgb.profile().to_bytes());
+    let mut color = crate::color_cmds::ColorState::default();
+    color.settings.monitor_profile = "srgb".into();
+    let d = color.canvas_display(&doc).unwrap();
+    assert!(d.encode_srgb);
+    let enc = |v: f32| photocraft_color::convert::linear_to_srgb(v.clamp(0.0, 65504.0));
+    let tex = d.texture_buffer(&buf);
+    assert_eq!(tex.rect, buf.rect);
+    for (t, p) in tex.px.iter().zip(&buf.px) {
+        let want = [enc(p[0]), enc(p[1]), enc(p[2]), p[3]];
+        assert!(t.iter().zip(want).all(|(a, b)| a.to_bits() == b.to_bits()), "{p:?} -> {t:?}, want {want:?}");
+    }
+    let code = |v: f32| (photocraft_color::convert::linear_to_srgb(((v.clamp(0.0, 1.0) * 65535.0 + 0.5) as usize) as f32 / 65535.0) * 255.0 + 0.5) as u8;
+    let img = d.to_rgba8(&buf);
+    for (o, p) in img.pixels.as_chunks::<4>().0.iter().zip(&buf.px) {
+        assert_eq!(*o, [code(p[0]), code(p[1]), code(p[2]), (p[3].clamp(0.0, 1.0) * 255.0 + 0.5) as u8], "{p:?}");
+    }
+}
+
+#[test]
+fn parallel_plain_quantize_matches_the_scalar_rounding() {
+    let n: usize = 3 * 16 * 1024 + 77;
+    let px: Vec<[f32; 4]> = (0..n)
+        .map(|i| {
+            let v = match i % 9 {
+                0 => f32::NAN,
+                1 => -0.5,
+                2 => 3.25,
+                _ => (i % 1001) as f32 / 1000.0,
+            };
+            [v, (i % 257) as f32 / 256.0, 1.0 - (i % 113) as f32 / 112.0, (i % 5) as f32 / 4.0]
+        })
+        .collect();
+    let buf = photocraft_compose::Buffer { rect: Rect::new(-4, 2, -4 + n as i32, 3), px };
+    let img = buf.to_rgba8();
+    let q = |v: f32| (v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
+    for (o, p) in img.pixels.as_chunks::<4>().0.iter().zip(&buf.px) {
+        assert_eq!(*o, p.map(q), "{p:?}");
+    }
+}
diff --git a/crates/engine/src/distort_cmds.rs b/crates/engine/src/distort_cmds.rs
index 75ebf529bc..ed56e50023 100644
--- a/crates/engine/src/distort_cmds.rs
+++ b/crates/engine/src/distort_cmds.rs
@@ -10,9 +10,11 @@
 //! resampling. The params are the data in every case (strokes, pins and planes are small
 //! compared with a field or a mesh, and replay is deterministic), so nothing needs a blob.
 
+use std::cell::RefCell;
+
 use photocraft_algo::liquify::{LiquifyField, LiquifyStroke, apply_liquify, auto_cell};
 use photocraft_algo::perspective::{PerspectiveMap, Plane, Straighten, straighten};
-use photocraft_algo::puppet::{PuppetDensity, PuppetMode, PuppetPin, PuppetWarp, puppet_warp};
+use photocraft_algo::puppet::{PuppetDensity, PuppetMode, PuppetPin, PuppetWarp, puppet_warp, puppet_warp_with_mask};
 use photocraft_algo::transform::Interp;
 use photocraft_algo::warp::{warp_mesh_gray, warp_mesh_surface};
 use photocraft_color::PixelFormat;
@@ -213,19 +215,10 @@ fn smart_layer(s: &Session) -> std::result::Result<(), String> {
     }
 }
 
-/// Unlocks a Background layer for an operation that exposes transparency (as Photoshop does).
-fn float_background(l: &mut Layer) {
-    if l.locks.position && l.name == "Background" {
-        l.locks.position = false;
-        l.locks.transparency = false;
-        l.name = "Layer 0".into();
-    }
-}
-
 fn check_locks(l: &Layer, group: Locks, position: bool) -> Result<()> {
     let locks = l.locks.union(group);
     if locks.all || locks.pixels || (position && locks.position) {
-        return Err(EngineError::Other(format!("layer \"{}\" is locked", l.name)));
+        return Err(EngineError::Other(format!("Could not complete your request because the layer \"{}\" is locked", l.name)));
     }
     Ok(())
 }
@@ -247,14 +240,18 @@ fn run_on_layer(s: &mut Session, cmd: &str, label: &str, p: &Value, moves: bool,
         let canvas = doc.bounds();
         let selection = doc.selection.clone();
         let group = crate::transform_cmds::group_locks(doc, id);
+        // A Background gains transparency when the distortion moves pixels (as in Photoshop).
+        if moves {
+            crate::extra_cmds::background_to_layer(doc, id);
+        }
         let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
         if let LayerContent::Smart(_) = l.content {
+            // As filters do: a pixel or full lock refuses the smart filter (the position lock
+            // doesn't, since the smart object itself stays put).
+            check_locks(l, group, false)?;
             let sf = SmartFilter { command: cmd.to_string(), params: params.clone(), blend: photocraft_color::BlendMode::Normal, opacity: 1.0, visible: true };
             return crate::smart_cmds::add_smart_filter(doc, id, sf, selection.as_ref());
         }
-        if moves {
-            float_background(l);
-        }
         check_locks(l, group, moves)?;
         let LayerContent::Raster(surf) = &mut l.content else {
             return Err(EngineError::Other(format!("{label} needs a pixel layer (rasterize it first)")));
@@ -333,7 +330,23 @@ fn puppet(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
     }
     let it = interp(p);
     let too_far = || bad(cmd, "the pins stretch the content too far: the result would cover more than 2^30 pixels");
-    run_on_layer(s, cmd, "Puppet Warp", p, true, &|surf, sel, _| deform_selected(surf, sel, &|x| puppet_surface(x, &w, it).ok_or_else(too_far)), None)
+    // A linked layer mask moves with the pixels on the same mesh (#4910): the layer's warp
+    // solves the mesh once and leaves the moved mask here for the mask step.
+    let linked = s.active().and_then(|d| d.doc.layer(id)).and_then(|l| l.mask.as_ref()).filter(|m| m.linked).map(|m| m.surface.clone());
+    let moved_mask: RefCell<Option<Surface>> = RefCell::new(None);
+    let layer_fn = |surf: &Surface, sel: Option<&Surface>, _: Rect| {
+        deform_selected(surf, sel, &|x| {
+            let b = x.content_bounds();
+            if b.is_empty() {
+                return Ok(x.clone());
+            }
+            let (out, mask) = puppet_warp_with_mask(x, b, &w, it, linked.as_ref()).ok_or_else(too_far)?;
+            *moved_mask.borrow_mut() = mask;
+            Ok(out)
+        })
+    };
+    let mask_fn = |m: &Surface, _: Option<&Surface>| Ok(moved_mask.borrow_mut().take().unwrap_or_else(|| m.clone()));
+    run_on_layer(s, cmd, "Puppet Warp", p, true, &layer_fn, Some(&mask_fn))
 }
 
 fn perspective(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
diff --git a/crates/engine/src/distort_cmds/tests.rs b/crates/engine/src/distort_cmds/tests.rs
index d0ea88ed05..81d17c28c2 100644
--- a/crates/engine/src/distort_cmds/tests.rs
+++ b/crates/engine/src/distort_cmds/tests.rs
@@ -124,6 +124,68 @@ fn puppet_identity_translation_and_undo() {
     }
 }
 
+fn mask_at(s: &Session, x: i32, y: i32) -> f32 {
+    let st = s.active().unwrap();
+    st.doc.layer(st.active_layer.unwrap()).unwrap().mask.as_ref().unwrap().surface.sample_channel(x, y, 0)
+}
+
+/// [`session`] with a reveal-all mask that hides the stripes `stripes` (x ranges, y 10..40).
+fn masked_session(depth: u64, stripes: &[(i32, i32)]) -> Session {
+    let mut s = session(depth);
+    s.execute("layer.layerMask.revealAll", json!({})).unwrap();
+    s.edit("mask", |doc, active| {
+        let m = doc.layer_mut(active.unwrap()).unwrap().mask.as_mut().unwrap();
+        for &(x0, x1) in stripes {
+            m.surface.fill_rect(Rect::new(x0, 10, x1, 40), &[0.0]);
+        }
+        Ok(())
+    })
+    .unwrap();
+    s
+}
+
+#[test]
+fn puppet_moves_a_linked_mask_with_the_pixels() {
+    // #4910: Puppet Warp warped only the pixels and left a linked mask behind. A one-pin rigid
+    // warp moves the block by (6, 4); the stripe the mask hides (x 20..24) must move with it.
+    for depth in [8u64, 16, 32] {
+        let mut s = masked_session(depth, &[(20, 24)]);
+        let before = s.active().unwrap().doc.clone();
+        s.execute(PUPPET, json!({"pins": [{"src": [30, 25], "dst": [36, 29]}], "mode": "rigid", "interpolation": "bilinear"})).unwrap();
+        for y in [16, 30, 42] {
+            assert!(mask_at(&s, 27, y) < 0.01, "{depth}: the stripe moved to x 26..30 (y {y})");
+            assert!(mask_at(&s, 21, y) > 0.99, "{depth}: and left x 20..24 (y {y})");
+        }
+        assert!(mask_at(&s, 27, 12) > 0.99, "{depth}: and down by 4");
+        // Pixels and mask still line up: the same layer pixel is hidden as before the warp.
+        let was = before.layer(s.active().unwrap().active_layer.unwrap()).unwrap().surface().unwrap().pixel(21, 26);
+        assert!(worst_px(&active_surface(&s).pixel(27, 30), &was) <= 1.0 / 255.0, "{depth}");
+        s.undo();
+        assert!(mask_at(&s, 21, 30) < 0.01 && mask_at(&s, 27, 30) > 0.99, "{depth}: undo puts the mask back");
+    }
+}
+
+#[test]
+fn puppet_leaves_an_unlinked_mask_in_place() {
+    let mut s = masked_session(8, &[(20, 24)]);
+    s.execute("layer.layerMask.linked", json!({"linked": false})).unwrap();
+    s.execute(PUPPET, json!({"pins": [{"src": [30, 25], "dst": [36, 29]}], "mode": "rigid"})).unwrap();
+    assert!(mask_at(&s, 21, 30) < 0.01 && mask_at(&s, 27, 30) > 0.99);
+    assert_eq!(active_surface(&s).content_bounds(), Rect::new(16, 14, 66, 44), "the pixels still moved");
+}
+
+#[test]
+fn puppet_with_a_selection_moves_only_the_selected_part_of_a_linked_mask() {
+    // The selection lifts the block's left part (x 10..30): the stripe hidden there moves with
+    // it, the one outside (x 40..44) stays over its pixels.
+    let mut s = masked_session(8, &[(20, 24), (40, 44)]);
+    s.execute("select.rect", json!({"x": 0, "y": 0, "width": 30, "height": 60})).unwrap();
+    s.execute(PUPPET, json!({"pins": [{"src": [20, 25], "dst": [26, 29]}], "mode": "rigid"})).unwrap();
+    assert!(mask_at(&s, 27, 30) < 0.01 && mask_at(&s, 21, 30) > 0.99, "the selected stripe moved");
+    assert!(mask_at(&s, 41, 30) < 0.01 && mask_at(&s, 45, 30) > 0.99, "the other stayed");
+    assert_eq!(active_surface(&s).pixel(41, 30)[3], 1.0, "over its pixels");
+}
+
 #[test]
 fn puppet_with_an_expansion_that_empties_the_mesh_keeps_the_layer() {
     // #951: a pinned warp over an empty mesh panicked in the solver; it must not erase the layer
@@ -352,3 +414,62 @@ fn liquify_with_a_far_off_stroke_point_returns() {
         assert_eq!(active_surface(&s).read_region(Rect::new(0, 0, 80, 60)), before.read_region(Rect::new(0, 0, 80, 60)), "{depth}: off-canvas only");
     }
 }
+
+/// The three distortions on the active smart object, each with a visible change.
+fn smart_distortions() -> [(&'static str, Value); 3] {
+    let q = [[10.0, 10.0], [60.0, 10.0], [60.0, 40.0], [10.0, 40.0]];
+    [
+        (LIQUIFY, json!({"strokes": [{"tool": "twirlCw", "size": 40, "points": [[35, 25], [35, 25], [35, 25]]}]})),
+        (PUPPET_SMART, json!({"pins": [{"src": [30, 25], "dst": [34, 25]}], "mode": "rigid"})),
+        (PERSPECTIVE_SMART, json!({"planes": [{"src": q, "dst": [[12.0, 10.0], [58.0, 10.0], [60.0, 40.0], [10.0, 40.0]]}]})),
+    ]
+}
+
+#[test]
+fn locked_smart_objects_refuse_distortions() {
+    // As filters do: a pixel or full lock (the layer's own or its group's) refuses the smart
+    // filter, leaving the layer and the history as they were.
+    for lock in [json!({"all": true}), json!({"pixels": true})] {
+        for on_group in [false, true] {
+            for (cmd, p) in smart_distortions() {
+                let mut s = session(8);
+                s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+                let layer = s.active().unwrap().active_layer.unwrap();
+                if on_group {
+                    s.execute("layer.new.groupFromLayers", json!({})).unwrap();
+                }
+                s.execute("layer.lockLayers", lock.clone()).unwrap();
+                s.execute("layer.select", json!({"layer": layer.0})).unwrap();
+                let locks = s.active().unwrap().doc.effective_locks(layer);
+                assert!(locks.all || locks.pixels, "the lock reaches the smart object ({lock}, group: {on_group})");
+                let steps = s.active().unwrap().history.past_len();
+                let before = s.active().unwrap().doc.layer(layer).unwrap().clone();
+                let r = s.execute(cmd, p);
+                assert!(r.is_err(), "{cmd} edited a smart object locked with {lock} (group: {on_group}): {r:?}");
+                let st = s.active().unwrap();
+                let LayerContent::Smart(sm) = &st.doc.layer(layer).unwrap().content else { panic!("not smart") };
+                assert!(sm.smart_filters.is_empty(), "{cmd} {lock} group: {on_group}");
+                assert_eq!(st.doc.layer(layer).unwrap().surface(), before.surface(), "{cmd} {lock} group: {on_group}");
+                assert_eq!(st.history.past_len(), steps, "{cmd} {lock} group: {on_group}: no history step");
+            }
+        }
+    }
+}
+
+#[test]
+fn unlocked_or_position_locked_smart_objects_take_distortions() {
+    // Filters don't check the position lock, so neither do the smart-filter distortions.
+    for lock in [None, Some(json!({"position": true})), Some(json!({"transparency": true}))] {
+        for (cmd, p) in smart_distortions() {
+            let mut s = session(8);
+            s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+            if let Some(lock) = &lock {
+                s.execute("layer.lockLayers", lock.clone()).unwrap();
+            }
+            let steps = s.active().unwrap().history.past_len();
+            s.execute(cmd, p).unwrap();
+            assert_eq!(smart(&s).smart_filters.len(), 1, "{cmd} {lock:?}");
+            assert_eq!(s.active().unwrap().history.past_len(), steps + 1, "{cmd} {lock:?}");
+        }
+    }
+}
diff --git a/crates/engine/src/edit_cmds.rs b/crates/engine/src/edit_cmds.rs
index f99a81a640..f0541136ad 100644
--- a/crates/engine/src/edit_cmds.rs
+++ b/crates/engine/src/edit_cmds.rs
@@ -28,6 +28,9 @@ pub struct Clip {
     /// than rasterize (see [`whole_layer`]): a scratch document in the source's colour holding it.
     /// `surface` still holds its pixels, for Paste Into, masks, channels and other apps.
     pub layers: Option<Box<Document>>,
+    /// The source document's resolution (ppi): File › New from the clipboard takes it, as
+    /// Photoshop's Clipboard preset does. None for an image from another app.
+    pub resolution: Option<f32>,
 }
 
 /// Photoshop's layer-based copy (CC 2018 on): with no selection, Copy takes the active layer
@@ -52,6 +55,46 @@ fn scratch_doc(doc: &Document) -> Document {
     copies
 }
 
+/// Scope linked records to the copied layer tree: a PSD block can also hold files belonging
+/// to unselected or hidden layers, which must not follow this copy into a native save.
+fn copy_linked_sources(source: &Document, copies: &mut Document) -> Result<()> {
+    fn collect<'a>(layers: &'a [Layer], depth: usize, paths: &mut std::collections::HashSet<&'a str>) -> Result<()> {
+        if depth > photocraft_doc::MAX_GROUP_DEPTH {
+            return Err(EngineError::Other("can't copy linked smart objects from layers nested too deeply".into()));
+        }
+        for layer in layers {
+            if let LayerContent::Smart(sm) = &layer.content
+                && let photocraft_doc::SmartSource::Linked { path } = &sm.source
+            {
+                paths.try_reserve(1).map_err(|_| EngineError::Other("not enough memory to copy smart-object source IDs".into()))?;
+                paths.insert(path);
+            }
+            if let Some(children) = layer.children().filter(|children| !children.is_empty()) {
+                collect(children, depth + 1, paths)?;
+            }
+        }
+        Ok(())
+    }
+    let mut paths = std::collections::HashSet::new();
+    collect(&copies.layers, 0, &mut paths)?;
+    if paths.is_empty() {
+        return Ok(());
+    }
+    for (signature, key, data) in &source.metadata.psd_global_blocks {
+        if !matches!(key, b"lnk2" | b"lnk3" | b"lnkD" | b"lnkE") {
+            continue;
+        }
+        let selected = photocraft_io::linked::select_items(data, &|uuid, _| paths.contains(uuid))
+            .map_err(|e| EngineError::Other(format!("Could not copy smart-object contents: {e}; the clipboard was not changed")))?;
+        let selected = selected.map(std::sync::Arc::new).unwrap_or_else(|| data.clone());
+        if !selected.is_empty() {
+            copies.metadata.psd_global_blocks.try_reserve(1).map_err(|_| EngineError::Other("not enough memory to copy smart-object source records".into()))?;
+            copies.metadata.psd_global_blocks.push((*signature, *key, selected));
+        }
+    }
+    Ok(())
+}
+
 /// The layer Copy takes whole ([`takes_whole`]): a scratch document in the source's colour
 /// holding it.
 fn whole_layer(d: &crate::DocState, id: LayerId) -> Option<Box<Document>> {
@@ -82,7 +125,7 @@ fn whole_layers(d: &crate::DocState, ids: &[LayerId]) -> Option<Box<Document>> {
     let mut copies = scratch_doc(&d.doc);
     for id in ids {
         let mut l = d.doc.layer(*id)?.clone();
-        if crate::extra_cmds::is_background(&l) {
+        if d.doc.is_background(*id) {
             l.name = "Layer 0".into();
             l.locks = Default::default();
         }
@@ -139,6 +182,11 @@ fn active_id(s: &Session) -> Result<LayerId> {
 }
 
 /// The pixels of `src` inside the selection (or all of them), as a straight-alpha surface.
+///
+/// Built tile by tile (#4516). A source tile that the copy takes whole (inside the canvas, fully
+/// selected or no selection, already in the clip's format) is shared copy-on-write, so a plain
+/// Copy or Select All, Copy costs a pointer per tile; only the other tiles are read and written,
+/// one at a time, instead of the whole area as one `f32` buffer.
 fn lift(src: &Surface, sel: Option<&Surface>, canvas: Rect) -> Result<Clip> {
     let fmt = src.format();
     let with_alpha = PixelFormat::new(fmt.mode, fmt.sample, true);
@@ -148,15 +196,39 @@ fn lift(src: &Surface, sel: Option<&Surface>, canvas: Rect) -> Result<Clip> {
     };
     let mut out = Surface::new(with_alpha);
     if area.is_empty() {
-        return Ok(Clip { surface: out, bounds: Rect::EMPTY, layers: None });
+        return Ok(Clip { surface: out, bounds: Rect::EMPTY, layers: None, resolution: None });
     }
     // Only the selected area is read: converting the whole layer (a 24 MP Background gaining
     // alpha) cost about a second per Layer via Copy (#668).
-    let n = with_alpha.channels();
+    let mut shared = Vec::new();
+    for tc in area.tiles() {
+        let tr = tc.rect().intersect(&area);
+        if fmt.alpha
+            && tr == tc.rect()
+            && let Some(tile) = src.tile(tc)
+            && sel.is_none_or(|m| crate::fill_cmds::Mask::of(m, tc).full(tr))
+        {
+            // Reading and writing it back would give the same bytes.
+            shared.push((tc, tile.clone()));
+            continue;
+        }
+        let px = lift_region(src, sel, tr, with_alpha.channels())?;
+        out.try_write_region(tr, &px).map_err(|e| EngineError::Other(format!("not enough memory while copying pixels ({e}); the document was not changed")))?;
+    }
+    out.put_tiles(shared);
+    out.prune();
+    let bounds = out.content_bounds();
+    Ok(Clip { surface: out, bounds, layers: None, resolution: None })
+}
+
+/// [`lift`] over one rectangle: `src`'s pixels with alpha (`n` channels), the selection
+/// multiplied into it.
+fn lift_region(src: &Surface, sel: Option<&Surface>, r: Rect, n: usize) -> Result<Vec<f32>> {
+    let fmt = src.format();
     let mut px = if fmt.alpha {
-        crate::allocation::read_region(src, area, "copying pixels")?
+        crate::allocation::read_region(src, r, "copying pixels")?
     } else {
-        let opaque = crate::allocation::read_region(src, area, "copying pixels")?;
+        let opaque = crate::allocation::read_region(src, r, "copying pixels")?;
         let k = fmt.channels();
         let len = opaque
             .len()
@@ -177,16 +249,15 @@ fn lift(src: &Surface, sel: Option<&Surface>, canvas: Rect) -> Result<Clip> {
         v
     };
     if let Some(m) = sel {
-        let mask = crate::allocation::read_region(m, area, "applying the selection to copied pixels")?;
+        let mask = crate::allocation::read_region(m, r, "applying the selection to copied pixels")?;
         let mk = m.format().channels().max(1);
-        for (p, a) in px.chunks_exact_mut(n).zip(mask.chunks_exact(mk)) {
-            p[n - 1] *= a[0];
+        for (p, a) in px.chunks_exact_mut(n.max(1)).zip(mask.chunks_exact(mk)) {
+            if let Some(alpha) = p.last_mut() {
+                *alpha *= a[0];
+            }
         }
     }
-    out.try_write_region(area, &px).map_err(|e| EngineError::Other(format!("not enough memory while copying pixels ({e}); the document was not changed")))?;
-    out.prune();
-    let bounds = out.content_bounds();
-    Ok(Clip { surface: out, bounds, layers: None })
+    Ok(px)
 }
 
 /// Merged composite of the visible document as a surface in the document's format.
@@ -203,7 +274,10 @@ fn copy(s: &mut Session, merged: bool) -> Result<Value> {
     } else {
         let id = d.active_layer.ok_or(EngineError::Other("no active layer".into()))?;
         let several = multi_copy_ids(d);
-        let layers = if several.is_empty() { whole_layer(d, id) } else { whole_layers(d, &several) };
+        let mut layers = if several.is_empty() { whole_layer(d, id) } else { whole_layers(d, &several) };
+        if let Some(copies) = &mut layers {
+            copy_linked_sources(&d.doc, copies)?;
+        }
         match (d.doc.layer(id).and_then(Layer::surface).filter(|_| several.is_empty()), &layers) {
             (Some(surf), _) => Clip { layers, ..lift(surf, d.doc.selection.as_ref(), canvas)? },
             // A group has no pixels of its own: the clipboard pixels are what it shows.
@@ -221,6 +295,7 @@ fn copy(s: &mut Session, merged: bool) -> Result<Value> {
         return Err(EngineError::Other("Could not copy: the selected area is empty".into()));
     }
     let b = clip.bounds;
+    let clip = Clip { resolution: Some(d.doc.resolution_dpi), ..clip };
     s.clipboard = Some(clip);
     Ok(json!({"bounds": [b.x0, b.y0, b.width(), b.height()]}))
 }
@@ -263,7 +338,8 @@ fn copy_mask(s: &mut Session) -> Result<Value> {
         return Err(EngineError::Other("Could not copy: the selected area is empty".into()));
     }
     let b = bounds;
-    s.clipboard = Some(Clip { surface, bounds: b, layers: None });
+    let resolution = Some(d.doc.resolution_dpi);
+    s.clipboard = Some(Clip { surface, bounds: b, layers: None, resolution });
     Ok(json!({"bounds": [b.x0, b.y0, b.width(), b.height()], "target": "mask"}))
 }
 
@@ -277,7 +353,8 @@ fn clear_selected(doc: &mut Document, id: LayerId, background: [f32; 4]) -> Resu
 /// Cut / Clear on a layer: makes the selected pixels transparent. The Background can't hold
 /// transparency, so there the area is filled with the background colour instead (Photoshop).
 pub(crate) fn clear_area(doc: &mut Document, id: LayerId, area: Rect, sel: Option<&Surface>, background: [f32; 4]) -> Result<()> {
-    let bg = crate::extra_cmds::is_background(doc.layer(id).ok_or(EngineError::NoLayer(id))?);
+    doc.layer(id).ok_or(EngineError::NoLayer(id))?;
+    let bg = doc.is_background(id);
     let surf = crate::commands::paint_surface(doc, id, &Value::Null)?;
     if bg {
         crate::pixels::try_fill_surface(surf, area, background, sel, true)?;
@@ -339,8 +416,27 @@ fn paste_layers(s: &mut Session, layers: &Document, dx: i32, dy: i32) -> Result<
     crate::layer_copy_cmds::adapt_copies(s, &mut copies, &d.doc)?;
     crate::layer_copy_cmds::translate_copies(&mut copies, dx, dy);
     let patterns: Vec<_> = copies.patterns.iter().filter(|pat| !d.doc.patterns.iter().any(|q| q.id == pat.id)).cloned().collect();
+    // A copied smart object may name a PSD-embedded linked file; land its `lnk` block too (#3584).
+    let mut linked = Vec::new();
+    for (signature, key, data) in copies.metadata.psd_global_blocks.iter().filter(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD" | b"lnkE")) {
+        if d.doc.metadata.psd_global_blocks.iter().any(|(_, dk, dd)| dk == key && std::sync::Arc::ptr_eq(dd, data)) {
+            continue;
+        }
+        // The clipboard may contain a subset of a destination block. Compare complete records,
+        // so copying one layer in the same document does not duplicate large embedded files.
+        let missing = photocraft_io::linked::select_items(data, &|_, raw| {
+            !d.doc.metadata.psd_global_blocks.iter().any(|(_, dk, dd)| dk == key && photocraft_io::linked::contains_item(dd, raw))
+        })
+        .map_err(|e| EngineError::Other(format!("Could not paste smart-object contents: {e}; the document was not changed")))?;
+        let missing = missing.map(std::sync::Arc::new).unwrap_or_else(|| data.clone());
+        if !missing.is_empty() {
+            linked.try_reserve(1).map_err(|_| EngineError::Other("not enough memory to paste smart-object source records".into()))?;
+            linked.push((*signature, *key, missing));
+        }
+    }
     let id = s.edit("Paste", |doc, active| {
         doc.patterns.extend(patterns);
+        doc.metadata.psd_global_blocks.extend(linked);
         for l in copies.layers {
             *active = Some(doc.insert_above(*active, l));
         }
@@ -403,10 +499,17 @@ fn new_from_clipboard(s: &mut Session) -> Result<Value> {
     let target = PixelFormat::new(fmt.mode, fmt.sample, true);
     let moved = if b.x0 == 0 && b.y0 == 0 { clip.surface } else { photocraft_algo::resample::translate_surface(&clip.surface, -b.x0, -b.y0) };
     let mut doc = Document::new("Untitled", photocraft_geom::Size::new(w, h), fmt.mode, fmt.sample);
+    if let Some(r) = clip.resolution.filter(|r| r.is_finite() && *r > 0.0) {
+        doc.resolution_dpi = r;
+    }
     let mut l = Layer::raster(doc.next_layer_name("Layer"), target);
     *crate::pixels_mut(&mut l)? = if moved.format() == target { moved } else { moved.convert(target) };
     doc.layers.push(l);
     let i = s.add_document(doc, None);
+    // Clipboard content has never been saved; closing this tab must ask before discarding it.
+    if let Some(st) = s.active_mut() {
+        st.saved_revision = 0;
+    }
     Ok(json!({"document": i, "width": w, "height": h}))
 }
 
@@ -461,7 +564,7 @@ fn merge_visible(s: &mut Session) -> Result<Value> {
         }
         let lowest = visible[0];
         let base = doc.layers[lowest].clone();
-        let is_background = base.name == "Background" && base.locks.transparency;
+        let is_background = lowest == 0 && doc.is_background(base.id);
         // Composite of visible layers only (hidden ones stay where they are).
         let mut solo = doc.clone();
         solo.layers.retain(|l| l.visible);
@@ -778,6 +881,32 @@ fn guide_cmd(s: &mut Session, p: &Value, op: &str) -> Result<Value> {
     Ok(Value::Null)
 }
 
+/// Farthest the ruler zero point may sit from the image, in document pixels.
+const MAX_RULER_ORIGIN: f64 = 1.0e7;
+
+/// Move the rulers' zero point (`view.setRulerOrigin`), or put it back at the image's top-left
+/// (`view.resetRulerOrigin`, `p` = None). Undoable like the guides.
+fn ruler_origin_cmd(s: &mut Session, p: Option<&Value>) -> Result<Value> {
+    let origin = match p {
+        None => [0.0, 0.0],
+        Some(p) => {
+            let axis = |k: &str| {
+                p.get(k)
+                    .and_then(Value::as_f64)
+                    .filter(|v| v.is_finite() && v.abs() <= MAX_RULER_ORIGIN)
+                    .ok_or_else(|| EngineError::Other(format!("`{k}` must be a number of pixels within ±{MAX_RULER_ORIGIN}")))
+            };
+            [axis("x")?, axis("y")?]
+        }
+    };
+    let label = if p.is_some() { "Set Ruler Origin" } else { "Reset Ruler Origin" };
+    s.edit(label, |doc, _| {
+        doc.ruler_origin = origin;
+        Ok(())
+    })?;
+    Ok(json!({"x": origin[0], "y": origin[1]}))
+}
+
 pub fn specs() -> Vec<CommandSpec> {
     macro_rules! spec {
         ($id:expr, $label:expr, $menu:expr, $sc:expr, $params:expr, $enabled:expr, $run:expr) => {
@@ -884,6 +1013,18 @@ pub fn specs() -> Vec<CommandSpec> {
         ),
         spec!("view.deleteGuide", "Delete Guide", &[], None, r##"{"orientation":"horizontal|vertical","index":n}"##, has_doc, |s, p| guide_cmd(s, p, "delete")),
         spec!("view.clearGuides", "Clear Guides", &["View"], None, "{}", has_doc, |s, p| guide_cmd(s, p, "clear")),
+        spec!(
+            "view.setRulerOrigin",
+            "Set Ruler Origin",
+            &[],
+            None,
+            r##"{"x":px,"y":px} (the rulers' zero point in document pixels; the rulers and Info panel measure from it)"##,
+            has_doc,
+            |s, p| ruler_origin_cmd(s, Some(p))
+        ),
+        spec!("view.resetRulerOrigin", "Reset Ruler Origin", &[], None, "{} (zero point back at the image's top-left)", has_doc, |s, _| ruler_origin_cmd(
+            s, None
+        )),
     ]
 }
 
@@ -1006,6 +1147,18 @@ mod tests {
         st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().content_bounds()
     }
 
+    /// New from Clipboard takes the copied document's resolution (Photoshop's Clipboard preset),
+    /// so a later Image Size by resolution scales from the right size.
+    #[test]
+    fn new_from_clipboard_keeps_the_source_resolution() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 60, "height": 40, "resolution": 300})).unwrap();
+        s.execute("select.all", json!({})).unwrap();
+        s.execute("edit.copy", json!({})).unwrap();
+        s.execute("file.newFromClipboard", json!({})).unwrap();
+        assert_eq!(s.active().unwrap().doc.resolution_dpi, 300.0);
+    }
+
     /// #368: the clipboard as a document of its own, from New from Clipboard or a Paste with
     /// nothing open, at every depth.
     #[test]
@@ -1015,6 +1168,7 @@ mod tests {
             assert!(!s.is_enabled("file.newFromClipboard") && !s.is_enabled("edit.paste"), "nothing copied yet");
             assert!(s.execute("file.newFromClipboard", json!({})).is_err());
             s.execute("file.new", json!({"width": 100, "height": 100, "depth": depth})).unwrap();
+            assert!(!s.active().unwrap().is_dirty(), "an untouched blank document is clean");
             s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
             s.execute("select.rect", json!({"x": 10, "y": 20, "width": 30, "height": 15})).unwrap();
             s.execute("edit.copy", json!({})).unwrap();
@@ -1022,6 +1176,7 @@ mod tests {
             let r = s.execute("file.newFromClipboard", json!({})).unwrap();
             assert_eq!((r["width"].as_u64(), r["height"].as_u64()), (Some(30), Some(15)), "{r}");
             assert_eq!(s.documents().len(), 2);
+            assert!(s.active().unwrap().is_dirty(), "a document made from clipboard pixels needs saving (#4665)");
             let d = &s.active().unwrap().doc;
             assert_eq!((d.size.width, d.size.height, d.layers.len()), (30, 15, 1));
             assert_eq!(d.pixel_format().sample, s.documents()[0].doc.pixel_format().sample, "{depth}-bit kept");
@@ -1035,6 +1190,7 @@ mod tests {
             assert!(s.is_enabled("edit.paste") && !s.is_enabled("edit.pasteSpecial.pasteInPlace"));
             s.execute("edit.paste", json!({})).unwrap();
             assert_eq!(s.documents().len(), 1);
+            assert!(s.active().unwrap().is_dirty(), "Paste with no tab also needs a save prompt");
             assert_eq!(active_bounds(&s), Rect::new(0, 0, 30, 15));
             assert!(s.execute("edit.pasteSpecial.pasteInPlace", json!({})).is_ok(), "into the new document");
         }
@@ -1363,7 +1519,7 @@ mod tests {
             let mut s = fresh();
             s.execute(cmd, json!({})).unwrap();
             let d = &s.active().unwrap().doc;
-            assert!(crate::extra_cmds::is_background(&d.layers[0]), "{cmd}: still the Background");
+            assert!(d.is_background(d.layers[0].id), "{cmd}: still the Background");
             assert_eq!(px(&s, 0, 8, 8), vec![1.0, 0.0, 0.0, 1.0], "{cmd}: cut area is the background colour");
             assert_eq!(px(&s, 0, 30, 20), vec![1.0, 1.0, 1.0, 1.0], "{cmd}: outside untouched");
         }
@@ -1609,9 +1765,9 @@ mod tests {
         let st = s.active().unwrap();
         assert_eq!(st.doc.layers.len(), 4);
         let pasted = &st.doc.layers[st.doc.layers.len() - 2];
-        assert!(!crate::extra_cmds::is_background(pasted));
+        assert!(!st.doc.is_background(pasted.id));
         assert_eq!(pasted.locks, Default::default());
-        assert!(crate::extra_cmds::is_background(&st.doc.layers[0]), "the real Background is untouched");
+        assert!(st.doc.is_background(st.doc.layers[0].id), "the real Background is untouched");
     }
 
     /// #2428: a smart object copied in one document pastes into another as a smart object, in
@@ -1628,6 +1784,34 @@ mod tests {
         assert_eq!(active_bounds(&s), Rect::new(10, 10, 50, 30), "on the canvas: in place");
     }
 
+    /// #3584: a PSD-embedded linked smart object (its bytes in the document's `lnk2` block, its
+    /// source a uuid) can still be opened after Copy + Paste into another document.
+    #[test]
+    fn paste_keeps_a_psd_embedded_smart_object_openable() {
+        use std::sync::Arc;
+        let mut s = session();
+        s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+        let outer = s.active().unwrap().active_layer.unwrap();
+        s.edit("embedded linked source", |doc, _| {
+            let LayerContent::Smart(sm) = &mut doc.layer_mut(outer).ok_or(EngineError::NoDocument)?.content else {
+                return Err(EngineError::Other("not a smart object".into()));
+            };
+            sm.source = photocraft_doc::SmartSource::Linked { path: "uuid-1".into() };
+            let linked = photocraft_io::linked::LinkedFile { uuid: "uuid-1".into(), file_name: "in.png".into(), bytes: vec![1, 2, 3, 4] };
+            doc.metadata.psd_global_blocks.push((*b"8BIM", *b"lnk2", Arc::new(photocraft_io::linked::encode_linked_file(&linked))));
+            Ok(())
+        })
+        .unwrap();
+        s.execute("edit.copy", json!({})).unwrap();
+        s.execute("file.new", json!({"width": 40, "height": 30})).unwrap();
+        s.execute("edit.paste", json!({})).unwrap();
+        let LayerContent::Smart(sm) = active_content(&s) else { panic!("the paste is a smart object") };
+        assert!(
+            crate::smart_cmds::source_bytes(&s.active().unwrap().doc.metadata, &sm.source).is_some(),
+            "the pasted PSD-embedded linked source must resolve (#3584)"
+        );
+    }
+
     /// Type and shape layers copy their rendered pixels too; groups and adjustments have none.
     #[test]
     fn copy_reads_any_layer_that_shows_pixels() {
@@ -1769,6 +1953,28 @@ mod tests {
         assert!(s.execute("view.moveGuide", json!({"orientation": "vertical", "index": 3, "position": 1})).is_err());
     }
 
+    /// #2955: the rulers' zero point is set and reset by command, undoable, and bad params are
+    /// refused without touching the document.
+    #[test]
+    fn ruler_origin_is_set_reset_and_undoable() {
+        let mut s = session();
+        assert_eq!(s.active().unwrap().doc.ruler_origin, [0.0, 0.0]);
+        assert_eq!(s.execute("view.setRulerOrigin", json!({"x": 40, "y": 12.5})).unwrap(), json!({"x": 40.0, "y": 12.5}));
+        assert_eq!(s.active().unwrap().doc.ruler_origin, [40.0, 12.5]);
+        s.execute("view.resetRulerOrigin", json!({})).unwrap();
+        assert_eq!(s.active().unwrap().doc.ruler_origin, [0.0, 0.0]);
+        s.undo();
+        assert_eq!(s.active().unwrap().doc.ruler_origin, [40.0, 12.5]);
+        for bad in [json!({}), json!({"x": 1}), json!({"x": "a", "y": 2}), json!({"x": 1e300, "y": 0}), json!({"x": -2e7, "y": 0}), json!(null), json!([1, 2])]
+        {
+            assert!(s.execute("view.setRulerOrigin", bad.clone()).is_err(), "{bad} is refused");
+        }
+        assert_eq!(s.active().unwrap().doc.ruler_origin, [40.0, 12.5]);
+        let mut empty = Session::new();
+        assert!(empty.execute("view.setRulerOrigin", json!({"x": 1, "y": 2})).is_err());
+        assert!(empty.execute("view.resetRulerOrigin", json!({})).is_err());
+    }
+
     /// The last guide added in `orientation` for `position`.
     fn new_guide(s: &mut Session, orientation: &str, position: Value) -> f64 {
         s.execute("view.newGuide", json!({"orientation": orientation, "position": position})).unwrap();
@@ -1906,4 +2112,89 @@ mod tests {
         let back = photocraft_io::import("g.psd", &psd).unwrap().document.guides;
         assert_eq!(wide(back.vertical[0]), far, "1032 stores 1/32 px");
     }
+
+    /// `lift` as it was before #4516: the whole area through one `f32` buffer. The oracle for
+    /// the tiled version.
+    fn lift_reference(src: &Surface, sel: Option<&Surface>, canvas: Rect) -> Clip {
+        let fmt = src.format();
+        let with_alpha = PixelFormat::new(fmt.mode, fmt.sample, true);
+        let area = match sel {
+            Some(m) => m.content_bounds().intersect(&canvas),
+            None => src.content_bounds().intersect(&canvas),
+        };
+        let mut out = Surface::new(with_alpha);
+        if area.is_empty() {
+            return Clip { surface: out, bounds: Rect::EMPTY, layers: None, resolution: None };
+        }
+        let px = lift_region(src, sel, area, with_alpha.channels()).unwrap();
+        out.try_write_region(area, &px).unwrap();
+        out.prune();
+        let bounds = out.content_bounds();
+        Clip { surface: out, bounds, layers: None, resolution: None }
+    }
+
+    fn noise(fmt: PixelFormat, r: Rect, seed: u32) -> Surface {
+        let mut s = Surface::new(fmt);
+        let n = r.width() as usize * r.height() as usize * fmt.channels();
+        let data: Vec<f32> = (0..n as u32)
+            .map(|i| {
+                let mut h = seed.wrapping_mul(0x9e37_79b9) ^ i.wrapping_mul(0x85eb_ca6b);
+                h ^= h >> 13;
+                h = h.wrapping_mul(0xc2b2_ae35);
+                (h >> 16) as f32 / 65535.0
+            })
+            .collect();
+        s.write_region(r, &data);
+        s
+    }
+
+    fn assert_same_clip(a: &Clip, b: &Clip, what: &str) {
+        assert_eq!(a.bounds, b.bounds, "{what}: bounds");
+        assert_eq!(a.surface.format(), b.surface.format(), "{what}: format");
+        let r = a.bounds.union(&b.bounds);
+        if !r.is_empty() {
+            let (pa, pb) = (a.surface.read_region(r), b.surface.read_region(r));
+            assert!(pa.iter().zip(&pb).all(|(x, y)| x.to_bits() == y.to_bits()), "{what}: pixels differ");
+        }
+    }
+
+    /// The tiled `lift` gives exactly the old result (#4516): with and without alpha, at every
+    /// depth, with no selection, Select All, a partial feathered selection and a selection off
+    /// the tile grid, and for content reaching past the canvas.
+    #[test]
+    fn tiled_lift_matches_the_whole_area_lift() {
+        use photocraft_color::{ColorMode, SampleType};
+        let canvas = Rect::new(0, 0, 700, 600);
+        for sample in [SampleType::U8, SampleType::U16, SampleType::F32] {
+            for alpha in [true, false] {
+                let fmt = PixelFormat::new(ColorMode::Rgb, sample, alpha);
+                let src = noise(fmt, Rect::new(-40, -30, 760, 640), 7);
+                let mut all = Surface::new(PixelFormat::GRAY8);
+                all.fill_rect(canvas, &[1.0]);
+                let mut partial = Surface::new(PixelFormat::GRAY8);
+                partial.fill_rect(Rect::new(100, 50, 600, 550), &[1.0]);
+                partial.write_region(Rect::new(90, 40, 610, 50), &vec![0.5; 520 * 10]);
+                let off_grid = noise(PixelFormat::GRAY8, Rect::new(13, 270, 333, 290), 9);
+                for (name, sel) in [("no selection", None), ("select all", Some(&all)), ("partial", Some(&partial)), ("off grid", Some(&off_grid))] {
+                    let what = format!("{sample:?} alpha {alpha} {name}");
+                    let new = lift(&src, sel, canvas).unwrap();
+                    assert_same_clip(&new, &lift_reference(&src, sel, canvas), &what);
+                }
+            }
+        }
+    }
+
+    /// Copy shares the layer's whole tiles instead of copying them.
+    #[test]
+    fn copy_shares_whole_tiles_with_the_layer() {
+        let src = noise(PixelFormat::RGBA8, Rect::new(0, 0, 1024, 768), 3);
+        let canvas = Rect::new(0, 0, 1024, 768);
+        let mut all = Surface::new(PixelFormat::GRAY8);
+        all.fill_rect(canvas, &[1.0]);
+        for sel in [None, Some(&all)] {
+            let clip = lift(&src, sel, canvas).unwrap();
+            let shared = src.tiles().filter(|(c, t)| clip.surface.tile(**c).is_some_and(|o| std::sync::Arc::ptr_eq(o, t))).count();
+            assert_eq!(shared, src.tile_count(), "every tile is shared");
+        }
+    }
 }
diff --git a/crates/engine/src/edit_menu_cmds.rs b/crates/engine/src/edit_menu_cmds.rs
index 103a5edc6e..cda3de84d4 100644
--- a/crates/engine/src/edit_menu_cmds.rs
+++ b/crates/engine/src/edit_menu_cmds.rs
@@ -151,14 +151,14 @@ fn surface_of(doc: &Document, id: LayerId, mask: bool) -> Option<&Surface> {
 
 /// Blend `after` back towards `before` over `area`: `before + opacity × (B(before, after) − before)`
 /// with blend mode `mode` (premultiplied, so alpha changes fade too).
-pub fn fade_surface(before: &Surface, after: &mut Surface, area: Rect, mode: BlendMode, opacity: f32) {
+pub fn fade_surface(before: &Surface, after: &mut Surface, area: Rect, mode: BlendMode, opacity: f32) -> Result<()> {
     let fmt = after.format();
     let n = fmt.channels();
     if area.is_empty() || n == 0 {
-        return;
+        return Ok(());
     }
-    let b = before.read_region(area);
-    let mut a = after.read_region(area);
+    let b = crate::allocation::read_region(before, area, "fading pixels")?;
+    let mut a = crate::allocation::read_region(after, area, "fading pixels")?;
     let k = opacity.clamp(0.0, 1.0);
     let lerp_premul = |pb: &[f32], pa: &[f32], out: &mut [f32], alpha: bool| {
         let m = out.len();
@@ -176,7 +176,7 @@ pub fn fade_surface(before: &Surface, after: &mut Surface, area: Rect, mode: Ble
         }
         out[m - 1] = ao;
     };
-    let mut tmp = vec![0.0f32; n];
+    let mut tmp = crate::allocation::filled(n, 0.0f32, "fading pixels")?;
     for (pa, pb) in a.chunks_exact_mut(n).zip(b.chunks_exact(n)) {
         if mode == BlendMode::Normal || n == 1 {
             lerp_premul(pb, pa, &mut tmp, fmt.alpha);
@@ -192,7 +192,8 @@ pub fn fade_surface(before: &Surface, after: &mut Surface, area: Rect, mode: Ble
             pa.copy_from_slice(&enc[..n]);
         }
     }
-    after.write_region(area, &a);
+    after.try_write_region(area, &a)?;
+    Ok(())
 }
 
 fn fade(s: &mut Session, p: &Value) -> Result<Value> {
@@ -212,7 +213,7 @@ fn fade(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit(&label, |doc, _| {
         let l = doc.layer_mut(src.layer).ok_or(EngineError::NoLayer(src.layer))?;
         let surf = if src.mask { l.mask.as_mut().map(|m| &mut m.surface) } else { l.surface_mut() }.ok_or(EngineError::NoLayer(src.layer))?;
-        fade_surface(&before, surf, area, mode, opacity);
+        fade_surface(&before, surf, area, mode, opacity)?;
         surf.prune();
         Ok(())
     })?;
@@ -274,6 +275,11 @@ fn purge(s: &mut Session, what: &str) -> Result<Value> {
             freed = freed.saturating_add(stages);
             items.push("smart filter cache");
         }
+        let strokes = photocraft_compose::shape_split::purge_cache();
+        if strokes > 0 {
+            freed = freed.saturating_add(strokes);
+            items.push("shape stroke cache");
+        }
     }
     s.edit_state.fade = None;
     let msg = if items.is_empty() { "nothing to purge".to_string() } else { format!("purged {}", items.join(", ")) };
@@ -391,6 +397,13 @@ fn content_aware_fill_as(s: &mut Session, p: &Value, cmd: &'static str, label: &
     }
     let surf = doc.layer(id).and_then(|l| l.surface()).ok_or(EngineError::NoLayer(id))?;
     let fmt = surf.format();
+    // Photoshop's Sample All Layers checkbox is off unless the caller asks. When the active
+    // layer has no pixels in the window there is nothing to sample, so that case uses the
+    // visible composite (#4026). An explicit false still reads only this layer.
+    let sample_all = match p.get("sampleAllLayers").and_then(Value::as_bool) {
+        Some(v) => v,
+        None => surf.content_bounds().intersect(&window).is_empty(),
+    };
     let n = fmt.channels();
     // Refuse a window too large to read before allocating for it, whatever the sampling (#963).
     let (w, h) = crate::fill_cmds::window_size(window)?;
@@ -407,7 +420,18 @@ fn content_aware_fill_as(s: &mut Session, p: &Value, cmd: &'static str, label: &
             ctx.progress(0.0, label);
             let cancel = || ctx.cancelled();
             let surf = doc.layer(id).and_then(|l| l.surface()).ok_or(EngineError::NoLayer(id))?;
-            let img = read_window(surf, window, &cancel).ok_or(EngineError::Cancelled)?;
+            let img = if sample_all {
+                if cancel() {
+                    return Err(EngineError::Cancelled);
+                }
+                let region = crate::retouch_cmds::composite_region(&doc, None, crate::retouch_cmds::SampleLayers::All, window, fmt);
+                if cancel() {
+                    return Err(EngineError::Cancelled);
+                }
+                region.data
+            } else {
+                read_window(surf, window, &cancel).ok_or(EngineError::Cancelled)?
+            };
             let hole = read_window_cover(&sel, window, &cancel).ok_or(EngineError::Cancelled)?;
             let mut source = match (sampling.as_str(), custom_rect, custom_mask.as_ref()) {
                 ("custom", Some(r), _) => (0..w * h).into_par_iter().map(|i| r.contains(window.x0 + (i % w) as i32, window.y0 + (i / w) as i32)).collect(),
@@ -894,6 +918,7 @@ fn find_replace(s: &mut Session, p: &Value) -> Result<Value> {
                 && let Some((id, a, b)) = cursor
                 && text_of(&doc, id).is_some_and(|t| find_matches(&t, &find, case, whole).contains(&(a, b)))
             {
+                crate::type_cmds::check_text_unlocked(&doc, id)?;
                 s.edit("Replace Text", |doc, _| {
                     let snapshot = doc.clone();
                     if let Some(LayerContent::Text(t)) = doc.layer_mut(id).map(|l| &mut l.content) {
@@ -903,7 +928,10 @@ fn find_replace(s: &mut Session, p: &Value) -> Result<Value> {
                     Ok(())
                 })?;
                 let end = a + replace.len();
-                s.edit_state.find_cursor = Some((id, end, end));
+                // Collapse the cursor on the side the search moves away from, so the next search
+                // skips the replaced text even when the replacement still matches.
+                let c = if forward { end } else { a };
+                s.edit_state.find_cursor = Some((id, c, c));
                 changed = Some((id, a, end));
                 if action == "change" {
                     return Ok(json!({"changed": {"layer": id.0, "start": a, "end": end}}));
@@ -1135,7 +1163,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Content-Aware Fill…",
             ["Edit"],
             None,
-            r##"{"sampling":"auto|rectangular|custom","margin":px?,"area":[x,y,w,h]?,"channel":index|name?,"colorAdaptation":"default|none|high|veryHigh","rotationAdaptation":"none|low|medium|high|full","scale":bool=false,"mirror":bool=false,"output":"current|new|duplicate","seed":u64=1}"##,
+            r##"{"sampling":"auto|rectangular|custom","margin":px?,"area":[x,y,w,h]?,"channel":index|name?,"colorAdaptation":"default|none|high|veryHigh","rotationAdaptation":"none|low|medium|high|full","scale":bool=false,"mirror":bool=false,"sampleAllLayers":bool=false,"output":"current|new|duplicate","seed":u64=1}"##,
             can_caf,
             content_aware_fill
         ),
diff --git a/crates/engine/src/edit_menu_cmds/tests.rs b/crates/engine/src/edit_menu_cmds/tests.rs
index 7b58891a82..f7c2f23e83 100644
--- a/crates/engine/src/edit_menu_cmds/tests.rs
+++ b/crates/engine/src/edit_menu_cmds/tests.rs
@@ -218,6 +218,38 @@ fn delete_and_fill_selection_removes_the_object_in_one_step() {
     assert!(s.execute("edit.deleteAndFillSelection", json!({})).is_err());
 }
 
+#[test]
+fn content_aware_fill_on_an_empty_layer_samples_the_composite() {
+    let mut s = blob_session(8);
+    s.execute("layer.new.layer", json!({})).unwrap();
+    let empty = s.active().unwrap().active_layer.unwrap();
+    assert_eq!(px(&s, 30, 20)[3], 0.0, "the new layer has no paint");
+    let r = s.execute("edit.contentAwareFill", json!({"colorAdaptation": "none"})).unwrap();
+    assert!(r["filled"].as_u64().unwrap() > 0);
+    assert_eq!(s.active().unwrap().active_layer, Some(empty));
+    assert!(px(&s, 30, 20)[3] > 0.5, "the hole is filled from the layers underneath");
+    s.undo();
+    let missed = s.execute("edit.contentAwareFill", json!({"sampleAllLayers": false, "colorAdaptation": "none"})).unwrap();
+    assert!(missed["filled"].as_u64().unwrap() > 0);
+    assert!(px(&s, 30, 20)[3] < 0.05, "sampling only the empty layer leaves it empty");
+}
+
+#[test]
+fn content_aware_fill_on_an_empty_cmyk_layer_uses_the_layer_format() {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 48, "height": 36, "mode": "cmyk", "background": "white"})).unwrap();
+    s.execute("select.rect", json!({"x": 16, "y": 12, "width": 12, "height": 10})).unwrap();
+    s.execute("layer.new.layer", json!({})).unwrap();
+    let before = px(&s, 20, 16);
+    assert!(before.iter().all(|c| *c < 0.05), "the new CMYK layer is empty: {before:?}");
+    s.execute("edit.contentAwareFill", json!({"colorAdaptation": "none"})).unwrap();
+    let v = px(&s, 20, 16);
+    assert_eq!(v.len(), before.len());
+    // White in the layer's CMYK is near zero ink with a covered alpha, not the compositor's RGBA.
+    assert!(v[..4].iter().all(|c| *c < 0.15), "CMYK ink stayed low: {v:?}");
+    assert!(v.last().copied().unwrap_or(0.0) > 0.5, "the hole is covered: {v:?}");
+}
+
 #[test]
 fn content_aware_fill_samples_photoshops_window() {
     // A 50 px selection samples the 200 px square centred on it (Photoshop 25.4's overlay);
@@ -446,6 +478,27 @@ fn find_and_replace_across_type_layers() {
     assert!(s.execute("edit.findAndReplaceText", json!({"find": ""})).is_err());
 }
 
+#[test]
+fn find_and_replace_change_rejects_a_layer_locked_after_the_find() {
+    // #4188: the found match's layer gets Lock All before Change; the text must stay.
+    let mut s = session(8);
+    let id = s.execute("type.create", json!({"text": "abc", "x": 2, "y": 12})).unwrap()["layer"].as_u64().unwrap();
+    // A second, unlocked type layer keeps the command enabled.
+    s.execute("type.create", json!({"text": "zzz", "x": 2, "y": 40})).unwrap();
+    let found = s.execute("edit.findAndReplaceText", json!({"find": "abc", "action": "find"})).unwrap();
+    assert_eq!(found["found"]["layer"].as_u64(), Some(id));
+    s.execute("layer.setProps", json!({"layer": id, "locked": true})).unwrap();
+    let history = s.active().unwrap().history.past_len();
+    let result = s.execute("edit.findAndReplaceText", json!({"find": "abc", "replace": "x", "action": "change"}));
+    assert!(matches!(&result, Err(EngineError::Other(message)) if message.contains("locked")), "{result:?}");
+    let text = match &s.active().unwrap().doc.layer(LayerId(id)).unwrap().content {
+        LayerContent::Text(t) => t.text.clone(),
+        _ => String::new(),
+    };
+    assert_eq!(text, "abc");
+    assert_eq!(s.active().unwrap().history.past_len(), history);
+}
+
 #[test]
 fn find_in_the_active_layer_finds_nothing_when_it_is_not_type() {
     // #703: `allLayers: false` with a raster layer active leaves nothing to search.
@@ -468,3 +521,46 @@ fn find_in_the_active_layer_finds_nothing_when_it_is_not_type() {
     let r = s.execute("edit.findAndReplaceText", json!({"find": "abc", "allLayers": false, "action": "find"})).unwrap();
     assert_eq!((r["found"]["layer"].as_u64(), r["found"]["text"].as_str()), (Some(id), Some("abc")));
 }
+
+#[test]
+fn backward_change_find_moves_past_the_replaced_text() {
+    // A backward Change/Find whose replacement still matches ("cat" -> "Cat", case-insensitive)
+    // must move on to the previous match, not find the replaced text again.
+    let mut s = session(8);
+    s.execute("type.create", json!({"text": "cat dog cat", "x": 2, "y": 12})).unwrap();
+    let p = |action: &str, forward: bool| json!({"find": "cat", "replace": "Cat", "action": action, "forward": forward, "allLayers": false});
+    let f = s.execute("edit.findAndReplaceText", p("find", false)).unwrap();
+    assert_eq!((f["found"]["start"].as_u64(), f["found"]["end"].as_u64()), (Some(8), Some(11)), "{f}");
+    let r = s.execute("edit.findAndReplaceText", p("changeFind", false)).unwrap();
+    assert_eq!((r["changed"]["start"].as_u64(), r["changed"]["end"].as_u64()), (Some(8), Some(11)), "{r}");
+    assert_eq!((r["found"]["start"].as_u64(), r["found"]["end"].as_u64()), (Some(0), Some(3)), "{r}");
+
+    // Forward is unchanged: replace the first match, then find the next one.
+    let mut s = session(8);
+    s.execute("type.create", json!({"text": "cat dog cat", "x": 2, "y": 12})).unwrap();
+    let f = s.execute("edit.findAndReplaceText", p("find", true)).unwrap();
+    assert_eq!(f["found"]["start"].as_u64(), Some(0), "{f}");
+    let r = s.execute("edit.findAndReplaceText", p("changeFind", true)).unwrap();
+    assert_eq!((r["changed"]["start"].as_u64(), r["changed"]["end"].as_u64()), (Some(0), Some(3)), "{r}");
+    assert_eq!((r["found"]["start"].as_u64(), r["found"]["end"].as_u64()), (Some(8), Some(11)), "{r}");
+}
+
+#[test]
+fn fade_allocation_failure_keeps_document_and_history() {
+    for depth in [8, 16, 32] {
+        let mut s = session(depth);
+        s.execute("edit.fill", json!({"color": "#000000"})).unwrap();
+        let before = s.active().unwrap().doc.clone();
+        let history = s.active().unwrap().history.entries();
+        crate::allocation::fail_next_for_test();
+        let result = s.execute("edit.fade", json!({"opacity": 25}));
+        let _ = crate::allocation::capacity::<u8>(0, "reset failpoint");
+        assert!(result.is_err());
+        assert_eq!(*s.active().unwrap().doc, *before);
+        assert_eq!(s.active().unwrap().history.entries(), history);
+        assert!(s.is_enabled("edit.fade"));
+        s.execute("edit.fade", json!({"opacity": 25})).unwrap();
+        assert!(s.undo());
+        assert_eq!(*s.active().unwrap().doc, *before);
+    }
+}
diff --git a/crates/engine/src/eraser_cmds.rs b/crates/engine/src/eraser_cmds.rs
index 98169aff72..920c96a014 100644
--- a/crates/engine/src/eraser_cmds.rs
+++ b/crates/engine/src/eraser_cmds.rs
@@ -27,7 +27,9 @@ fn flag(p: &Value, k: &str, d: bool) -> bool {
 }
 
 /// A finite number param clamped to `range`, `default` when absent; non-numbers are an error.
-fn number(p: &Value, cmd: &str, k: &str, default: f64, range: std::ops::RangeInclusive<f64>) -> Result<f64> {
+/// A numeric param clamped to `range`; missing or null gives `default`, anything else not a
+/// finite number is BadParams. Shared with the Paint Bucket and Gradient opacity.
+pub(crate) fn number(p: &Value, cmd: &str, k: &str, default: f64, range: std::ops::RangeInclusive<f64>) -> Result<f64> {
     match p.get(k) {
         None | Some(Value::Null) => Ok(default),
         Some(v) => {
@@ -59,19 +61,6 @@ fn active_pixel_layer(s: &Session, cmd: &str) -> Result<LayerId> {
     s.active().and_then(|d| d.active_layer).ok_or_else(|| bad(cmd, "no active layer"))
 }
 
-fn is_background(l: &Layer) -> bool {
-    l.name == "Background" && l.locks.transparency && l.locks.position && matches!(l.content, LayerContent::Raster(_))
-}
-
-/// Photoshop converts the Background to a normal layer before erasing to transparency.
-fn unlock_background(l: &mut Layer) {
-    if is_background(l) {
-        l.name = "Layer 0".into();
-        l.locks.transparency = false;
-        l.locks.position = false;
-    }
-}
-
 fn pixels_locked(doc: &Document, l: &Layer) -> Option<EngineError> {
     let locks = doc.effective_locks(l.id);
     (locks.pixels || locks.all).then(|| EngineError::Other(format!("Could not complete your request because the layer \"{}\" is locked", l.name)))
@@ -114,7 +103,9 @@ fn magic_eraser(s: &mut Session, p: &Value) -> Result<Value> {
     let bg = s.tools.background;
     let dmg = s.edit("Magic Eraser", |doc, _| {
         let selection = doc.selection.clone();
-        unlock_background(doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?);
+        // Photoshop converts the Background to a normal layer before erasing to transparency.
+        doc.layer(id).ok_or(EngineError::NoLayer(id))?;
+        crate::extra_cmds::background_to_layer(doc, id);
         let lock = doc.effective_locks(id).transparency;
         let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
         let surf = l.surface_mut().ok_or_else(|| bad(CMD, "not a pixel layer"))?;
@@ -149,15 +140,15 @@ fn background_eraser(s: &mut Session, p: &Value) -> Result<Value> {
         if let Some(e) = pixels_locked(&d.doc, l) {
             return Err(e);
         }
-        if d.doc.effective_locks(id).transparency && !is_background(l) {
+        if d.doc.effective_locks(id).transparency && !d.doc.is_background(id) {
             return Err(EngineError::Other(format!("Could not use the Background Eraser because the transparency of layer \"{}\" is locked", l.name)));
         }
     }
     let stroke = Stroke { brush, points: pts };
     let dmg = s.edit("Background Eraser", |doc, _| {
         let selection = doc.selection.clone();
+        crate::extra_cmds::background_to_layer(doc, id);
         let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
-        unlock_background(l);
         let surf = l.surface_mut().ok_or_else(|| bad(CMD, "not a pixel layer"))?;
         Ok(apply_background_eraser(surf, &stroke, &bs, selection.as_ref()))
     })?;
diff --git a/crates/engine/src/exr_cmds.rs b/crates/engine/src/exr_cmds.rs
index c0a3310f9f..908942d4fd 100644
--- a/crates/engine/src/exr_cmds.rs
+++ b/crates/engine/src/exr_cmds.rs
@@ -210,6 +210,46 @@ mod tests {
         std::fs::remove_dir_all(&dir).unwrap();
     }
 
+    /// A single-part EXR with no part name (the usual render output) plus an AOV group.
+    fn write_unnamed_grouped(path: &std::path::Path) {
+        use exr::prelude::*;
+        let (w, h) = (4usize, 4usize);
+        let mk = |n: &str, v: f32| AnyChannel::new(n, FlatSamples::F32(vec![v; w * h]));
+        let list = vec![mk("R", 0.7), mk("G", 0.7), mk("B", 0.7), mk("diffuse.R", 0.3), mk("diffuse.G", 0.3), mk("diffuse.B", 0.3)];
+        let layer = Layer::new(
+            (w, h),
+            LayerAttributes::default(),
+            Encoding { compression: Compression::Uncompressed, blocks: Blocks::ScanLines, line_order: LineOrder::Increasing },
+            AnyChannels::sort(list.into_iter().collect()),
+        );
+        let image = Image::from_layers(ImageAttributes::new(IntegerBounds::new((0, 0), (w, h))), vec![layer]);
+        image.write().to_buffered(&mut std::io::BufWriter::new(std::fs::File::create(path).expect("create fixture"))).expect("write fixture");
+    }
+
+    #[test]
+    fn an_unnamed_part_opens_by_the_name_the_listing_gives_it() {
+        // #4210: the listing names an unnamed part "part 0"; feeding that name back must open it.
+        let dir = std::env::temp_dir().join(format!("pcraft-exr-unnamed-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("unnamed.exr");
+        write_unnamed_grouped(&path);
+        let info = entries_json(path.to_str().unwrap()).unwrap();
+        let part = info.as_array().unwrap().iter().find(|e| e["kind"] == "part").expect("a part entry");
+        let name = part["name"].as_str().unwrap();
+        assert_eq!(name, "part 0", "{info}");
+        let key = format!("part/{name}");
+        let mut s = session();
+        s.execute("file.openExrParts", json!({"path": path.to_str().unwrap(), key: true})).unwrap();
+        let doc = &s.active().unwrap().doc;
+        assert_eq!(doc.layers.len(), 1);
+        assert_eq!(doc.layers[0].name, "part 0");
+        if let photocraft_doc::LayerContent::Raster(surface) = &doc.layers[0].content {
+            let px = surface.pixel(0, 0);
+            assert!((px[0] - 0.7).abs() < 1e-4, "{:?}", px);
+        }
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
     #[test]
     fn precomp_sums_the_light_path_set_and_refuses_an_incomplete_one() {
         let dir = std::env::temp_dir().join(format!("pcraft-exr-precomp-{}", std::process::id()));
diff --git a/crates/engine/src/extra_cmds.rs b/crates/engine/src/extra_cmds.rs
index f25ea9a2e9..1f3748d7b9 100644
--- a/crates/engine/src/extra_cmds.rs
+++ b/crates/engine/src/extra_cmds.rs
@@ -43,13 +43,9 @@ fn has_clip_and_selection(s: &Session) -> std::result::Result<(), String> {
     d.doc.selection.as_ref().map(|_| ()).ok_or_else(|| "Paste Into needs a selection".into())
 }
 
-pub(crate) fn is_background(l: &Layer) -> bool {
-    l.name == "Background" && l.locks.transparency && l.locks.position && matches!(l.content, LayerContent::Raster(_))
-}
-
 fn has_background(s: &Session) -> std::result::Result<(), String> {
     let d = s.active().ok_or("no document open")?;
-    d.doc.layers.first().filter(|l| is_background(l)).map(|_| ()).ok_or_else(|| "the document has no Background layer".into())
+    d.doc.background().map(|_| ()).ok_or_else(|| "the document has no Background layer".into())
 }
 
 /// The layers a layer-style command acts on: as [`crate::layer_multi_cmds::targets`], but with
@@ -60,7 +56,7 @@ pub(crate) fn style_targets(s: &Session, p: &Value, fits: impl Fn(&Layer) -> boo
         return Ok(ids);
     }
     let d = s.active().ok_or(EngineError::NoDocument)?;
-    let ids: Vec<LayerId> = ids.into_iter().filter(|id| d.doc.layer(*id).is_some_and(|l| !is_background(l) && fits(l))).collect();
+    let ids: Vec<LayerId> = ids.into_iter().filter(|id| d.doc.layer(*id).is_some_and(|l| !d.doc.is_background(l.id) && fits(l))).collect();
     if ids.is_empty() {
         return Err(EngineError::Other("none of the selected layers can take this layer style change".into()));
     }
@@ -140,6 +136,8 @@ fn stroke(s: &mut Session, p: &Value) -> Result<Value> {
     // Whole pixels, rounded up, as in Photoshop (0.5 px strokes 1 px).
     let width = p.get("width").and_then(Value::as_f64).filter(|w| w.is_finite()).unwrap_or(1.0).clamp(1.0, 250.0).ceil() as usize;
     let color = color_param(p, "color", s.tools.foreground);
+    // A colour picked as CMYK strokes a CMYK document with the picked inks (#4196).
+    let picked = s.tools.picked_cmyk([color[0], color[1], color[2]]);
     let mode = match p.get("mode") {
         None | Some(Value::Null) => photocraft_color::BlendMode::Normal,
         Some(Value::String(m)) => crate::commands::blend_from_str(m)
@@ -218,7 +216,7 @@ fn stroke(s: &mut Session, p: &Value) -> Result<Value> {
         let surf = crate::commands::paint_surface(doc, id, &Value::Null)?;
         let area = band.content_bounds().intersect(&canvas);
         if !area.is_empty() {
-            crate::fill_cmds::blend_color_mask(surf, area, color, &band, mode, opacity, preserve || lock)?;
+            crate::fill_cmds::blend_color_mask(surf, area, color, picked, &band, mode, opacity, preserve || lock)?;
             surf.prune();
         }
         Ok(())
@@ -439,11 +437,20 @@ pub fn reveal_all_bounds(doc: &Document) -> Rect {
 
 // ---------- layers ----------
 
-fn layer_from_background(s: &mut Session) -> Result<Value> {
+fn layer_from_background(s: &mut Session, p: &Value) -> Result<Value> {
+    let d = s.active().ok_or(EngineError::NoDocument)?;
+    if d.doc.background().is_none() && p.get("ifPresent").and_then(Value::as_bool) == Some(true) {
+        return Ok(json!({"layer": null}));
+    }
+    // `select: false`: the targeted layer stays targeted, as when a Photoshop action's `set`
+    // names the Background while another layer is selected.
+    let select = p.get("select").and_then(Value::as_bool).unwrap_or(true);
     let id = s.edit("Layer From Background", |doc, active| {
-        let l = doc.layers.first_mut().filter(|l| is_background(l)).ok_or(EngineError::Other("the document has no Background layer".into()))?;
+        let l = doc.background_mut().ok_or(EngineError::Other("the document has no Background layer".into()))?;
         unlock_background(l);
-        *active = Some(l.id);
+        if select || active.is_none() {
+            *active = Some(l.id);
+        }
         Ok(l.id)
     })?;
     Ok(json!({"layer": id.0}))
@@ -458,7 +465,14 @@ pub(crate) fn unlock_background(l: &mut Layer) {
 /// Before `id` gets a layer mask: the Background can't have one, so it becomes a normal layer
 /// first ("Layer 0"), as when adding a mask to it in Photoshop. Other layers are left alone.
 pub(crate) fn background_to_layer_for_mask(doc: &mut photocraft_doc::Document, id: photocraft_doc::LayerId) {
-    if let Some(l) = doc.layers.first_mut().filter(|l| l.id == id && is_background(l)) {
+    background_to_layer(doc, id);
+}
+
+/// If `id` is the Background ([`photocraft_doc::Document::background`], whatever its name), turns
+/// it into a normal layer ("Layer 0"), as Photoshop does before an edit the Background can't
+/// take (moving, transforming, exposing transparency, a style). Other layers are left alone.
+pub(crate) fn background_to_layer(doc: &mut photocraft_doc::Document, id: photocraft_doc::LayerId) {
+    if let Some(l) = doc.background_mut().filter(|l| l.id == id) {
         unlock_background(l);
     }
 }
@@ -563,6 +577,35 @@ fn set_visible(s: &mut Session, p: &Value, visible: bool) -> Result<Value> {
     Ok(Value::Null)
 }
 
+/// Layer › Hide Layers (⌘,): hide the targeted layers, or show them when every one is already
+/// hidden, as Photoshop's item does (it reads Show Layers then), so ⌘, toggles.
+fn hide_or_show(s: &mut Session, p: &Value) -> Result<Value> {
+    let st = s.active().ok_or(EngineError::NoDocument)?;
+    let targets = if crate::layer_multi_cmds::multi(s, p) { crate::layer_multi_cmds::selected(s) } else { vec![layer_param(s, p)?] };
+    let all_hidden = targets.iter().all(|id| st.doc.layer(*id).is_some_and(|l| !l.visible));
+    set_visible(s, p, all_hidden)
+}
+
+/// `/`: Lock Transparent Pixels on or off for the targeted layers, as the Layers panel's first lock
+/// button does. With several layers targeted, any unlocked one means lock them all. The
+/// Background, which can't take this lock, is left out.
+fn toggle_lock_transparency(s: &mut Session, p: &Value) -> Result<Value> {
+    let st = s.active().ok_or(EngineError::NoDocument)?;
+    let targets: Vec<LayerId> = if crate::layer_multi_cmds::multi(s, p) { crate::layer_multi_cmds::selected(s) } else { vec![layer_param(s, p)?] };
+    let targets: Vec<LayerId> = targets.into_iter().filter(|id| st.doc.layer(*id).is_some_and(|l| !st.doc.is_background(l.id))).collect();
+    if targets.is_empty() {
+        return Err(EngineError::Other("the Background layer can't lock transparent pixels".into()));
+    }
+    let lock = !targets.iter().all(|id| st.doc.layer(*id).is_some_and(|l| l.locks.transparency));
+    s.edit(if lock { "Lock Transparent Pixels" } else { "Unlock Transparent Pixels" }, |doc, _| {
+        for id in &targets {
+            doc.layer_mut(*id).ok_or(EngineError::NoLayer(*id))?.locks.transparency = lock;
+        }
+        Ok(())
+    })?;
+    Ok(json!({"locked": lock}))
+}
+
 /// Is the layer at `path` shown alone: it and its enclosing groups visible, every layer outside
 /// it hidden (the layers inside a group keep their own visibility)?
 fn shown_alone(doc: &Document, path: &[usize]) -> bool {
@@ -664,15 +707,42 @@ fn rasterize_content(s: &mut Session, id: LayerId, only: Option<&str>, key: &str
         "shape" => {
             s.execute("layer.rasterize.shape", json!({"layer": id.0, "coalesce": key}))?;
         }
-        _ => {
-            let label = if kind == "fill" { "Rasterize Fill Content" } else { "Rasterize Smart Object" };
+        "smart" => {
             s.coalesce_request = Some(key.to_string());
-            let r = s.edit(label, |doc, _| {
+            let r = s.edit("Rasterize Smart Object", |doc, _| {
+                let snapshot = doc.clone();
+                let mut snap = doc.layer(id).cloned().ok_or(EngineError::NoLayer(id))?;
+                if matches!(snap.content, LayerContent::Smart(ref sm) if sm.cache.is_none()) {
+                    let _ = crate::smart_cmds::refresh_layer(&snapshot, &mut snap);
+                }
+                let fmt = snapshot.pixel_format();
+                let surface = match &mut snap.content {
+                    LayerContent::Smart(sm) => match sm.cache.take() {
+                        Some(c) => c,
+                        None => content_pixels(&snapshot, &snap),
+                    },
+                    _ => return Err(EngineError::Other(format!("layer {} is not a smart object", id.0))),
+                };
+                let surface = if surface.format() == fmt { surface } else { surface.convert(fmt) };
+                let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
+                l.content = LayerContent::Raster(surface);
+                l.psd_blocks.retain(|(k, _)| k != b"SoLd" && k != b"SoLE" && k != b"PlLd");
+                Ok(())
+            });
+            s.coalesce_request = None;
+            r?;
+        }
+        _ => {
+            s.coalesce_request = Some(key.to_string());
+            let r = s.edit("Rasterize Fill Content", |doc, _| {
                 let snap = doc.layer(id).cloned().ok_or(EngineError::NoLayer(id))?;
                 let px = content_pixels(doc, &snap);
                 let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
                 l.content = LayerContent::Raster(px);
                 l.fill_cache = None;
+                // The PSD fill or placed-layer blocks no longer describe the layer: kept, they
+                // would reopen it as a fill layer or smart object and drop these pixels.
+                l.psd_blocks.retain(|(k, _)| !matches!(k, b"SoCo" | b"GdFl" | b"PtFl" | b"SoLd" | b"PlLd" | b"SoLE"));
                 Ok(())
             });
             s.coalesce_request = None;
@@ -797,7 +867,15 @@ pub fn specs() -> Vec<CommandSpec> {
             s.execute("image.crop", json!({"x": all.x0, "y": all.y0, "width": all.width(), "height": all.height(), "deleteCroppedPixels": false}))?;
             Ok(json!({"changed": true}))
         }),
-        spec!("layer.new.layerFromBackground", "Layer From Background…", &["Layer", "New"], None, "{}", has_background, |s, _| layer_from_background(s)),
+        spec!(
+            "layer.new.layerFromBackground",
+            "Layer From Background…",
+            &["Layer", "New"],
+            None,
+            r##"{"ifPresent":bool=false (true: a document without a Background is left as it is, as a Photoshop action's step needs on an image that opened as a normal layer),"select":bool=true (false: the targeted layer stays targeted)}"##,
+            has_background,
+            layer_from_background
+        ),
         spec!("layer.layerStyle.copyLayerStyle", "Copy Layer Style", &["Layer", "Layer Style"], None, r##"{"layer":id?}"##, has_layer, |s, p| {
             let id = layer_param(s, p)?;
             let l = s.active().and_then(|d| d.doc.layer(id)).ok_or(EngineError::NoLayer(id))?;
@@ -910,8 +988,25 @@ pub fn specs() -> Vec<CommandSpec> {
             },
             ungroup
         ),
-        spec!("layer.hideLayers", "Hide Layers", &["Layer"], Some("Cmd+,"), r##"{"layer":id?}"##, has_layer, |s, p| set_visible(s, p, false)),
+        spec!(
+            "layer.hideLayers",
+            "Hide Layers",
+            &["Layer"],
+            Some("Cmd+,"),
+            r##"{"layer":id?} (shows them instead when every targeted layer is already hidden, so ⌘, toggles)"##,
+            has_layer,
+            hide_or_show
+        ),
         spec!("layer.showLayers", "Show Layers", &[], None, r##"{"layer":id?}"##, has_layer, |s, p| set_visible(s, p, true)),
+        spec!(
+            "layer.toggleLockTransparency",
+            "Lock Transparent Pixels",
+            &[],
+            Some("/"),
+            r##"{"layer":id?} (toggles; several layers selected: locks them all unless every one is locked)"##,
+            has_layer,
+            toggle_lock_transparency
+        ),
         spec!(
             "layer.showOnly",
             "Show Only This Layer",
@@ -1490,6 +1585,48 @@ mod tests {
         assert_eq!(doc(&s).layers[0].name, "Background");
     }
 
+    #[test]
+    fn hide_layers_toggles_once_every_target_is_hidden() {
+        let mut s = session(8);
+        s.execute("layer.new.layer", json!({})).unwrap();
+        let b = active(&s).id;
+        let visible = |s: &Session| doc(s).layer(b).unwrap().visible;
+        // Select › All Layers leaves out the Background, as in Photoshop.
+        let all = |s: &Session| crate::layer_multi_cmds::selected(s).iter().map(|id| doc(s).layer(*id).unwrap().visible).collect::<Vec<_>>();
+        s.execute("layer.hideLayers", json!({})).unwrap();
+        assert!(!visible(&s));
+        s.execute("layer.hideLayers", json!({})).unwrap();
+        assert!(visible(&s), "⌘, again shows it");
+        // Several selected: any one still shown means hide them all; then they all come back.
+        s.execute("layer.hideLayers", json!({"layer": b.0})).unwrap();
+        s.execute("select.allLayers", json!({})).unwrap();
+        assert!(all(&s).len() > 1);
+        s.execute("layer.hideLayers", json!({})).unwrap();
+        assert!(all(&s).iter().all(|v| !v));
+        s.execute("layer.hideLayers", json!({})).unwrap();
+        assert!(all(&s).iter().all(|v| *v));
+    }
+
+    #[test]
+    fn slash_toggles_lock_transparent_pixels_but_not_on_the_background() {
+        let mut s = session(8);
+        let bg = doc(&s).layers[0].id;
+        assert!(doc(&s).is_background(bg));
+        s.execute("layer.new.layer", json!({})).unwrap();
+        let top = active(&s).id;
+        let locked = |s: &Session, id: LayerId| doc(s).layer(id).unwrap().locks.transparency;
+        assert_eq!(s.execute("layer.toggleLockTransparency", json!({})).unwrap()["locked"], true);
+        assert!(locked(&s, top));
+        s.execute("layer.toggleLockTransparency", json!({})).unwrap();
+        assert!(!locked(&s, top));
+        s.undo();
+        assert!(locked(&s, top), "one undoable step each");
+        let bg_locks = doc(&s).layer(bg).unwrap().locks;
+        assert!(s.execute("layer.toggleLockTransparency", json!({"layer": bg.0})).is_err());
+        assert_eq!(doc(&s).layer(bg).unwrap().locks, bg_locks, "the Background is left alone");
+        assert!(s.execute("layer.toggleLockTransparency", json!({"layer": 999_999})).is_err());
+    }
+
     #[test]
     fn layer_utilities() {
         let mut s = session(8);
@@ -1561,4 +1698,56 @@ mod tests {
         assert_eq!(s.active().unwrap().history.past_len(), steps + 1);
         assert!(doc(&s).walk().iter().all(|(_, _, l)| !matches!(l.content, LayerContent::Fill(_))));
     }
+
+    #[test]
+    fn rasterize_smart_object_layer() {
+        let mut s = session(8);
+        s.execute("edit.fill", json!({"contents": "color", "color": "#ff0000"})).unwrap();
+        let px_before = pixel(&s, 5, 5);
+        s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+        assert!(matches!(active(&s).content, LayerContent::Smart(_)));
+        s.execute("layer.rasterize.smartObject", json!({})).unwrap();
+        assert!(matches!(active(&s).content, LayerContent::Raster(_)));
+        let px_after = pixel(&s, 5, 5);
+        assert_eq!(px_after, px_before);
+
+        // Case 2: New layer above background
+        let mut s2 = session(8);
+        s2.execute("layer.new.layer", json!({})).unwrap();
+        s2.execute("select.rect", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+        s2.execute("edit.fill", json!({"contents": "color", "color": "#00ff00"})).unwrap();
+        s2.execute("select.deselect", json!({})).unwrap();
+        let px_mid = pixel(&s2, 20, 20);
+        assert_eq!(px_mid[1], 1.0); // green
+        s2.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+        assert!(matches!(active(&s2).content, LayerContent::Smart(_)));
+        s2.execute("layer.rasterize.smartObject", json!({})).unwrap();
+        assert!(matches!(active(&s2).content, LayerContent::Raster(_)));
+        let px_after_rast = pixel(&s2, 20, 20);
+        assert_eq!(px_after_rast, px_mid);
+
+        // Case 3: Shape layer converted to smart object then rasterized
+        let mut s3 = session(8);
+        s3.execute("shape.create", json!({"kind": "rect", "rect": [10, 10, 40, 40], "fill": "#0000ff"})).unwrap();
+        let px_shape = pixel(&s3, 20, 20);
+        s3.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+        assert!(matches!(active(&s3).content, LayerContent::Smart(_)));
+        s3.execute("layer.rasterize.layer", json!({})).unwrap();
+        assert!(matches!(active(&s3).content, LayerContent::Raster(_)));
+        let px_after_shape = pixel(&s3, 20, 20);
+        assert_eq!(px_after_shape, px_shape);
+
+        // Case 4: Transformed smart object
+        let mut s4 = session(8);
+        s4.execute("layer.new.layer", json!({})).unwrap();
+        s4.execute("select.rect", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+        s4.execute("edit.fill", json!({"contents": "color", "color": "#ffff00"})).unwrap();
+        s4.execute("select.deselect", json!({})).unwrap();
+        s4.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+        // Move smart object by 10, 10
+        s4.execute("edit.transform", json!({"matrix": [1, 0, 0, 1, 10, 10]})).unwrap();
+        s4.execute("layer.rasterize.smartObject", json!({})).unwrap();
+        assert!(matches!(active(&s4).content, LayerContent::Raster(_)));
+        assert_eq!(pixel(&s4, 30, 30), vec![1.0, 1.0, 0.0, 1.0]);
+    }
 }
diff --git a/crates/engine/src/file_cmds.rs b/crates/engine/src/file_cmds.rs
index 6e4bf49f11..7689f39679 100644
--- a/crates/engine/src/file_cmds.rs
+++ b/crates/engine/src/file_cmds.rs
@@ -20,6 +20,8 @@ use serde_json::{Value, json};
 use crate::commands::{CommandSpec, layer_param};
 use crate::{EngineError, Result, Session};
 
+mod batch_naming;
+
 // ---------- predicates ----------
 
 fn has_doc(s: &Session) -> std::result::Result<(), String> {
@@ -98,7 +100,7 @@ pub(crate) fn write_file(path: &str, _bytes: &[u8]) -> Result<()> {
 
 /// Files of a folder that look like images we can open, sorted by name.
 #[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn list_images(dir: &str) -> Result<Vec<String>> {
+pub fn list_images(dir: &str) -> Result<Vec<String>> {
     let rd = std::fs::read_dir(dir).map_err(|e| EngineError::Other(format!("{dir}: {e}")))?;
     let mut out: Vec<String> = rd
         .filter_map(|e| e.ok())
@@ -110,15 +112,16 @@ pub(crate) fn list_images(dir: &str) -> Result<Vec<String>> {
     Ok(out)
 }
 #[cfg(target_arch = "wasm32")]
-pub(crate) fn list_images(dir: &str) -> Result<Vec<String>> {
+pub fn list_images(dir: &str) -> Result<Vec<String>> {
     Err(EngineError::Other(format!("cannot list {dir}: no file system on the web")))
 }
 
 /// Extensions the batch commands pick up from a folder.
 #[cfg(not(target_arch = "wasm32"))]
 const OPENABLE: &[&str] = &[
-    "pdn", "ora", "psd", "psb", "pcraft", "png", "jpg", "jpeg", "tif", "tiff", "webp", "gif", "bmp", "tga", "exr", "hdr", "qoi", "ico", "pnm", "ppm", "pgm",
-    "fits", "fit", "fts", "heic", "heif", "hif", "dng", "cr2", "nef", "nrw", "arw", "pef", "svg", "svgz", "af", "afdesign", "afphoto", "afpub",
+    "pdn", "ora", "kra", "krz", "psd", "psb", "pcraft", "png", "jpg", "jpeg", "tif", "tiff", "webp", "gif", "bmp", "tga", "exr", "hdr", "qoi", "ico", "pnm",
+    "ppm", "pgm", "fits", "fit", "fts", "dpx", "heic", "heif", "hif", "dng", "cr2", "nef", "nrw", "arw", "pef", "svg", "svgz", "af", "afdesign", "afphoto",
+    "afpub",
 ];
 
 /// Whether saving `doc` as a TIFF writes Photoshop layer data (anything beyond a lone
@@ -150,8 +153,9 @@ pub fn extension(path: &str) -> Option<String> {
     file_name(path).rsplit_once('.').filter(|(base, ext)| !base.is_empty() && !ext.is_empty()).map(|(_, ext)| ext.to_ascii_lowercase())
 }
 
-/// Whether a save without a new path may write back to `path`: only layered files (PSD, PSB,
-/// .pcraft). A flat file goes through Save As instead, so it is never flattened over the original.
+/// Whether a save without a new path may write back to `path` as far as its format goes: only
+/// layered files (PSD, PSB, OpenRaster, .pcraft). A flat file goes through Save As instead, so it
+/// is never flattened over the original. Whether this document fits is [`holds_at`].
 pub fn saves_in_place(path: &str) -> bool {
     extension(path).is_some_and(|ext| layered_extension(&ext))
 }
@@ -163,6 +167,33 @@ pub fn layered_extension(ext: &str) -> bool {
     matches!(ext, "psd" | "psb" | "pcraft" | "ora")
 }
 
+/// Whether a file in format `ext` (lower-case) holds the whole of `doc`, so it can be the
+/// document's own file: PSD, PSB and .pcraft always; OpenRaster only when it drops nothing (no
+/// adjustment layers, styles, masks…, [`photocraft_io::ora_losses`]). A save to a format that
+/// doesn't hold the document is a copy, and File › Save goes through Save As, so an editable
+/// original is never overwritten with less than it had (#3806).
+pub fn holds(doc: &photocraft_doc::Document, ext: &str) -> bool {
+    match ext {
+        "psd" | "psb" | "pcraft" => true,
+        "ora" => photocraft_io::ora_losses(doc).is_empty(),
+        _ => false,
+    }
+}
+
+/// [`holds`] for the file at `path`.
+pub fn holds_at(doc: &photocraft_doc::Document, path: &str) -> bool {
+    extension(path).is_some_and(|ext| holds(doc, &ext))
+}
+
+/// What a save of `doc` to `path` would leave out when its format can't hold it: OpenRaster's
+/// [`photocraft_io::ora_losses`]; empty for other formats.
+pub fn losses_at(doc: &photocraft_doc::Document, path: &str) -> Vec<String> {
+    match extension(path).as_deref() {
+        Some("ora") => photocraft_io::ora_losses(doc),
+        _ => Vec::new(),
+    }
+}
+
 /// Whether `path` names a document template (.psdt). A template opens as a new untitled document
 /// without its path, so a save never writes over the template.
 pub fn is_template(path: &str) -> bool {
@@ -218,8 +249,8 @@ pub(crate) fn import(name: &str, bytes: &[u8]) -> Result<Document> {
     Ok(r.document)
 }
 
-/// What a headless save writes beyond the format: JPEG quality, TIFF layers, Targa bits and PSD
-/// previews.
+/// What a headless save writes beyond the format: JPEG quality, TIFF layers, Targa bits, PSD
+/// previews and the PSD merged image.
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct SaveOpts {
     /// Photoshop's 0–12 JPEG scale.
@@ -229,27 +260,35 @@ pub(crate) struct SaveOpts {
     /// Targa: 24 or 32 bits per pixel (`"tgaBits"`); unset, 32 with an alpha channel or
     /// transparency, else 24.
     pub tga_bits: Option<photocraft_io::TgaBits>,
+    /// DPX: 8, 10, 12 or 16 bits per sample (`"dpxBits"`); unset, 8 for an 8-bit document, else 16.
+    pub dpx_bits: Option<photocraft_io::DpxBits>,
     /// PSD/PSB: embed the thumbnail resource (Preferences › File Handling › Image Previews).
     pub image_previews: bool,
+    /// PSD/PSB: write the real merged image (Preferences › File Handling › Maximize PSD and PSB
+    /// File Compatibility).
+    pub psd_maximize_compatibility: bool,
 }
 
 impl Default for SaveOpts {
     fn default() -> Self {
-        SaveOpts { quality: None, tiff_layers: false, tga_bits: None, image_previews: true }
+        SaveOpts { quality: None, tiff_layers: false, tga_bits: None, dpx_bits: None, image_previews: true, psd_maximize_compatibility: true }
     }
 }
 
 impl SaveOpts {
     /// `quality`, `tiffLayers` and `tgaBits` from command `cmd`'s params (a `tgaBits` other than
-    /// 24 or 32 is an error); the image previews from the session's File Handling preferences
-    /// (Ask When Saving has no dialog here, so it saves them, as Photoshop's Save As checkbox
-    /// starts on).
+    /// 24 or 32 is an error); the image previews and the PSD merged image from the session's File
+    /// Handling preferences (Ask When Saving has no dialog here, so it saves them, as Photoshop's
+    /// Save As checkbox and its Maximize Compatibility checkbox both start on).
     pub(crate) fn from_params(s: &Session, p: &Value, cmd: &str) -> Result<Self> {
+        let file_handling = &s.prefs().file_handling;
         Ok(SaveOpts {
             quality: f64_param(p, "quality"),
             tiff_layers: p.get("tiffLayers").and_then(Value::as_bool).unwrap_or(false),
             tga_bits: tga_bits_param(p, cmd)?,
-            image_previews: s.prefs().file_handling.image_previews != crate::prefs::Ask::Never,
+            dpx_bits: dpx_bits_param(p, cmd)?,
+            image_previews: file_handling.image_previews != crate::prefs::Ask::Never,
+            psd_maximize_compatibility: file_handling.maximize_psd_compatibility != crate::prefs::Ask::Never,
         })
     }
 
@@ -279,12 +318,34 @@ pub fn tga_bits_param(p: &Value, cmd: &str) -> Result<Option<photocraft_io::TgaB
     }
 }
 
+/// The DPX bits per sample in `p` (`"dpxBits": 8 | 10 | 12 | 16`; absent or null: the document's
+/// depth). Anything else is a bad parameter of command `cmd`.
+pub fn dpx_bits_param(p: &Value, cmd: &str) -> Result<Option<photocraft_io::DpxBits>> {
+    match p.get("dpxBits") {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => v
+            .as_u64()
+            .and_then(photocraft_io::DpxBits::from_bits)
+            .map(Some)
+            .ok_or_else(|| EngineError::BadParams { cmd: cmd.into(), msg: format!("`dpxBits` must be 8, 10, 12 or 16, got {v}") }),
+    }
+}
+
 /// Encodes `doc` for `path`'s extension.
 pub(crate) fn encode(doc: &Document, path: &str, save: impl Into<SaveOpts>) -> Result<(Vec<u8>, Vec<String>)> {
     crate::allocation::checkpoint("saving document")?;
     let save = save.into();
-    let mut opts =
-        photocraft_io::ExportOptions { tiff_layers: save.tiff_layers, tga_bits: save.tga_bits, image_previews: save.image_previews, ..Default::default() };
+    let mut opts = photocraft_io::ExportOptions {
+        tiff_layers: save.tiff_layers,
+        tga_bits: save.tga_bits,
+        image_previews: save.image_previews,
+        psd_maximize_compatibility: save.psd_maximize_compatibility,
+        ..Default::default()
+    };
+    // No quality chosen: write the file the way it was opened (a JPEG at its own quality, a WebP
+    // lossy or lossless as it was), as Photoshop's Save does.
+    photocraft_io::apply_file_encoding(doc, &mut opts.encode);
+    opts.encode.dpx_bits = save.dpx_bits;
     if let Some(q) = save.quality {
         let q = (q.clamp(0.0, 12.0) / 12.0 * 99.0 + 1.0).round() as u8;
         opts.encode.jpeg_quality = q;
@@ -872,19 +933,25 @@ pub(crate) fn batch_inputs(p: &Value, cmd: &str) -> Result<Vec<String>> {
 /// Opens each input in a scratch session, runs `f` on it and saves it to `output` as `format`
 /// (`"same"` keeps the input's extension). Errors per file are collected, not fatal.
 pub(crate) fn process_files(inputs: &[String], output: &str, format: &str, save: SaveOpts, suffix: &str, f: &dyn Fn(&mut Session) -> Result<()>) -> Value {
+    let outputs = inputs.iter().map(|path| {
+        let ext =
+            if format == "same" { path.rsplit('.').next().unwrap_or("png").to_ascii_lowercase() } else { format.trim_start_matches('.').to_ascii_lowercase() };
+        (path.as_str(), join(output, &format!("{}{suffix}.{ext}", stem(path))))
+    });
+    process_outputs(outputs, save, f)
+}
+
+fn process_outputs<'a>(outputs: impl IntoIterator<Item = (&'a str, String)>, save: SaveOpts, f: &dyn Fn(&mut Session) -> Result<()>) -> Value {
     let mut files = Vec::new();
     let mut errors = Vec::new();
     let mut written = OutputClaims::default();
-    for path in inputs {
-        let ext =
-            if format == "same" { path.rsplit('.').next().unwrap_or("png").to_ascii_lowercase() } else { format.trim_start_matches('.').to_ascii_lowercase() };
-        let out = join(output, &format!("{}{suffix}.{ext}", stem(path)));
+    for (path, out) in outputs {
         let r = (|| -> Result<()> {
             written.check(&out).map_err(EngineError::Other)?;
             let bytes = read_file(path)?;
             let mut scratch = Session::new();
             let doc = import(&file_name(path), &bytes)?;
-            scratch.add_document(doc, Some(path.clone()));
+            scratch.add_document(doc, Some(path.to_string()));
             f(&mut scratch)?;
             let d = scratch.active().ok_or(EngineError::NoDocument)?;
             save_doc(&d.doc, &out, save)?;
@@ -929,7 +996,7 @@ fn batch(s: &mut Session, p: &Value) -> Result<Value> {
     // Each result goes to the destination folder, which overrides the action's recorded Save /
     // Save As steps (Photoshop's "Override Action 'Save As' Commands"). Recorded view steps
     // (zoom, fit) don't change the output, so they are skipped (#2752).
-    steps.retain(|(id, _)| !crate::actions_cmds::shell_save_command(id) && !crate::actions_cmds::shell_view_command(id));
+    steps.retain(|(id, _)| !crate::actions_cmds::shell_save_command(id) && !crate::actions_cmds::shell_view_command(id) && id != "file.export.quickExport");
     if let Some((id, _)) = steps.iter().find(|(id, _)| crate::commands::find(id).is_none()) {
         return Err(EngineError::BadParams { cmd: cmd.into(), msg: format!("unknown command `{id}` in the action") });
     }
@@ -951,7 +1018,9 @@ fn batch(s: &mut Session, p: &Value) -> Result<Value> {
         }
     };
     let actions = crate::actions_cmds::ActionState { list, playing: s.actions.playing, playback_stack: s.actions.playback_stack.clone(), ..Default::default() };
-    let r = process_files(&inputs, &output, &format, SaveOpts::from_params(s, p, cmd)?, "", &|scratch| {
+    let names = batch_naming::plan(&inputs, &output, &format, p)?;
+    let save = SaveOpts::from_params(s, p, cmd)?;
+    let run = |scratch: &mut Session| {
         scratch.actions = actions.clone();
         for (id, params) in &steps {
             let r = scratch.execute(id, params.clone())?;
@@ -961,7 +1030,11 @@ fn batch(s: &mut Session, p: &Value) -> Result<Value> {
             }
         }
         Ok(())
-    });
+    };
+    let r = match names {
+        Some(names) => process_outputs(inputs.iter().map(String::as_str).zip(names), save, &run),
+        None => process_files(&inputs, &output, &format, save, "", &run),
+    };
     Ok(r)
 }
 
@@ -1014,7 +1087,11 @@ fn load_files_into_stack(s: &mut Session, p: &Value) -> Result<Value> {
         stack.layers.push(Layer::new(name.clone(), LayerContent::Raster(flattened(d, fmt))));
     }
     let n = stack.layers.len();
-    if p.get("createSmartObject").and_then(Value::as_bool).unwrap_or(false) {
+    let smart = p.get("createSmartObject").and_then(Value::as_bool).unwrap_or(false);
+    // "Attempt to Automatically Align Source Images": Auto-Align Layers on the loaded layers, before
+    // they go into the smart object.
+    let align = p.get("align").and_then(Value::as_bool).unwrap_or(false) && n > 1;
+    if smart && !align {
         // "Create Smart Object after Loading Layers": the layers go inside one smart object, ready
         // for Layer › Smart Objects › Stack Mode. Like Photoshop, they sit at the top level of the
         // contents, with no wrapper group.
@@ -1023,6 +1100,23 @@ fn load_files_into_stack(s: &mut Session, p: &Value) -> Result<Value> {
         stack.layers = vec![smart];
     }
     let i = s.add_document(stack, None);
+    if align {
+        s.execute("select.allLayers", json!({}))?;
+        s.execute("edit.autoAlignLayers", json!({"projection": "auto"}))?;
+        if smart {
+            let name = s.active().map(|d| d.doc.name.clone()).unwrap_or_default();
+            s.edit("Convert to Smart Object", |doc, active| {
+                let layers = std::mem::take(&mut doc.layers);
+                let smart = crate::smart_cmds::layers_to_smart(doc, &name, layers)?;
+                *active = Some(smart.id);
+                doc.layers = vec![smart];
+                Ok(())
+            })?;
+            if let Some(st) = s.active_mut() {
+                st.selected_layers = st.active_layer.into_iter().collect();
+            }
+        }
+    }
     Ok(json!({"document": i, "layers": n}))
 }
 
@@ -1032,8 +1126,10 @@ fn has_live_effects(l: &Layer) -> bool {
     l.effects.enabled && l.effects.items.iter().any(|e| e.enabled())
 }
 
-/// The layer rendered alone (keeping what `keep` says), as a surface in `fmt`.
-fn bake(l: &Layer, canvas: Rect, fmt: PixelFormat, keep_effects: bool) -> Surface {
+/// The layer rendered alone (keeping what `keep` says), as a surface in `fmt`. With `apply_mask`
+/// off the layer's pixel and vector masks are left out of the render, so a caller that keeps them
+/// live on the baked raster does not mask the pixels twice.
+fn bake(l: &Layer, canvas: Rect, fmt: PixelFormat, keep_effects: bool, apply_mask: bool) -> Surface {
     let mut tmp = l.clone();
     tmp.opacity = 1.0;
     tmp.blend = photocraft_color::BlendMode::Normal;
@@ -1043,6 +1139,10 @@ fn bake(l: &Layer, canvas: Rect, fmt: PixelFormat, keep_effects: bool) -> Surfac
         tmp.effects.items.clear();
         tmp.fill_opacity = 1.0;
     }
+    if !apply_mask {
+        tmp.mask = None;
+        tmp.vector_mask = None;
+    }
     // Render over the union of the canvas and the content so off-canvas pixels survive.
     let area = l.surface().map_or(canvas, |s| s.content_bounds().union(&canvas));
     let area = if keep_effects { area.inflate(256) } else { area };
@@ -1063,12 +1163,12 @@ fn flatten_all_effects(s: &mut Session) -> Result<Value> {
             if !has_live_effects(l) || matches!(l.content, LayerContent::Group(_) | LayerContent::Adjustment(_)) {
                 continue;
             }
-            let px = bake(l, canvas, fmt, true);
+            // The pixel and vector masks stay on the layer (baking must not destroy them), so the
+            // pixels are baked without them and each mask then applies once to the baked raster.
+            let px = bake(l, canvas, fmt, true, false);
             let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
             l.content = LayerContent::Raster(px);
             l.effects = Default::default();
-            l.mask = None;
-            l.vector_mask = None;
             l.fill_opacity = 1.0;
             l.fill_cache = None;
             l.psd_blocks.retain(|(k, _)| !matches!(k, b"TySh" | b"SoLd" | b"PlLd" | b"SoLE" | b"vmsk" | b"vsms" | b"vogk" | b"vscg" | b"vstk"));
@@ -1096,7 +1196,7 @@ fn flatten_all_masks(s: &mut Session) -> Result<Value> {
                 skipped += 1;
                 continue;
             }
-            let px = bake(l, canvas, fmt, false);
+            let px = bake(l, canvas, fmt, false, true);
             let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
             l.content = LayerContent::Raster(px);
             l.mask = None;
@@ -1386,7 +1486,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Save a Copy…",
             &["File"],
             Some("Cmd+Alt+S"),
-            r##"{"path":str (format from the extension),"quality":0..12? (JPEG),"layers":bool=true,"tiffLayers":bool=false (TIFF: keep the layers; flat by default),"tgaBits":24|32? (TGA: 32 writes the alpha channel, or else the transparency, as the alpha; unset, 32 with an alpha channel or transparency, else 24)}"##,
+            r##"{"path":str (format from the extension),"quality":0..12? (JPEG),"layers":bool=true,"tiffLayers":bool=false (TIFF: keep the layers; flat by default),"tgaBits":24|32? (TGA: 32 writes the alpha channel, or else the transparency, as the alpha; unset, 32 with an alpha channel or transparency, else 24),"dpxBits":8|10|12|16? (DPX: bits per sample; unset, 8 for an 8-bit document, else 16)}"##,
             native_doc,
             save_a_copy
         ),
@@ -1449,7 +1549,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Batch…",
             &["File", "Automate"],
             None,
-            r##"{"steps":[[commandId,params]|{"command":id,"params":{}}…] (a recorded action),"input":folder|[paths],"output":folder,"format":"same|png|jpg|psd|tiff|…"="same","quality":0..12?,"tiffLayers":bool=false,"tgaBits":24|32?,"calledActions":[{"name","steps"}…]? (the actions Play Action steps call; default: the session's)} → {files, errors} (an input whose output name was already written in the run goes to errors)"##,
+            r##"{"steps":[[commandId,params]|{"command":id,"params":{}}…] (a recorded action),"input":folder|[paths],"output":folder,"format":"same|png|jpg|psd|tiff|…"="same","quality":0..12?,"naming":string? (blank keeps source names; {name}, {serial} padded to 3 digits, {date} as YYYY-MM-DD UTC; extension added automatically),"startingSerial":1..4294967295=1 (input position, including failed inputs),"tiffLayers":bool=false,"tgaBits":24|32?,"dpxBits":8|10|12|16? (DPX: bits per sample; unset, 8 for an 8-bit document, else 16),"calledActions":[{"name","steps"}…]? (the actions Play Action steps call; default: the session's)} → {files, errors} (an input whose output name was already written in the run goes to errors)"##,
             native,
             batch
         ),
@@ -1458,7 +1558,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Image Processor…",
             &["File", "Scripts"],
             None,
-            r##"{"input":folder|[paths],"output":folder,"format":"jpg|png|psd|tiff|…"="jpg","quality":0..12=8,"tiffLayers":bool=false,"tgaBits":24|32?,"width":px?,"height":px? (fit, never enlarge),"convertToSrgb":bool=false} → {files, errors} (an input whose output name was already written in the run goes to errors)"##,
+            r##"{"input":folder|[paths],"output":folder,"format":"jpg|png|psd|tiff|…"="jpg","quality":0..12=8,"tiffLayers":bool=false,"tgaBits":24|32?,"dpxBits":8|10|12|16? (DPX: bits per sample; unset, 8 for an 8-bit document, else 16),"width":px?,"height":px? (fit, never enlarge),"convertToSrgb":bool=false} → {files, errors} (an input whose output name was already written in the run goes to errors)"##,
             native,
             image_processor
         ),
@@ -1467,7 +1567,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Load Files into Stack…",
             &["File", "Scripts"],
             None,
-            r##"{"paths":[str]|folder,"createSmartObject":bool=false} → new document with one layer per file (inside one smart object with createSmartObject)"##,
+            r##"{"paths":[str]|folder,"align":bool=false (Auto-Align Layers on them first),"createSmartObject":bool=false} → new document with one layer per file (inside one smart object with createSmartObject)"##,
             native,
             load_files_into_stack
         ),
@@ -1486,7 +1586,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Layers to Files…",
             &["File", "Export"],
             None,
-            r##"{"dir":folder,"format":"png|jpg|psd|tiff|…"="png","prefix":str=document name,"visibleOnly":bool=true,"quality":0..12?,"tiffLayers":bool=false,"tgaBits":24|32?} → {files}"##,
+            r##"{"dir":folder,"format":"png|jpg|psd|tiff|…"="png","prefix":str=document name,"visibleOnly":bool=true,"quality":0..12?,"tiffLayers":bool=false,"tgaBits":24|32?,"dpxBits":8|10|12|16? (DPX: bits per sample; unset, 8 for an 8-bit document, else 16)} → {files}"##,
             native_doc,
             layers_to_files
         ),
diff --git a/crates/engine/src/file_cmds/batch_naming.rs b/crates/engine/src/file_cmds/batch_naming.rs
new file mode 100644
index 0000000000..2a32f71328
--- /dev/null
+++ b/crates/engine/src/file_cmds/batch_naming.rs
@@ -0,0 +1,123 @@
+//! Batch output names are planned before opening or writing files. Names substituted from an
+//! input are literal: braces in a source filename must never be interpreted as template tokens.
+
+use super::{EngineError, Result, Value, join, stem};
+
+fn bad(message: impl Into<String>) -> EngineError {
+    EngineError::BadParams { cmd: "file.automate.batch".into(), msg: message.into() }
+}
+
+enum Part<'a> {
+    Literal(&'a str),
+    Name,
+    Serial,
+    Date,
+}
+
+fn parse(template: &str) -> Result<Vec<Part<'_>>> {
+    let mut parts = Vec::new();
+    let mut rest = template;
+    while let Some(at) = rest.find(['{', '}']) {
+        parts.push(Part::Literal(&rest[..at]));
+        rest = &rest[at..];
+        if rest.starts_with('}') {
+            return Err(bad("naming: unmatched closing brace"));
+        }
+        let end = rest.find('}').ok_or_else(|| bad("naming: unclosed token"))?;
+        parts.push(match &rest[1..end] {
+            "name" => Part::Name,
+            "serial" => Part::Serial,
+            "date" => Part::Date,
+            token => return Err(bad(format!("naming: unknown token {{{token}}}; use {{name}}, {{serial}} or {{date}}"))),
+        });
+        rest = &rest[end + 1..];
+    }
+    parts.push(Part::Literal(rest));
+    Ok(parts)
+}
+
+fn expand(parts: &[Part<'_>], name: &str, serial: u32, date: &str) -> String {
+    let mut out = String::new();
+    for part in parts {
+        match part {
+            Part::Literal(s) => out.push_str(s),
+            Part::Name => out.push_str(name),
+            Part::Serial => out.push_str(&format!("{serial:03}")),
+            Part::Date => out.push_str(date),
+        }
+    }
+    out
+}
+
+/// An absent or empty template preserves the old filename path exactly. An explicit template
+/// generates one component per input; the export format supplies the extension separately.
+pub(super) fn plan(inputs: &[String], output: &str, format: &str, params: &Value) -> Result<Option<Vec<String>>> {
+    let start = match params.get("startingSerial") {
+        None => 1,
+        Some(n) => {
+            n.as_u64().and_then(|n| u32::try_from(n).ok()).filter(|&n| n > 0).ok_or_else(|| bad("startingSerial must be an integer from 1 to 4294967295"))?
+        }
+    };
+    let template = match params.get("naming") {
+        None => "",
+        Some(Value::String(s)) => s,
+        Some(_) => return Err(bad("naming must be a string")),
+    };
+    if template.is_empty() {
+        return Ok(None);
+    }
+    if template.len() > 255 {
+        return Err(bad("naming must be at most 255 bytes"));
+    }
+    let parts = parse(template)?;
+    let has_serial = parts.iter().any(|p| matches!(p, Part::Serial));
+    let timestamp = crate::analysis_cmds::now_iso();
+    let date = timestamp.get(..10).unwrap_or("");
+    if date.is_empty() && parts.iter().any(|p| matches!(p, Part::Date)) {
+        return Err(bad("naming: the current UTC date is unavailable"));
+    }
+    let mut outputs = Vec::with_capacity(inputs.len());
+    for (index, path) in inputs.iter().enumerate() {
+        let serial = if has_serial {
+            u32::try_from(index).ok().and_then(|index| start.checked_add(index)).ok_or_else(|| bad("startingSerial plus the input count exceeds 4294967295"))?
+        } else {
+            start
+        };
+        let base = expand(&parts, &stem(path), serial, date);
+        if base.is_empty() || base.ends_with(['.', ' ']) {
+            return Err(bad("naming must produce a nonempty filename stem without a trailing dot or space"));
+        }
+        let ext =
+            if format == "same" { path.rsplit('.').next().unwrap_or("png").to_ascii_lowercase() } else { format.trim_start_matches('.').to_ascii_lowercase() };
+        let name = format!("{base}.{ext}");
+        if name.len() > 255 || name.chars().any(|c| c.is_control() || "/\\<>:\"|?*".contains(c)) {
+            return Err(bad("naming must produce a filename of at most 255 bytes without path separators or reserved characters"));
+        }
+        outputs.push(join(output, &name));
+    }
+    // Renaming within the source folder could replace a later input before it is read. Resolve
+    // existing paths so aliases such as `source/./001.png` cannot bypass the check. The default
+    // (no template) path keeps its existing in-place behavior.
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let sources: std::collections::HashSet<_> = inputs.iter().filter_map(|p| std::fs::canonicalize(p).ok()).collect();
+        for output in &outputs {
+            if std::fs::canonicalize(output).ok().is_some_and(|p| sources.contains(&p)) {
+                return Err(bad(format!("naming would replace an input file: {output}; choose a different destination or template")));
+            }
+        }
+    }
+    Ok(Some(outputs))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn substituted_names_are_literal_and_serials_do_not_wrap_or_truncate() {
+        let parts = parse("{date}_{name}_{serial}").unwrap();
+        assert_eq!(expand(&parts, "photo{serial}", 7, "2026-10-13"), "2026-10-13_photo{serial}_007");
+        assert_eq!(expand(&parts, "photo", 1000, "2026-10-13"), "2026-10-13_photo_1000");
+    }
+}
diff --git a/crates/engine/src/file_cmds/tests.rs b/crates/engine/src/file_cmds/tests.rs
index f301d4c9a6..99ddce15de 100644
--- a/crates/engine/src/file_cmds/tests.rs
+++ b/crates/engine/src/file_cmds/tests.rs
@@ -155,6 +155,32 @@ fn save_a_copy_writes_the_targa_bits_asked_for() {
     }
 }
 
+/// `dpxBits` picks a DPX's bits per sample (byte 803 of the header); unset, it follows the
+/// document's depth. Anything but 8, 10, 12 or 16 is refused before anything is written.
+#[test]
+fn save_a_copy_writes_the_dpx_bits_asked_for() {
+    let dir = tmp("dpx-bits");
+    for (depth, params, bits) in
+        [(8, json!({}), 8), (16, json!({}), 16), (16, json!({"dpxBits": 10}), 10), (8, json!({"dpxBits": 12}), 12), (16, json!({"dpxBits": null}), 16)]
+    {
+        let mut s = session(12, 6, depth);
+        let out = join(&dir, "a.dpx");
+        let mut p = params.clone();
+        p["path"] = json!(out);
+        s.execute("file.saveACopy", p).unwrap();
+        let bytes = std::fs::read(&out).unwrap();
+        assert_eq!((&bytes[..4], bytes[803]), (&b"SDPX"[..], bits), "{depth}-bit {params}");
+        assert_eq!(photocraft_io::import("a.dpx", &bytes).unwrap().document.size, photocraft_geom::Size::new(12, 6));
+    }
+    let mut s = session(8, 8, 8);
+    for bad in [json!(24), json!(0), json!("10"), json!(10.5)] {
+        let out = join(&dir, "bad.dpx");
+        let r = s.execute("file.saveACopy", json!({"path": out, "dpxBits": bad}));
+        assert!(matches!(r, Err(EngineError::BadParams { .. })), "{bad}: {r:?}");
+        assert!(!std::path::Path::new(&out).exists(), "{bad}: nothing written");
+    }
+}
+
 /// A `tgaBits` other than 24 or 32 is a bad parameter, reported before anything is written.
 #[test]
 fn bad_targa_bits_are_refused_before_writing() {
@@ -192,6 +218,26 @@ fn image_previews_preference_controls_the_psd_thumbnail() {
     }
 }
 
+/// Preferences › File Handling › Maximize PSD and PSB File Compatibility decides whether a
+/// layered PSD keeps its real merged image: Always and Ask When Saving write it, Never writes
+/// Photoshop's placeholder and says so in resource 1057.
+#[test]
+fn maximize_compatibility_preference_controls_the_psd_merged_image() {
+    use crate::prefs::Ask;
+    let dir = tmp("maximize");
+    let mut s = session(300, 200, 16);
+    s.execute("layer.new.layer", json!({})).unwrap();
+    let real_merged = |path: &str| photocraft_psd::PsdFile::from_bytes(&std::fs::read(path).unwrap()).unwrap().has_real_merged_data();
+    for (ask, expect) in [(Ask::Always, true), (Ask::Never, false), (Ask::Ask, true)] {
+        s.edit_prefs(|p| p.file_handling.maximize_psd_compatibility = ask);
+        for ext in ["psd", "psb"] {
+            let out = join(&dir, &format!("{ask:?}.{ext}"));
+            s.execute("file.saveACopy", json!({"path": out})).unwrap();
+            assert_eq!(real_merged(&out), Some(expect), "{ask:?} {ext}");
+        }
+    }
+}
+
 #[test]
 fn open_as_forces_the_decoder() {
     let dir = tmp("openas");
@@ -554,6 +600,118 @@ fn flatten_all_layer_effects_and_masks() {
     }
 }
 
+/// Flatten All Layer Effects must bake the effect visuals without destroying the layer's masks:
+/// an enabled raster mask and a vector mask on one layer, a disabled raster mask on another
+/// (#3804). The command is a visual no-op; the masks (pixels and state) survive, including a
+/// `.pcraft` round trip.
+#[test]
+fn flatten_all_layer_effects_keeps_masks() {
+    for depth in [8, 16, 32] {
+        let mut s = session(40, 40, depth);
+        // Layer 1: a red square with a green colour overlay, an enabled raster mask revealing
+        // x < 20 and a vector mask revealing x 15..30.
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("select.rect", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+        s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+        s.execute("select.deselect", json!({})).unwrap();
+        let id1 = s.active().unwrap().active_layer.unwrap();
+        s.edit("fx", |doc, _| {
+            let l = doc.layer_mut(id1).unwrap();
+            l.effects.enabled = true;
+            l.effects.items.push(photocraft_doc::Effect::ColorOverlay {
+                common: photocraft_doc::effects::FxCommon::new(photocraft_color::BlendMode::Normal, 1.0),
+                color: photocraft_color::Color::rgb(0.0, 1.0, 0.0),
+            });
+            l.vector_mask = Some(photocraft_doc::VectorMask::new(photocraft_doc::Path::new(vec![photocraft_doc::Subpath::polygon(&[
+                (15.0, 15.0),
+                (30.0, 15.0),
+                (30.0, 30.0),
+                (15.0, 30.0),
+            ])])));
+            Ok(())
+        })
+        .unwrap();
+        s.execute("select.rect", json!({"x": 0, "y": 0, "width": 20, "height": 40})).unwrap();
+        s.execute("layer.layerMask.revealSelection", json!({})).unwrap();
+        s.execute("select.deselect", json!({})).unwrap();
+        // Layer 2: a red square at the bottom-right with the same overlay and a *disabled* mask.
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("select.rect", json!({"x": 30, "y": 30, "width": 8, "height": 8})).unwrap();
+        s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+        s.execute("select.deselect", json!({})).unwrap();
+        let id2 = s.active().unwrap().active_layer.unwrap();
+        s.edit("fx", |doc, _| {
+            let l = doc.layer_mut(id2).unwrap();
+            l.effects.enabled = true;
+            l.effects.items.push(photocraft_doc::Effect::ColorOverlay {
+                common: photocraft_doc::effects::FxCommon::new(photocraft_color::BlendMode::Normal, 1.0),
+                color: photocraft_color::Color::rgb(0.0, 1.0, 0.0),
+            });
+            Ok(())
+        })
+        .unwrap();
+        s.execute("select.rect", json!({"x": 34, "y": 34, "width": 2, "height": 2})).unwrap();
+        s.execute("layer.layerMask.revealSelection", json!({})).unwrap();
+        s.execute("select.deselect", json!({})).unwrap();
+        s.edit("disable", |doc, _| {
+            if let Some(m) = doc.layer_mut(id2).and_then(|l| l.mask.as_mut()) {
+                m.enabled = false;
+            }
+            Ok(())
+        })
+        .unwrap();
+        let m1 = doc(&s).layer(id1).unwrap().mask.clone();
+        let v1 = doc(&s).layer(id1).unwrap().vector_mask.clone();
+        let m2 = doc(&s).layer(id2).unwrap().mask.clone();
+        assert_eq!(m1.as_ref().map(|m| m.enabled), Some(true), "layer 1 raster mask is enabled");
+        assert!(v1.as_ref().is_some_and(|v| v.enabled), "layer 1 vector mask is enabled");
+        assert_eq!(m2.as_ref().map(|m| m.enabled), Some(false), "layer 2 raster mask is disabled");
+        let before = [
+            composite(&s, 17, 15), // layer 1: inside both masks
+            composite(&s, 22, 15), // layer 1: raster mask hides
+            composite(&s, 12, 15), // layer 1: vector mask hides
+            composite(&s, 34, 34), // layer 2: the disabled mask does not hide
+        ];
+        assert!(before[0][1] > 0.99 && before[0][0] < 0.01, "overlay renders green: {:?}", before[0]);
+        // The white background shows where a mask hides the layer.
+        assert!(before[1][0] > 0.99 && before[1][1] > 0.99, "the raster mask hides: {:?}", before[1]);
+        assert!(before[2][0] > 0.99 && before[2][1] > 0.99, "the vector mask hides: {:?}", before[2]);
+        assert!(before[3][1] > 0.99, "the disabled mask does not hide");
+        let r = s.execute("file.scripts.flattenAllLayerEffects", json!({})).unwrap();
+        assert_eq!(r["flattened"], 2);
+        {
+            let d = doc(&s);
+            assert_eq!(d.layer(id1).unwrap().mask, m1, "layer 1 raster mask survives");
+            assert_eq!(d.layer(id1).unwrap().vector_mask, v1, "layer 1 vector mask survives");
+            assert_eq!(d.layer(id2).unwrap().mask, m2, "the disabled mask survives");
+        }
+        let after = [composite(&s, 17, 15), composite(&s, 22, 15), composite(&s, 12, 15), composite(&s, 34, 34)];
+        for (a, b) in after.iter().zip(&before) {
+            for k in 0..4 {
+                assert!((a[k] - b[k]).abs() < 0.01, "flattening is a visual no-op: {after:?} vs {before:?}");
+            }
+        }
+        // One history step: undo restores the effects, redo re-flattens, and the masks stay.
+        assert!(s.undo());
+        assert!(!doc(&s).layer(id1).unwrap().effects.items.is_empty());
+        assert_eq!(doc(&s).layer(id1).unwrap().mask, m1);
+        assert!(s.redo());
+        assert_eq!(doc(&s).layer(id1).unwrap().mask, m1);
+        assert_eq!(doc(&s).layer(id1).unwrap().vector_mask, v1);
+        assert_eq!(doc(&s).layer(id2).unwrap().mask, m2);
+        // The masks survive a `.pcraft` save and reopen.
+        let dir = tmp("flatten-effects-masks");
+        let path = join(&dir, "masks.pcraft");
+        save_doc(doc(&s), &path, None).unwrap();
+        let bytes = std::fs::read(&path).unwrap();
+        let mut s2 = Session::new();
+        open_bytes_as(&mut s2, "masks.pcraft", &bytes, None, None).unwrap();
+        let layers: Vec<_> = doc(&s2).walk().into_iter().map(|(_, _, l)| l).collect();
+        assert!(layers.iter().any(|l| l.mask == m1 && l.vector_mask == v1), "the raster and vector masks survive .pcraft");
+        assert!(layers.iter().any(|l| l.mask == m2), "the disabled mask survives .pcraft");
+    }
+}
+
 #[test]
 fn layers_to_files_writes_each_visible_layer() {
     let dir = tmp("layers");
@@ -598,6 +756,18 @@ fn load_files_into_stack_and_image_processor_and_batch() {
     let inv = photocraft_io::import("a.png", &std::fs::read(join(&out, "a.png")).unwrap()).unwrap().document;
     let px = photocraft_compose::render(&inv, Rect::new(1, 1, 2, 2)).px[0];
     assert!(px[0] < 0.01 && px[1] > 0.99 && px[2] > 0.99, "red inverted to cyan: {px:?}");
+    // A recorded Quick Export writes to the current document path, but Batch owns
+    // the destination. Replaying it would fail for scratch documents with no save path.
+    let quick_out = join(&dir, "batch-with-quick-export");
+    let r = s
+        .execute(
+            "file.automate.batch",
+            json!({"steps": [["image.adjustments.invert", {}], ["file.export.quickExport", {}]], "input": input, "output": quick_out, "format": "png"}),
+        )
+        .unwrap();
+    assert_eq!(r["files"].as_array().unwrap().len(), 2, "{r}");
+    assert!(r["errors"].as_array().unwrap().is_empty(), "{r}");
+    assert!(std::path::Path::new(&join(&quick_out, "a.png")).is_file());
     assert!(s.execute("file.automate.batch", json!({"steps": [["no.such.command", {}]], "input": input, "output": out})).is_err());
 }
 
@@ -743,6 +913,26 @@ fn only_layered_files_save_in_place() {
     assert_eq!(extension("my.dir/name"), None);
 }
 
+/// #3806: a layered format holds a document only if it keeps everything in it.
+#[test]
+fn openraster_holds_a_document_only_when_it_drops_nothing() {
+    let mut s = session(16, 16, 8);
+    s.execute("layer.new.layer", json!({})).unwrap();
+    let plain = doc(&s).clone();
+    for p in ["a.psd", "a.psb", "a.pcraft", "a.ora", "A.ORA"] {
+        assert!(holds_at(&plain, p), "{p}");
+    }
+    for p in ["a.png", "a.tif", "a", ""] {
+        assert!(!holds_at(&plain, p), "{p}");
+    }
+    assert!(losses_at(&plain, "a.ora").is_empty());
+    s.execute("layer.newAdjustmentLayer.invert", json!({})).unwrap();
+    let adjusted = doc(&s).clone();
+    assert!(holds_at(&adjusted, "a.psd") && !holds_at(&adjusted, "a.ora"));
+    assert!(losses_at(&adjusted, "a.ora").iter().any(|l| l.contains("adjustment layers")), "{:?}", losses_at(&adjusted, "a.ora"));
+    assert!(losses_at(&adjusted, "a.psd").is_empty());
+}
+
 #[test]
 fn templates_open_untitled_without_their_path() {
     assert!(is_template("dir/card.PSDT") && !is_template("card.psd") && !is_template("psdt"));
@@ -756,6 +946,34 @@ fn templates_open_untitled_without_their_path() {
     assert_eq!(opened, [("Untitled-1", None), ("Untitled-2", None)]);
 }
 
+#[test]
+fn batch_naming_serial_keeps_same_named_inputs_and_their_pixels() {
+    let dir = tmp("naming-serial");
+    let first = join(&dir, "first");
+    let second = join(&dir, "second");
+    std::fs::create_dir_all(&first).unwrap();
+    std::fs::create_dir_all(&second).unwrap();
+    let inputs = [png(&first, "photo.png", 8, 8, "#ff0000"), png(&second, "photo.png", 8, 8, "#0000ff")];
+    let out = join(&dir, "out");
+    let mut s = Session::new();
+    let result = s
+        .execute(
+            "file.automate.batch",
+            json!({
+                "input": inputs, "output": out, "steps": [], "format": "png",
+                "naming": "{name}_{serial}", "startingSerial": 7
+            }),
+        )
+        .unwrap();
+    assert_eq!(result["errors"], json!([]), "{result}");
+    assert_eq!(result["files"], json!([join(&out, "photo_007.png"), join(&out, "photo_008.png")]));
+    for (name, expected) in [("photo_007.png", [1.0, 0.0, 0.0, 1.0]), ("photo_008.png", [0.0, 0.0, 1.0, 1.0])] {
+        let saved = photocraft_io::import(name, &std::fs::read(join(&out, name)).unwrap()).unwrap().document;
+        let pixel = photocraft_compose::render(&saved, Rect::new(1, 1, 2, 2)).px[0];
+        assert_eq!(pixel, expected, "{name}");
+    }
+}
+
 /// Two inputs with one output name: the first result is kept and the second is an error, never
 /// a silent overwrite listed as written (#422).
 #[test]
@@ -829,3 +1047,103 @@ fn reveal_in_finder_reveals_the_documents_saved_path() {
     assert_eq!(r["program"], json!(program));
     assert_eq!(r["args"], json!(args));
 }
+#[test]
+fn batch_naming_validates_the_whole_plan_before_writing() {
+    let dir = tmp("naming-invalid");
+    let input = png(&dir, "source.png", 8, 8, "#ff0000");
+    let mut s = Session::new();
+    for (index, extra) in [
+        json!({"naming": "../{name}"}),
+        json!({"naming": "sub\\{name}"}),
+        json!({"naming": "C:{name}"}),
+        json!({"naming": "{unknown}"}),
+        json!({"naming": "{name"}),
+        json!({"naming": "name}"}),
+        json!({"naming": 42}),
+        json!({"naming": "{serial}", "startingSerial": 0}),
+        json!({"naming": "{serial}", "startingSerial": 1.5}),
+        json!({"naming": "{serial}", "startingSerial": "1"}),
+        json!({"naming": "{serial}", "startingSerial": 4294967295_u64}),
+        json!({"naming": "x".repeat(256)}),
+    ]
+    .into_iter()
+    .enumerate()
+    {
+        let out = join(&dir, &format!("out-{index}"));
+        let mut params = json!({"input": [input, input], "output": out, "steps": []});
+        params.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
+        let error = s.execute("file.automate.batch", params).unwrap_err();
+        assert!(matches!(error, EngineError::BadParams { .. }), "{error}");
+        assert!(!std::path::Path::new(&out).exists(), "invalid naming wrote outputs: {extra}");
+    }
+}
+
+#[test]
+fn batch_naming_keeps_serial_positions_after_errors_and_captures_the_utc_date() {
+    let dir = tmp("naming-errors");
+    let input = png(&dir, "good.png", 8, 8, "#0000ff");
+    let out = join(&dir, "out");
+    let before = crate::analysis_cmds::now_iso();
+    let mut s = Session::new();
+    let result = s
+        .execute(
+            "file.automate.batch",
+            json!({
+                "input": [join(&dir, "missing.png"), input], "output": out, "steps": [],
+                "naming": "{date}_{serial}_{name}", "startingSerial": 9
+            }),
+        )
+        .unwrap();
+    let after = crate::analysis_cmds::now_iso();
+    assert_eq!(result["errors"].as_array().unwrap().len(), 1, "{result}");
+    let files = result["files"].as_array().unwrap();
+    assert_eq!(files.len(), 1, "{result}");
+    let name = file_name(files[0].as_str().unwrap());
+    assert!(
+        name == format!("{}_010_good.png", &before[..10]) || name == format!("{}_010_good.png", &after[..10]),
+        "the missing input still consumes its serial: {name}"
+    );
+}
+
+#[test]
+fn batch_naming_still_reports_collisions_instead_of_overwriting() {
+    let dir = tmp("naming-collision");
+    let red = png(&dir, "red.png", 8, 8, "#ff0000");
+    let blue = png(&dir, "blue.png", 8, 8, "#0000ff");
+    let out = join(&dir, "out");
+    let mut s = Session::new();
+    let result = s
+        .execute(
+            "file.automate.batch",
+            json!({
+                "input": [red, blue], "output": out, "steps": [], "naming": "constant"
+            }),
+        )
+        .unwrap();
+    assert_eq!(result["files"], json!([join(&out, "constant.png")]));
+    assert_eq!(result["errors"].as_array().unwrap().len(), 1, "{result}");
+    assert!(result["errors"][0]["error"].as_str().unwrap().contains("not written"));
+    let saved = photocraft_io::import("constant.png", &std::fs::read(join(&out, "constant.png")).unwrap()).unwrap().document;
+    assert_eq!(photocraft_compose::render(&saved, Rect::new(1, 1, 2, 2)).px[0], [1.0, 0.0, 0.0, 1.0]);
+}
+#[test]
+fn batch_naming_rejects_outputs_that_replace_inputs_before_processing() {
+    let dir = tmp("naming-input-alias");
+    let first = png(&dir, "002.png", 8, 8, "#ff0000");
+    let second = png(&dir, "001.png", 8, 8, "#0000ff");
+    let before = [std::fs::read(&first).unwrap(), std::fs::read(&second).unwrap()];
+    let mut s = Session::new();
+    // Without preflight, processing 002 first writes 001, so the next input's original pixels
+    // are lost before it is read. The full plan must be rejected without writing either file.
+    let error = s
+        .execute(
+            "file.automate.batch",
+            json!({
+                "input": [first, second], "output": join(&dir, "."), "steps": [], "naming": "{serial}"
+            }),
+        )
+        .unwrap_err();
+    assert!(error.to_string().contains("input"), "{error}");
+    assert_eq!(std::fs::read(&first).unwrap(), before[0]);
+    assert_eq!(std::fs::read(&second).unwrap(), before[1]);
+}
diff --git a/crates/engine/src/fill_cmds.rs b/crates/engine/src/fill_cmds.rs
index a7350dafc1..68e617bc8c 100644
--- a/crates/engine/src/fill_cmds.rs
+++ b/crates/engine/src/fill_cmds.rs
@@ -25,6 +25,12 @@ fn bad(msg: impl Into<String>) -> EngineError {
 /// What a pixel of the filled area gets before blending.
 enum Source {
     Color([f32; 4]),
+    /// An opaque colour that was picked as CMYK inks: `rgba` is its sRGB stand-in (what other
+    /// colour models and blend modes use), `cmyk` the inks a CMYK target gets as they are.
+    Cmyk {
+        rgba: [f32; 4],
+        cmyk: [f32; 4],
+    },
     /// Straight RGBA per pixel of `rect` (row-major).
     Pixels(Rect, Vec<[f32; 4]>),
 }
@@ -33,6 +39,7 @@ impl Source {
     fn at(&self, x: i32, y: i32) -> [f32; 4] {
         match self {
             Source::Color(c) => *c,
+            Source::Cmyk { rgba, .. } => *rgba,
             Source::Pixels(r, px) => {
                 if !r.contains(x, y) {
                     return [0.0; 4];
@@ -93,20 +100,20 @@ pub fn fill(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.active().ok_or(EngineError::NoDocument)?;
     let doc_bounds = st.doc.bounds();
     let sel = st.doc.selection.clone();
-    let area = sel.as_ref().map(|m| m.content_bounds()).unwrap_or(doc_bounds);
+    let area = sel.as_ref().map_or(doc_bounds, |m| m.content_bounds().intersect(&doc_bounds));
     let mut out = json!({ "contents": contents });
     let restore = contents == "history";
     let source = match contents {
-        "foreground" => Source::Color(s.tools.foreground),
-        "background" => Source::Color(s.tools.background),
-        "color" => Source::Color(color_param(p, "color", s.tools.foreground)),
+        "foreground" => color_source(s, s.tools.foreground),
+        "background" => color_source(s, s.tools.background),
+        "color" => color_source(s, color_param(p, "color", s.tools.foreground)),
         "black" => Source::Color([0.0, 0.0, 0.0, 1.0]),
         "gray" => Source::Color([128.0 / 255.0, 128.0 / 255.0, 128.0 / 255.0, 1.0]),
         "white" => Source::Color([1.0; 4]),
         "pattern" => {
             let pat = crate::pattern_cmds::resolve_param(s, CMD, p)?;
             let (scale, angle, _, phase) = crate::pattern_cmds::placement(p);
-            let tile = photocraft_compose::pattern::Tile::new(&pat).ok_or_else(|| bad("the pattern is empty"))?;
+            let tile = photocraft_compose::pattern::Tile::new(&pat).ok_or_else(|| bad("the pattern is empty or too large to paint"))?;
             // Photoshop's Fill uses the canvas origin.
             let place = photocraft_compose::pattern::Placement::new(Rect::EMPTY, false, phase, scale, angle);
             out["pattern"] = json!(pat.id);
@@ -141,19 +148,47 @@ pub fn fill(s: &mut Session, p: &Value) -> Result<Value> {
         }
         _ => return Err(bad(format!("unknown contents `{contents}`"))),
     };
-    let area = area.intersect(&doc_bounds);
     if area.is_empty() {
         return Ok(out);
     }
-    s.edit("Fill", |doc, _| {
-        let sel = doc.selection.clone();
-        let (surf, lock) = crate::channel_cmds::target_surface(doc, id, p)?;
-        blend_into(surf, area, &source, sel.as_ref(), Blend { mode, opacity, keep_alpha: preserve || lock, restore })?;
-        Ok(())
+    // The document's own CMYK profile converts the fill colour, like the compositor and brush.
+    let cmyk = crate::brush_cmds::doc_cmyk_space(s);
+    photocraft_color::convert::with_cmyk_space(cmyk.as_ref(), || {
+        s.edit("Fill", |doc, _| {
+            let sel = doc.selection.clone();
+            let (surf, lock) = crate::channel_cmds::target_surface(doc, id, p)?;
+            blend_into(surf, area, &source, sel.as_ref(), Blend { mode, opacity, keep_alpha: preserve || lock, restore })?;
+            Ok(())
+        })
     })?;
     Ok(out)
 }
 
+/// A fill colour: the inks it was picked as when it was picked as CMYK (#4196), else plain sRGB.
+fn color_source(s: &Session, c: [f32; 4]) -> Source {
+    match s.tools.picked_cmyk([c[0], c[1], c[2]]) {
+        Some(cmyk) if c[3] >= 1.0 => Source::Cmyk { rgba: c, cmyk },
+        _ => Source::Color(c),
+    }
+}
+
+/// `source`'s opaque colour as samples of `fmt` (alpha last, as in [`from_rgba_into`]), or `None`
+/// for a source that is not one colour. A CMYK pick keeps its inks in a CMYK target.
+fn encode_color(fmt: &photocraft_color::PixelFormat, source: &Source, enc: &mut [f32; 8]) -> Option<usize> {
+    let (rgba, cmyk) = match source {
+        Source::Color(c) if c[3] >= 1.0 => (*c, None),
+        Source::Cmyk { rgba, cmyk } => (*rgba, Some(*cmyk)),
+        _ => return None,
+    };
+    let n = from_rgba_into(fmt, rgba, enc);
+    if let Some(k) = cmyk
+        && fmt.mode == photocraft_color::ColorMode::Cmyk
+    {
+        enc[..4].copy_from_slice(&k);
+    }
+    Some(n)
+}
+
 fn read_rgba(src: &Surface, area: Rect, purpose: &str) -> Result<Vec<[f32; 4]>> {
     let len = (area.width() as usize)
         .checked_mul(area.height() as usize)
@@ -179,16 +214,22 @@ pub(crate) fn fill_color(surf: &mut Surface, area: Rect, color: [f32; 4], sel: O
 /// Reuse Edit › Fill's compositing for Edit › Stroke. The stroke's rasterized band
 /// is already a grayscale coverage mask; opacity, blend modes and alpha locking
 /// must behave identically for both commands at 8/16/32-bit depth.
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn blend_color_mask(
     surf: &mut Surface,
     area: Rect,
     color: [f32; 4],
+    picked: Option<[f32; 4]>,
     coverage: &Surface,
     mode: BlendMode,
     opacity: f32,
     preserve_transparency: bool,
 ) -> Result<()> {
-    blend_into(surf, area, &Source::Color(color), Some(coverage), Blend { mode, opacity, keep_alpha: preserve_transparency, restore: false })
+    let source = match picked {
+        Some(cmyk) if color[3] >= 1.0 => Source::Cmyk { rgba: color, cmyk },
+        _ => Source::Color(color),
+    };
+    blend_into(surf, area, &source, Some(coverage), Blend { mode, opacity, keep_alpha: preserve_transparency, restore: false })
 }
 
 /// The selection filled from its surroundings (`photocraft_algo::content_aware`), as straight
@@ -336,12 +377,9 @@ fn blend_into(surf: &mut Surface, area: Rect, source: &Source, sel: Option<&Surf
     let fmt = surf.format();
     // An opaque colour in Normal mode at 100 % that may replace alpha: fully covered tiles become
     // one shared solid tile (copy-on-write), which costs nothing per pixel.
-    let solid = match source {
-        Source::Color(c) if c[3] >= 1.0 && b.mode == BlendMode::Normal && b.opacity >= 1.0 && (!b.keep_alpha || !fmt.alpha) => {
-            let mut enc = [0.0f32; 8];
-            let n = from_rgba_into(&fmt, *c, &mut enc);
-            Some(surf.solid_tile(enc.get(..n).unwrap_or(&[])))
-        }
+    let mut enc = [0.0f32; 8];
+    let solid = match encode_color(&fmt, source, &mut enc) {
+        Some(n) if b.mode == BlendMode::Normal && b.opacity >= 1.0 && (!b.keep_alpha || !fmt.alpha) => Some(surf.solid_tile(enc.get(..n).unwrap_or(&[]))),
         _ => None,
     };
     let count = area.tiles().count();
@@ -360,6 +398,12 @@ fn blend_into(surf: &mut Surface, area: Rect, source: &Source, sel: Option<&Surf
             done.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push((tc, s.clone()));
             return Ok(());
         }
+        // Nothing selected in this tile (or no opacity): `blend_tile` would leave every pixel as
+        // it is, so keep the tile itself rather than a copy the history would hold again (#4517).
+        if b.opacity <= 0.0 || mask.as_ref().is_some_and(|m| m.empty(tr)) {
+            done.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push((tc, tile));
+            return Ok(());
+        }
         let mut tile = match std::sync::Arc::try_unwrap(tile) {
             Ok(tile) => tile,
             Err(tile) => tile
@@ -397,6 +441,10 @@ impl<'a> Mask<'a> {
     pub(crate) fn full(&self, r: Rect) -> bool {
         (r.y0..r.y1).all(|y| (r.x0..r.x1).all(|x| self.at(x, y) >= 1.0))
     }
+    /// Whether nothing in `r` is selected.
+    pub(crate) fn empty(&self, r: Rect) -> bool {
+        (r.y0..r.y1).all(|y| (r.x0..r.x1).all(|x| self.at(x, y) <= 0.0))
+    }
 }
 
 /// Blend into one tile's encoded pixels (`bytes`, the tile at `origin`) over `tr`.
@@ -409,9 +457,8 @@ fn blend_tile(bytes: &mut [u8], fmt: &photocraft_color::PixelFormat, origin: Rec
     let mut enc = [0.0f32; 8];
     // An opaque colour at full coverage in Normal mode just replaces the colour (and the alpha
     // unless it is kept): copy its encoded bytes.
-    let opaque = match source {
-        Source::Color(c) if c[3] >= 1.0 && mode == BlendMode::Normal => {
-            let m = from_rgba_into(fmt, *c, &mut enc);
+    let opaque = match encode_color(fmt, source, &mut enc) {
+        Some(m) if mode == BlendMode::Normal => {
             let mut bytes = vec![0u8; bpp];
             photocraft_raster::encode_pixel(fmt, enc.get(..m.min(n)).unwrap_or(&[]), &mut bytes);
             // Keeping alpha: copy the colour samples only (alpha is the last sample).
@@ -481,6 +528,24 @@ mod tests {
         a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1.5 / 255.0)
     }
 
+    #[test]
+    fn history_fill_reads_only_the_selection_inside_the_canvas() {
+        let mut s = session();
+        s.edit("selection", |doc, _| {
+            let mut selection = Surface::new(photocraft_color::PixelFormat::GRAY8);
+            selection.write_pixel(-2_000_000_000, -2_000_000_000, &[1.0]);
+            selection.write_pixel(4, 4, &[1.0]);
+            doc.selection = Some(selection);
+            Ok(())
+        })
+        .unwrap();
+        // Reading the full sparse selection rectangle overflows the allocation size;
+        // only its intersection with this small canvas is meaningful to Fill.
+        s.execute(CMD, json!({"contents": "history"})).unwrap();
+        assert!(s.undo());
+        assert!(s.active().unwrap().doc.selection.as_ref().unwrap().sample_channel(4, 4, 0) > 0.0);
+    }
+
     #[test]
     fn every_constant_contents() {
         let mut s = session();
@@ -708,4 +773,42 @@ mod tests {
         s.execute(CMD, json!({"contents": "contentAware", "colorAdaptation": false})).unwrap();
         assert!(close(px(&s, 17, 12), [0x33 as f32 / 255.0, 0x66 as f32 / 255.0, 0x99 as f32 / 255.0, 1.0]), "{:?}", px(&s, 17, 12));
     }
+
+    /// A Stroke, Fill or Clear inside a selection keeps the tiles the selection doesn't reach as
+    /// they were (shared with the history), instead of storing a copy of each (#4517).
+    #[test]
+    fn unselected_tiles_stay_shared() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 1024, "height": 1024, "background": "white"})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("edit.fill", json!({"color": "#336699"})).unwrap();
+        let id = s.active().unwrap().active_layer.unwrap();
+        let surf = |s: &Session| s.active().unwrap().doc.layer(id).unwrap().surface().unwrap().clone();
+        for (cmd, params) in [
+            ("edit.fill", json!({"color": "#ff0000"})),
+            ("edit.stroke", json!({"width": 4, "color": "#00ff00", "location": "inside"})),
+            ("edit.clear", json!({})),
+        ] {
+            // Two small selections in opposite corners (256 px tiles): the selection's bounds
+            // span every tile, but only the two corner tiles have anything selected.
+            s.execute("select.rect", json!({"x": 20, "y": 20, "width": 100, "height": 100})).unwrap();
+            s.execute("select.rect", json!({"x": 900, "y": 900, "width": 100, "height": 100, "mode": "add"})).unwrap();
+            let before = surf(&s);
+            s.execute(cmd, params).unwrap();
+            let after = surf(&s);
+            let corners = [photocraft_geom::Rect::new(0, 0, 256, 256), photocraft_geom::Rect::new(768, 768, 1024, 1024)];
+            let mut kept = 0;
+            for (c, t) in before.tiles() {
+                if corners.iter().all(|r| c.rect().intersect(r).is_empty()) {
+                    assert!(after.tile(*c).is_some_and(|a| std::sync::Arc::ptr_eq(a, t)), "{cmd}: unselected tile {c:?} was copied");
+                    kept += 1;
+                }
+            }
+            assert_eq!(kept, 14, "{cmd}: the 14 tiles between the corners");
+            for r in corners {
+                assert_ne!(before.read_region(r), after.read_region(r), "{cmd} changed the selected corner {r:?}");
+            }
+            s.execute("select.deselect", json!({})).unwrap();
+        }
+    }
 }
diff --git a/crates/engine/src/fill_key_cmds.rs b/crates/engine/src/fill_key_cmds.rs
index 6235b629bb..6b94e6cd47 100644
--- a/crates/engine/src/fill_key_cmds.rs
+++ b/crates/engine/src/fill_key_cmds.rs
@@ -1,33 +1,82 @@
 //! Photoshop's fill keys (#249): ⌥⌫ fills the selection (or the whole layer) with the foreground
-//! colour, ⌘⌫ with the background colour, and with ⇧ added they preserve transparency. Photoshop
+//! colour, ⌘⌫ with the background colour, and with ⇧ added they preserve transparency. ⌘⌥⌫ fills
+//! from history: the History Brush's source state (the oldest state still held). Photoshop
 //! has no menu item for them; here they are ordinary commands with default shortcuts, so they
 //! appear in Edit › Keyboard Shortcuts (Tools) and can be rebound, recorded and driven by agents.
 //!
 //! Each one is `edit.fill` with the colour and Preserve Transparency fixed: one "Fill" history
 //! step, the Channels panel target (alpha channel, Quick Mask) honoured, locked layers refused.
+//! When targeting a vector shape layer, the fill keys recolor the shape's fill; on a type layer
+//! they recolor the text (#4580), and the layer stays type.
 
+use photocraft_doc::{LayerContent, LayerId};
 use serde_json::{Map, Value, json};
 
 use crate::commands::CommandSpec;
 use crate::{EngineError, Result, Session};
 
 /// The fill-key command ids (routed to the Channels panel target like `edit.fill`).
-pub const IDS: [&str; 4] = ["edit.fillForeground", "edit.fillBackground", "edit.fillForegroundPreserve", "edit.fillBackgroundPreserve"];
+pub const IDS: [&str; 5] = ["edit.fillForeground", "edit.fillBackground", "edit.fillForegroundPreserve", "edit.fillBackgroundPreserve", "edit.fillHistory"];
 
 const PARAMS: &str = r##"{"layer":id?,"target":"pixels"|"mask"|"quickMask"|{"channel":i}?}"##;
 
+/// The shape or type layer the colour fill keys recolor instead of filling pixels.
+fn target_live_layer(s: &Session, p: &Value) -> Option<LayerId> {
+    if let Some(t) = p.get("target")
+        && (t.as_str() == Some("mask") || t.as_str() == Some("quickMask") || t.get("channel").is_some())
+    {
+        return None;
+    }
+    let st = s.active()?;
+    if st.channel_view.target == crate::channel_cmds::ChannelTarget::LayerMask {
+        return None;
+    }
+    let id = if let Some(v) = p.get("layer") { LayerId(v.as_u64()?) } else { st.active_layer? };
+    let layer = st.doc.layer(id)?;
+    if matches!(layer.content, LayerContent::Shape(_) | LayerContent::Text(_)) { Some(id) } else { None }
+}
+
+/// The colour fill keys also recolor a targeted shape layer's fill or type layer's text.
 fn enabled(s: &Session) -> std::result::Result<(), String> {
+    if target_live_layer(s, &Value::Null).is_some() {
+        return Ok(());
+    }
+    fill_enabled(s)
+}
+
+/// Enabled when `edit.fill` is (Fill from History has no shape-layer meaning).
+fn fill_enabled(s: &Session) -> std::result::Result<(), String> {
     let edit_fill = crate::commands::find("edit.fill").ok_or_else(|| "Fill is unavailable".to_string())?;
     (edit_fill.enabled)(s)
 }
 
-/// Run `edit.fill` with `color` (the foreground or background colour) and Preserve Transparency.
+/// Run `edit.fill` with `color` (the foreground or background colour) and Preserve Transparency,
+/// or recolor the vector shape fill or the text when targeting a shape or type layer.
 fn fill(s: &mut Session, p: &Value, cmd: &str, background: bool, preserve: bool) -> Result<Value> {
     let mut q: Map<String, Value> = match p {
         Value::Object(m) => m.clone(),
         Value::Null => Map::new(),
         _ => return Err(EngineError::BadParams { cmd: cmd.into(), msg: "expected an object".into() }),
     };
+
+    if let Some(id) = target_live_layer(s, p) {
+        let c = if background { s.tools.background } else { s.tools.foreground };
+        if s.active().and_then(|st| st.doc.layer(id)).is_some_and(|l| matches!(l.content, LayerContent::Text(_))) {
+            // type.setStyle doesn't check locks itself; refuse like the pixel fill does.
+            crate::commands::check_pixels_unlocked(&s.active().ok_or(EngineError::NoDocument)?.doc, id)?;
+            let set_style = crate::commands::find("type.setStyle").ok_or_else(|| EngineError::Other("type.setStyle is unavailable".into()))?;
+            return (set_style.run)(s, &json!({ "layer": id.0, "color": [c[0], c[1], c[2], 1.0] }));
+        }
+        let q_u8 = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
+        let hex = if c[3] < 1.0 {
+            format!("#{:02x}{:02x}{:02x}{:02x}", q_u8(c[0]), q_u8(c[1]), q_u8(c[2]), q_u8(c[3]))
+        } else {
+            format!("#{:02x}{:02x}{:02x}", q_u8(c[0]), q_u8(c[1]), q_u8(c[2]))
+        };
+        let shape_edit = crate::commands::find("shape.edit").ok_or_else(|| EngineError::Other("shape.edit is unavailable".into()))?;
+        return (shape_edit.run)(s, &json!({ "layer": id.0, "fill": hex }));
+    }
+
     // The colour and transparency handling are what the key means; don't let params override them.
     for k in ["color", "contents", "pattern", "preserveTransparency", "opacity"] {
         q.remove(k);
@@ -39,6 +88,22 @@ fn fill(s: &mut Session, p: &Value, cmd: &str, background: bool, preserve: bool)
     (edit_fill.run)(s, &Value::Object(q))
 }
 
+/// ⌘⌥⌫: `edit.fill` from history, the History Brush's source unless `state` names another.
+fn fill_history(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "edit.fillHistory";
+    let mut q: Map<String, Value> = match p {
+        Value::Object(m) => m.clone(),
+        Value::Null => Map::new(),
+        _ => return Err(EngineError::BadParams { cmd: CMD.into(), msg: "expected an object".into() }),
+    };
+    for k in ["color", "contents", "pattern"] {
+        q.remove(k);
+    }
+    q.insert("contents".into(), json!("history"));
+    let edit_fill = crate::commands::find("edit.fill").ok_or_else(|| EngineError::Other("Fill is unavailable".into()))?;
+    (edit_fill.run)(s, &Value::Object(q))
+}
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         CommandSpec {
@@ -81,6 +146,16 @@ pub fn specs() -> Vec<CommandSpec> {
             run: |s, p| fill(s, p, "edit.fillBackgroundPreserve", true, true),
             journal: true,
         },
+        CommandSpec {
+            id: "edit.fillHistory",
+            label: "Fill from History",
+            menu: &[],
+            shortcut: Some("Cmd+Alt+Backspace"),
+            params: r##"{"state":n? (default: the History Brush's source, the oldest state still held),"layer":id?,"target":"pixels"|"mask"|"quickMask"|{"channel":i}?,"preserveTransparency":bool?}"##,
+            enabled: fill_enabled,
+            run: fill_history,
+            journal: true,
+        },
     ]
 }
 
@@ -133,6 +208,27 @@ mod tests {
         }
     }
 
+    #[test]
+    fn fill_from_history_restores_the_history_brush_source_in_the_selection() {
+        let mut s = session();
+        assert_eq!(crate::commands::find("edit.fillHistory").and_then(|c| c.shortcut), Some("Cmd+Alt+Backspace"));
+        s.execute("edit.fillForeground", json!({})).unwrap();
+        s.execute("select.rect", json!({"x": 0, "y": 0, "width": 4, "height": 6})).unwrap();
+        s.execute("edit.fillHistory", json!({})).unwrap();
+        // The oldest state (the new, transparent layer) comes back inside the selection only.
+        assert_eq!(px(&s, 1, 1)[3], 0.0);
+        assert_eq!(px(&s, 6, 1), [1.0, 0.0, 0.0, 1.0]);
+        // A named state, and refused ones change nothing.
+        s.execute("select.deselect", json!({})).unwrap();
+        let steps = s.active().unwrap().history.past_len();
+        for bad in [json!({"state": 99}), json!({"state": "x"}), json!(7)] {
+            assert!(s.execute("edit.fillHistory", bad.clone()).is_err(), "{bad}");
+        }
+        assert_eq!(s.active().unwrap().history.past_len(), steps);
+        s.execute("edit.fillHistory", json!({"state": 1})).unwrap();
+        assert_eq!(px(&s, 1, 1), [1.0, 0.0, 0.0, 1.0], "state 1 is after the foreground fill");
+    }
+
     #[test]
     fn background_fills_only_the_selection() {
         let mut s = session();
@@ -204,6 +300,35 @@ mod tests {
         }
     }
 
+    /// The inks of the active layer's pixel at (0, 0), exactly as stored.
+    fn inks(s: &Session) -> Vec<f32> {
+        let st = s.active().unwrap();
+        let surf = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap();
+        surf.read_region(photocraft_geom::Rect::new(0, 0, 1, 1)).into_iter().take(4).collect()
+    }
+
+    /// #4196: a foreground picked as CMYK 100/0/0/0 fills a CMYK document with those inks, not with
+    /// whatever its sRGB stand-in converts back to (100/28/0/17).
+    #[test]
+    fn cmyk_pick_fills_a_cmyk_document_with_the_picked_inks() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 4, "height": 4})).unwrap();
+        s.execute("image.mode.cmyk", json!({})).unwrap();
+        let rgb = photocraft_color::convert::cmyk_to_rgb([1.0, 0.0, 0.0, 0.0]).map(|c| c.clamp(0.0, 1.0));
+        s.execute("tools.setColors", json!({"foreground": rgb, "foregroundCmyk": [1.0, 0.0, 0.0, 0.0]})).unwrap();
+        s.execute("edit.fillForeground", json!({})).unwrap();
+        let got = inks(&s);
+        assert!(got.iter().zip([1.0, 0.0, 0.0, 0.0]).all(|(a, b)| (a - b).abs() < 0.01), "{got:?}");
+    }
+
+    #[test]
+    fn malformed_cmyk_pick_is_an_error_not_a_panic() {
+        let mut s = session();
+        for bad in [json!([1.0]), json!("cyan"), json!([1.0, 0.0, 0.0, "x"]), json!({"c": 1})] {
+            assert!(s.execute("tools.setColors", json!({"foregroundCmyk": bad})).is_err());
+        }
+    }
+
     #[test]
     fn registered_with_photoshop_default_shortcuts() {
         let sc = |id| crate::commands::find(id).and_then(|c| c.shortcut);
@@ -212,4 +337,78 @@ mod tests {
         assert_eq!(sc("edit.fillForegroundPreserve"), Some("Alt+Shift+Backspace"));
         assert_eq!(sc("edit.fillBackgroundPreserve"), Some("Cmd+Shift+Backspace"));
     }
+
+    #[test]
+    fn fill_keys_recolor_shape_layer() {
+        let mut s = session();
+        s.execute("shape.create", json!({"kind": "rect", "rect": [1, 1, 5, 5], "fill": "#000000"})).unwrap();
+        let info = s.execute("shape.info", json!({})).unwrap();
+        assert_eq!(info["fill"], "#000000");
+
+        // Alt+Backspace fills with foreground (#ff0000)
+        s.execute("edit.fillForeground", json!({})).unwrap();
+        let info_fg = s.execute("shape.info", json!({})).unwrap();
+        assert_eq!(info_fg["fill"], "#ff0000");
+
+        // Cmd+Backspace fills with background (#0000ff)
+        s.execute("edit.fillBackground", json!({})).unwrap();
+        let info_bg = s.execute("shape.info", json!({})).unwrap();
+        assert_eq!(info_bg["fill"], "#0000ff");
+
+        // Undo restores previous fill (#ff0000)
+        assert!(s.undo());
+        let info_undone = s.execute("shape.info", json!({})).unwrap();
+        assert_eq!(info_undone["fill"], "#ff0000");
+
+        // Alt+Shift+Backspace also recolors shape
+        s.execute("tools.setColors", json!({"foreground": "#00ff00"})).unwrap();
+        s.execute("edit.fillForegroundPreserve", json!({})).unwrap();
+        let info_shift = s.execute("shape.info", json!({})).unwrap();
+        assert_eq!(info_shift["fill"], "#00ff00");
+
+        // Locked shape layer errors gracefully without crashing
+        s.execute("layer.lockLayers", json!({"pixels": true})).unwrap();
+        for id in &IDS[..4] {
+            let err = s.execute(id, json!({})).unwrap_err().to_string();
+            assert!(err.contains("locked"), "{id}: {err}");
+        }
+    }
+
+    /// The colour of every run of the active type layer, as RGB.
+    fn type_colors(s: &Session) -> Vec<[f32; 3]> {
+        let st = s.active().unwrap();
+        let LayerContent::Text(t) = &st.doc.layer(st.active_layer.unwrap()).unwrap().content else { panic!("not a type layer any more") };
+        t.char_runs().iter().map(|r| r.style.color.to_rgb()).collect()
+    }
+
+    /// #4580: on a type layer the fill keys recolour the text, like Photoshop, instead of being
+    /// disabled; the layer stays editable type.
+    #[test]
+    fn fill_keys_recolor_type_layer() {
+        let mut s = session();
+        s.execute("type.create", json!({"x": 1, "y": 5, "text": "Hello", "size": 4, "color": "#000000"})).unwrap();
+        s.execute("type.setStyle", json!({"range": [0, 2], "color": "#00ff00"})).unwrap();
+        assert_eq!(type_colors(&s).len(), 2, "two runs before the fill");
+        for id in &IDS[..4] {
+            let e = crate::commands::find(id).unwrap().enabled;
+            assert!(e(&s).is_ok(), "{id} on a type layer: {:?}", e(&s));
+        }
+        assert!(crate::commands::find("edit.fillHistory").map(|c| (c.enabled)(&s).is_err()).unwrap());
+
+        s.execute("edit.fillForeground", json!({})).unwrap();
+        assert_eq!(type_colors(&s), [[1.0, 0.0, 0.0]], "every run takes the foreground");
+        let steps = s.active().unwrap().history.past_len();
+        s.execute("edit.fillBackgroundPreserve", json!({})).unwrap();
+        assert_eq!(type_colors(&s), [[0.0, 0.0, 1.0]]);
+        assert_eq!(s.active().unwrap().history.past_len(), steps + 1, "one undo step");
+        assert!(s.undo());
+        assert_eq!(type_colors(&s), [[1.0, 0.0, 0.0]]);
+
+        s.execute("layer.lockLayers", json!({"pixels": true})).unwrap();
+        for id in &IDS[..4] {
+            let err = s.execute(id, json!({})).unwrap_err().to_string();
+            assert!(err.contains("locked"), "{id}: {err}");
+        }
+        assert_eq!(type_colors(&s), [[1.0, 0.0, 0.0]]);
+    }
 }
diff --git a/crates/engine/src/fill_layer_mode_tests.rs b/crates/engine/src/fill_layer_mode_tests.rs
index 69f786baa8..4bcc25ef26 100644
--- a/crates/engine/src/fill_layer_mode_tests.rs
+++ b/crates/engine/src/fill_layer_mode_tests.rs
@@ -122,6 +122,9 @@ fn rgb_documents_keep_rgb_fill_colours() {
 #[test]
 fn gray_fill_converts_with_the_document() {
     let mut s = session("gray", 16);
+    // Tagged sGray, where a gray value reads the same as RGB, so the before/after pixels compare
+    // directly (an untagged gray document takes the Dot Gain 20 %-compatible default).
+    s.execute("edit.assignProfile", json!({"profile": "sgray"})).unwrap();
     s.execute("layer.newFillLayer.solidColor", json!({"color": "#0000ff"})).unwrap();
     let before = pixel(&mut s, 10, 10);
     s.execute("image.mode.rgb", json!({})).unwrap();
diff --git a/crates/engine/src/filters.rs b/crates/engine/src/filters.rs
index 2ccc999b40..a9b6564309 100644
--- a/crates/engine/src/filters.rs
+++ b/crates/engine/src/filters.rs
@@ -52,7 +52,22 @@ fn preserve(p: &Value) -> Preserve {
 fn preset(id: &str) -> Option<(&'static str, FilterParams)> {
     Some(match id {
         "filter.blur.blur" => ("Blur", FilterParams::GaussianBlur { radius: 0.6 }),
-        "filter.blur.blurMore" => ("Blur More", FilterParams::GaussianBlur { radius: 1.4 }),
+        // Photoshop 27.11's Blur More is the 3×3 kernel [1 2 1; 2 2 2; 1 2 1] / 14 (its response
+        // to a single white pixel, exactly).
+        "filter.blur.blurMore" => (
+            "Blur More",
+            FilterParams::Custom {
+                kernel: vec![
+                    0.0, 0.0, 0.0, 0.0, 0.0, //
+                    0.0, 1.0, 2.0, 1.0, 0.0, //
+                    0.0, 2.0, 2.0, 2.0, 0.0, //
+                    0.0, 1.0, 2.0, 1.0, 0.0, //
+                    0.0, 0.0, 0.0, 0.0, 0.0,
+                ],
+                scale: 14.0,
+                offset: 0.0,
+            },
+        ),
         "filter.sharpen.sharpen" => ("Sharpen", FilterParams::UnsharpMask { amount: 60.0, radius: 0.5, threshold: 0.0 }),
         "filter.sharpen.sharpenMore" => ("Sharpen More", FilterParams::UnsharpMask { amount: 150.0, radius: 0.6, threshold: 0.0 }),
         "filter.sharpen.sharpenEdges" => ("Sharpen Edges", FilterParams::UnsharpMask { amount: 100.0, radius: 0.8, threshold: 6.0 }),
@@ -185,7 +200,10 @@ pub fn apply_filter_to_surface(
     if id == crate::plugin_cmds::RUN {
         return crate::plugin_cmds::apply_to_surface(id, params, surf, selection, canvas);
     }
-    let fp = params_for(id, params)?;
+    let mut fp = params_for(id, params)?;
+    // A map that can no longer be read (moved or deleted since) leaves the pixels alone, like an
+    // unknown filter; the command itself already refused an unreadable map when it was added.
+    crate::filters_ext::resolve_map_path(&mut fp, params).ok()?;
     let sel_bounds = selection.map(photocraft_raster::Surface::content_bounds);
     let content = surf.content_bounds();
     let area = algo::output_area(&fp, content, bounds, sel_bounds);
@@ -410,7 +428,7 @@ pub fn specs() -> Vec<CommandSpec> {
 /// The most recent filter command in the session journal, retargeted at the active layer: dialogs
 /// such as the Filter Gallery record the layer they ran on, and Last Filter applies to the
 /// current layer, as in Photoshop (#1270).
-pub(crate) fn last_filter(s: &Session) -> Option<(String, Value)> {
+pub fn last_filter(s: &Session) -> Option<(String, Value)> {
     let (id, mut params) = s.journal.iter().rev().find(|(id, _)| params_for(id, &Value::Null).is_some() && id.starts_with("filter.")).cloned()?;
     if let Value::Object(m) = &mut params {
         m.remove("layer");
@@ -624,6 +642,30 @@ mod tests {
         }
     }
 
+    #[test]
+    fn minimum_signed_offset_matches_its_wrapped_distance() {
+        for depth in [8, 16, 32] {
+            let make_session = || {
+                let mut s = Session::new();
+                s.execute("file.new", json!({"width": 48, "height": 32, "depth": depth})).unwrap();
+                s.execute("layer.new.layer", json!({})).unwrap();
+                paint_pattern(&mut s);
+                s
+            };
+            let mut actual = make_session();
+            let before = active_pixels(&actual);
+            actual.execute("filter.other.offset", json!({"horizontal": i32::MIN, "vertical": i32::MIN})).unwrap();
+            let mut expected = make_session();
+            expected.execute("filter.other.offset", json!({"horizontal": i32::MIN.rem_euclid(48), "vertical": i32::MIN.rem_euclid(32)})).unwrap();
+            let after = active_pixels(&actual);
+            assert_eq!(after, active_pixels(&expected), "depth {depth}");
+            assert_ne!(after, before);
+            actual.execute("edit.undo", json!({})).unwrap();
+            assert_eq!(active_pixels(&actual), before);
+            actual.execute("edit.redo", json!({})).unwrap();
+            assert_eq!(active_pixels(&actual), after);
+        }
+    }
     #[test]
     fn huge_offsets_clamp_instead_of_wrapping() {
         // 3e9 wrapped to a negative offset through `as i32`; it saturates now, so it
diff --git a/crates/engine/src/filters_ext.rs b/crates/engine/src/filters_ext.rs
index bf1656cae7..dae5e9b98b 100644
--- a/crates/engine/src/filters_ext.rs
+++ b/crates/engine/src/filters_ext.rs
@@ -153,7 +153,8 @@ pub fn params_for(id: &str, p: &Value) -> Option<FilterParams> {
             vertical: f(p, "vertical", 10.0).clamp(-999.0, 999.0),
             stretch: s(p, "fit", "stretch") != "tile",
             undefined: undefined(p, "repeat"),
-            map: None,
+            // A Displace imported from PSD carries its map; `mapPath` / `mapDocument` resolve later.
+            map: photocraft_io::smart_map::displace_embedded_map(p),
         },
         "filter.distort.shear" => FilterParams::Shear {
             points: list::<[f32; 2]>(p, "points").unwrap_or_else(|| {
@@ -435,10 +436,8 @@ pub(crate) fn resolve(s: &Session, fp: &mut FilterParams, p: &Value) -> Result<(
         return Ok(());
     }
     let layer = p.get("mapLayer").and_then(Value::as_u64);
-    let img = if let Some(path) = p.get("mapPath").and_then(Value::as_str).filter(|p| !p.is_empty()) {
-        let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("cannot read displacement map `{path}`: {e}")))?;
-        let imported = crate::file_cmds::import(path, &bytes).map_err(|e| EngineError::Other(format!("cannot open displacement map `{path}`: {e}")))?;
-        map_from_document(&imported, layer)
+    let img = if let Some(path) = map_path(p) {
+        map_from_path(path, layer)?
     } else if let Some(d) = p.get("mapDocument") {
         let docs = s.documents();
         let found = match d {
@@ -454,6 +453,30 @@ pub(crate) fn resolve(s: &Session, fp: &mut FilterParams, p: &Value) -> Result<(
     Ok(())
 }
 
+fn map_path(p: &Value) -> Option<&str> {
+    p.get("mapPath").and_then(Value::as_str).filter(|p| !p.is_empty())
+}
+
+/// Displace's map read from a file (flattened, or its `mapLayer`).
+fn map_from_path(path: &str, layer: Option<u64>) -> Result<Option<algo::Image>> {
+    let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("cannot read displacement map `{path}`: {e}")))?;
+    let imported = crate::file_cmds::import(path, &bytes).map_err(|e| EngineError::Other(format!("cannot open displacement map `{path}`: {e}")))?;
+    Ok(map_from_document(&imported, layer))
+}
+
+/// The session-free part of [`resolve`]: Displace's `mapPath`. Smart filters record params, not
+/// the map, so their re-render reads the map again here; without it the filter passed the pixels
+/// through. `mapDocument` needs the session and is left unresolved.
+pub(crate) fn resolve_map_path(fp: &mut FilterParams, p: &Value) -> Result<()> {
+    if let FilterParams::Displace { map, .. } = fp
+        && map.is_none()
+        && let Some(path) = map_path(p)
+    {
+        *map = map_from_path(path, p.get("mapLayer").and_then(Value::as_u64))?.map(Arc::new);
+    }
+    Ok(())
+}
+
 /// Resolves inputs read from the target layer itself: the layer mask as Lens Blur depth.
 pub(crate) fn resolve_in_layer(fp: &mut FilterParams, layer: &Layer, bounds: Rect) {
     if let FilterParams::LensBlur { depth: DepthSource::LayerMask, depth_map, .. } = fp
diff --git a/crates/engine/src/flatten_cmyk_tests.rs b/crates/engine/src/flatten_cmyk_tests.rs
new file mode 100644
index 0000000000..4fd187ceed
--- /dev/null
+++ b/crates/engine/src/flatten_cmyk_tests.rs
@@ -0,0 +1,169 @@
+//! #3778: Flatten Image, Merge Visible and Merge Down keep a CMYK document's ink values instead
+//! of round-tripping them through RGB.
+
+use photocraft_cms::synth::{CmykParams, cmyk_profile};
+use photocraft_color::{ColorMode, PixelFormat, SampleType};
+use photocraft_doc::{Document, Layer, LayerContent, Size};
+use photocraft_geom::Rect;
+use photocraft_raster::Surface;
+use serde_json::json;
+
+use crate::Session;
+
+const W: i32 = 16;
+const H: i32 = 8;
+
+fn canvas() -> Rect {
+    Rect::new(0, 0, W, H)
+}
+
+/// Ink values that vary per pixel and per channel, away from the 8-bit grid.
+fn ink(x: i32, y: i32) -> [f32; 4] {
+    let f = |k: i32| ((x * 7 + y * 13 + k * 29) % 97) as f32 / 96.0 * 0.9 + 0.0371;
+    [f(0), f(1), f(2), f(3)]
+}
+
+/// A 16-bit CMYK document tagged with a synthetic profile (not the built-in coated CMYK), holding
+/// just an opaque Background of varied ink.
+fn cmyk_doc() -> Document {
+    let mut d = Document::new("cmyk", Size::new(W as u32, H as u32), ColorMode::Cmyk, SampleType::U16);
+    let profile =
+        cmyk_profile(&CmykParams { description: "Flatten Test CMYK".into(), tvi: [0.26, 0.26, 0.26, 0.3], grid_a2b: 5, grid_b2a: 9, ..Default::default() });
+    d.icc_profile = Some(profile.to_bytes());
+    let mut bg = Surface::new(PixelFormat::new(ColorMode::Cmyk, SampleType::U16, false));
+    for y in 0..H {
+        for x in 0..W {
+            bg.write_pixel(x, y, &ink(x, y));
+        }
+    }
+    let mut layer = Layer::new("Background", LayerContent::Raster(bg));
+    layer.locks.transparency = true;
+    layer.locks.position = true;
+    d.layers.push(layer);
+    d
+}
+
+/// A layer above the Background: solid ink on the left half, half-transparent ink on a strip,
+/// nothing on the rest.
+fn upper_layer() -> Layer {
+    let mut s = Surface::new(PixelFormat::new(ColorMode::Cmyk, SampleType::U16, true));
+    s.fill_rect(Rect::new(0, 0, W / 2, H), &[0.8123, 0.1234, 0.4567, 0.0789, 1.0]);
+    s.fill_rect(Rect::new(W / 2, 0, W / 2 + 2, H), &[0.25, 0.5, 0.75, 0.1, 0.5]);
+    Layer::new("Layer 1", LayerContent::Raster(s))
+}
+
+fn session(doc: Document) -> Session {
+    let mut s = Session::new();
+    s.add_document(doc, None);
+    s
+}
+
+/// The bottom layer's ink values (C, M, Y, K per pixel, without any alpha channel).
+fn pixels(s: &Session) -> Vec<f32> {
+    let surf = s.active().unwrap().doc.layers[0].surface().unwrap();
+    let n = surf.channels();
+    surf.read_region(canvas()).chunks_exact(n).flat_map(|p| p[..4].to_vec()).collect()
+}
+
+fn bottom_format(s: &Session) -> PixelFormat {
+    s.active().unwrap().doc.layers[0].surface().unwrap().format()
+}
+
+#[test]
+fn flattening_a_lone_cmyk_background_keeps_its_pixels() {
+    let doc = cmyk_doc();
+    let before = doc.layers[0].surface().unwrap().read_region(canvas());
+    let mut s = session(doc);
+    s.execute("layer.flattenImage", json!({})).unwrap();
+    let fmt = bottom_format(&s);
+    assert_eq!((fmt.mode, fmt.sample), (ColorMode::Cmyk, SampleType::U16), "16-bit CMYK stays 16-bit CMYK");
+    let moved = pixels(&s).iter().zip(&before).filter(|(a, b)| a != b).count();
+    assert_eq!(moved, 0, "a single Background must flatten to the same ink values");
+}
+
+/// What a Normal 100 % layer over the Background gives, worked out in ink values: the solid part
+/// replaces the ink, the half-transparent strip mixes half and half, the rest shows the Background.
+fn expected_two_layers() -> Vec<f32> {
+    let mut out = Vec::new();
+    for y in 0..H {
+        for x in 0..W {
+            let below = ink(x, y);
+            let px = if x < W / 2 {
+                [0.8123, 0.1234, 0.4567, 0.0789]
+            } else if x < W / 2 + 2 {
+                let top = [0.25, 0.5, 0.75, 0.1];
+                [0, 1, 2, 3].map(|c| top[c] * 0.5 + below[c] * 0.5)
+            } else {
+                below
+            };
+            out.extend_from_slice(&px);
+        }
+    }
+    out
+}
+
+fn assert_close(got: &[f32], want: &[f32], what: &str) {
+    assert_eq!(got.len(), want.len(), "{what}: pixel count");
+    // One 16-bit code (the stored value is quantised to 1/65535).
+    let worst = got.iter().zip(want).map(|(a, b)| (a - b).abs()).fold(0.0f32, f32::max);
+    assert!(worst <= 1.0 / 65535.0 + 1e-6, "{what}: ink values moved by up to {worst}");
+}
+
+#[test]
+fn flattening_normal_cmyk_layers_composites_in_ink_values() {
+    let mut doc = cmyk_doc();
+    doc.layers.push(upper_layer());
+    let mut s = session(doc);
+    s.execute("layer.flattenImage", json!({})).unwrap();
+    assert_eq!(s.active().unwrap().doc.layers.len(), 1);
+    assert_eq!(bottom_format(&s).sample, SampleType::U16);
+    assert_close(&pixels(&s), &expected_two_layers(), "Flatten Image");
+}
+
+#[test]
+fn merge_visible_and_merge_down_keep_cmyk_ink_values() {
+    for cmd in ["layer.mergeVisible", "layer.mergeDown"] {
+        let mut doc = cmyk_doc();
+        let upper = upper_layer();
+        let id = upper.id;
+        doc.layers.push(upper);
+        let mut s = session(doc);
+        s.execute(cmd, json!({"layer": id.0})).unwrap();
+        assert_eq!(s.active().unwrap().doc.layers.len(), 1, "{cmd}");
+        assert_eq!(bottom_format(&s).sample, SampleType::U16, "{cmd}");
+        assert_close(&pixels(&s), &expected_two_layers(), cmd);
+    }
+}
+
+/// A stack the ink-value path can't take (a Multiply layer) still goes through the compositor,
+/// but separates back through the document's profile, the one it read the ink through, so the
+/// round trip lands near the original ink instead of on the built-in profile's separation.
+#[test]
+fn compositor_flatten_separates_through_the_documents_profile() {
+    let mut doc = cmyk_doc();
+    // Light inks, inside the printable gamut, so a separation can give them back.
+    let bg = doc.layers[0].surface_mut().unwrap();
+    for y in 0..H {
+        for x in 0..W {
+            bg.write_pixel(x, y, &ink(x, y).map(|v| v * 0.4));
+        }
+    }
+    let before = doc.layers[0].surface().unwrap().read_region(canvas());
+    let mut empty = Layer::new("Layer 1", LayerContent::Raster(Surface::new(PixelFormat::new(ColorMode::Cmyk, SampleType::U16, true))));
+    empty.blend = photocraft_color::blend::BlendMode::Multiply;
+    doc.layers.push(empty);
+    let mut s = session(doc);
+    s.execute("layer.flattenImage", json!({})).unwrap();
+    // Compare what the inks print as (a CMYK colour has many separations): RGB through the profile.
+    let d = &s.active().unwrap().doc;
+    let space = photocraft_compose::cmyk_space(d);
+    let shown = |v: &[f32]| -> Vec<[f32; 3]> {
+        photocraft_color::convert::with_cmyk_space(space.as_ref(), || v.as_chunks::<4>().0.iter().map(|p| photocraft_color::convert::cmyk_to_rgb(*p)).collect())
+    };
+    let (a, b) = (shown(&pixels(&s)), shown(&before));
+    let diffs: Vec<f32> = a.iter().zip(&b).flat_map(|(p, q)| (0..3).map(move |c| (p[c] - q[c]).abs())).collect();
+    let mean = diffs.iter().sum::<f32>() / diffs.len() as f32;
+    // The synthetic profile's small tables don't round-trip exactly; the built-in profile's
+    // separation lands about 0.08 off on average.
+    assert!(mean < 0.03, "flattening shifted the printed colour by {mean} on average");
+}
diff --git a/crates/engine/src/float_cmds.rs b/crates/engine/src/float_cmds.rs
index 892f754748..e5450b2339 100644
--- a/crates/engine/src/float_cmds.rs
+++ b/crates/engine/src/float_cmds.rs
@@ -8,7 +8,8 @@
 //! - `select.drop` drops the piece into its layer and moves the selection with it, as one history
 //!   step.
 //! - Any other command drops the piece first (so it lands exactly where it was shown), except Undo,
-//!   which puts it back where it was cut (nothing was changed yet).
+//!   which puts it back where it was cut (nothing was changed yet), and `history.selectState`,
+//!   which puts it back and then returns to the chosen state.
 //!
 //! While floating, the document is unchanged; [`displayed`] gives the document with the piece at
 //! its offset, for the canvas. The selection stays where it was until the drop.
@@ -58,7 +59,7 @@ impl CutParts {
         // A mask has no alpha: it keeps its format, and the cut leaves background colour.
         let mut rest = if mask { surf.clone() } else { full.clone() };
         let mut piece = Surface::new(with_alpha);
-        let fill = !copy && (mask || crate::extra_cmds::is_background(l));
+        let fill = !copy && (mask || doc.is_background(layer));
         // A mask's untouched pixels (its default, e.g. white) move too, so take the whole canvas.
         let b = sel.content_bounds().intersect(&if mask { doc.bounds() } else { surf.content_bounds() });
         if !b.is_empty() {
@@ -165,7 +166,7 @@ fn can_float(s: &Session) -> std::result::Result<(), String> {
 /// floating? The Background is position-locked, but its selected pixels move (Photoshop).
 pub fn locked_for_float(doc: &Document, l: &photocraft_doc::Layer) -> bool {
     let locks = doc.effective_locks(l.id);
-    locks.all || (locks.position && !crate::extra_cmds::is_background(l))
+    locks.all || (locks.position && !doc.is_background(l.id))
 }
 
 fn float(s: &mut Session, p: &Value) -> Result<Value> {
@@ -221,6 +222,13 @@ pub(crate) fn before_command(s: &mut Session, id: &str) -> Result<Option<Value>>
             st.floating = None;
             Ok(Some(json!({"floating": "returned"})))
         }
+        // Returning to a History state puts the piece back too (it never reached the document),
+        // and then moves the history: dropping it first would add a step and discard the redo
+        // states the jump may be heading for.
+        "history.selectState" => {
+            st.floating = None;
+            Ok(None)
+        }
         _ if keeps_floating(id) => Ok(None),
         _ => drop_floating(s).map(|_| None),
     }
diff --git a/crates/engine/src/frame_cmds.rs b/crates/engine/src/frame_cmds.rs
index df84bdcfd1..c97006e746 100644
--- a/crates/engine/src/frame_cmds.rs
+++ b/crates/engine/src/frame_cmds.rs
@@ -137,7 +137,7 @@ fn new_frame(s: &mut Session, p: &Value) -> Result<Value> {
         let gid = match content {
             Some(id) => {
                 let l = doc.layer(id).ok_or(EngineError::NoLayer(id))?;
-                if !matches!(l.content, LayerContent::Raster(_)) || crate::extra_cmds::is_background(l) {
+                if !matches!(l.content, LayerContent::Raster(_)) || doc.is_background(id) {
                     return Err(bad("only a pixel layer (not the Background) can go in a frame".into()));
                 }
                 let gid = doc.insert_above(Some(id), Layer::group(name, vec![]));
diff --git a/crates/engine/src/history_cmds.rs b/crates/engine/src/history_cmds.rs
index bb9cb34391..cc18df581e 100644
--- a/crates/engine/src/history_cmds.rs
+++ b/crates/engine/src/history_cmds.rs
@@ -199,8 +199,39 @@ fn has_doc(s: &Session) -> std::result::Result<(), String> {
     s.active().map(|_| ()).ok_or_else(|| "no document open".into())
 }
 
+/// `history.undo` / `history.redo` enable predicates, matching `edit.undo` / `edit.redo`.
+fn can_undo(s: &Session) -> std::result::Result<(), String> {
+    s.active().filter(|d| d.history.can_undo()).map(|_| ()).ok_or_else(|| "nothing to undo".into())
+}
+
+fn can_redo(s: &Session) -> std::result::Result<(), String> {
+    s.active().filter(|d| d.history.can_redo()).map(|_| ()).ok_or_else(|| "nothing to redo".into())
+}
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
+        // `history.*` aliases of Edit › Undo / Redo, so a client reaching for the History namespace
+        // finds them (`edit.undo` / `edit.redo` remain the menu items and own the shortcuts, #3675).
+        CommandSpec {
+            id: "history.undo",
+            label: "Undo",
+            menu: &[],
+            shortcut: None,
+            params: "{} (the same action as `edit.undo`)",
+            enabled: can_undo,
+            run: |s, _| Ok(json!(s.undo())),
+            journal: false,
+        },
+        CommandSpec {
+            id: "history.redo",
+            label: "Redo",
+            menu: &[],
+            shortcut: None,
+            params: "{} (the same action as `edit.redo`)",
+            enabled: can_redo,
+            run: |s, _| Ok(json!(s.redo())),
+            journal: false,
+        },
         CommandSpec {
             id: "history.deleteState",
             label: "Delete State",
@@ -282,6 +313,16 @@ mod tests {
         s.active().unwrap().history.entries()
     }
 
+    #[test]
+    fn history_undo_and_redo_alias_edit_undo_and_redo() {
+        let mut s = session();
+        let n = s.active().unwrap().history.past_len();
+        s.execute("history.undo", json!({})).unwrap();
+        assert_eq!(s.active().unwrap().history.past_len(), n - 1, "history.undo steps back like edit.undo");
+        s.execute("history.redo", json!({})).unwrap();
+        assert_eq!(s.active().unwrap().history.past_len(), n, "history.redo steps forward like edit.redo");
+    }
+
     #[test]
     fn delete_current_state_steps_back_and_drops_it() {
         let mut s = session();
diff --git a/crates/engine/src/history_select_cmds.rs b/crates/engine/src/history_select_cmds.rs
new file mode 100644
index 0000000000..e05a859a5a
--- /dev/null
+++ b/crates/engine/src/history_select_cmds.rs
@@ -0,0 +1,258 @@
+//! History panel › click a state: `history.selectState` returns the document to that state in one
+//! step (#2966), as Photoshop does. The panel used to run Edit › Undo / Redo once per state: each
+//! bumped the document revision, so the canvas could no longer tell what the jump changed and
+//! recomposited (and re-uploaded) the whole document, plus N rounds of per-command bookkeeping.
+//!
+//! States are numbered as the History panel lists them, like `history.deleteState`: 0 is the
+//! oldest state still held, `past` (the number of undo states) is the current one, and the redo
+//! states (dimmed in the panel) follow it. Jumping back leaves the skipped states redoable;
+//! jumping forward redoes them. Nothing is discarded until the next edit.
+
+use serde_json::{Value, json};
+
+use crate::commands::{CommandSpec, int};
+use crate::{EngineError, Result, Session};
+
+const CMD: &str = "history.selectState";
+
+fn bad(msg: impl Into<String>) -> EngineError {
+    EngineError::BadParams { cmd: CMD.into(), msg: msg.into() }
+}
+
+fn select_state(s: &mut Session, p: &Value) -> Result<Value> {
+    let st = s.active().ok_or(EngineError::NoDocument)?;
+    let past = st.history.past_len();
+    let last = past.saturating_add(st.history.redo_labels().count());
+    let v = match p.get("state") {
+        None | Some(Value::Null) => return Err(bad("missing `state` (the History entry to return to, 0 = oldest)")),
+        Some(_) => int(p, "state").ok_or_else(|| bad("`state` must be a number"))?,
+    };
+    let target = usize::try_from(v).ok().filter(|i| *i <= last).ok_or_else(|| bad(format!("`state` = {v} is not a state (0..={last})")))?;
+    // A background job is computing from the current state: it must not move under it.
+    if s.active_job().is_some() {
+        return Err(EngineError::Other("the history can't move while a command is still running on this document".into()));
+    }
+    let st = s.active_mut().ok_or(EngineError::NoDocument)?;
+    if target == past {
+        return Ok(json!({ "state": target, "changed": false }));
+    }
+    st.coalesce = None;
+    // Step the history itself (pointer moves, no pixels touched), then make the reached state
+    // current once: one revision, one damage rect for the canvas.
+    let start = st.doc.clone();
+    let mut doc = start.clone();
+    let mut layers = None;
+    let mut at = past;
+    while at != target {
+        let step = if target < at { st.history.undo(doc.clone()) } else { st.history.redo(doc.clone()) };
+        let Some((d, l)) = step else { break };
+        doc = d;
+        layers = Some(l);
+        at = if target < at { at - 1 } else { at + 1 };
+    }
+    let Some(layers) = layers else {
+        return Err(EngineError::Other("the history can't step right now".into()));
+    };
+    // Save As changes file identity outside history, as Edit › Undo keeps it.
+    if doc.name != start.name {
+        std::sync::Arc::make_mut(&mut doc).name.clone_from(&start.name);
+    }
+    let damage = crate::layer_multi_cmds::step_damage(&start, &doc);
+    st.doc = doc;
+    crate::restore_target(st, layers);
+    st.revision += 1;
+    st.last_damage = damage;
+    if at != target {
+        // Not reached (the bounds were checked): the document is consistent at the state reached.
+        return Err(EngineError::Other(format!("the history stopped at state {at}")));
+    }
+    Ok(json!({ "state": target, "changed": true, "current": st.history.entries().last() }))
+}
+
+fn can_select(s: &Session) -> std::result::Result<(), String> {
+    let st = s.active().ok_or_else(|| "no document open".to_string())?;
+    if st.history.can_undo() || st.history.can_redo() { Ok(()) } else { Err("the history holds only one state".into()) }
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![CommandSpec {
+        id: CMD,
+        label: "Select History State",
+        menu: &[],
+        shortcut: None,
+        params: r##"{"state":index} (History entry as the panel lists them: 0 = oldest, then the current state, then the redo states) → {state,changed,current?}: returns the document to that state in one step; the states after it stay redoable"##,
+        enabled: can_select,
+        run: select_state,
+        journal: true,
+    }]
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use super::*;
+
+    /// A document with four steps after Open, each targeting different layers.
+    fn session() -> Session {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 64, "height": 32})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("edit.fill", json!({"color": "#00ff00"})).unwrap();
+        s
+    }
+
+    type Look = (Arc<photocraft_doc::Document>, Option<photocraft_doc::LayerId>, Vec<photocraft_doc::LayerId>, Vec<String>, Vec<String>);
+
+    /// What the panel can see of a session: the document, the targeted layers, the entries and
+    /// the redo states.
+    fn look(s: &Session) -> Look {
+        let st = s.active().unwrap();
+        (st.doc.clone(), st.active_layer, st.selected_layers.clone(), st.history.entries(), st.history.redo_labels().map(str::to_string).collect())
+    }
+
+    /// Step from the current state to `target` with Edit › Undo / Redo, note what that gives, and
+    /// step back.
+    fn stepped(s: &mut Session, target: usize) -> Look {
+        let current = s.active().unwrap().history.past_len();
+        let (there, back) = if target < current { ("edit.undo", "edit.redo") } else { ("edit.redo", "edit.undo") };
+        let n = target.abs_diff(current);
+        for _ in 0..n {
+            s.execute(there, json!({})).unwrap();
+        }
+        let seen = look(s);
+        for _ in 0..n {
+            s.execute(back, json!({})).unwrap();
+        }
+        seen
+    }
+
+    fn same(a: &Look, b: &Look) {
+        assert!(Arc::ptr_eq(&a.0, &b.0), "the same document");
+        assert_eq!((&a.1, &a.2, &a.3, &a.4), (&b.1, &b.2, &b.3, &b.4));
+    }
+
+    #[test]
+    fn jumping_back_and_forward_matches_stepping() {
+        for target in 0..=4usize {
+            for from_back in [0usize, 2, 4] {
+                // Start `from_back` states before the end, then jump to `target`.
+                let mut s = session();
+                for _ in 0..from_back {
+                    s.execute("edit.undo", json!({})).unwrap();
+                }
+                let current = 4 - from_back;
+                let expected = stepped(&mut s, target);
+                let rev = s.active().unwrap().revision;
+                let r = s.execute(CMD, json!({"state": target})).unwrap();
+                assert_eq!(r["state"], json!(target));
+                assert_eq!(r["changed"], json!(target != current));
+                same(&look(&s), &expected);
+                assert_eq!(s.active().unwrap().history.past_len(), target);
+                let bumps = s.active().unwrap().revision - rev;
+                assert_eq!(bumps, u64::from(target != current), "{from_back} → {target}: one revision for the jump");
+            }
+        }
+    }
+
+    #[test]
+    fn a_jump_reports_only_the_pixels_it_changed() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 400, "height": 300})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("select.rect", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+        s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+        s.execute("select.rect", json!({"x": 40, "y": 30, "width": 10, "height": 10})).unwrap();
+        s.execute("edit.fill", json!({"color": "#0000ff"})).unwrap();
+        let past = s.active().unwrap().history.past_len();
+        s.execute(CMD, json!({"state": past - 4})).unwrap();
+        let damage = s.active().unwrap().last_damage.expect("a bounded damage rect, not a full recomposite");
+        assert!(damage.width() < 400 && damage.height() < 300, "{damage:?}");
+        // And forward again.
+        s.execute(CMD, json!({"state": past})).unwrap();
+        assert!(s.active().unwrap().last_damage.is_some());
+    }
+
+    #[test]
+    fn redo_states_survive_a_jump_and_go_with_the_next_edit() {
+        let mut s = session();
+        let all = s.active().unwrap().history.entries();
+        s.execute(CMD, json!({"state": 1})).unwrap();
+        let (_, _, _, entries, redo) = look(&s);
+        assert_eq!(entries, all[..2].to_vec());
+        assert_eq!(redo, all[2..].to_vec(), "the later states are dimmed, next one first");
+        assert!(s.is_enabled(CMD));
+        s.execute("edit.fill", json!({"color": "#0000ff"})).unwrap();
+        assert!(!s.active().unwrap().history.can_redo(), "a new step discards them");
+    }
+
+    #[test]
+    fn select_state_restores_the_layers_the_state_targeted() {
+        let mut s = session();
+        let bottom = s.active().unwrap().doc.layers.first().unwrap().id;
+        // Target the bottom layer, then jump back to the first fill: its layer comes back, as
+        // with Undo.
+        s.select_layer(bottom).unwrap();
+        let expected = stepped(&mut s, 2);
+        s.select_layer(bottom).unwrap();
+        s.execute(CMD, json!({"state": 2})).unwrap();
+        same(&look(&s), &expected);
+        assert_ne!(s.active().unwrap().active_layer, Some(bottom));
+    }
+
+    #[test]
+    fn a_floating_piece_goes_back_and_the_jump_still_happens() {
+        let mut s = session();
+        s.execute("select.rect", json!({"x": 2, "y": 2, "width": 8, "height": 8})).unwrap();
+        s.execute("select.float", json!({"dx": 5, "dy": 0})).unwrap();
+        let all = s.active().unwrap().history.entries();
+        let doc = s.active().unwrap().doc.clone();
+        assert!(s.active().unwrap().floating.is_some());
+        s.execute(CMD, json!({"state": 1})).unwrap();
+        let st = s.active().unwrap();
+        assert!(st.floating.is_none(), "the piece went back, it wasn't dropped");
+        assert_eq!(st.history.past_len(), 1);
+        let redo: Vec<String> = st.history.redo_labels().map(str::to_string).collect();
+        assert_eq!(redo, all[2..].to_vec(), "no Drop step was added");
+        // Forward to the state the piece was floated on: the document as it was, without the piece.
+        s.execute(CMD, json!({"state": all.len() - 1})).unwrap();
+        assert!(Arc::ptr_eq(&s.active().unwrap().doc, &doc));
+    }
+
+    #[test]
+    fn select_state_refuses_bad_params_and_changes_nothing() {
+        let mut s = Session::new();
+        assert!(s.execute(CMD, json!({"state": 0})).is_err(), "no document");
+        assert!(!s.is_enabled(CMD));
+        s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
+        assert!(!s.is_enabled(CMD), "only the opening state");
+        let mut s = session();
+        s.execute("edit.undo", json!({})).unwrap();
+        let before = look(&s);
+        let rev = s.active().unwrap().revision;
+        for p in [
+            json!({}),
+            json!({"state": null}),
+            json!({"state": -1}),
+            json!({"state": 5}),
+            json!({"state": 99}),
+            json!({"state": i64::MAX}),
+            json!({"state": f64::MAX}),
+            json!({"state": "x"}),
+            json!({"state": "1"}),
+            json!({"state": [1]}),
+            json!({"state": {"i": 1}}),
+            json!({"state": true}),
+            json!([1]),
+        ] {
+            assert!(s.execute(CMD, p.clone()).is_err(), "{p}");
+            let now = look(&s);
+            assert!(Arc::ptr_eq(&now.0, &before.0) && now.3 == before.3 && now.4 == before.4, "{p} changed nothing");
+        }
+        assert_eq!(s.active().unwrap().revision, rev);
+        // The last redo state is reachable.
+        assert!(s.execute(CMD, json!({"state": 4})).is_ok());
+    }
+}
diff --git a/crates/engine/src/image_cmds.rs b/crates/engine/src/image_cmds.rs
index c8055a4d3c..15a71376b0 100644
--- a/crates/engine/src/image_cmds.rs
+++ b/crates/engine/src/image_cmds.rs
@@ -99,7 +99,9 @@ pub(crate) fn reidentify_copied_layers(doc: &mut Document) {
     }
 }
 
-pub(crate) fn scale_effects(fx: &mut Effects, k: f32) {
+/// Scale every size and distance of a style by `k` (Image Size's Scale Styles, Layer Style ›
+/// Scale Effects, and previews that draw a style at a reduced resolution).
+pub fn scale_effects(fx: &mut Effects, k: f32) {
     for e in &mut fx.items {
         match e {
             Effect::DropShadow(s) | Effect::InnerShadow(s) => {
@@ -163,8 +165,26 @@ fn image_size(s: &mut Session, p: &Value) -> Result<Value> {
     let d = s.active().ok_or(EngineError::NoDocument)?;
     let (ow, oh) = (d.doc.size.width, d.doc.size.height);
     let resample = parse_resample(p.get("resample").and_then(Value::as_str).unwrap_or("bicubic"));
-    let pw = p.get("width").and_then(Value::as_f64);
-    let ph = p.get("height").and_then(Value::as_f64);
+    let mut pw = p.get("width").and_then(Value::as_f64);
+    let mut ph = p.get("height").and_then(Value::as_f64);
+    // `percent` scales both sides (what a Photoshop action records as "200%"); an explicit side wins.
+    if let Some(pc) = p.get("percent") {
+        let pc = pc.as_f64().filter(|v| v.is_finite() && *v > 0.0).ok_or_else(|| bad("image.imageSize", "`percent` must be a positive number"))?;
+        pw = pw.or(Some(ow as f64 * pc / 100.0));
+        ph = ph.or(Some(oh as f64 * pc / 100.0));
+    }
+    // `keepPrintSize`: only the resolution given, the pixels follow it (Photoshop's Image Size
+    // with Resample on, as an action records it).
+    if p.get("keepPrintSize").and_then(Value::as_bool) == Some(true)
+        && pw.is_none()
+        && ph.is_none()
+        && let Some(r) = p.get("resolution").and_then(Value::as_f64)
+    {
+        let r = r.clamp(1.0, 10_000.0);
+        let old = f64::from(d.doc.resolution_dpi).max(1.0);
+        pw = Some(ow as f64 * r / old);
+        ph = Some(oh as f64 * r / old);
+    }
     // Missing dimension keeps the aspect ratio.
     let (nw, nh) = match (pw, ph) {
         (Some(w), Some(h)) => (w, h),
@@ -298,7 +318,7 @@ fn crop_doc(doc: &mut Document, cmd: &str, r: Rect, delete_pixels: bool, extensi
     // A Background cannot hold transparent pixels: like an opaque Canvas Size extension, the area
     // an extending Crop adds is filled with the extension (background) colour.
     if extends
-        && let Some(bg) = doc.layers.first_mut().filter(|l| crate::extra_cmds::is_background(l))
+        && let Some(bg) = doc.background_mut()
         && let LayerContent::Raster(surf) = &mut bg.content
     {
         let old = old_canvas.translate(dx, dy);
@@ -315,22 +335,28 @@ fn crop_doc(doc: &mut Document, cmd: &str, r: Rect, delete_pixels: bool, extensi
     Ok(())
 }
 
-fn anchor_factors(a: &str) -> (f64, f64) {
-    let x = if a.contains("Left") || a == "left" {
-        0.0
-    } else if a.contains("Right") || a == "right" {
-        1.0
-    } else {
-        0.5
-    };
-    let y = if a.starts_with("top") {
-        0.0
-    } else if a.starts_with("bottom") {
-        1.0
-    } else {
-        0.5
-    };
-    (x, y)
+/// The nine documented canvas-size anchors, in the order the command lists them, each mapped to
+/// its (x, y) factor (0.0 = top/left edge, 0.5 = centre, 1.0 = bottom/right edge).
+const ANCHORS: [(&str, (f64, f64)); 9] = [
+    ("topLeft", (0.0, 0.0)),
+    ("top", (0.5, 0.0)),
+    ("topRight", (1.0, 0.0)),
+    ("left", (0.0, 0.5)),
+    ("center", (0.5, 0.5)),
+    ("right", (1.0, 0.5)),
+    ("bottomLeft", (0.0, 1.0)),
+    ("bottom", (0.5, 1.0)),
+    ("bottomRight", (1.0, 1.0)),
+];
+
+/// Resolves an anchor name to its (x, y) factors, matching the nine documented values exactly.
+/// Anything else is an error naming `anchor` and listing them, rather than resolving the two axes
+/// independently (which let a misspelling like `"topleft"` land between two valid anchors, #2946).
+fn anchor_factors(cmd: &str, a: &str) -> Result<(f64, f64)> {
+    ANCHORS.iter().find(|(name, _)| *name == a).map(|&(_, f)| f).ok_or_else(|| {
+        let names = ANCHORS.iter().map(|&(n, _)| n).collect::<Vec<_>>().join("|");
+        bad(cmd, format!("`anchor` must be one of {names}"))
+    })
 }
 
 fn extension_color(s: &Session, p: &Value) -> [f32; 4] {
@@ -357,7 +383,7 @@ fn canvas_size(s: &mut Session, p: &Value) -> Result<Value> {
     let h = p.get("height").and_then(Value::as_f64).unwrap_or(if relative { 0.0 } else { oh });
     let (nw, nh) = if relative { (ow + w, oh + h) } else { (w, h) };
     let (nw, nh) = (nw.round().clamp(1.0, 300_000.0) as u32, nh.round().clamp(1.0, 300_000.0) as u32);
-    let (ax, ay) = anchor_factors(p.get("anchor").and_then(Value::as_str).unwrap_or("center"));
+    let (ax, ay) = anchor_factors("image.canvasSize", p.get("anchor").and_then(Value::as_str).unwrap_or("center"))?;
     let dx = ((nw as f64 - ow) * ax).round() as i32;
     let dy = ((nh as f64 - oh) * ay).round() as i32;
     let ext = extension_color(s, p);
@@ -373,16 +399,13 @@ fn canvas_size(s: &mut Session, p: &Value) -> Result<Value> {
         // A shrink or no-op resize must not silently convert the Background.
         if ext[3] == 0.0
             && (nw > ow as u32 || nh > oh as u32)
-            && let Some(bg) = doc.layers.first_mut()
-            && crate::extra_cmds::is_background(bg)
+            && let Some(bg) = doc.background_mut()
         {
             crate::extra_cmds::unlock_background(bg);
         }
         // The locked Background layer is extended with the extension colour.
         if ext[3] > 0.0
-            && let Some(bg) = doc.layers.first_mut()
-            && bg.name == "Background"
-            && bg.locks.transparency
+            && let Some(bg) = doc.background_mut()
             && let LayerContent::Raster(surf) = &mut bg.content
         {
             let fmt = surf.format();
@@ -645,7 +668,20 @@ fn convert_depth(s: &mut Session, depth: SampleType) -> Result<Value> {
         return Ok(Value::Null);
     }
     s.edit("Bit Depth", |doc, _| {
+        // 32-bit documents hold linear light (as Photoshop's do: grey 128 becomes 0.2159, measured
+        // in Photoshop 27.11), so the colour samples cross the document's tone curve when the
+        // depth crosses 32 bits: decoded after widening, encoded before narrowing (so no linear
+        // value is quantised to 8 or 16 bits). Masks, alpha and channels are not colour.
+        let crosses = (current == SampleType::F32) != (depth == SampleType::F32) && matches!(doc.mode, ColorMode::Rgb | ColorMode::Grayscale);
+        let to_linear = depth == SampleType::F32;
+        let transfer = photocraft_compose::adjust::Transfer::for_document(doc.mode, if to_linear { current } else { depth });
+        if crosses && !to_linear {
+            for_each_surface(&mut doc.layers, false, &mut |surf, _| surf.map_color(|v| transfer.encode(v).clamp(0.0, 1.0)));
+        }
         convert_layers_depth(&mut doc.layers, depth);
+        if crosses && to_linear {
+            for_each_surface(&mut doc.layers, false, &mut |surf, _| surf.map_color(|v| transfer.decode(v)));
+        }
         for ch in doc.channels.iter_mut().chain(doc.quick_mask.as_mut()) {
             let f = ch.surface.format().with_sample(depth);
             ch.surface = ch.surface.convert(f);
@@ -695,7 +731,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "image.imageSize",
             "Image Size…",
             ["Image"],
-            r##"{"width":px,"height":px,"resolution":ppi,"resample":"automatic|preserveDetails|bicubicSmoother|bicubicSharper|bicubicAutomatic|bicubic|nearest|bilinear|lanczos|none"="bicubic"} → {width,height} (the document's size after the command; "none" changes the resolution only)"##,
+            r##"{"width":px,"height":px,"percent":%? (both sides; an explicit side wins),"resolution":ppi,"keepPrintSize":bool=false (with only a resolution: resample the pixels to keep the print size),"resample":"automatic|preserveDetails|bicubicSmoother|bicubicSharper|bicubicAutomatic|bicubic|nearest|bilinear|lanczos|none"="bicubic"} → {width,height} (the document's size after the command; "none" changes the resolution only)"##,
             has_doc,
             image_size
         ),
@@ -838,6 +874,21 @@ mod tests {
         &s.active().unwrap().doc
     }
 
+    /// Resample on with only a new resolution keeps the print size, as Photoshop's Image Size
+    /// does (an action's `imageSize` with `Rslt` alone); without `keepPrintSize` only the
+    /// resolution changes.
+    #[test]
+    fn image_size_keep_print_size_resamples_to_the_resolution() {
+        let mut s = session();
+        s.execute("image.imageSize", json!({"resolution": 144, "resample": "bicubic"})).unwrap();
+        assert_eq!((doc(&s).size, doc(&s).resolution_dpi), (Size::new(40, 20), 144.0));
+        s.execute("image.imageSize", json!({"resolution": 288, "resample": "bicubic", "keepPrintSize": true})).unwrap();
+        assert_eq!((doc(&s).size, doc(&s).resolution_dpi), (Size::new(80, 40), 288.0));
+        // An explicit side still wins.
+        s.execute("image.imageSize", json!({"width": 20, "resolution": 72, "resample": "bicubic", "keepPrintSize": true})).unwrap();
+        assert_eq!(doc(&s).size, Size::new(20, 10));
+    }
+
     #[test]
     fn image_size_scales_everything() {
         for resample in ["bicubic", "bicubicSmoother", "bicubicSharper", "bicubicAutomatic", "automatic", "bilinear", "nearest", "lanczos", "preserveDetails"] {
@@ -980,6 +1031,42 @@ mod tests {
         assert_eq!(doc(&s).layers[1].surface().unwrap().content_bounds(), Rect::new(20, 10, 30, 20));
     }
 
+    #[test]
+    fn canvas_size_anchor_offsets_and_rejects_unlisted() {
+        // 64x48 -> 100x80: dx spans 36 and dy spans 32, so each anchor factor lands on a known
+        // offset. All nine documented values must anchor exactly where they do today (#2946).
+        let expected = [
+            ("topLeft", [0, 0]),
+            ("top", [18, 0]),
+            ("topRight", [36, 0]),
+            ("left", [0, 16]),
+            ("center", [18, 16]),
+            ("right", [36, 16]),
+            ("bottomLeft", [0, 32]),
+            ("bottom", [18, 32]),
+            ("bottomRight", [36, 32]),
+        ];
+        for (anchor, off) in expected {
+            let mut s = Session::new();
+            s.execute("file.new", json!({"width": 64, "height": 48, "background": "white"})).unwrap();
+            let r = s.execute("image.canvasSize", json!({"width": 100, "height": 80, "anchor": anchor})).unwrap();
+            assert_eq!(r["offset"], json!(off), "anchor {anchor}");
+        }
+        // An omitted anchor still defaults to center.
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 64, "height": 48, "background": "white"})).unwrap();
+        assert_eq!(s.execute("image.canvasSize", json!({"width": 100, "height": 80})).unwrap()["offset"], json!([18, 16]));
+        // A misspelling or unknown value is a BadParams error naming `anchor`, never an anchor
+        // between two of the nine (the old independent-axis matching produced top-centre etc.).
+        for anchor in ["topleft", "TopLeft", "TOPLEFT", "bottomleft", "bottomright", "middle", "", "NOPE"] {
+            let mut s = Session::new();
+            s.execute("file.new", json!({"width": 64, "height": 48, "background": "white"})).unwrap();
+            let err = s.execute("image.canvasSize", json!({"width": 100, "height": 80, "anchor": anchor})).unwrap_err();
+            assert!(matches!(err, EngineError::BadParams { .. }), "anchor {anchor:?} must be rejected, got {err:?}");
+            assert!(err.to_string().contains("anchor"), "the error for {anchor:?} must name `anchor`: {err}");
+        }
+    }
+
     #[test]
     fn crop_to_selection_and_trim() {
         let mut s = session();
@@ -1296,6 +1383,54 @@ mod tests {
         assert_eq!(doc(&s).size, Size::new(10, 10));
     }
 
+    #[test]
+    fn thirty_two_bit_holds_linear_light() {
+        // Photoshop 27.11: an 8-bit sRGB grey 128 becomes 0.2159 in 32 bits (and 32 → 0.0144),
+        // and comes back unchanged; alpha keeps its value.
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 4, "height": 1, "background": "white"})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.edit("paint", |doc, active| {
+            let l = doc.layer_mut(active.unwrap()).unwrap();
+            l.surface_mut().unwrap().fill_rect(Rect::new(0, 0, 2, 1), &[128.0 / 255.0, 32.0 / 255.0, 1.0, 0.5]);
+            Ok(())
+        })
+        .unwrap();
+        s.execute("image.mode.bits32", json!({})).unwrap();
+        let px = doc(&s).layers[1].surface().unwrap().pixel(0, 0);
+        for (got, want) in px.iter().zip([0.2159, 0.0144, 1.0, 128.0 / 255.0]) {
+            assert!((got - want).abs() < 2e-4, "{px:?}");
+        }
+        s.execute("image.mode.bits8", json!({})).unwrap();
+        let px = doc(&s).layers[1].surface().unwrap().pixel(0, 0);
+        for (got, want) in px.iter().zip([128.0 / 255.0, 32.0 / 255.0, 1.0, 128.0 / 255.0]) {
+            assert!((got - want).abs() < 0.6 / 255.0, "{px:?}");
+        }
+    }
+
+    #[test]
+    fn grayscale_conversion_matches_photoshop() {
+        // Photoshop 27.11, default Color Settings (working gray Dot Gain 20 %): Image > Mode >
+        // Grayscale turns sRGB 64 / 128 / 192 grey and pure red into 46 / 105 / 177 / 107.
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 4, "height": 1, "background": "white"})).unwrap();
+        s.edit("paint", |doc, _| {
+            let l = doc.layers.first_mut().unwrap();
+            let surf = l.surface_mut().unwrap();
+            for (x, c) in [[64.0, 64.0, 64.0], [128.0, 128.0, 128.0], [192.0, 192.0, 192.0], [255.0, 0.0, 0.0]].iter().enumerate() {
+                surf.fill_rect(Rect::new(x as i32, 0, x as i32 + 1, 1), &[c[0] / 255.0, c[1] / 255.0, c[2] / 255.0, 1.0]);
+            }
+            Ok(())
+        })
+        .unwrap();
+        s.execute("image.mode.grayscale", json!({})).unwrap();
+        let surf = doc(&s).layers[0].surface().unwrap();
+        for (x, want) in [46.0, 105.0, 177.0, 107.0].iter().enumerate() {
+            let got = surf.pixel(x as i32, 0)[0] * 255.0;
+            assert!((got - want).abs() <= 1.5, "pixel {x}: {got} vs {want}");
+        }
+    }
+
     #[test]
     fn mode_and_depth_conversions() {
         let mut s = session();
diff --git a/crates/engine/src/inspect.rs b/crates/engine/src/inspect.rs
index d0b2a72e98..22c3d3a96f 100644
--- a/crates/engine/src/inspect.rs
+++ b/crates/engine/src/inspect.rs
@@ -38,7 +38,7 @@ pub fn document(d: &DocState) -> Value {
         "isolatedLayers": d.isolated_layers.iter().map(|l| l.0).collect::<Vec<_>>(),
         "hasSelection": doc.selection.is_some(),
         "selectionBounds": doc.selection.as_ref().map(|s| { let r = s.content_bounds(); [r.x0, r.y0, r.width() as i32, r.height() as i32] }),
-        "layers": doc.layers.iter().rev().map(|l| layer_sel(l, &selected)).collect::<Vec<_>>(),
+        "layers": doc.layers.iter().rev().map(|l| layer_sel(l, &selected, Some(&doc.metadata))).collect::<Vec<_>>(),
         "history": d.history.entries(),
         "snapshots": d.snapshots.iter().map(|snap| json!({"id": snap.id, "name": snap.name})).collect::<Vec<_>>(),
         "canUndo": d.history.can_undo(),
@@ -63,11 +63,12 @@ pub fn document(d: &DocState) -> Value {
 
 /// Layer tree top-to-bottom (display order).
 pub fn layer(l: &Layer) -> Value {
-    layer_sel(l, &[])
+    layer_sel(l, &[], None)
 }
 
-/// [`layer`] with a `selected` flag on every node (Layers panel multi-selection).
-fn layer_sel(l: &Layer, selected: &[photocraft_doc::LayerId]) -> Value {
+/// [`layer`] with a `selected` flag on every node (Layers panel multi-selection); with the
+/// document's `meta`, a smart object whose file is embedded in the PSD says so.
+fn layer_sel(l: &Layer, selected: &[photocraft_doc::LayerId], meta: Option<&photocraft_doc::Metadata>) -> Value {
     let bounds = l.surface().map(|s| {
         let r = s.content_bounds();
         [r.x0, r.y0, r.width() as i32, r.height() as i32]
@@ -91,14 +92,16 @@ fn layer_sel(l: &Layer, selected: &[photocraft_doc::LayerId]) -> Value {
     });
     match &l.content {
         LayerContent::Group(g) => {
-            v["children"] = Value::Array(g.children.iter().rev().map(|c| layer_sel(c, selected)).collect());
+            v["children"] = Value::Array(g.children.iter().rev().map(|c| layer_sel(c, selected, meta)).collect());
             v["expanded"] = json!(g.expanded);
             if let Some(a) = &g.artboard {
                 v["artboard"] = json!({"rect": [a.rect.x0, a.rect.y0, a.rect.width(), a.rect.height()], "background": a.background.name(), "preset": a.preset});
             }
         }
         LayerContent::Adjustment(a) => {
-            v["adjustment"] = serde_json::to_value(a).unwrap_or(Value::Null);
+            // The same kind and parameters the adjustment commands take (`inBlack` 0..255, …),
+            // not the internal model.
+            v["adjustment"] = json!({"kind": crate::commands::adjustment_kind(a), "params": crate::adjust_params::to_params(a)});
         }
         LayerContent::Smart(sm) => {
             v["smartFilters"] = Value::Array(
@@ -109,11 +112,15 @@ fn layer_sel(l: &Layer, selected: &[photocraft_doc::LayerId]) -> Value {
             );
             v["smartFiltersEnabled"] = json!(sm.filters_enabled);
             // Where the contents come from. A PSD placed layer (embedded or linked in Photoshop) is
-            // `linked` to the `Idnt` uuid of its file, which its duplicates share; New Smart Object
-            // via Copy embeds its own copy of the file instead.
+            // `linked` to the `Idnt` uuid of its file, which its duplicates share; when the file
+            // is embedded in the PSD (a `liFD` item) it is reported as embedded, with that uuid.
+            // New Smart Object via Copy embeds its own copy of the file instead.
             v["smartSource"] = match &sm.source {
                 SmartSource::Embedded { file_name, .. } => json!({"kind": "embedded", "fileName": file_name}),
-                SmartSource::Linked { path } => json!({"kind": "linked", "path": path}),
+                SmartSource::Linked { path } => match meta.and_then(|m| photocraft_io::linked::embedded_file_name(m, path)) {
+                    Some(name) => json!({"kind": "embedded", "fileName": name, "uuid": path}),
+                    None => json!({"kind": "linked", "path": path}),
+                },
             };
         }
         LayerContent::Text(t) => {
@@ -165,6 +172,25 @@ mod tests {
     use photocraft_color::PixelFormat;
     use photocraft_doc::{LayerMask, Path, VectorMask};
 
+    #[test]
+    fn an_adjustment_layer_is_reported_with_the_params_its_command_takes() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 4, "height": 4})).unwrap();
+        s.execute("layer.newAdjustmentLayer.levels", json!({"inBlack": 10, "inWhite": 240, "gamma": 1.2})).unwrap();
+        let info = s.execute("document.inspect", json!({})).unwrap();
+        let adj = &info["layers"][0]["adjustment"];
+        assert_eq!(adj["kind"], "levels");
+        assert_eq!((adj["params"]["inBlack"].as_f64(), adj["params"]["inWhite"].as_f64()), (Some(10.0), Some(240.0)), "{adj}");
+        // Fed back to the command, the params give the same adjustment; no internal field names.
+        let model = match &s.active().unwrap().doc.layers[1].content {
+            LayerContent::Adjustment(a) => a.clone(),
+            c => panic!("{c:?}"),
+        };
+        let back = crate::adjust_params::from_params("levels", &adj["params"], None, photocraft_color::ColorMode::Rgb).unwrap();
+        assert_eq!(crate::adjust_params::to_params(&back), crate::adjust_params::to_params(&model));
+        assert!(!adj.to_string().contains('_'), "{adj}");
+    }
+
     #[test]
     fn document_inspect_reports_raster_and_vector_masks_when_nested() {
         let cases = [(false, None), (true, None), (false, Some(true)), (false, Some(false)), (true, Some(true))];
diff --git a/crates/engine/src/jobs.rs b/crates/engine/src/jobs.rs
index f678a6c7d3..dc43f4d794 100644
--- a/crates/engine/src/jobs.rs
+++ b/crates/engine/src/jobs.rs
@@ -412,7 +412,10 @@ impl Session {
     /// Open a file in the background: read (for a path) and decode on a worker, with progress
     /// (per layer for PSD/PSB) and cancellation, then add the document like
     /// [`Session::open_document`] (Color Settings policies apply). `name` names the document.
-    /// The job's result is `{document, name, warnings, color}`; on wasm it runs inline.
+    /// The job's result is `{document, name, warnings, color}`; on wasm it runs inline. When
+    /// Color Settings ask about the file's profile, the document is held back instead and the
+    /// result is `{held, name, warnings, color}` (`color` the question): take it with
+    /// [`Session::take_held_open`] once answered.
     pub fn start_open(&mut self, name: &str, source: OpenSource) -> Result<Started> {
         let label = format!("Opening {name}");
         let name_w = name.to_string();
@@ -438,6 +441,13 @@ impl Session {
                     })
             },
             move |s, r: photocraft_io::ImportResult| {
+                // Ask When Opening: held back until the prompt is answered (`take_held_open`). A
+                // developed raw has no embedded profile to ask about.
+                let raw = r.warnings.iter().any(|w| w.contains(photocraft_io::raw::DEVELOPED_NOTE));
+                if let Some(question) = s.color.open_question(&r.document).filter(|_| !raw) {
+                    let held = s.hold_open(r.document, r.source_read_only);
+                    return Ok(json!({"held": held, "name": name_a, "warnings": r.warnings, "color": question}));
+                }
                 let (index, color) = s.open_document(r.document, None);
                 if let Some(st) = s.active_mut() {
                     st.source_read_only = r.source_read_only;
@@ -527,6 +537,11 @@ impl Session {
     /// stays unchanged. The document is unlocked at once. False if no such job is running.
     pub fn cancel_job(&mut self, id: JobId) -> bool {
         let Some(i) = self.jobs.running.iter().position(|r| r.id == id) else { return false };
+        // A print worker can already have handed the job to the OS. Discarding its result
+        // would falsely report cancellation; removal belongs to the system print queue.
+        if matches!(self.jobs.running[i].command.as_str(), "file.print" | "file.printOneCopy") {
+            return false;
+        }
         let job = self.jobs.running.remove(i);
         job.ctx.cancel();
         self.end_job(&job, JobOutcome::Cancelled);
@@ -627,6 +642,7 @@ impl Session {
         if id == "file.new" {
             crate::document_preset_cmds::validate_new_params(self, &params)?;
         }
+        crate::param_check::check(spec, &params)?;
         crate::filters::validate_params(id, &params)?;
         // A floating selection drops before any other command (Undo puts it back instead).
         if let Some(v) = crate::float_cmds::before_command(self, id)? {
@@ -746,18 +762,25 @@ impl Session {
         };
         self.coalesce_request = coalesce.clone();
         self.color_restrict = *color_restrict;
+        // Apply-time hooks can dispatch commands too. Keep the same single-step recording
+        // contract as synchronous dispatch without truncating work done while the worker ran.
+        let nested_from = self.journal.len();
+        let recording = if *journal && crate::actions_cmds::replayable(command) { self.actions.recording.take() } else { None };
         let r = match apply {
             Some(f) => std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| f(self, payload)))
                 .unwrap_or_else(|_| Err(EngineError::Other(format!("`{label}` failed with an internal error (logged); the document is unchanged")))),
             None => Err(EngineError::Other("internal error: job applied twice".into())),
         };
+        if self.actions.recording.is_none() {
+            self.actions.recording = recording;
+        }
         self.coalesce_request = None;
         self.color_restrict = None;
         // Finish successful command bookkeeping on the document the job edited.
         // Restoring the viewed document first would attribute Fade and slice updates
         // to that document instead, when the user switched tabs mid-job.
         if r.is_ok() {
-            self.after_command(command, params.clone(), *journal, None);
+            self.after_command(command, params.clone(), *journal, Some(nested_from));
         }
         // Keep the user's active document unless the job opened a new one.
         // This also restores the selection when the apply step returned an error.
@@ -814,11 +837,17 @@ pub fn specs() -> Vec<crate::commands::CommandSpec> {
                 None | Some(Value::Null) => {
                     let n = s.jobs.running.len();
                     s.cancel_all_jobs();
-                    Ok(json!({"cancelled": n}))
+                    Ok(json!({"cancelled": n.saturating_sub(s.jobs.running.len())}))
                 }
                 Some(v) => {
                     let id = v.as_u64().ok_or_else(|| EngineError::BadParams { cmd: "jobs.cancel".into(), msg: "`job` must be a job id".into() })?;
-                    if s.cancel_job(JobId(id)) { Ok(json!({"cancelled": 1})) } else { Err(EngineError::Other(format!("no running job {id}"))) }
+                    if s.cancel_job(JobId(id)) {
+                        Ok(json!({"cancelled": 1}))
+                    } else if s.job(JobId(id)).is_some() {
+                        Err(EngineError::Other("printing cannot be cancelled here; use the system print queue".into()))
+                    } else {
+                        Err(EngineError::Other(format!("no running job {id}")))
+                    }
                 }
             },
             journal: false,
diff --git a/crates/engine/src/jobs_tests.rs b/crates/engine/src/jobs_tests.rs
index 4f631e82ef..0126922818 100644
--- a/crates/engine/src/jobs_tests.rs
+++ b/crates/engine/src/jobs_tests.rs
@@ -78,6 +78,22 @@ fn a_job_applies_as_one_undo_step_and_matches_the_inline_result() {
     assert!(s.jobs().is_empty());
 }
 
+#[test]
+fn free_transform_runs_as_a_job_with_the_inline_result() {
+    let quad = json!({"quad": [[20, 10], [280, 30], [260, 190], [40, 170]]});
+    let mut inline = session(300, 200);
+    inline.execute("edit.transform", quad.clone()).unwrap();
+
+    let mut s = session(300, 200);
+    let steps = s.active().unwrap().history.past_len();
+    let id = job(s.start("edit.transform", quad).unwrap());
+    let e = wait_event(&mut s, id);
+    assert!(matches!(e.outcome, JobOutcome::Done(_)), "{e:?}");
+    assert_eq!(e.label, "Free Transform");
+    assert_eq!(s.active().unwrap().history.past_len(), steps + 1, "one undo step");
+    assert_eq!(pixels(&s), pixels(&inline), "same pixels as the synchronous command");
+}
+
 #[test]
 fn cancel_leaves_the_document_byte_identical() {
     let mut s = session(1600, 1200);
@@ -447,6 +463,33 @@ fn open_runs_as_a_job_and_cancel_adds_nothing() {
     assert!(matches!(wait_event(&mut s, id).outcome, JobOutcome::Failed(_)));
 }
 
+/// Ask When Opening: a file whose profile doesn't match is decoded but not added; the shell takes
+/// it once the prompt is answered. Without Ask it opens as usual.
+#[test]
+fn an_open_that_asks_about_its_profile_holds_the_document_back() {
+    let mut src = session(8, 8);
+    let mut doc = (*src.active().unwrap().doc).clone();
+    doc.icc_profile = Some(photocraft_cms::Builtin::from_id("adobe-rgb-compat").unwrap().profile().to_bytes());
+    let bytes = Arc::new(photocraft_io::export(&doc, "x.png", &Default::default()).unwrap().bytes);
+    src.close(0);
+    let mut s = Session::new();
+    s.execute("edit.colorSettings", json!({"askOnMismatch": true, "policyRgb": "preserve"})).unwrap();
+    let id = job(s.start_open("x.png", OpenSource::Bytes(Arc::clone(&bytes))).unwrap());
+    let JobOutcome::Done(v) = wait_event(&mut s, id).outcome else { panic!() };
+    assert!(s.documents().is_empty(), "held back, not opened");
+    assert_eq!((v["color"]["mismatch"].as_bool(), v["color"]["ask"].as_bool(), v["color"]["action"].as_str()), (Some(true), Some(true), Some("preserve")));
+    let held = v["held"].as_u64().unwrap();
+    let (taken, _) = s.take_held_open(held).expect("the held document");
+    assert!(taken.icc_profile.is_some());
+    assert!(s.take_held_open(held).is_none(), "taken once");
+
+    s.execute("edit.colorSettings", json!({"askOnMismatch": false})).unwrap();
+    let id = job(s.start_open("x.png", OpenSource::Bytes(bytes)).unwrap());
+    let JobOutcome::Done(v) = wait_event(&mut s, id).outcome else { panic!() };
+    assert!(v.get("held").is_none());
+    assert_eq!(s.documents().len(), 1);
+}
+
 #[test]
 fn wait_job_blocks_until_applied() {
     let mut s = session(400, 300);
diff --git a/crates/engine/src/layer_copy_cmds.rs b/crates/engine/src/layer_copy_cmds.rs
index 29eff4c8df..d08955fdf6 100644
--- a/crates/engine/src/layer_copy_cmds.rs
+++ b/crates/engine/src/layer_copy_cmds.rs
@@ -163,7 +163,7 @@ fn copy_to_document(s: &mut Session, p: &Value) -> Result<Value> {
         let src_layer = sdoc.layer(*id).ok_or(EngineError::NoLayer(*id))?;
         let mut l = src_layer.duplicate();
         // A dragged Background arrives as an ordinary layer (the destination keeps its own).
-        if crate::extra_cmds::is_background(src_layer) && sdoc.layers.first().is_some_and(|b| b.id == *id) {
+        if sdoc.is_background(*id) {
             l.name = ddoc.next_layer_name("Layer");
             l.locks = Default::default();
         }
@@ -213,6 +213,66 @@ fn copy_to_document(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"document": dest, "layers": new.iter().map(|l| l.0).collect::<Vec<_>>(), "offset": [dx, dy]}))
 }
 
+/// `layer.duplicate` with `"document": "new"`: Photoshop's Duplicate Layer… ›
+/// Document: New. A new document the size of the source's canvas holds just the duplicated
+/// layers at their canvas positions (a transparent background elsewhere); the source is
+/// untouched and the new document becomes active. Mode, depth, resolution, profile,
+/// patterns and global light come along so the copies render the same.
+pub(crate) fn duplicate_to_new_document(s: &mut Session, p: &Value) -> Result<Value> {
+    let src = s.active_index().ok_or(EngineError::NoDocument)?;
+    let sdoc = s.documents().get(src).ok_or(EngineError::NoDocument)?.doc.clone();
+    let ids = match crate::commands::explicit_layer(s, p)? {
+        Some(id) => vec![id],
+        None => s.active().ok_or(EngineError::NoDocument)?.selected_layers(),
+    };
+    if let Some(missing) = ids.iter().find(|id| sdoc.layer(**id).is_none()) {
+        return Err(EngineError::NoLayer(*missing));
+    }
+    let ids = crate::layer_multi_cmds::top_level(&sdoc, &ids);
+    if ids.is_empty() {
+        return Err(bad("no layers to copy"));
+    }
+    if !layered(sdoc.mode) {
+        return Err(EngineError::Other(format!("layers can't be duplicated with a {:?} document", sdoc.mode)));
+    }
+    let doc_name = p.get("documentName").and_then(Value::as_str).filter(|n| !n.is_empty()).map(str::to_string).unwrap_or_else(|| format!("{} copy", sdoc.name));
+    let mut nd = Document::new(doc_name, sdoc.size, sdoc.mode, sdoc.depth);
+    nd.resolution_dpi = sdoc.resolution_dpi;
+    nd.icc_profile.clone_from(&sdoc.icc_profile);
+    nd.patterns.clone_from(&sdoc.patterns);
+    nd.global_light = sdoc.global_light;
+    for id in &ids {
+        let mut l = sdoc.layer(*id).ok_or(EngineError::NoLayer(*id))?.duplicate();
+        if ids.len() == 1
+            && let Some(name) = p.get("name").and_then(Value::as_str).filter(|n| !n.is_empty())
+        {
+            l.name = name.to_string();
+        }
+        nd.layers.push(l);
+    }
+    // Contents ids belong to a document: fresh ones keep the copies independent of the
+    // source while preserving sharing within the batch (as `adapt_copies` does).
+    let mut contents = HashMap::new();
+    let smart_ids: Vec<_> = nd.walk().into_iter().filter_map(|(_, _, l)| matches!(l.content, LayerContent::Smart(_)).then_some(l.id)).collect();
+    for id in smart_ids {
+        if let Some(l) = nd.layer_mut(id)
+            && let LayerContent::Smart(sm) = &mut l.content
+        {
+            sm.contents_id = *contents.entry(sm.contents_id).or_insert_with(SmartContentsId::fresh);
+        }
+    }
+    let new_ids: Vec<LayerId> = nd.layers.iter().map(|l| l.id).collect();
+    let index = s.add_document(nd, None);
+    crate::layer_multi_cmds::reselect(s, new_ids.clone(), new_ids.last().copied());
+    let mut out = json!({"document": index, "layers": new_ids.iter().map(|l| l.0).collect::<Vec<_>>()});
+    if let [one] = new_ids.as_slice()
+        && let Some(map) = out.as_object_mut()
+    {
+        map.insert("layer".into(), json!(one.0));
+    }
+    Ok(out)
+}
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![CommandSpec {
         id: CMD,
diff --git a/crates/engine/src/layer_copy_cmds/tests.rs b/crates/engine/src/layer_copy_cmds/tests.rs
index 476df18790..a81ebbdc47 100644
--- a/crates/engine/src/layer_copy_cmds/tests.rs
+++ b/crates/engine/src/layer_copy_cmds/tests.rs
@@ -1,5 +1,5 @@
 use photocraft_color::{ColorMode, PixelFormat, SampleType};
-use photocraft_doc::{Document, LayerId, Pattern};
+use photocraft_doc::{Document, LayerContent, LayerId, Pattern};
 use photocraft_geom::Rect;
 use photocraft_raster::Surface;
 use serde_json::{Value, json};
@@ -218,6 +218,118 @@ fn copied_link_groups_are_distinct_from_each_other_and_destination() {
     assert_ne!(first, second);
 }
 
+/// One painted layer, `depth`-bit RGB, as the only layer above the Background.
+fn one_doc(depth: u32) -> (Session, LayerId) {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 40, "height": 30, "depth": depth})).unwrap();
+    let paint = LayerId(s.execute("layer.new.layer", json!({"name": "paint"})).unwrap()["layer"].as_u64().unwrap());
+    s.execute("select.rect", json!({"x": 4, "y": 6, "width": 10, "height": 10})).unwrap();
+    s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    (s, paint)
+}
+
+#[test]
+fn duplicate_to_a_new_document_keeps_size_pixels_and_place_at_every_depth() {
+    for depth in [8, 16, 32] {
+        let (mut s, paint) = one_doc(depth);
+        let source_before = doc(&s, 0).clone();
+        let r = s.execute("layer.duplicate", json!({"document": "new"})).unwrap();
+        assert_eq!(r["document"], 1);
+        assert_eq!(s.active_index(), Some(1), "the new document becomes active");
+        let (src, dst) = (doc(&s, 0), doc(&s, 1));
+        assert_eq!(*src, source_before, "the source is untouched");
+        assert_eq!(dst.size, src.size, "same canvas, as Photoshop");
+        assert_eq!((dst.mode, dst.depth, dst.resolution_dpi), (src.mode, src.depth, src.resolution_dpi));
+        assert_eq!(dst.name, format!("{} copy", src.name));
+        let layers = r["layers"].as_array().unwrap();
+        assert_eq!(layers.len(), 1);
+        let id = LayerId(layers[0].as_u64().unwrap());
+        assert_eq!(r["layer"], id.0);
+        assert_ne!(id, paint, "a copy has its own id");
+        assert_eq!(dst.layers.len(), 1, "just the duplicated layer");
+        assert_eq!(dst.layers[0].name, "paint");
+        assert_eq!(bounds(&s, 1, id), Rect::new(4, 6, 14, 16), "same canvas position");
+        assert_eq!(
+            dst.layers[0].surface().unwrap().read_region(Rect::new(4, 6, 14, 16)),
+            src.layer(paint).unwrap().surface().unwrap().read_region(Rect::new(4, 6, 14, 16)),
+            "depth {depth}: identical pixels"
+        );
+        assert_eq!(s.active().unwrap().selected_layers(), vec![id]);
+    }
+}
+
+#[test]
+fn duplicate_to_a_new_document_names_the_copy_and_the_document() {
+    let (mut s, _) = one_doc(8);
+    let r = s.execute("layer.duplicate", json!({"document": "new", "name": "Ink", "documentName": "Card"})).unwrap();
+    assert_eq!(doc(&s, 1).name, "Card");
+    assert_eq!(doc(&s, 1).layers[0].name, "Ink");
+    assert_eq!(r["layer"].as_u64(), r["layers"][0].as_u64());
+}
+
+#[test]
+fn duplicate_to_a_new_document_carries_every_selected_layer_in_order() {
+    let (mut s, paint) = one_doc(8);
+    let bg = doc(&s, 0).layers[0].id;
+    s.execute("layer.select", json!({"layer": paint.0, "mode": "add"})).unwrap();
+    s.execute("layer.select", json!({"layer": bg, "mode": "add"})).unwrap();
+    let r = s.execute("layer.duplicate", json!({"document": "new"})).unwrap();
+    let names: Vec<&str> = doc(&s, 1).layers.iter().map(|l| l.name.as_str()).collect();
+    assert_eq!(names, ["Background", "paint"]);
+    assert_eq!(r["layers"].as_array().unwrap().len(), 2);
+    assert!(r.get("layer").is_none(), "no single layer to report");
+    // A duplicated Background stays a Background: the new document has no destination one.
+    let back = &doc(&s, 1).layers[0];
+    assert!(back.locks.transparency && back.locks.position);
+}
+
+#[test]
+fn duplicate_to_a_new_document_cuts_smart_objects_loose_as_a_batch() {
+    let (mut s, _) = one_doc(8);
+    s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+    let original = s.active().unwrap().active_layer.unwrap();
+    let sibling = LayerId(s.execute("layer.duplicate", json!({})).unwrap()["layer"].as_u64().unwrap());
+    let contents = |s: &Session, i: usize, id: LayerId| {
+        let LayerContent::Smart(sm) = &doc(s, i).layer(id).unwrap().content else { panic!("smart object") };
+        sm.contents_id
+    };
+    assert_eq!(contents(&s, 0, original), contents(&s, 0, sibling), "instances share contents");
+    s.execute("layer.select", json!({"layer": original.0, "mode": "add"})).unwrap();
+    s.execute("layer.select", json!({"layer": sibling.0, "mode": "add"})).unwrap();
+    let r = s.execute("layer.duplicate", json!({"document": "new"})).unwrap();
+    let ids: Vec<LayerId> = r["layers"].as_array().unwrap().iter().map(|id| LayerId(id.as_u64().unwrap())).collect();
+    assert_eq!(contents(&s, 1, ids[0]), contents(&s, 1, ids[1]), "sharing survives within the batch");
+    assert_ne!(contents(&s, 1, ids[0]), contents(&s, 0, original), "independent of the source");
+}
+
+#[test]
+fn duplicate_destinations_that_are_not_new_fail_cleanly() {
+    let (mut s, _) = one_doc(8);
+    for p in [
+        json!({"document": 1}),
+        json!({"document": 7}),
+        json!({"document": true}),
+        json!({"document": 1.5}),
+        json!({"document": []}),
+        json!({"document": {}}),
+        json!({"document": "other"}),
+        json!({"document": "new", "layer": 999_999}),
+    ] {
+        let before = (doc(&s, 0).clone(), s.documents().len(), s.active_index());
+        let err = s.execute("layer.duplicate", p.clone()).unwrap_err().to_string();
+        if p == json!({"document": 1}) {
+            assert!(err.contains("layer.copyToDocument"), "{p}: {err}");
+        }
+        assert_eq!(s.active_index(), before.2, "{p}: the source stays active");
+        assert_eq!(s.documents().len(), before.1, "{p}: no document created");
+        assert_eq!(*doc(&s, 0), before.0, "{p}: the source is untouched");
+    }
+    // One open document: same-document duplicates still work, and stay enabled.
+    assert!(s.is_enabled("layer.duplicate"));
+    s.execute("layer.duplicate", json!({})).unwrap();
+}
+
 #[test]
 fn a_named_duplicate_takes_the_name_in_one_step() {
     let (mut s, paint) = two_docs(40, 30, 8);
diff --git a/crates/engine/src/layer_mask_props_cmds/tests.rs b/crates/engine/src/layer_mask_props_cmds/tests.rs
index b183b1f879..cd32de150f 100644
--- a/crates/engine/src/layer_mask_props_cmds/tests.rs
+++ b/crates/engine/src/layer_mask_props_cmds/tests.rs
@@ -44,7 +44,11 @@ fn edits_preserve_mask_pixels_and_layer_at_all_depths_with_undo_redo() {
             assert_eq!(*s.active().unwrap().doc, expected, "only density and feather change");
             assert_eq!(s.active().unwrap().active_layer, Some(background));
             assert_eq!(s.active().unwrap().history.entries().len(), count + 1);
-            assert!(s.active().unwrap().last_damage.is_none(), "properties invalidate the composite");
+            // Properties invalidate the composite as far as their undo would (the masked layer is
+            // empty here; the adjustment reaches everything).
+            let damage = s.active().unwrap().last_damage;
+            assert_eq!(damage, crate::layer_multi_cmds::step_damage(&before, &s.active().unwrap().doc));
+            assert_eq!(damage.is_none(), adjustment);
             s.execute("edit.undo", json!({})).unwrap();
             assert_eq!(*s.active().unwrap().doc, *before);
             s.execute("edit.redo", json!({})).unwrap();
diff --git a/crates/engine/src/layer_menu_cmds.rs b/crates/engine/src/layer_menu_cmds.rs
index a895210c19..366f9c8d39 100644
--- a/crates/engine/src/layer_menu_cmds.rs
+++ b/crates/engine/src/layer_menu_cmds.rs
@@ -612,8 +612,14 @@ fn blend_range(v: &Value) -> Option<BlendRange> {
 
 fn global_light(s: &mut Session, p: &Value) -> Result<Value> {
     let cur = s.active().ok_or(EngineError::NoDocument)?.doc.global_light;
-    let angle = num(p, "angle", cur.angle);
-    let altitude = num(p, "altitude", cur.altitude).clamp(0.0, 90.0);
+    // Read as f64 and reject what f32 can't hold: 1e39 would become inf, and rem_euclid NaN.
+    let f32_param = |key: &str, default: f32| match p.get(key).and_then(Value::as_f64) {
+        None => Ok(default),
+        Some(v) if v.is_finite() && v.abs() <= f64::from(f32::MAX) => Ok(v as f32),
+        Some(_) => Err(bad("layer.layerStyle.globalLight", format!("{key} must be a finite number"))),
+    };
+    let angle = f32_param("angle", cur.angle)?;
+    let altitude = f32_param("altitude", cur.altitude)?.clamp(0.0, 90.0);
     let angle = (angle + 180.0).rem_euclid(360.0) - 180.0;
     s.edit("Global Light", |doc, _| {
         doc.global_light.angle = angle;
diff --git a/crates/engine/src/layer_menu_cmds/tests.rs b/crates/engine/src/layer_menu_cmds/tests.rs
index 51ad90500f..708bee5fce 100644
--- a/crates/engine/src/layer_menu_cmds/tests.rs
+++ b/crates/engine/src/layer_menu_cmds/tests.rs
@@ -140,6 +140,24 @@ fn global_light_blending_options_scale_effects() {
     }
 }
 
+#[test]
+fn global_light_rejects_numbers_beyond_f32() {
+    let mut s = session(8, "rgb");
+    // In-range values still wrap into -180..=180 and clamp to 0..=90.
+    s.execute("layer.layerStyle.globalLight", json!({"angle": 450, "altitude": 120})).unwrap();
+    assert_eq!((doc(&s).global_light.angle, doc(&s).global_light.altitude), (90.0, 90.0));
+    s.execute("layer.layerStyle.globalLight", json!({"angle": 540, "altitude": 30})).unwrap();
+    assert_eq!((doc(&s).global_light.angle.abs(), doc(&s).global_light.altitude), (180.0, 30.0));
+    let before = doc(&s).global_light;
+    let steps = s.active().unwrap().history.past_len();
+    // 1e39 overflowed f32 to inf, which rem_euclid turned into a stored NaN (#4181).
+    for p in [json!({"angle": 1e39}), json!({"angle": -1e39}), json!({"altitude": 1e39}), json!({"altitude": -1e39})] {
+        assert!(s.execute("layer.layerStyle.globalLight", p.clone()).is_err(), "{p}");
+        assert_eq!(doc(&s).global_light, before, "{p}");
+        assert_eq!(s.active().unwrap().history.past_len(), steps, "{p}");
+    }
+}
+
 #[test]
 fn blending_options_blend_if() {
     for depth in DEPTHS {
diff --git a/crates/engine/src/layer_multi_cmds.rs b/crates/engine/src/layer_multi_cmds.rs
index 31dc49d09c..21e9e2caac 100644
--- a/crates/engine/src/layer_multi_cmds.rs
+++ b/crates/engine/src/layer_multi_cmds.rs
@@ -44,7 +44,7 @@ pub(crate) fn mask_targets(s: &Session, p: &serde_json::Value) -> Result<Vec<Lay
         return Ok(ids);
     }
     let d = s.active().ok_or(EngineError::NoDocument)?;
-    let ids: Vec<LayerId> = ids.into_iter().filter(|id| d.doc.layer(*id).is_some_and(|l| l.mask.is_none() && !crate::extra_cmds::is_background(l))).collect();
+    let ids: Vec<LayerId> = ids.into_iter().filter(|id| d.doc.layer(*id).is_some_and(|l| l.mask.is_none() && !d.doc.is_background(l.id))).collect();
     if ids.is_empty() {
         return Err(EngineError::Other("none of the selected layers can take a layer mask".into()));
     }
@@ -113,9 +113,9 @@ fn range_order(layers: &[Layer], include_collapsed: bool, out: &mut Vec<LayerId>
     }
 }
 
-/// `layer.select`: `{"layer": id, "mode": "replace|toggle|range|add"}`.
+/// `layer.select`: `{"layer": id, "mode": "replace|toggle|range|add|remove"}`.
 pub fn select(s: &mut Session, p: &Value) -> Result<Value> {
-    let id = LayerId(p.get("layer").and_then(Value::as_u64).ok_or_else(|| bad("layer.select", "missing `layer`"))?);
+    let id = crate::commands::explicit_layer(s, p)?.ok_or_else(|| bad("layer.select", "missing `layer`"))?;
     let mode = p.get("mode").and_then(Value::as_str).unwrap_or("replace");
     let st = s.active().ok_or(EngineError::NoDocument)?;
     if st.doc.layer(id).is_none() {
@@ -144,6 +144,15 @@ pub fn select(s: &mut Session, p: &Value) -> Result<Value> {
                 set_selection(s, sel, Some(id), Some(id))?;
             }
         }
+        // Toggle's removing half: a layer that isn't selected stays unselected (Photoshop's
+        // `removeFromSelection`, recorded by actions).
+        "remove" => {
+            if sel.contains(&id) && sel.len() > 1 {
+                sel.retain(|x| *x != id);
+                let active = if st.active_layer == Some(id) { sel.last().copied() } else { st.active_layer };
+                set_selection(s, sel, active, active)?;
+            }
+        }
         "range" => {
             let anchor = st.layer_anchor.filter(|a| st.doc.layer(*a).is_some()).or(st.active_layer).unwrap_or(id);
             let mut order = Vec::new();
@@ -163,13 +172,9 @@ pub fn select(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"selected": selected(s).iter().map(|l| l.0).collect::<Vec<_>>()}))
 }
 
-pub(crate) fn is_locked_background(l: &Layer) -> bool {
-    l.name == "Background" && l.locks.transparency && matches!(l.content, LayerContent::Raster(_))
-}
-
 fn select_all_layers(s: &mut Session) -> Result<Value> {
     let d = s.active().ok_or(EngineError::NoDocument)?;
-    let ids: Vec<LayerId> = d.doc.walk().into_iter().filter(|(_, _, l)| !is_locked_background(l)).map(|(_, _, l)| l.id).collect();
+    let ids: Vec<LayerId> = d.doc.walk().into_iter().filter(|(_, _, l)| !d.doc.is_background(l.id)).map(|(_, _, l)| l.id).collect();
     if ids.is_empty() {
         return Err(EngineError::Other("there are no layers to select".into()));
     }
@@ -265,9 +270,9 @@ pub(crate) fn with_links(doc: &Document, ids: &[LayerId]) -> Vec<LayerId> {
 }
 
 /// Move layers by whole pixels the way the Move tool does: pixels, linked masks, type and
-/// vector content (shapes, linked vector masks) all move together.
-pub(crate) fn move_layers(doc: &mut Document, moves: &[(LayerId, i32, i32)]) -> Result<()> {
-    let snapshot = doc.clone();
+/// vector content (shapes, linked vector masks) all move together. `before` is `doc` as it was
+/// before any of the moves (the edit's starting document), read when type and shapes re-render.
+pub(crate) fn move_layers(doc: &mut Document, before: &Document, moves: &[(LayerId, i32, i32)]) -> Result<()> {
     for &(id, dx, dy) in moves {
         if dx == 0 && dy == 0 {
             continue;
@@ -277,34 +282,73 @@ pub(crate) fn move_layers(doc: &mut Document, moves: &[(LayerId, i32, i32)]) ->
         if locks.position || locks.all {
             return Err(EngineError::Other(format!("layer \"{}\" is position-locked", l.name)));
         }
-        crate::commands::translate_layer(&snapshot, l, dx, dy);
-        crate::vector_cmds::translate_vectors(&snapshot, l, dx as f64, dy as f64);
+        crate::commands::translate_layer(before, l, dx, dy);
+        crate::vector_cmds::translate_vectors(before, l, dx as f64, dy as f64);
     }
     Ok(())
 }
 
+/// Does a move aimed at the layer mask (`"target":"mask"`) move `l`'s mask alone? Only an
+/// unlinked mask does (the chain off); a linked one moves with its layer, as in Photoshop.
+pub fn moves_mask_alone(l: &Layer) -> bool {
+    l.mask.as_ref().is_some_and(|m| !m.linked)
+}
+
 /// `layer.translate`: the explicit layer, or every selected layer, plus their linked layers.
+/// With `"target":"mask"` a layer whose mask is unlinked moves that mask alone.
 pub fn translate(s: &mut Session, p: &Value) -> Result<Value> {
-    let dx = int_i32("layer.translate", p, "dx")?.unwrap_or(0);
-    let dy = int_i32("layer.translate", p, "dy")?.unwrap_or(0);
+    let (dx, dy) = match p.get("units").and_then(Value::as_str) {
+        None | Some("px") => (int_i32("layer.translate", p, "dx")?.unwrap_or(0), int_i32("layer.translate", p, "dy")?.unwrap_or(0)),
+        // Points (1/72 in), as a Photoshop action records a nudge: whole pixels at this
+        // document's resolution.
+        Some("pt") => {
+            let dpi = s.active().map_or(72.0, |d| f64::from(d.doc.resolution_dpi));
+            let to_px = |key: &str| -> Result<i32> {
+                let pt = match p.get(key) {
+                    None => 0.0,
+                    Some(v) => v.as_f64().filter(|f| f.is_finite()).ok_or_else(|| bad("layer.translate", format!("`{key}` must be a number")))?,
+                };
+                let px = (pt * dpi / 72.0).round();
+                if px.abs() > f64::from(i32::MAX) {
+                    return Err(bad("layer.translate", format!("`{key}` = {pt} pt is outside the 32-bit coordinate range")));
+                }
+                Ok(px as i32)
+            };
+            (to_px("dx")?, to_px("dy")?)
+        }
+        Some(other) => return Err(bad("layer.translate", format!("unknown units `{other}` (px|pt)"))),
+    };
     if dx == 0 && dy == 0 {
         return Ok(Value::Null);
     }
-    let roots = match p.get("layer").and_then(Value::as_u64) {
-        Some(id) => vec![LayerId(id)],
+    let roots = match crate::commands::explicit_layer(s, p)? {
+        Some(id) => vec![id],
         None => selected(s),
     };
     if roots.is_empty() {
         return Err(EngineError::Other("no active layer".into()));
     }
+    let mask_target = p.get("target").and_then(Value::as_str) == Some("mask");
     let before = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
     let ids = s.edit("Move", |doc, _| {
-        let ids = move_targets(doc, &roots);
-        if ids.is_empty() {
+        let (alone, rest): (Vec<LayerId>, Vec<LayerId>) = roots.iter().partition(|id| mask_target && doc.layer(**id).is_some_and(moves_mask_alone));
+        let mut ids = move_targets(doc, &rest);
+        if ids.is_empty() && alone.is_empty() {
             return Err(EngineError::NoLayer(roots[0]));
         }
         let moves: Vec<_> = ids.iter().map(|&id| (id, dx, dy)).collect();
-        move_layers(doc, &moves)?;
+        move_layers(doc, &before, &moves)?;
+        for id in alone {
+            let locks = doc.effective_locks(id);
+            let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
+            if locks.position || locks.all {
+                return Err(EngineError::Other(format!("layer \"{}\" is position-locked", l.name)));
+            }
+            if let Some(m) = &mut l.mask {
+                m.surface = shift_surface(&m.surface, dx, dy);
+            }
+            ids.push(id);
+        }
         // A board moved past any canvas edge grows the canvas, as a new one does (#1531, #3070).
         if ids.iter().any(|id| doc.layer(*id).is_some_and(|l| l.artboard().is_some())) {
             crate::artboard_cmds::fit_canvas(doc);
@@ -326,6 +370,11 @@ pub fn move_targets(doc: &Document, roots: &[LayerId]) -> Vec<LayerId> {
 /// shift as they are instead of re-rendering (the commit re-renders them), so a drag frame costs
 /// copying the moving pixels only.
 pub fn moved(doc: &Document, ids: &[LayerId], dx: i32, dy: i32) -> Result<Document> {
+    moved_target(doc, ids, dx, dy, false)
+}
+
+/// [`moved`] for a drag aimed at the layer mask (`mask_target`): unlinked masks move alone.
+pub fn moved_target(doc: &Document, ids: &[LayerId], dx: i32, dy: i32, mask_target: bool) -> Result<Document> {
     let mut out = doc.clone();
     for &id in ids {
         let locks = doc.effective_locks(id);
@@ -333,6 +382,12 @@ pub fn moved(doc: &Document, ids: &[LayerId], dx: i32, dy: i32) -> Result<Docume
         if locks.position || locks.all {
             return Err(EngineError::Other(format!("layer \"{}\" is position-locked", l.name)));
         }
+        if mask_target && moves_mask_alone(l) {
+            if let Some(m) = &mut l.mask {
+                m.surface = shift_surface(&m.surface, dx, dy);
+            }
+            continue;
+        }
         shift_shown(doc, l, dx, dy);
     }
     Ok(out)
@@ -368,13 +423,20 @@ fn shift_shown(doc: &Document, l: &mut Layer, dx: i32, dy: i32) {
         LayerContent::Shape(sh) => {
             // The rendered shape is cut at the canvas: one that reaches past it renders again.
             let canvas = doc.bounds();
-            let inside = sh.cache.as_ref().is_some_and(|c| {
+            let was_inside = sh.cache.as_ref().is_some_and(|c| {
                 let b = photocraft_compose::bounds::content_bounds(c);
                 b.is_empty() || (b.x0 > canvas.x0 && b.y0 > canvas.y0 && b.x1 < canvas.x1 && b.y1 < canvas.y1)
             });
             crate::vector_cmds::transform_shape(sh, &a);
+            let stroke_pad = sh.stroke.as_ref().filter(|s| s.opacity > 0.0).map_or(0.0, |s| f64::from(s.width.ceil()));
+            let stays_inside = sh.path.control_bounds().is_some_and(|(x0, y0, x1, y1)| {
+                (x0 - stroke_pad) > canvas.x0 as f64
+                    && (y0 - stroke_pad) > canvas.y0 as f64
+                    && (x1 + stroke_pad) < canvas.x1 as f64
+                    && (y1 + stroke_pad) < canvas.y1 as f64
+            });
             match &mut sh.cache {
-                Some(c) if inside => *c = translate_surface(c, dx, dy),
+                Some(c) if was_inside && stays_inside => *c = translate_surface(c, dx, dy),
                 _ => crate::vector_cmds::refresh_shape(doc, sh),
             }
         }
@@ -577,6 +639,7 @@ fn doc_pixels_equal(a: &Document, b: &Document) -> bool {
         layers: _,
         channels,
         guides: _,
+        ruler_origin: _,
         selection: _,
         metadata: _,
         global_light,
@@ -597,6 +660,7 @@ fn doc_pixels_equal(a: &Document, b: &Document) -> bool {
         slices: _,
         variables: _,
         timeline: _,
+        file_encoding: _,
     } = a;
     *size == b.size
         && resolution_dpi.to_bits() == b.resolution_dpi.to_bits()
@@ -639,35 +703,31 @@ pub fn same_pixels(a: &Document, b: &Document) -> bool {
 }
 
 /// Pixels a single history step can have changed between `a` and `b` (the documents on either
-/// side of an undo or redo): the union of the change bounds of every layer whose pixels
-/// differ, so undoing a local edit recomposites only that area instead of the whole canvas.
-/// `None` (composite everything, as before) when the step touched anything the layer walk
-/// cannot bound: document-level fields the compositor reads (canvas size, mode, depth,
-/// profile, global light, patterns, channels, palettes), the layer structure (order,
-/// additions, removals, kind changes; adding or removing a layer that draws nothing, see
-/// [`inert_at`], is no change), layer properties that reach outside their own bounds
-/// (clipping, excluded channels — what `layer.setProps` already reports as unbounded), and
-/// video layers.
-pub fn step_damage(a: &Document, b: &Document) -> Option<Rect> {
-    damage_between(a, b, false)
-}
-
-/// [`step_damage`] for an edit from `before` to `after` that may also have added layers which
-/// change pixels only within their own bounds (see [`added_bounds`]), as Duplicate Layer does:
-/// each contributes its change bounds instead of making the whole canvas recomposite. Inserting a
-/// copy of a 12 MP layer used to recomposite every layer of the document (#2883, P8/P9 in
+/// side of an edit, its undo or its redo): the union of the change bounds of every layer whose
+/// pixels differ, so a local edit recomposites only that area instead of the whole canvas. A
+/// layer only one side has (a duplicate, a paste, a deleted layer) counts where it draws (see
+/// [`one_sided_bounds`]); one that draws nothing ([`inert_at`]) changes nothing. `None`
+/// (composite everything) when the step touched anything the layer walk cannot bound:
+/// document-level fields the compositor reads (canvas size, mode, depth, profile, global light,
+/// patterns, channels, palettes), layer order and kind changes, layers added or removed that
+/// reach outside their own bounds, layer properties that do (clipping, excluded channels —
+/// what `layer.setProps` already reports as unbounded), and video layers. Inserting a copy of a
+/// 12 MP layer used to recomposite every layer of the document (#2883, P8/P9 in
 /// `perf/budgets.toml`).
-pub(crate) fn insert_damage(before: &Document, after: &Document) -> Option<Rect> {
-    damage_between(before, after, true)
-}
-
-fn damage_between(a: &Document, b: &Document, bounded_additions: bool) -> Option<Rect> {
+pub fn step_damage(a: &Document, b: &Document) -> Option<Rect> {
     if !doc_pixels_equal(a, b) {
         return None;
     }
-    fn walk(xs: &[Layer], ys: &[Layer], a: &Document, b: &Document, added: bool, out: &mut Rect) -> bool {
-        // Pair the layers by id, stepping over layers only one side has when they draw nothing
-        // (a new empty layer or group, #1771): adding or deleting one changes no pixels.
+    fn walk(xs: &[Layer], ys: &[Layer], a: &Document, b: &Document, out: &mut Rect) -> bool {
+        // Pair the layers by id, stepping over layers only one side has: one that draws nothing
+        // changes no pixels (a new empty layer or group, #1771), any other only where it draws.
+        let one_sided = |layers: &[Layer], k: usize, canvas: Rect, out: &mut Rect| {
+            let Some(r) = one_sided_bounds(layers, k, canvas) else { return false };
+            if !r.is_empty() {
+                *out = if out.is_empty() { r } else { out.union(&r) };
+            }
+            true
+        };
         let (mut i, mut j) = (0, 0);
         loop {
             let (x, y) = match (xs.get(i), ys.get(j)) {
@@ -677,19 +737,25 @@ fn damage_between(a: &Document, b: &Document, bounded_additions: bool) -> Option
                     j += 1;
                     continue;
                 }
-                _ if added && ys.get(j).is_some_and(|y| xs.iter().all(|x| x.id != y.id)) => {
-                    // A layer only `b` has: bounded when it is self-contained.
-                    let Some(r) = added_bounds(ys, j, b.bounds()) else { return false };
-                    if !r.is_empty() {
-                        *out = if out.is_empty() { r } else { out.union(&r) };
-                    }
-                    j += 1;
-                    continue;
-                }
                 _ if inert_at(xs, i) => {
                     i += 1;
                     continue;
                 }
+                (_, Some(y)) if xs.iter().all(|x| x.id != y.id) => {
+                    if !one_sided(ys, j, b.bounds(), out) {
+                        return false;
+                    }
+                    j += 1;
+                    continue;
+                }
+                (Some(x), _) if ys.iter().all(|y| y.id != x.id) => {
+                    if !one_sided(xs, i, a.bounds(), out) {
+                        return false;
+                    }
+                    i += 1;
+                    continue;
+                }
+                // Both sides have the layer, in another order.
                 _ => return false,
             };
             i += 1;
@@ -711,7 +777,7 @@ fn damage_between(a: &Document, b: &Document, bounded_additions: bool) -> Option
             }
             match (x.children(), y.children()) {
                 (Some(xc), Some(yc)) => {
-                    if !walk(xc, yc, a, b, added, out) {
+                    if !walk(xc, yc, a, b, out) {
                         return false;
                     }
                 }
@@ -721,15 +787,15 @@ fn damage_between(a: &Document, b: &Document, bounded_additions: bool) -> Option
         }
     }
     let mut out = Rect::EMPTY;
-    if walk(&a.layers, &b.layers, a, b, bounded_additions, &mut out) { Some(out) } else { None }
+    if walk(&a.layers, &b.layers, a, b, &mut out) { Some(out) } else { None }
 }
 
-/// The pixels adding `layers[k]` can change, when that is bounded: its change bounds
+/// The pixels adding or removing `layers[k]` can change, when that is bounded: its change bounds
 /// (`photocraft_compose::change_bounds`: not for an adjustment, or a pass-through group holding
-/// one), provided it doesn't become the clipping base of clipped layers above it, and neither it
-/// nor anything inside it is a video layer or excludes channels (both reach outside the layer's
-/// bounds, see [`step_damage`]).
-fn added_bounds(layers: &[Layer], k: usize, canvas: Rect) -> Option<Rect> {
+/// one), provided it isn't the clipping base of clipped layers above it (they would change base),
+/// and neither it nor anything inside it is a video layer or excludes channels (both reach
+/// outside the layer's bounds, see [`step_damage`]).
+fn one_sided_bounds(layers: &[Layer], k: usize, canvas: Rect) -> Option<Rect> {
     fn contained(l: &Layer, depth: usize) -> bool {
         depth < 256 && l.video.is_none() && l.excluded_channels == 0 && l.children().is_none_or(|c| c.iter().all(|c| contained(c, depth + 1)))
     }
@@ -776,11 +842,12 @@ pub(crate) fn note_inert_insert(s: &mut Session, id: LayerId) {
     }
 }
 
-/// Report the pixels an edit from `before` that added layers changed ([`insert_damage`]), so
-/// the canvas recomposites only where the new layers draw instead of the whole document.
+/// Report the pixels an edit from `before` that added layers changed ([`step_damage`]), for
+/// commands made of more than one edit, so the canvas recomposites only where the new layers
+/// draw instead of the whole document.
 pub(crate) fn note_insert(s: &mut Session, before: &Document) {
     let Some(st) = s.active_mut() else { return };
-    st.last_damage = insert_damage(before, &st.doc);
+    st.last_damage = step_damage(before, &st.doc);
 }
 
 /// Content bounds used by Align/Distribute: the layer's pixels (type and shape layers use their
@@ -842,6 +909,7 @@ fn align(s: &mut Session, p: &Value, kind: &str) -> Result<Value> {
     let edge = Edge::parse(kind).ok_or_else(|| bad(&cmd, "unknown edge"))?;
     let sel = selected(s);
     let to = p.get("to").and_then(Value::as_str).unwrap_or("auto").to_string();
+    let before = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
     let moved = s.edit("Align", |doc, _| {
         let items = bounded_selection(doc, &sel);
         if items.is_empty() {
@@ -873,7 +941,7 @@ fn align(s: &mut Session, p: &Value, kind: &str) -> Result<Value> {
             })
             .collect();
         let moves = dedup_moves(doc, moves);
-        move_layers(doc, &moves)?;
+        move_layers(doc, &before, &moves)?;
         Ok(moves.iter().filter(|m| m.1 != 0 || m.2 != 0).count())
     })?;
     Ok(json!({"moved": moved}))
@@ -896,6 +964,7 @@ fn dedup_moves(doc: &Document, moves: Vec<(LayerId, i32, i32)>) -> Vec<(LayerId,
 fn distribute(s: &mut Session, kind: &str) -> Result<Value> {
     let sel = selected(s);
     let kind = kind.to_string();
+    let before = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
     let moved = s.edit("Distribute", |doc, _| {
         let mut items = bounded_selection(doc, &sel);
         if items.len() < 3 {
@@ -935,7 +1004,7 @@ fn distribute(s: &mut Session, kind: &str) -> Result<Value> {
         }
         let moves: Vec<_> = moves.into_iter().flat_map(|(id, dx, dy)| with_links(doc, &[id]).into_iter().map(move |l| (l, dx, dy))).collect();
         let moves = dedup_moves(doc, moves);
-        move_layers(doc, &moves)?;
+        move_layers(doc, &before, &moves)?;
         Ok(moves.iter().filter(|m| m.1 != 0 || m.2 != 0).count())
     })?;
     Ok(json!({"moved": moved}))
@@ -1100,13 +1169,7 @@ fn lock_layers(s: &mut Session, p: &Value) -> Result<Value> {
         for id in &sel {
             let l = doc.layer_mut(*id).ok_or(EngineError::NoLayer(*id))?;
             for (k, v) in &given {
-                match *k {
-                    "transparency" => l.locks.transparency = *v,
-                    "pixels" => l.locks.pixels = *v,
-                    "position" => l.locks.position = *v,
-                    "artboard" => l.locks.artboard = *v,
-                    _ => l.locks.all = *v,
-                }
+                l.locks.set(k, *v);
             }
         }
         Ok(())
@@ -1157,8 +1220,8 @@ pub(crate) fn check_group_depth(doc: &Document, what: &str) -> Result<()> {
 /// Group Layers (⌘G) / Group from Layers: the explicit layer, or every selected layer, moves
 /// into a new group placed where the top-most of them was. Bottom-to-top order is preserved.
 pub fn group_layers(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = match p.get("layer").and_then(Value::as_u64) {
-        Some(id) => vec![LayerId(id)],
+    let ids = match crate::commands::explicit_layer(s, p)? {
+        Some(id) => vec![id],
         None => selected(s),
     };
     if ids.is_empty() {
@@ -1186,6 +1249,12 @@ pub fn group_layers(s: &mut Session, p: &Value) -> Result<Value> {
 fn merge_layers(s: &mut Session) -> Result<Value> {
     let sel = selected(s);
     if sel.len() < 2 {
+        // ⌘E on a lone group is Photoshop's Merge Group (#3832); on a layer, Merge Down.
+        if let Some(&id) = sel.first()
+            && s.active().and_then(|d| d.doc.layer(id)).is_some_and(|l| matches!(l.content, LayerContent::Group(_)))
+        {
+            return s.execute("layer.mergeGroup", json!({ "layer": id.0 }));
+        }
         return s.execute("layer.mergeDown", json!({}));
     }
     let mid = s.edit("Merge Layers", |doc, active| {
@@ -1443,6 +1512,95 @@ mod tests {
         s.active().unwrap().last_damage
     }
 
+    /// A Photoshop action's nudge in points moves whole pixels at the document's resolution:
+    /// 0.36 pt is 1 px at 200 ppi and 1.5 → 2 px at 300 ppi.
+    #[test]
+    fn translate_in_points_follows_the_resolution() {
+        for (res, moved) in [(200, 1), (300, 2), (72, 0)] {
+            let mut s = Session::new();
+            s.execute("file.new", json!({"width": 100, "height": 80, "resolution": res})).unwrap();
+            let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
+            s.execute("layer.translate", json!({"dx": 0.36, "dy": -0.36, "units": "pt"})).unwrap();
+            assert_eq!(bounds(&s, a), Rect::new(10 + moved, 10 - moved, 20 + moved, 20 - moved), "{res} ppi");
+        }
+        let mut s = session(8);
+        rect_layer(&mut s, Rect::new(10, 10, 20, 20));
+        for bad in [json!({"dx": 1, "units": "in"}), json!({"dx": "x", "units": "pt"}), json!({"dx": 1e300, "units": "pt"})] {
+            assert!(s.execute("layer.translate", bad.clone()).is_err(), "{bad}");
+        }
+    }
+
+    /// `remove` deselects a selected layer, leaves an unselected one alone and never empties the
+    /// selection.
+    #[test]
+    fn select_remove_takes_a_layer_out_of_the_selection() {
+        let mut s = session(8);
+        let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
+        let b = rect_layer(&mut s, Rect::new(30, 10, 40, 20));
+        let c = rect_layer(&mut s, Rect::new(50, 10, 60, 20));
+        s.execute("layer.select", json!({"layer": a.0})).unwrap();
+        s.execute("layer.select", json!({"layer": b.0, "mode": "add"})).unwrap();
+        s.execute("layer.select", json!({"layer": c.0, "mode": "remove"})).unwrap();
+        assert_eq!(sel(&s).len(), 2, "an unselected layer stays out");
+        s.execute("layer.select", json!({"layer": b.0, "mode": "remove"})).unwrap();
+        assert_eq!(sel(&s), vec![a]);
+        s.execute("layer.select", json!({"layer": a.0, "mode": "remove"})).unwrap();
+        assert_eq!(sel(&s), vec![a], "the last selected layer stays");
+    }
+
+    /// A mask with its chain off stays put while the layer moves; a linked one moves along.
+    #[test]
+    fn translate_leaves_an_unlinked_mask_in_place() {
+        for depth in [8, 16] {
+            let mut s = session(depth);
+            let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
+            s.execute("layer.select", json!({"layer": a.0})).unwrap();
+            s.execute("layer.layerMask.hideAll", json!({})).unwrap();
+            s.edit("mask", |doc, _| {
+                doc.layer_mut(a).unwrap().mask.as_mut().unwrap().surface.fill_rect(Rect::new(12, 12, 18, 18), &[1.0]);
+                Ok(())
+            })
+            .unwrap();
+            let mval = |s: &Session, x, y| doc(s).layer(a).unwrap().mask.as_ref().unwrap().surface.sample_channel(x, y, 0);
+            s.execute("layer.layerMask.linked", json!({"linked": false})).unwrap();
+            s.execute("layer.translate", json!({"dx": 30, "dy": 0})).unwrap();
+            assert!(mval(&s, 14, 14) > 0.9, "{depth}-bit: unlinked mask stays");
+            assert!(mval(&s, 44, 14) < 0.1);
+            s.execute("edit.undo", json!({})).unwrap();
+            s.execute("layer.layerMask.linked", json!({"linked": true})).unwrap();
+            s.execute("layer.translate", json!({"dx": 30, "dy": 0})).unwrap();
+            assert!(mval(&s, 44, 14) > 0.9, "{depth}-bit: linked mask moves");
+        }
+    }
+
+    /// Aimed at the mask, a move shifts an unlinked mask alone and leaves a linked one with its layer.
+    #[test]
+    fn translate_with_the_mask_targeted_moves_an_unlinked_mask_alone() {
+        for depth in [8, 16] {
+            let mut s = session(depth);
+            let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
+            s.execute("layer.select", json!({"layer": a.0})).unwrap();
+            s.execute("layer.layerMask.hideAll", json!({})).unwrap();
+            s.edit("mask", |doc, _| {
+                doc.layer_mut(a).unwrap().mask.as_mut().unwrap().surface.fill_rect(Rect::new(12, 12, 18, 18), &[1.0]);
+                Ok(())
+            })
+            .unwrap();
+            let mval = |s: &Session, x, y| doc(s).layer(a).unwrap().mask.as_ref().unwrap().surface.sample_channel(x, y, 0);
+            // Linked: the layer and its mask move together.
+            s.execute("layer.translate", json!({"dx": 30, "dy": 0, "target": "mask"})).unwrap();
+            assert_eq!(bounds(&s, a), Rect::new(40, 10, 50, 20), "{depth}-bit");
+            assert!(mval(&s, 44, 14) > 0.9);
+            s.execute("layer.layerMask.linked", json!({"linked": false})).unwrap();
+            s.execute("layer.translate", json!({"dx": -30, "dy": 0, "target": "mask"})).unwrap();
+            assert_eq!(bounds(&s, a), Rect::new(40, 10, 50, 20), "{depth}-bit: the layer stays");
+            assert!(mval(&s, 14, 14) > 0.9, "the mask moved");
+            assert!(mval(&s, 44, 14) < 0.1);
+            s.execute("edit.undo", json!({})).unwrap();
+            assert!(mval(&s, 44, 14) > 0.9, "undo puts the mask back");
+        }
+    }
+
     #[test]
     fn moves_and_layer_props_report_only_their_area() {
         let mut s = session(8);
@@ -1507,7 +1665,7 @@ mod tests {
     }
 
     #[test]
-    fn new_layers_that_change_pixels_still_recomposite_everything() {
+    fn new_layers_that_change_clipping_recomposite_everything() {
         let mut s = session(8);
         let base = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
         let clipped = rect_layer(&mut s, Rect::new(0, 0, 100, 80));
@@ -1531,21 +1689,33 @@ mod tests {
         assert_eq!(step_damage(&before, &split), None);
         assert_eq!(step_damage(&split, &before), None);
         s.execute("edit.undo", json!({})).unwrap();
-        // A step that adds a layer with pixels (Layer via Copy, paste…) is not inert either.
+        // A step that adds a layer with pixels (Layer via Copy, paste…) changes where it draws.
         let before = doc(&s).clone();
         let mut after = before.clone();
         let mut l = Layer::raster("painted", after.pixel_format());
         l.surface_mut().unwrap().fill_rect(Rect::new(1, 1, 2, 2), &[0.0, 1.0, 0.0, 1.0]);
         after.insert_above(None, l);
-        assert_eq!(step_damage(&before, &after), None);
-        assert_eq!(step_damage(&after, &before), None);
-        // Nor, conservatively, an empty layer in another blend mode.
+        assert_eq!(step_damage(&before, &after), Some(Rect::new(1, 1, 2, 2)));
+        assert_eq!(step_damage(&after, &before), Some(Rect::new(1, 1, 2, 2)));
+        // Unless it becomes the base of clipped layers above it.
+        let mut based = before.clone();
+        let mut l = Layer::raster("base", based.pixel_format());
+        l.surface_mut().unwrap().fill_rect(Rect::new(1, 1, 2, 2), &[0.0, 1.0, 0.0, 1.0]);
+        let under = based.layers.iter().position(|l| l.id == clipped).unwrap();
+        based.layers.insert(under, l);
+        assert_eq!(step_damage(&before, &based), None);
+        assert_eq!(step_damage(&based, &before), None);
+        // An adjustment reaches every pixel below it.
+        let mut adjusted = before.clone();
+        adjusted.insert_above(None, Layer::new("inv", LayerContent::Adjustment(photocraft_doc::Adjustment::Invert)));
+        assert_eq!(step_damage(&before, &adjusted), None);
+        assert_eq!(step_damage(&adjusted, &before), None);
+        // Empty layers draw nothing, in any blend mode.
         let mut styled = before.clone();
         let mut l = Layer::raster("styled", styled.pixel_format());
         l.blend = photocraft_doc::BlendMode::Multiply;
         styled.insert_above(None, l);
-        assert_eq!(step_damage(&before, &styled), None);
-        // An empty layer in Normal mode is.
+        assert_eq!(step_damage(&before, &styled), Some(Rect::EMPTY));
         let mut plain = before.clone();
         plain.insert_above(None, Layer::raster("plain", plain.pixel_format()));
         assert_eq!(step_damage(&before, &plain), Some(Rect::EMPTY));
@@ -1588,6 +1758,40 @@ mod tests {
         }
     }
 
+    /// The composite of `after` equals `before`'s outside `damage`.
+    fn unchanged_outside(before: &Document, after: &Document, damage: Rect) -> bool {
+        let (x, y) = (photocraft_compose::render(before, before.bounds()), photocraft_compose::render(after, after.bounds()));
+        let w = before.bounds().width() as i32;
+        x.px.iter().zip(&y.px).enumerate().all(|(i, (p, q))| p == q || damage.contains(i as i32 % w, i as i32 / w))
+    }
+
+    /// Duplicate, paste and delete, and their undo and redo, recomposite only where the layer
+    /// draws; undoing a duplicate used to recomposite the whole document.
+    #[test]
+    fn duplicate_paste_and_delete_report_where_the_layer_draws() {
+        let mut s = session(8);
+        let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
+        let full = doc(&s).bounds();
+        let step = |s: &mut Session, id: &str, p: serde_json::Value| {
+            let before = doc(s).clone();
+            s.execute(id, p).unwrap();
+            let d = damage(s).unwrap_or_else(|| panic!("{id}: unbounded damage"));
+            assert!(d.width() < full.width(), "{id}: {d:?}");
+            assert!(unchanged_outside(&before, doc(s), d), "{id}: pixels changed outside {d:?}");
+            s.execute("edit.undo", json!({})).unwrap();
+            assert_eq!(damage(s), Some(d), "undo {id}");
+            s.execute("edit.redo", json!({})).unwrap();
+            assert_eq!(damage(s), Some(d), "redo {id}");
+        };
+        step(&mut s, "layer.duplicate", json!({"layer": a.0}));
+        s.execute("layer.select", json!({"layer": a.0})).unwrap();
+        s.execute("select.rect", json!({"x": 12, "y": 12, "width": 4, "height": 4})).unwrap();
+        s.execute("edit.copy", json!({})).unwrap();
+        s.execute("select.deselect", json!({})).unwrap();
+        step(&mut s, "edit.paste", json!({}));
+        step(&mut s, "layer.delete", json!({"layer": a.0}));
+    }
+
     #[test]
     fn the_move_preview_matches_the_move() {
         let mut s = session(8);
@@ -1604,6 +1808,42 @@ mod tests {
         assert!(moved(&before, &[LayerId(999_999)], 1, 1).is_err());
     }
 
+    #[test]
+    fn move_stroked_shape_across_canvas_edge_matches_fresh_render() {
+        let mut s = session(8);
+        let id = LayerId(
+            s.execute("shape.create", json!({"kind": "rect", "rect": [10, 10, 30, 30], "stroke": {"width": 4, "color": "#ff0000"}})).unwrap()["layer"]
+                .as_u64()
+                .unwrap(),
+        );
+        let before = doc(&s).clone();
+        let ids = move_targets(&before, &[id]);
+
+        // Drag the stroked shape across the left canvas boundary:
+        let moved_doc = moved(&before, &ids, -25, 0).unwrap();
+        let moved_layer = moved_doc.layer(id).unwrap();
+        let LayerContent::Shape(sh) = &moved_layer.content else { panic!("not a shape") };
+        let cached = sh.cache.as_ref().expect("cached render");
+
+        let mut fresh_sh = sh.clone();
+        crate::vector_cmds::refresh_shape(&moved_doc, &mut fresh_sh);
+        let fresh = fresh_sh.cache.as_ref().expect("fresh render");
+
+        assert_eq!(cached, fresh, "dragged shape cached render must match fresh render across canvas edge");
+
+        // Drag it back inside the canvas:
+        let moved_back = moved(&moved_doc, &ids, 30, 0).unwrap();
+        let back_layer = moved_back.layer(id).unwrap();
+        let LayerContent::Shape(back_sh) = &back_layer.content else { panic!("not a shape") };
+        let back_cached = back_sh.cache.as_ref().expect("cached render");
+
+        let mut fresh_back = back_sh.clone();
+        crate::vector_cmds::refresh_shape(&moved_back, &mut fresh_back);
+        let fresh_back_render = fresh_back.cache.as_ref().expect("fresh render");
+
+        assert_eq!(back_cached, fresh_back_render, "cached render must match fresh render when dragged back");
+    }
+
     fn select_all(s: &mut Session, ids: &[LayerId]) {
         s.execute("layer.select", json!({"layer": ids[0].0})).unwrap();
         for id in &ids[1..] {
@@ -2124,12 +2364,12 @@ mod tests {
         assert_ne!(doc(&s).size, photocraft_doc::Size::new(100, 80));
         s.undo();
         assert_eq!(damage(&s), None, "a size change recomposites the whole canvas");
-        // A structural change (a layer removed and restored) neither.
+        // A layer removed and restored changes only where it draws.
         let b = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
         select_all(&mut s, &[b]);
         s.execute("layer.delete", json!({})).unwrap();
         s.undo();
-        assert_eq!(damage(&s), None);
+        assert_eq!(damage(&s), Some(Rect::new(0, 0, 5, 5)));
     }
 
     #[test]
@@ -2361,6 +2601,31 @@ mod tests {
         assert_eq!(s.active().unwrap().history.entries().last().map(|e| e.as_str()), Some("Reverse"));
     }
 
+    /// #4892: Lock Image Pixels includes Lock Transparent Pixels, so the two are never both on:
+    /// locking the pixels clears the transparency lock, which stays off while they are locked,
+    /// through both `layer.setProps` and `layer.lockLayers`.
+    #[test]
+    fn locking_pixels_clears_and_holds_off_the_transparency_lock() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
+        let id = LayerId(s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap());
+        let locks = |s: &Session| doc(s).layer(id).unwrap().locks;
+        s.execute("layer.setProps", json!({"locks": {"transparency": true}})).unwrap();
+        assert!(locks(&s).transparency);
+        s.execute("layer.setProps", json!({"locks": {"pixels": true}})).unwrap();
+        assert!(locks(&s).pixels && !locks(&s).transparency, "locking the pixels clears the transparency lock");
+        s.execute("layer.setProps", json!({"locks": {"transparency": true}})).unwrap();
+        assert!(!locks(&s).transparency, "and it stays off while the pixels are locked");
+        s.execute("layer.setProps", json!({"locks": {"transparency": true, "pixels": true}})).unwrap();
+        assert!(locks(&s).pixels && !locks(&s).transparency, "both at once: the pixel lock wins");
+        s.execute("layer.lockLayers", json!({"pixels": false})).unwrap();
+        s.execute("layer.lockLayers", json!({"transparency": true})).unwrap();
+        assert!(locks(&s).transparency && !locks(&s).pixels, "with the pixels unlocked it can be set again");
+        s.execute("layer.lockLayers", json!({"pixels": true})).unwrap();
+        assert!(locks(&s).pixels && !locks(&s).transparency);
+        assert!(s.execute("layer.setProps", json!({"locks": {"nope": true}})).is_err());
+    }
+
     #[test]
     fn inspect_reports_selection() {
         let mut s = session(8);
diff --git a/crates/engine/src/layer_style.rs b/crates/engine/src/layer_style.rs
index bf2d55a5a5..fbbc949e20 100644
--- a/crates/engine/src/layer_style.rs
+++ b/crates/engine/src/layer_style.rs
@@ -52,9 +52,21 @@ fn color(p: &Value, k: &str, d: [f32; 3]) -> Color {
     let c = color_of(p, k).map_or(d, |c| c.to_rgb());
     Color::rgb(c[0], c[1], c[2])
 }
+/// The stops of a two-colour gradient, baked with Photoshop's interpolation when `method` names
+/// one (`classic`, `perceptual`, `linear`, `smooth`; `smoothness` 0..=100, default 100 as in
+/// Photoshop): the compositors interpolate stops linearly, so the curve becomes dense stops, as on
+/// PSD import. Photoshop 27.11's Classic Gradient Overlay eases (t + smoothstep(t)) / 2 between the
+/// colours: a straight ramp was up to 12 levels off.
+fn gradient_stops(p: &Value, from: Color, to: Color) -> Vec<(f32, Color)> {
+    let stops = vec![(0.0, from), (1.0, to)];
+    match p.get("method").and_then(Value::as_str).and_then(photocraft_io::GradientMethod::from_name) {
+        Some(m) => photocraft_io::bake_gradient(stops, &[0.5], (f(p, "smoothness", 100.0) / 100.0).clamp(0.0, 1.0), m),
+        None => stops,
+    }
+}
 fn gradient(p: &Value) -> Gradient {
     Gradient {
-        stops: vec![(0.0, color(p, "from", [0.0; 3])), (1.0, color(p, "to", [1.0; 3]))],
+        stops: gradient_stops(p, color(p, "from", [0.0; 3]), color(p, "to", [1.0; 3])),
         style: gradient_style(p.get("style").and_then(Value::as_str).unwrap_or("linear")),
         angle: f(p, "angle", 90.0),
         scale: f(p, "scale", 100.0) / 100.0,
@@ -98,39 +110,250 @@ pub fn effect_defaults(kind: &str) -> Value {
 /// A contour preset point: input, output (both `0..=1`) and whether it is a corner.
 pub type ContourPoint = (f32, f32, bool);
 
-/// Built-in contour presets, in the order of Photoshop's default contour picker. The shapes are
-/// our own control points, drawn to match each preset's visible curve; imported PSD contours keep
-/// their own points. Points are sorted by input; a corner point bends the curve sharply.
+/// Built-in contour presets, in the order of Photoshop's default contour picker. Each is Photoshop's
+/// own curve as measured in Photoshop 27.11 (a Satin of each preset against a Linear one, 38
+/// levels per curve, read back through Satin's mirrored lookup — see
+/// `photocraft_compose::effects::satin_lut` — and thinned to within 1 %), joined by straight
+/// segments (every inner point a corner). Imported PSD contours keep their own points.
 pub const CONTOURS: &[(&str, &[ContourPoint])] = &[
     ("Linear", &[(0.0, 0.0, false), (1.0, 1.0, false)]),
-    ("Cone", &[(0.0, 0.0, false), (0.5, 1.0, true), (1.0, 0.0, false)]),
-    ("Cone - Inverted", &[(0.0, 1.0, false), (0.5, 0.0, true), (1.0, 1.0, false)]),
-    ("Cove - Deep", &[(0.0, 0.0, false), (0.3, 0.02, false), (0.6, 0.12, false), (0.85, 0.4, false), (1.0, 1.0, false)]),
-    ("Cove - Shallow", &[(0.0, 0.0, false), (0.5, 0.22, false), (1.0, 1.0, false)]),
-    ("Gaussian", &[(0.0, 0.0, false), (0.25, 0.08, false), (0.5, 0.5, false), (0.75, 0.92, false), (1.0, 1.0, false)]),
-    ("Half Round", &[(0.0, 0.0, false), (0.04, 0.28, false), (0.15, 0.53, false), (0.35, 0.8, false), (0.65, 0.95, false), (1.0, 1.0, false)]),
-    ("Ring", &[(0.0, 0.0, false), (0.25, 0.7, false), (0.5, 1.0, false), (0.75, 0.7, false), (1.0, 0.0, false)]),
-    ("Ring - Double", &[(0.0, 0.0, false), (0.25, 1.0, false), (0.5, 0.0, true), (0.75, 1.0, false), (1.0, 0.0, false)]),
-    ("Rolling Slope - Descending", &[(0.0, 1.0, false), (0.25, 0.62, false), (0.5, 0.58, false), (0.75, 0.28, false), (1.0, 0.0, false)]),
     (
-        "Rounded Steps",
+        "Cone",
         &[
             (0.0, 0.0, false),
-            (0.08, 0.01, false),
-            (0.165, 0.167, false),
-            (0.25, 0.323, false),
-            (0.333, 0.333, true),
-            (0.413, 0.343, false),
-            (0.5, 0.5, false),
-            (0.587, 0.657, false),
-            (0.667, 0.667, true),
-            (0.747, 0.677, false),
-            (0.833, 0.833, false),
-            (0.92, 0.99, false),
+            (0.172, 0.477, true),
+            (0.195, 0.555, true),
+            (0.266, 0.711, true),
+            (0.383, 0.922, true),
+            (0.43, 0.969, true),
+            (0.477, 0.992, true),
+            (0.523, 0.992, true),
+            (0.57, 0.969, true),
+            (0.664, 0.859, true),
+            (0.703, 0.789, true),
+            (0.742, 0.711, true),
+            (0.836, 0.477, true),
+            (0.859, 0.398, true),
+            (0.914, 0.266, true),
+            (0.945, 0.156, true),
+            (0.977, 0.078, true),
+            (1.0, 0.0, false),
+        ],
+    ),
+    (
+        "Cone - Inverted",
+        &[
+            (0.0, 1.0, false),
+            (0.031, 0.922, true),
+            (0.07, 0.789, true),
+            (0.172, 0.523, true),
+            (0.195, 0.445, true),
+            (0.266, 0.289, true),
+            (0.383, 0.078, true),
+            (0.43, 0.031, true),
+            (0.477, 0.008, true),
+            (0.523, 0.008, true),
+            (0.57, 0.031, true),
+            (0.664, 0.141, true),
+            (0.703, 0.211, true),
+            (0.742, 0.289, true),
+            (0.836, 0.523, true),
+            (0.859, 0.602, true),
+            (0.914, 0.734, true),
+            (0.945, 0.844, true),
+            (0.977, 0.922, true),
             (1.0, 1.0, false),
         ],
     ),
-    ("Sawtooth 1", &[(0.0, 0.0, false), (0.3, 1.0, true), (0.34, 0.0, true), (0.64, 1.0, true), (0.68, 0.0, true), (1.0, 1.0, false)]),
+    (
+        "Cove - Deep",
+        &[
+            (0.0, 0.258, false),
+            (0.344, 0.289, true),
+            (0.383, 0.297, true),
+            (0.477, 0.352, true),
+            (0.57, 0.43, true),
+            (0.617, 0.484, true),
+            (0.664, 0.57, true),
+            (0.703, 0.711, true),
+            (0.742, 0.906, true),
+            (0.773, 1.0, true),
+            (1.0, 1.0, false),
+        ],
+    ),
+    (
+        "Cove - Shallow",
+        &[
+            (0.0, 0.0, false),
+            (0.008, 0.164, true),
+            (0.016, 0.477, true),
+            (0.039, 0.508, true),
+            (0.172, 0.57, true),
+            (0.305, 0.688, true),
+            (0.344, 0.734, true),
+            (0.477, 0.945, true),
+            (0.523, 1.0, true),
+            (1.0, 1.0, false),
+        ],
+    ),
+    (
+        "Gaussian",
+        &[
+            (0.0, 0.0, false),
+            (0.117, 0.023, true),
+            (0.172, 0.055, true),
+            (0.234, 0.117, true),
+            (0.305, 0.234, true),
+            (0.383, 0.414, true),
+            (0.523, 0.688, true),
+            (0.617, 0.812, true),
+            (0.703, 0.891, true),
+            (0.805, 0.953, true),
+            (1.0, 1.0, false),
+        ],
+    ),
+    (
+        "Half Round",
+        &[
+            (0.0, 0.0, false),
+            (0.07, 0.18, true),
+            (0.195, 0.445, true),
+            (0.266, 0.555, true),
+            (0.383, 0.703, true),
+            (0.523, 0.828, true),
+            (0.617, 0.883, true),
+            (0.773, 0.945, true),
+            (1.0, 1.0, false),
+        ],
+    ),
+    (
+        "Ring",
+        &[
+            (0.0, 0.0, false),
+            (0.031, 0.078, true),
+            (0.039, 0.117, true),
+            (0.117, 0.383, true),
+            (0.172, 0.609, true),
+            (0.195, 0.734, true),
+            (0.266, 0.953, true),
+            (0.305, 1.0, true),
+            (0.344, 0.992, true),
+            (0.383, 0.922, true),
+            (0.43, 0.805, true),
+            (0.477, 0.641, true),
+            (0.57, 0.281, true),
+            (0.617, 0.141, true),
+            (0.664, 0.055, true),
+            (0.703, 0.016, true),
+            (0.742, 0.016, true),
+            (0.773, 0.062, true),
+            (0.836, 0.234, true),
+            (0.859, 0.344, true),
+            (0.891, 0.445, true),
+            (0.914, 0.547, true),
+            (0.945, 0.734, true),
+            (0.977, 0.875, true),
+            (1.0, 1.0, false),
+        ],
+    ),
+    (
+        "Ring - Double",
+        &[
+            (0.0, 0.0, false),
+            (0.055, 0.086, true),
+            (0.094, 0.172, true),
+            (0.117, 0.242, true),
+            (0.172, 0.477, true),
+            (0.195, 0.625, true),
+            (0.266, 0.891, true),
+            (0.305, 0.945, true),
+            (0.344, 0.891, true),
+            (0.383, 0.695, true),
+            (0.43, 0.367, true),
+            (0.477, 0.07, true),
+            (0.523, 0.047, true),
+            (0.57, 0.32, true),
+            (0.617, 0.648, true),
+            (0.664, 0.867, true),
+            (0.703, 0.93, true),
+            (0.742, 0.852, true),
+            (0.773, 0.641, true),
+            (0.805, 0.375, true),
+            (0.836, 0.156, true),
+            (0.859, 0.031, true),
+            (0.891, 0.023, true),
+            (0.914, 0.109, true),
+            (0.977, 0.703, true),
+            (0.984, 0.82, true),
+            (1.0, 1.0, false),
+        ],
+    ),
+    (
+        "Rolling Slope - Descending",
+        &[
+            (0.0, 1.0, false),
+            (0.008, 1.0, true),
+            (0.031, 0.93, true),
+            (0.039, 0.883, true),
+            (0.07, 0.758, true),
+            (0.141, 0.539, true),
+            (0.195, 0.406, true),
+            (0.266, 0.352, true),
+            (0.305, 0.352, true),
+            (0.523, 0.57, true),
+            (0.57, 0.602, true),
+            (0.617, 0.617, true),
+            (0.703, 0.602, true),
+            (0.742, 0.562, true),
+            (0.836, 0.391, true),
+            (0.914, 0.211, true),
+            (0.945, 0.109, true),
+            (0.977, 0.039, true),
+            (0.984, 0.008, true),
+            (1.0, 0.0, false),
+        ],
+    ),
+    (
+        "Rounded Steps",
+        &[
+            (0.0, 0.234, false),
+            (0.031, 0.305, true),
+            (0.039, 0.336, true),
+            (0.094, 0.43, true),
+            (0.141, 0.477, true),
+            (0.234, 0.492, true),
+            (0.266, 0.516, true),
+            (0.305, 0.602, true),
+            (0.344, 0.664, true),
+            (0.383, 0.711, true),
+            (0.477, 0.734, true),
+            (0.523, 0.797, true),
+            (0.57, 0.898, true),
+            (0.617, 0.953, true),
+            (0.664, 0.984, true),
+            (0.773, 0.984, true),
+            (0.836, 0.906, true),
+            (0.891, 0.891, true),
+            (0.914, 0.898, true),
+            (1.0, 1.0, false),
+        ],
+    ),
+    (
+        "Sawtooth 1",
+        &[
+            (0.0, 0.0, false),
+            (0.031, 0.047, true),
+            (0.195, 0.375, true),
+            (0.266, 0.492, true),
+            (0.477, 0.047, true),
+            (0.523, 0.055, true),
+            (0.742, 0.469, true),
+            (0.773, 0.445, true),
+            (0.914, 0.18, true),
+            (0.945, 0.102, true),
+            (1.0, 0.0, false),
+        ],
+    ),
 ];
 
 /// Names earlier versions offered, still accepted by `contour` params (scripts, saved defaults).
@@ -335,6 +558,13 @@ fn fresh_effect(kind: &str) -> Option<Effect> {
 /// Edits an existing gradient in place: only the end colours and geometry.
 /// Intermediate stops, opacity stops, alignment and offset survive a round trip.
 fn overlay_gradient(g: &mut Gradient, p: &Value) {
+    // A method rebuilds the gradient from its end colours (the stops between are the old curve).
+    if p.get("method").and_then(Value::as_str).is_some_and(|m| photocraft_io::GradientMethod::from_name(m).is_some()) {
+        let ends = (g.stops.first().map(|s| s.1), g.stops.last().map(|s| s.1));
+        let from = color_of(p, "from").or(ends.0).unwrap_or(Color::BLACK);
+        let to = color_of(p, "to").or(ends.1).unwrap_or(Color::WHITE);
+        g.stops = gradient_stops(p, from, to);
+    }
     if let Some(c) = color_of(p, "from")
         && let Some(first) = g.stops.first_mut()
     {
@@ -626,10 +856,7 @@ const MAX_EFFECTS: usize = 256;
 /// mismatches and malformed snapshots are errors, never panics.
 fn replace_effects(s: &mut Session, p: &Value) -> Result<Value> {
     const CMD: &str = "layer.layerStyle.replace";
-    let id = match p.get("layer").and_then(Value::as_u64) {
-        Some(id) => photocraft_doc::LayerId(id),
-        None => s.active().and_then(|d| d.active_layer).ok_or(EngineError::Other("no active layer".into()))?,
-    };
+    let id = crate::commands::layer_param(s, p)?;
     let entries = p.get("effects").and_then(Value::as_array).ok_or_else(|| bad(CMD, "need `effects`: [{kind, params, fx?}]"))?;
     if entries.len() > MAX_EFFECTS {
         return Err(bad(CMD, format!("at most {MAX_EFFECTS} effects")));
@@ -680,10 +907,7 @@ fn set_effect(s: &mut Session, p: &Value, kind: &str) -> Result<Value> {
     let (fx, pattern) = crate::pattern_cmds::resolve_effect(s, fx)?;
     let label = format!("Layer Style: {}", fx.label());
     let add = b(p, "add", false);
-    let id = match p.get("layer").and_then(Value::as_u64) {
-        Some(id) => photocraft_doc::LayerId(id),
-        None => s.active().and_then(|d| d.active_layer).ok_or(EngineError::Other("no active layer".into()))?,
-    };
+    let id = crate::commands::layer_param(s, p)?;
     s.edit(&label, |doc, _| {
         if let Some(pat) = &pattern {
             crate::pattern_cmds::ensure_in_doc(doc, pat);
@@ -778,13 +1002,13 @@ pub fn specs() -> Vec<CommandSpec> {
         style_cmd!(
             "stroke",
             "Stroke…",
-            r##"{"size":px=3,"position":"outside|inside|center","color":"#rrggbb","from":"#rrggbb","to":"#rrggbb","style":str,"angle":deg,"opacity":0..100,"blend":str,"add":bool}"##
+            r##"{"size":px=3,"position":"outside|inside|center","color":"#rrggbb","from":"#rrggbb","to":"#rrggbb","method":"classic|perceptual|linear|smooth"?,"smoothness":0..100=100,"style":str,"angle":deg,"opacity":0..100,"blend":str,"add":bool}"##
         ),
         style_cmd!("colorOverlay", "Color Overlay…", r##"{"color":"#rrggbb","opacity":0..100=100,"blend":str,"add":bool}"##),
         style_cmd!(
             "gradientOverlay",
             "Gradient Overlay…",
-            r##"{"from":"#rrggbb","to":"#rrggbb","style":"linear|radial|angle|reflected|diamond","angle":deg=90,"scale":10..150=100,"reverse":bool,"opacity":0..100,"blend":str,"add":bool}"##
+            r##"{"from":"#rrggbb","to":"#rrggbb","method":"classic|perceptual|linear|smooth"? (Photoshop's interpolation; omitted: straight stops),"smoothness":0..100=100,"style":"linear|radial|angle|reflected|diamond","angle":deg=90,"scale":10..150=100,"reverse":bool,"opacity":0..100,"blend":str,"add":bool}"##
         ),
         style_cmd!(
             "patternOverlay",
@@ -1118,10 +1342,49 @@ mod tests {
         assert_eq!(lin.contour, Contour::Linear);
     }
 
+    #[test]
+    fn contour_presets_match_photoshop() {
+        // Photoshop 27.11, measured through Satin: Cone and Cone − Inverted Satins are identical,
+        // and Gaussian reads 0.36 at 0.5 through Satin but 0.64 as the preset curve (glows, gloss).
+        let lut = |name: &str| {
+            let Some(Contour::Custom { points, corners, .. }) = builtin_contour(name) else { panic!("{name}") };
+            photocraft_compose::adjust::contour_curve_lut(&points, &corners)
+        };
+        let satin = |name: &str| photocraft_compose::effects::satin_lut(&builtin_contour(name).unwrap()).unwrap();
+        let at = |l: &[f32], x: f32| l[(x * (l.len() - 1) as f32).round() as usize];
+        let (cone, inverted) = (satin("Cone"), satin("Cone - Inverted"));
+        for x in [0.1, 0.25, 0.5, 0.8] {
+            assert!((at(&cone, x) - at(&inverted, x)).abs() < 0.03, "{x}: {} vs {}", at(&cone, x), at(&inverted, x));
+        }
+        assert!((at(&satin("Gaussian"), 0.5) - 0.36).abs() < 0.04, "{}", at(&satin("Gaussian"), 0.5));
+        assert!((at(&lut("Gaussian"), 0.5) - 0.64).abs() < 0.03, "{}", at(&lut("Gaussian"), 0.5));
+        assert!((at(&lut("Cove - Deep"), 0.0) - 0.26).abs() < 0.02, "Cove - Deep starts above zero");
+    }
+
+    #[test]
+    fn gradient_overlay_method_matches_photoshop() {
+        // Photoshop 27.11, Classic Gradient Overlay #000000 → #ffffff (Smoothness 100 %): 0.037 at
+        // t = 1/16 and 0.5 in the middle; straight stops would give 0.0625.
+        let mut s = session();
+        s.execute("layer.layerStyle.gradientOverlay", json!({"from": "#000000", "to": "#ffffff", "method": "classic"})).unwrap();
+        let Effect::GradientOverlay { gradient, .. } = &effects(&s)[0] else { panic!() };
+        let at = |t: f32| {
+            let w = gradient.stops.windows(2).find(|w| t >= w[0].0 && t <= w[1].0).unwrap();
+            let u = (t - w[0].0) / (w[1].0 - w[0].0).max(1e-6);
+            w[0].1.to_rgb()[0] + (w[1].1.to_rgb()[0] - w[0].1.to_rgb()[0]) * u
+        };
+        assert!((at(1.0 / 16.0) - 0.037).abs() < 0.004, "{}", at(1.0 / 16.0));
+        assert!((at(0.5) - 0.5).abs() < 0.004, "{}", at(0.5));
+        // Without a method the two stops stay as they are.
+        s.execute("layer.layerStyle.gradientOverlay", json!({"from": "#000000", "to": "#ffffff", "add": true})).unwrap();
+        let plain = effects(&s).iter().filter(|e| matches!(e, Effect::GradientOverlay { gradient, .. } if gradient.stops.len() == 2)).count();
+        assert_eq!(plain, 1, "the added overlay keeps its two stops");
+    }
+
     #[test]
     fn contour_presets_and_custom_curves_apply_in_one_undo_step() {
         let mut s = session();
-        // Picking Cone: the preset's own curve, its peak a corner, in one undo step.
+        // Picking Cone: the preset's own curve, its points corners, in one undo step.
         s.execute("layer.layerStyle.dropShadow", json!({"contour": "Cone", "antiAlias": true})).unwrap();
         let Effect::DropShadow(sh) = &effects(&s)[0] else { panic!() };
         assert_eq!(sh.contour, builtin_contour("Cone").unwrap());
@@ -1129,7 +1392,9 @@ mod tests {
         let Contour::Custom { points, corners, .. } = &sh.contour else { panic!() };
         let lut = photocraft_compose::adjust::contour_curve_lut(points, corners);
         let at = |x: f32| lut[(x * (lut.len() - 1) as f32).round() as usize];
-        assert!((at(0.5) - 1.0).abs() < 1e-3 && (at(0.25) - 0.5).abs() < 0.01, "a sharp Λ, not a rounded hump");
+        // Photoshop's measured Cone: 0 at both ends, a 0.99 peak at 0.5, symmetric.
+        assert!(at(0.0).abs() < 1e-3 && at(1.0).abs() < 1e-3 && at(0.5) > 0.98, "a Λ: {} {} {}", at(0.0), at(0.5), at(1.0));
+        assert!((at(0.25) - at(0.75)).abs() < 0.03, "symmetric: {} vs {}", at(0.25), at(0.75));
         assert_eq!(contour_param(&sh.contour), json!("Cone"));
         s.execute("edit.undo", json!({})).unwrap();
         assert!(effects(&s).is_empty(), "one undo removes it");
diff --git a/crates/engine/src/lens_cmds.rs b/crates/engine/src/lens_cmds.rs
index c0513cf373..379ca2402a 100644
--- a/crates/engine/src/lens_cmds.rs
+++ b/crates/engine/src/lens_cmds.rs
@@ -287,6 +287,7 @@ fn run_filter(s: &mut Session, cmd: &str, label: &str, stored: Value, float_bg:
         let canvas = doc.bounds();
         let selection = doc.selection.clone();
         let locks = doc.effective_locks(id);
+        let background = doc.is_background(id);
         let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
         if let LayerContent::Smart(_) = l.content {
             let sf = SmartFilter { command: cmd.to_string(), params: stored.clone(), blend: photocraft_color::BlendMode::Normal, opacity: 1.0, visible: true };
@@ -296,7 +297,7 @@ fn run_filter(s: &mut Session, cmd: &str, label: &str, stored: Value, float_bg:
             return Err(EngineError::Other(format!("layer \"{}\" is locked", l.name)));
         }
         // A Background layer gains transparency when the edge mode exposes it (as in Photoshop).
-        if float_bg && l.locks.position && l.name == "Background" {
+        if float_bg && background {
             l.locks.position = false;
             l.locks.transparency = false;
             l.name = "Layer 0".into();
@@ -368,7 +369,28 @@ fn adaptive_wide_angle(s: &mut Session, p: &Value) -> Result<Value> {
     }))
 }
 
+/// The transfer curve Camera Raw decodes `doc`'s values with ([`CameraRaw::encoding_gamma`]):
+/// ProPhoto's gamma 1.8 (raws open in it), Adobe RGB's 563/256, 1 for linear sRGB, else 0 for
+/// the sRGB curve.
+pub fn encoding_gamma(doc: &Document) -> f32 {
+    use photocraft_cms::Builtin;
+    let profile = crate::color_cmds::document_profile(doc);
+    [(Builtin::ProPhotoCompat, 1.8), (Builtin::AdobeRgbCompat, 563.0 / 256.0), (Builtin::LinearSrgb, 1.0)]
+        .into_iter()
+        .find(|(b, _)| profile.same_colors(b.profile()))
+        .map_or(0.0, |(_, g)| g)
+}
+
 fn camera_raw_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    // The document's transfer curve goes with the settings, so a Smart Filter keeps it.
+    let mut p = p.clone();
+    if p.get("encodingGamma").is_none()
+        && let Some(g) = s.active().map(|d| encoding_gamma(&d.doc)).filter(|g| *g > 0.0)
+        && let Value::Object(m) = &mut p
+    {
+        m.insert("encodingGamma".into(), json!((f64::from(g) * 1e4).round() / 1e4));
+    }
+    let p = &p;
     let cr = raw_params(RAW, p)?;
     // New settings are strict; stored Smart Filters re-apply through the lenient `raw_params`.
     cr.validate().map_err(|e| bad(RAW, e))?;
@@ -582,6 +604,32 @@ mod tests {
         assert!((p[0] - p[2]).abs() < 0.01, "{p:?}");
     }
 
+    #[test]
+    fn camera_raw_decodes_light_with_the_documents_curve() {
+        // A raw opens in ProPhoto (gamma 1.8): the filter keeps that with its settings, so Whites,
+        // Blacks, Shadows and Highlights work on the same light as when it was applied.
+        let mut s = session(16);
+        s.execute("edit.assignProfile", json!({"profile": "prophoto-compat"})).unwrap();
+        assert_eq!(encoding_gamma(&s.active().unwrap().doc), 1.8);
+        s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+        s.execute(RAW, json!({"shadows": 40, "whites": -30})).unwrap();
+        let d = s.active().unwrap();
+        let filters = match &d.doc.layer(d.active_layer.unwrap()).unwrap().content {
+            LayerContent::Smart(so) => so.smart_filters.clone(),
+            _ => panic!("smart object expected"),
+        };
+        assert_eq!(filters[0].params["encodingGamma"], json!(1.8));
+        // sRGB documents use the sRGB curve, the default, and store nothing.
+        let mut s = session(8);
+        assert_eq!(encoding_gamma(&s.active().unwrap().doc), 0.0);
+        s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+        s.execute(RAW, json!({"shadows": 40})).unwrap();
+        let d = s.active().unwrap();
+        if let LayerContent::Smart(so) = &d.doc.layer(d.active_layer.unwrap()).unwrap().content {
+            assert!(so.smart_filters[0].params.get("encodingGamma").is_none());
+        }
+    }
+
     #[test]
     fn camera_raw_rejects_an_area_too_large_to_develop() {
         // #962: `area.width() * area.height()` overflowed u32 on a legal 65536×65536 canvas,
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 21f3c8adb0..ff3cde6e4c 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -8,12 +8,14 @@
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
 pub mod actions_cmds;
+pub mod actions_edit_cmds;
 pub mod adjust_cmds;
 pub mod adjust_params;
 pub mod align_cmds;
 mod allocation;
 pub mod analysis_cmds;
 pub mod artboard_cmds;
+pub mod atn_cmds;
 pub mod automate_cmds;
 pub mod background_cmds;
 pub mod brush_cmds;
@@ -52,6 +54,7 @@ pub mod group_view_cmds;
 pub mod guide_layout;
 pub mod hidden_target;
 pub mod history_cmds;
+pub mod history_select_cmds;
 pub mod image_cmds;
 pub mod inspect;
 pub mod installed_profiles;
@@ -74,6 +77,7 @@ pub mod multichannel_cmds;
 pub mod new_layer;
 pub mod notes_cmds;
 pub mod paint_cmds;
+mod param_check;
 mod path_edit_cmds;
 pub mod pattern_cmds;
 pub mod pattern_fill_cmds;
@@ -194,6 +198,8 @@ pub struct DocState {
     /// Increments on every change; UIs re-render when it moves.
     pub revision: u64,
     pub saved_revision: u64,
+    /// How much of `revision` came from view-only changes (channel eyes, targeting): pixel caches can ignore those.
+    pub view_revision: u64,
     /// Area changed by the latest revision (None = assume everything changed).
     pub last_damage: Option<photocraft_geom::Rect>,
     /// Coalescing key of the latest history step (see [`Session::execute`]'s `coalesce` param).
@@ -239,6 +245,7 @@ impl DocState {
             source_read_only: false,
             revision: 1,
             saved_revision: 1,
+            view_revision: 0,
             last_damage: None,
             coalesce: None,
             channel_view: Default::default(),
@@ -292,18 +299,54 @@ pub struct ToolState {
     /// preset stays "the current brush" so `brush.presets.update` can overwrite it); cleared when
     /// the brush is reset or the preset is gone.
     pub current_preset: Option<String>,
+    /// Bumped whenever `brush` or `current_preset` changes ([`ToolState::brush_changed`]). The
+    /// last-brush persistence watches it instead of comparing the brush itself, so an unchanged
+    /// brush costs a counter compare per frame, not a clone and serialise.
+    pub brush_rev: u64,
+    /// The revision whose value is in `Preferences::last_brush` (a restored one counts as saved):
+    /// [`brush_rev`](Self::brush_rev) == `brush_saved_rev` means there is nothing new to write.
+    pub brush_saved_rev: u64,
     /// A layer mask is the edit target ([`ToolState::target_mask`]).
     pub mask_targeted: bool,
     /// The foreground/background pair of the edit target that isn't current: the layer pixels'
     /// colours while a mask is targeted, the mask's while the pixels are (#2166).
     pub other_colors: [[f32; 4]; 2],
+    /// Colours picked as CMYK, newest last: the sRGB colour that stands for them and the ink
+    /// values chosen. The tool colours are stored as sRGB, and an sRGB round trip does not give
+    /// back what was typed (100/0/0/0 cyan is outside sRGB), so a CMYK document is filled with
+    /// the inks the person picked (#4196). Matched by colour, so it follows a swap, a reset or a
+    /// mask pair without bookkeeping.
+    pub cmyk_picks: Vec<([f32; 3], [f32; 4])>,
 }
 
 impl ToolState {
+    /// How many CMYK picks are remembered.
+    const CMYK_PICKS: usize = 8;
+
+    /// Remember that sRGB colour `rgb` was picked as the inks `cmyk` (each 0..1).
+    pub fn remember_cmyk(&mut self, rgb: [f32; 3], cmyk: [f32; 4]) {
+        self.cmyk_picks.retain(|(c, _)| *c != rgb);
+        self.cmyk_picks.push((rgb, cmyk));
+        let extra = self.cmyk_picks.len().saturating_sub(Self::CMYK_PICKS);
+        self.cmyk_picks.drain(..extra);
+    }
+
+    /// The inks `rgb` was picked as, if it was picked as CMYK.
+    pub fn picked_cmyk(&self, rgb: [f32; 3]) -> Option<[f32; 4]> {
+        self.cmyk_picks.iter().rev().find(|(c, _)| *c == rgb).map(|(_, k)| *k)
+    }
+
     /// Photoshop's colour pair for a layer mask that has none yet: white foreground, black
     /// background (reveal-paint first).
     pub const MASK_COLORS: [[f32; 4]; 2] = [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 1.0]];
 
+    /// Note that `brush` or `current_preset` changed. Every setter of either (commands and the
+    /// shell's tool-switch paths) calls this; the last-brush persistence only serialises when the
+    /// revision has moved since the stored value ([`Self::brush_saved_rev`]).
+    pub fn brush_changed(&mut self) {
+        self.brush_rev = self.brush_rev.wrapping_add(1);
+    }
+
     /// Switch the edit target between layer pixels and a layer mask. Like Photoshop, the mask and
     /// the pixels keep separate app-wide foreground/background pairs: changing the target puts
     /// the current pair aside and brings back the other one, so colours picked while a mask is
@@ -336,8 +379,11 @@ impl Default for ToolState {
             mixer: Default::default(),
             brush_gesture: None,
             current_preset: None,
+            brush_rev: 0,
+            brush_saved_rev: 0,
             mask_targeted: false,
             other_colors: Self::MASK_COLORS,
+            cmyk_picks: Vec::new(),
         }
     }
 }
@@ -407,9 +453,17 @@ pub struct Session {
     pub link_scan: Option<link_watch::LinkScan>,
     /// Select Subject's last result, reused while the pixels are unchanged (#2865).
     subject_cache: smartselect_cmds::SubjectCache,
+    /// Object Selection's Object Finder results (#4087), shared by the hover preview and the
+    /// click that commits it; valid while the pixels are unchanged.
+    pub object_finder: smartselect_cmds::ObjectFinderCache,
     /// A finished live stroke offered to the `paint.stroke` / `paint.pencil` that commits it
     /// ([`Session::offer_live_stroke`]).
     pub(crate) live_commit: Option<brush_cmds::LiveCommit>,
+    /// Documents a background open decoded but held back until the user answers the profile
+    /// prompt ([`ColorState::open_question`](color_cmds::ColorState::open_question)): `(id,
+    /// document, source read-only)`. The shell takes them with [`Session::take_held_open`].
+    held_opens: Vec<(u64, Document, bool)>,
+    next_held_open: u64,
 }
 
 /// Move item `i` of `v` to position `to`, clamped to the end. Returns where it went; `None` when
@@ -495,6 +549,21 @@ impl Session {
         i
     }
 
+    /// Holds a decoded document back from opening (see `held_opens`); returns its id.
+    pub(crate) fn hold_open(&mut self, doc: Document, source_read_only: bool) -> u64 {
+        self.next_held_open = self.next_held_open.wrapping_add(1);
+        self.held_opens.push((self.next_held_open, doc, source_read_only));
+        self.next_held_open
+    }
+
+    /// Takes a document a background open held back for the profile prompt: the document and
+    /// whether its source is read-only. `None` when there is no such document (already taken).
+    pub fn take_held_open(&mut self, id: u64) -> Option<(Document, bool)> {
+        let i = self.held_opens.iter().position(|(h, _, _)| *h == id)?;
+        let (_, doc, read_only) = self.held_opens.remove(i);
+        Some((doc, read_only))
+    }
+
     pub fn close(&mut self, index: usize) -> Option<DocState> {
         if index >= self.docs.len() {
             return None;
@@ -503,6 +572,7 @@ impl Session {
         if let Some(id) = self.docs.get(index).map(|d| d.doc.id) {
             self.cancel_jobs_on(id);
             self.subject_cache.forget_doc(id);
+            self.object_finder.forget_doc(id);
         }
         let d = self.docs.remove(index);
         self.active = if self.docs.is_empty() {
@@ -542,6 +612,15 @@ impl Session {
         Ok(())
     }
 
+    /// [`Self::offer_live_stroke`] for a live Clone Stamp or History Brush stroke, taken by the
+    /// `paint.cloneStamp` / `paint.historyBrush` it was drawn for. Refused for the Healing Brush
+    /// (it blends on release) and when the brush, layer or clone source changed during the stroke.
+    pub fn offer_live_retouch(&mut self, live: retouch_cmds::LiveRetouch) -> Result<()> {
+        let commit = live.into_commit(self)?;
+        self.live_commit = Some(commit);
+        Ok(())
+    }
+
     /// Withdraw an offer the command didn't take.
     pub fn clear_live_stroke(&mut self) {
         self.live_commit = None;
@@ -575,6 +654,10 @@ impl Session {
         if self.names_existing_layer(spec.id, params) {
             return Ok(());
         }
+        // `ifPresent`: with no Background there is nothing to do, which isn't an error.
+        if spec.id == "layer.new.layerFromBackground" && params.get("ifPresent").and_then(Value::as_bool) == Some(true) {
+            return self.active().map(|_| ()).ok_or_else(|| "no document open".into());
+        }
         channel_cmds::mask_target_enabled(self, spec.id, params).unwrap_or_else(|| (spec.enabled)(self))
     }
 
@@ -644,11 +727,12 @@ impl Session {
             st.color_samplers.retain(|p| bounds.contains(p[0].floor() as i32, p[1].floor() as i32));
             samplers_removed = n - st.color_samplers.len();
         }
-        // An edit that changes no pixels (a selection, guides, a layer's name) leaves the canvas
-        // as it is; anything else recomposites the whole document unless the command reports
-        // its own damage after this. A new lasso selection on a large document used to cost a
-        // full recomposite (seconds on the CPU path, #1773).
-        let unchanged = layer_multi_cmds::same_pixels(&before, &st.doc);
+        // The pixels the edit can have changed, as its undo would report them: nothing for a
+        // selection, guides or a layer's name (a new lasso selection used to recomposite a large
+        // document, seconds on the CPU path, #1773), a new or deleted layer's bounds (a
+        // duplicate or a paste), and everything when that can't be bounded. A command may still
+        // report its own, tighter damage after this.
+        let damage = layer_multi_cmds::step_damage(&before, &st.doc);
         let key = self.coalesce_request.clone();
         let st = self.active_mut().ok_or(EngineError::NoDocument)?;
         let layers = st.layer_target();
@@ -661,11 +745,12 @@ impl Session {
         }
         st.coalesce = key;
         st.revision += 1;
-        st.last_damage = unchanged.then_some(photocraft_geom::Rect::EMPTY);
+        st.last_damage = damage;
         self.samplers_removed += samplers_removed;
-        if !unchanged {
+        if damage.is_none_or(|d| !d.is_empty()) {
             // Free the mask early; a stale entry would only miss (it is keyed by pixels).
             self.subject_cache = Default::default();
+            self.object_finder = Default::default();
         }
         Ok(r)
     }
diff --git a/crates/engine/src/mode_cmds.rs b/crates/engine/src/mode_cmds.rs
index def9440c84..fe22a192c7 100644
--- a/crates/engine/src/mode_cmds.rs
+++ b/crates/engine/src/mode_cmds.rs
@@ -27,6 +27,14 @@ fn num(p: &Value, key: &str, default: f32) -> f32 {
     p.get(key).and_then(Value::as_f64).map_or(default, |v| v as f32)
 }
 
+/// A finite number param, `default` when absent or null; anything else is a bad-params error.
+fn finite_num(p: &Value, cmd: &str, key: &str, default: f64) -> Result<f64> {
+    match p.get(key) {
+        None | Some(Value::Null) => Ok(default),
+        Some(v) => v.as_f64().filter(|f| f.is_finite()).ok_or_else(|| bad(cmd, format!("`{key}` must be a number"))),
+    }
+}
+
 fn str_or<'a>(p: &'a Value, key: &str, default: &'a str) -> &'a str {
     p.get(key).and_then(Value::as_str).unwrap_or(default)
 }
@@ -91,8 +99,9 @@ pub(crate) fn rotate_arbitrary(s: &mut Session, p: &Value) -> Result<Value> {
         let canvas = doc.bounds();
         let fmt = doc.pixel_format();
         let dpi = doc.resolution_dpi;
+        let background_id = doc.background().map(|l| l.id);
         for l in doc.layers.iter_mut() {
-            let background = l.name == "Background" && l.locks.position && matches!(l.content, LayerContent::Raster(_));
+            let background = Some(l.id) == background_id;
             if background && let Some(surf) = l.surface_mut() {
                 // The Background stays a Background: rotated pixels over the background colour.
                 let src = surf.content_bounds();
@@ -320,8 +329,14 @@ fn color_table(s: &mut Session, p: &Value) -> Result<Value> {
     }
     match p.get("transparent") {
         Some(Value::Null) => table.transparent = None,
-        Some(v) => table.transparent = v.as_u64().filter(|&i| (i as usize) < table.colors.len()).map(|i| i as u8).or(table.transparent),
-        None => {}
+        Some(v) => {
+            let len = table.colors.len();
+            let i =
+                v.as_u64().filter(|&i| i < len as u64).ok_or_else(|| bad(CMD, format!("transparent: an index from 0 to {} or null", len.saturating_sub(1))))?;
+            table.transparent = u8::try_from(i).ok();
+        }
+        // A shrunk table can't keep a transparent entry past its end (#4186).
+        None => table.transparent = table.transparent.filter(|&i| usize::from(i) < table.colors.len()),
     }
     let report = |t: &ColorTable| json!({"colors": t.colors.iter().map(|c| hex(*c)).collect::<Vec<_>>(), "transparent": t.transparent});
     if table == cur {
@@ -381,9 +396,14 @@ fn bitmap(s: &mut Session, p: &Value) -> Result<Value> {
         "pattern" => BitmapMethod::Pattern,
         "diffusion" => BitmapMethod::Diffusion,
         "halftone" => {
-            let freq = num(p, "frequency", 53.0).clamp(1.0, 999.0);
+            // Photoshop's Halftone Screen: frequency 1..999 lines/inch, angle -180..180 degrees.
+            let freq = finite_num(p, CMD, "frequency", 53.0)?.clamp(1.0, 999.0) as f32;
+            let angle = finite_num(p, CMD, "angle", 45.0)?;
+            if !(-180.0..=180.0).contains(&angle) {
+                return Err(bad(CMD, format!("angle {angle} is outside -180..180")));
+            }
             let shape = HalftoneShape::from_id(str_or(p, "shape", "round")).ok_or_else(|| bad(CMD, "shape: round|ellipse|line|square|diamond|cross"))?;
-            BitmapMethod::Halftone { cell: (dpi / freq).max(2.0), angle: num(p, "angle", 45.0), shape }
+            BitmapMethod::Halftone { cell: (dpi / freq).max(2.0), angle: angle as f32, shape }
         }
         m => {
             return Err(bad(CMD, format!("method `{m}` (threshold|pattern|diffusion|halftone)")));
diff --git a/crates/engine/src/mode_cmds/tests.rs b/crates/engine/src/mode_cmds/tests.rs
index 1fbed4018d..d6d020699e 100644
--- a/crates/engine/src/mode_cmds/tests.rs
+++ b/crates/engine/src/mode_cmds/tests.rs
@@ -291,6 +291,38 @@ fn bitmap_methods_need_grayscale() {
     }
 }
 
+#[test]
+fn bitmap_halftone_rejects_bad_angles_and_frequencies_without_editing_the_document() {
+    // Photoshop's Halftone Screen takes an angle in -180..180 degrees (#4214): 1e39 used to become
+    // inf, then NaN in the screen rotation, and an almost white bitmap landed in history.
+    let mut s = session(16, 16, 8, "grayscale");
+    let before = s.active().unwrap().history.past_len();
+    let bad = [
+        ("angle", json!(1e39)),
+        ("angle", json!(500)),
+        ("angle", json!(-181)),
+        ("angle", json!(180.01)),
+        ("angle", json!("x")),
+        ("frequency", json!("x")),
+        ("frequency", json!(true)),
+    ];
+    for (key, value) in bad {
+        let mut p = json!({"method": "halftone"});
+        p[key] = value.clone();
+        assert!(s.execute("image.mode.bitmap", p).is_err(), "{key}: {value}");
+        assert_eq!(s.active().unwrap().history.past_len(), before, "{key}: {value}");
+        assert_eq!(doc(&s).mode, ColorMode::Grayscale, "{key}: {value}");
+    }
+    for angle in [-180.0, 30.0, 180.0] {
+        s.execute("image.mode.bitmap", json!({"method": "halftone", "angle": angle})).unwrap();
+        assert_eq!(doc(&s).mode, ColorMode::Bitmap, "{angle}");
+        s.execute("edit.undo", json!({})).unwrap();
+    }
+    // Frequency stays clamped to the documented 1..999 lines/inch.
+    s.execute("image.mode.bitmap", json!({"method": "halftone", "frequency": 1e39})).unwrap();
+    assert_eq!(doc(&s).mode, ColorMode::Bitmap);
+}
+
 #[test]
 fn duotone_inks_and_display() {
     let mut s = session(16, 8, 8, "gray");
@@ -409,3 +441,66 @@ fn duotone_to_rgb_inks_fill_layer_colours() {
         assert!((g - w).abs() < 0.02, "{c:?}");
     }
 }
+
+/// Three-entry Indexed doc (red, blue, transparent at index 2) from an RGB doc with clear pixels.
+fn indexed_with_transparency() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 8, "height": 8, "background": "transparent"})).unwrap();
+    paint(&mut s, |x, _| {
+        if x < 3 {
+            [1.0, 0.0, 0.0, 1.0]
+        } else if x < 6 {
+            [0.0, 0.0, 1.0, 1.0]
+        } else {
+            [0.0; 4]
+        }
+    });
+    s.execute("image.mode.indexedColor", json!({"palette": "exact", "colors": 4, "forced": "none", "dither": "none"})).unwrap();
+    assert_eq!(doc(&s).color_table.as_ref().unwrap().transparent, Some(2));
+    s
+}
+
+#[test]
+fn shrinking_the_color_table_drops_a_transparent_index_past_its_end() {
+    // #4186: the transparent index stayed at 2 after the table shrank to 2 entries, so the palette
+    // PNG export refused the table.
+    let mut s = indexed_with_transparency();
+    s.execute("image.mode.colorTable", json!({"colors": ["#000000", "#ffffff"]})).unwrap();
+    let d = doc(&s);
+    let t = d.color_table.as_ref().unwrap();
+    assert_eq!(t.colors.len(), 2);
+    assert!(t.transparent.is_none_or(|i| usize::from(i) < t.colors.len()), "stale transparent index {:?}", t.transparent);
+    // The pixels end up exactly as with an explicit `"transparent": null`.
+    let mut cleared = indexed_with_transparency();
+    cleared.execute("image.mode.colorTable", json!({"colors": ["#000000", "#ffffff"], "transparent": null})).unwrap();
+    assert_eq!(doc(&cleared).color_table.as_ref(), Some(t));
+    let (a, b) = (d.layers[0].surface().unwrap(), doc(&cleared).layers[0].surface().unwrap());
+    for y in 0..8 {
+        for x in 0..8 {
+            assert_eq!(a.rgba(x, y), b.rgba(x, y), "({x},{y})");
+        }
+    }
+    let png = photocraft_io::export(d, "png", &Default::default()).expect("palette PNG export");
+    assert!(png.warnings.iter().any(|w| w.contains("palette PNG")), "{:?}", png.warnings);
+    // Undo restores the transparent entry.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(doc(&s).color_table.as_ref().unwrap().transparent, Some(2));
+}
+
+#[test]
+fn color_table_rejects_an_invalid_transparent_index_without_editing() {
+    let mut s = indexed_with_transparency();
+    let before = doc(&s).color_table.clone();
+    let n = s.active().unwrap().history.past_len();
+    for t in [json!(999), json!(3), json!(-1), json!(1.5), json!("0"), json!(true)] {
+        assert!(s.execute("image.mode.colorTable", json!({"transparent": t})).is_err(), "{t}");
+        // Validated against the new colours, before any edit.
+        assert!(s.execute("image.mode.colorTable", json!({"colors": ["#000000", "#ffffff"], "transparent": t})).is_err(), "{t}");
+    }
+    assert!(s.execute("image.mode.colorTable", json!({"colors": ["#000000", "#ffffff"], "transparent": 2})).is_err());
+    assert_eq!(doc(&s).color_table, before);
+    assert_eq!(s.active().unwrap().history.past_len(), n);
+    // A valid index still applies.
+    s.execute("image.mode.colorTable", json!({"transparent": 0})).unwrap();
+    assert_eq!(doc(&s).color_table.as_ref().unwrap().transparent, Some(0));
+}
diff --git a/crates/engine/src/new_layer.rs b/crates/engine/src/new_layer.rs
index ca814e6d4c..a6f4cefd38 100644
--- a/crates/engine/src/new_layer.rs
+++ b/crates/engine/src/new_layer.rs
@@ -24,7 +24,8 @@ pub fn neutral_color(mode: BlendMode) -> Option<([f32; 3], &'static str)> {
     }
 }
 
-/// `layer.new.layer`: a pixel layer above the active one, joining the clip group it lands in.
+/// `layer.new.layer`: a pixel layer above the active one (below it with `position: below`, the
+/// Layers panel's ⌘/Ctrl-click), joining the clip group it lands in.
 pub fn run(s: &mut Session, p: &Value) -> Result<Value> {
     let flag = |k: &str| match p.get(k) {
         None | Some(Value::Null) => Ok(false),
@@ -49,6 +50,14 @@ pub fn run(s: &mut Session, p: &Value) -> Result<Value> {
     };
     let neutral =
         if fill_neutral { Some(neutral_color(mode).ok_or_else(|| bad(format!("{} has no neutral color to fill with", mode.label())))?.0) } else { None };
+    let below = match p.get("position") {
+        None | Some(Value::Null) => false,
+        Some(v) => match v.as_str() {
+            Some("above") => false,
+            Some("below") => true,
+            _ => return Err(bad("`position` must be above or below")),
+        },
+    };
     let name = match p.get("name") {
         None | Some(Value::Null) => None,
         Some(v) => Some(v.as_str().ok_or_else(|| bad("`name` must be a string"))?.to_string()),
@@ -65,7 +74,11 @@ pub fn run(s: &mut Session, p: &Value) -> Result<Value> {
             let px = photocraft_raster::from_rgba(&surface.format(), [rgb[0], rgb[1], rgb[2], 1.0]);
             surface.fill_rect(bounds, &px);
         }
-        let id = doc.insert_above(*active, layer);
+        // Nothing may sit under the Background: below it the layer lands above it instead.
+        let id = match *active {
+            Some(a) if below && doc.layer(a).is_some() && !doc.is_background(a) => doc.insert_below(Some(a), layer),
+            _ => doc.insert_above(*active, layer),
+        };
         crate::clip_group::settle(doc, &[id], &Default::default(), clip);
         *active = Some(id);
         Ok(id)
@@ -158,6 +171,24 @@ mod tests {
         assert_eq!(l.surface().unwrap().tile_count(), 0);
     }
 
+    /// `position: below` (⌘/Ctrl-click on the panel button) lands under the active layer; the
+    /// Background stays at the bottom, so below it the layer lands above it.
+    #[test]
+    fn position_below_lands_under_the_active_layer() {
+        let mut s = busy("rgb", 8);
+        let names = |s: &Session| s.active().unwrap().doc.layers.iter().map(|l| l.name.clone()).collect::<Vec<_>>();
+        s.execute("layer.new.layer", json!({"name": "A"})).unwrap();
+        let below = s.execute("layer.new.layer", json!({"name": "Below", "position": "below"})).unwrap()["layer"].as_u64().unwrap();
+        assert_eq!(names(&s), ["Background", "Below", "A"]);
+        assert_eq!(s.active().unwrap().active_layer, Some(photocraft_doc::LayerId(below)));
+        s.execute("layer.new.layer", json!({"name": "Above", "position": "above"})).unwrap();
+        assert_eq!(names(&s), ["Background", "Below", "Above", "A"]);
+        let bg = s.active().unwrap().doc.layers[0].id.0;
+        s.execute("layer.select", json!({"layer": bg})).unwrap();
+        s.execute("layer.new.layer", json!({"name": "OverBg", "position": "below"})).unwrap();
+        assert_eq!(names(&s), ["Background", "OverBg", "Below", "Above", "A"]);
+    }
+
     /// Bad params are errors, never panics, and change nothing.
     #[test]
     fn bad_params_are_errors() {
@@ -175,6 +206,8 @@ mod tests {
             json!({"fillNeutral": "yes"}),
             json!({"clipToPrevious": 1}),
             json!({"name": 7}),
+            json!({"position": "sideways"}),
+            json!({"position": 1}),
         ] {
             assert!(s.execute("layer.new.layer", p.clone()).is_err(), "{p}");
         }
diff --git a/crates/engine/src/paint_cmds.rs b/crates/engine/src/paint_cmds.rs
index 7366758e93..497d7f4fb1 100644
--- a/crates/engine/src/paint_cmds.rs
+++ b/crates/engine/src/paint_cmds.rs
@@ -1,6 +1,6 @@
 //! Paint helpers: Paint Bucket and Gradient tool.
 
-use photocraft_algo::paint::{GradientShape, bucket_fill, bucket_fill_region_src, bucket_fill_src, paint_gradient};
+use photocraft_algo::paint::{GradientShape, bucket_fill_inks, bucket_fill_region_inks, bucket_fill_region_src, bucket_fill_src, paint_gradient};
 use serde_json::{Value, json};
 
 use crate::commands::{CommandSpec, blend_from_str};
@@ -35,11 +35,18 @@ fn point(p: &Value, k: &str) -> Option<(f32, f32)> {
     Some((a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32))
 }
 
+/// `opacity` (1..100 %) as a coverage in 0.01..=1, clamped like the Magic Eraser's: a value
+/// above 1 would overshoot the blend (#4167).
+fn opacity(p: &Value, cmd: &str) -> Result<f32> {
+    Ok(crate::eraser_cmds::number(p, cmd, "opacity", 100.0, 1.0..=100.0)? as f32 / 100.0)
+}
+
 fn bucket(s: &mut Session, p: &Value) -> Result<Value> {
     let fg = s.tools.foreground;
     let c = color(p.get("color"), fg);
     let (x, y) = (f(p, "x", 0.0).floor() as i32, f(p, "y", 0.0).floor() as i32);
-    let (tol, contiguous, aa, opacity) = (f(p, "tolerance", 32.0), b(p, "contiguous", true), b(p, "antiAlias", true), f(p, "opacity", 100.0) / 100.0);
+    let (tol, contiguous, aa) = (f(p, "tolerance", 32.0), b(p, "contiguous", true), b(p, "antiAlias", true));
+    let opacity = opacity(p, "paint.bucket")?;
     let all = b(p, "sampleAllLayers", false) && crate::channel_cmds::target_of(p) == crate::channel_cmds::Target::Pixels;
     // Other visible layers can define the region, but the fill still writes only to the target.
     let region = if all {
@@ -55,12 +62,14 @@ fn bucket(s: &mut Session, p: &Value) -> Result<Value> {
     let pattern = if source == "pattern" {
         let pat = crate::pattern_cmds::resolve_param(s, "paint.bucket", p)?;
         let tile = photocraft_compose::pattern::Tile::new(&pat)
-            .ok_or_else(|| EngineError::BadParams { cmd: "paint.bucket".into(), msg: "the pattern is empty".into() })?;
+            .ok_or_else(|| EngineError::BadParams { cmd: "paint.bucket".into(), msg: "the pattern is empty or too large to paint".into() })?;
         let (scale, angle, _, phase) = crate::pattern_cmds::placement(p);
         Some((tile, scale, angle, phase))
     } else {
         None
     };
+    // A foreground picked as CMYK fills a CMYK document with the picked inks (#4196).
+    let inks = s.tools.picked_cmyk([c[0], c[1], c[2]]).filter(|_| c[3] >= 1.0 && pattern.is_none());
     let filled = s.edit("Paint Bucket", |doc, active| {
         let area = doc.bounds();
         let sel = doc.selection.clone();
@@ -80,10 +89,10 @@ fn bucket(s: &mut Session, p: &Value) -> Result<Value> {
                 bucket_fill_src(surf, area, (x, y), tol, contiguous, aa, opacity, sel.as_ref(), lock, src)
             }
         } else if let Some(region) = &region {
-            bucket_fill_region_src(surf, region, opacity, sel.as_ref(), lock, |_, _| c);
+            bucket_fill_region_inks(surf, region, opacity, sel.as_ref(), lock, |_, _| c, inks);
             true
         } else {
-            bucket_fill(surf, area, (x, y), tol, contiguous, aa, c, opacity, sel.as_ref(), lock)
+            bucket_fill_inks(surf, area, (x, y), tol, contiguous, aa, opacity, sel.as_ref(), lock, |_, _| c, inks)
         };
         surf.prune();
         Ok(ok)
@@ -114,8 +123,25 @@ fn gradient(s: &mut Session, p: &Value) -> Result<Value> {
             gradients::apply_opacity(cs, &gradients::transparency_param(p, "paint.gradient")?.unwrap_or_default())
         }
     };
+    // Photoshop's interpolation (`method`, with `smoothness` 0..=100, default 100) baked into dense
+    // stops, as for Gradient Overlay: Photoshop 27.11's Classic black → white is 0.037 at t = 1/16
+    // where straight stops give 0.0625.
+    let stops = match p.get("method").and_then(Value::as_str).and_then(photocraft_io::GradientMethod::from_name) {
+        Some(m) if stops.len() >= 2 => {
+            let colors = stops.iter().map(|(t, c)| (*t, photocraft_color::Color::rgba(c[0], c[1], c[2], c[3]))).collect();
+            let mids = vec![0.5; stops.len() - 1];
+            photocraft_io::bake_gradient(colors, &mids, (f(p, "smoothness", 100.0) / 100.0).clamp(0.0, 1.0), m)
+                .into_iter()
+                .map(|(t, c)| {
+                    let rgb = c.to_rgb();
+                    (t, [rgb[0], rgb[1], rgb[2], c.alpha])
+                })
+                .collect()
+        }
+        _ => stops,
+    };
     let reverse = b(p, "reverse", false);
-    let opacity = f(p, "opacity", 100.0) / 100.0;
+    let opacity = opacity(p, "paint.gradient")?;
     let blend = p.get("mode").and_then(Value::as_str).and_then(blend_from_str).unwrap_or(photocraft_color::BlendMode::Normal);
     let dither = b(p, "dither", true); // Photoshop dithers gradients by default (reduces banding).
     s.edit("Gradient", |doc, active| {
@@ -146,7 +172,7 @@ pub fn specs() -> Vec<CommandSpec> {
             label: "Gradient",
             menu: &[],
             shortcut: None,
-            params: r##"{"from":[x,y],"to":[x,y],"style":"linear|radial|angle|reflected|diamond"="linear","colors":["#rrggbb",…]? (evenly spaced),"gradient":preset name?,"stops":[[t,"#rrggbb"|"foreground"|"background"],…]?,"transparency":[[t,0..100],…]? (default: the current gradient, see gradient.presets.select),"reverse":bool=false,"dither":bool=true,"opacity":1..100=100,"mode":"normal|multiply|…"="normal","target":"pixels"|"mask"|"quickMask"|{"channel":i}=Channels panel target}"##,
+            params: r##"{"from":[x,y],"to":[x,y],"style":"linear|radial|angle|reflected|diamond"="linear","colors":["#rrggbb",…]? (evenly spaced),"gradient":preset name?,"stops":[[t,"#rrggbb"|"foreground"|"background"],…]?,"transparency":[[t,0..100],…]? (default: the current gradient, see gradient.presets.select),"method":"classic|perceptual|linear|smooth"? (Photoshop's interpolation; omitted: straight stops),"smoothness":0..100=100,"reverse":bool=false,"dither":bool=true,"opacity":1..100=100,"mode":"normal|multiply|…"="normal","target":"pixels"|"mask"|"quickMask"|{"channel":i}=Channels panel target}"##,
             enabled: crate::commands::has_paintable,
             run: gradient,
             journal: true,
@@ -330,6 +356,30 @@ mod tests {
         assert_eq!(px(&s, 5, 5), vec![0.0, 0.0, 1.0, 1.0]);
     }
 
+    /// #4196: the Paint Bucket and Edit > Stroke write a CMYK pick as its inks into a CMYK document,
+    /// not as its sRGB stand-in converted back (100/0/0/0 cyan would come out as about 100/28/0/17).
+    #[test]
+    fn bucket_and_stroke_write_a_cmyk_pick_as_its_inks() {
+        let cyan = [1.0f32, 0.0, 0.0, 0.0];
+        let mut s = session();
+        s.execute("image.mode.cmyk", json!({})).unwrap();
+        let rgb = photocraft_color::convert::cmyk_to_rgb(cyan).map(|c| c.clamp(0.0, 1.0));
+        s.execute("tools.setColors", json!({"foreground": rgb, "foregroundCmyk": cyan})).unwrap();
+        let inks_at = |s: &Session, x: i32, y: i32| -> Vec<f32> {
+            let st = s.active().unwrap();
+            let surf = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap();
+            surf.read_region(Rect::new(x, y, x + 1, y + 1)).into_iter().take(4).collect()
+        };
+        let is_cyan = |got: &[f32]| got.iter().zip(cyan).all(|(a, b)| (a - b).abs() < 0.02);
+        s.execute("paint.bucket", json!({"x": 2, "y": 2, "antiAlias": false})).unwrap();
+        let got = inks_at(&s, 5, 5);
+        assert!(is_cyan(&got), "bucket: {got:?}");
+        s.execute("select.all", json!({})).unwrap();
+        s.execute("edit.stroke", json!({"width": 2, "location": "inside", "color": rgb})).unwrap();
+        let got = inks_at(&s, 0, 5);
+        assert!(is_cyan(&got), "stroke: {got:?}");
+    }
+
     #[test]
     fn bucket_fills_with_a_pattern() {
         // Paint Bucket with contents="pattern" flood-fills the region with a pattern, not a colour.
@@ -381,4 +431,59 @@ mod tests {
         let noisy = run(true);
         assert!(noisy.windows(2).any(|w| w[0] != w[1]), "dither: per-pixel variation");
     }
+
+    /// The two commands under test, each painting #808080 over a white document.
+    fn grey_fill(cmd: &str, opacity: Value) -> Value {
+        match cmd {
+            "paint.bucket" => json!({"x": 2, "y": 2, "color": "#808080", "opacity": opacity}),
+            _ => json!({"from": [0, 0], "to": [19, 0], "colors": ["#808080", "#808080"], "dither": false, "opacity": opacity}),
+        }
+    }
+
+    fn white(depth: u32) -> Session {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 20, "height": 10, "depth": depth, "background": "white"})).unwrap();
+        s
+    }
+
+    /// Issue #4167: an opacity above 100 overshot the blend (200 painted near-black on white).
+    #[test]
+    fn bucket_and_gradient_clamp_opacity_like_the_magic_eraser() {
+        for cmd in ["paint.bucket", "paint.gradient"] {
+            for depth in [8, 16, 32] {
+                let mut full = white(depth);
+                full.execute(cmd, grey_fill(cmd, json!(100))).unwrap();
+                let expected = px(&full, 5, 5);
+                assert!((expected[0] - 128.0 / 255.0).abs() < 0.01, "{cmd} depth {depth}: 100% paints #808080, got {expected:?}");
+                for over in [200.0, 1e9] {
+                    let mut s = white(depth);
+                    s.execute(cmd, grey_fill(cmd, json!(over))).unwrap();
+                    assert_eq!(px(&s, 5, 5), expected, "{cmd} depth {depth}: opacity {over} clamps to 100");
+                }
+                let (mut low, mut one) = (white(depth), white(depth));
+                low.execute(cmd, grey_fill(cmd, json!(-50))).unwrap();
+                one.execute(cmd, grey_fill(cmd, json!(1))).unwrap();
+                assert_eq!(px(&low, 5, 5), px(&one, 5, 5), "{cmd} depth {depth}: opacity below 1 clamps to 1");
+                assert!(px(&low, 5, 5).iter().all(|v| (0.0..=1.0).contains(v)), "{cmd} depth {depth}: no overshoot");
+            }
+        }
+    }
+
+    #[test]
+    fn bucket_and_gradient_reject_non_numeric_opacity_without_editing() {
+        for cmd in ["paint.bucket", "paint.gradient"] {
+            for bad in [json!("50"), json!(true), json!([50]), json!({"v": 50})] {
+                let mut s = white(8);
+                let (before, steps) = (px(&s, 5, 5), s.active().unwrap().history.past_len());
+                let err = s.execute(cmd, grey_fill(cmd, bad.clone())).unwrap_err();
+                assert!(matches!(err, EngineError::BadParams { .. }), "{cmd} {bad}: {err:?}");
+                assert_eq!(px(&s, 5, 5), before, "{cmd} {bad}: pixels unchanged");
+                assert_eq!(s.active().unwrap().history.past_len(), steps, "{cmd} {bad}: no history step");
+            }
+            // An explicit null keeps the default (100%), like the Magic Eraser.
+            let mut s = white(8);
+            s.execute(cmd, grey_fill(cmd, Value::Null)).unwrap();
+            assert!((px(&s, 5, 5)[0] - 128.0 / 255.0).abs() < 0.01, "{cmd}: null opacity is 100%");
+        }
+    }
 }
diff --git a/crates/engine/src/param_check.rs b/crates/engine/src/param_check.rs
new file mode 100644
index 0000000000..a59236d1d1
--- /dev/null
+++ b/crates/engine/src/param_check.rs
@@ -0,0 +1,138 @@
+//! Reject params a command does not document (#4336).
+//!
+//! Commands read the keys they know from a JSON object and used to ignore the rest, so a
+//! misspelled key (`{"ids":[4]}` for `{"layer":4}`) ran the command on its defaults and reported
+//! success. For the commands in [`STRICT`] the dispatcher now checks the keys against the
+//! command's `params` doc once, for every transport (CLI, MCP, control channel, UI, actions).
+//!
+//! This is opt-in because `params` docs are free-form text and many are not complete yet (the
+//! engine's own tests pass undocumented keys to `paint.pencil`, `timeline.create`,
+//! `layer.new.artboard`, the Selective Color and Color Lookup adjustments and more). To opt a
+//! command in: make sure its `params` doc names every key the command reads as `"key":...`, and
+//! add its id to [`STRICT`]; `strict_commands_have_closed_docs` checks the doc is parseable.
+//! A doc with a top-level `…` is open-ended and is never checked.
+
+use serde_json::Value;
+
+use crate::commands::CommandSpec;
+use crate::{EngineError, Result};
+
+/// Keys any command accepts: the history-coalescing key every command honours (see
+/// `Session::execute`) and the Channels-panel `"target"` that pixel commands follow.
+const UNIVERSAL: &[&str] = &["coalesce", "target"];
+
+/// The commands whose unknown params are rejected: their `params` doc is complete.
+const STRICT: &[&str] = &["layer.hideLayers", "layer.showLayers"];
+
+/// The keys a `params` doc names, or `None` when the doc is open-ended.
+fn documented_keys(doc: &str) -> Option<Vec<&str>> {
+    let bytes = doc.as_bytes();
+    let (mut depth, mut in_str, mut start) = (0usize, false, 0usize);
+    let mut quoted: Vec<(usize, usize)> = Vec::new();
+    for (i, &b) in bytes.iter().enumerate() {
+        if in_str {
+            if b == b'"' {
+                in_str = false;
+                quoted.push((start, i));
+            }
+            continue;
+        }
+        match b {
+            b'"' => {
+                in_str = true;
+                start = i + 1;
+            }
+            b'{' | b'[' => depth += 1,
+            b'}' | b']' => depth = depth.saturating_sub(1),
+            _ => {}
+        }
+        // `…` / `...` straight inside the top-level braces: the list is not complete.
+        if depth == 1
+            && (doc.get(i..).is_some_and(|r| r.starts_with('…') || r.starts_with("...")))
+            && doc.get(..i).is_some_and(|l| l.trim_start().starts_with('{'))
+        {
+            return None;
+        }
+    }
+    let mut keys = Vec::new();
+    for (n, &(a, b)) in quoted.iter().enumerate() {
+        let Some(word) = doc.get(a..b) else { continue };
+        if word.is_empty() || !word.bytes().all(|c| c.is_ascii_alphanumeric() || c == b'_') {
+            continue;
+        }
+        // A key is followed by `:`, or by `,"other"` pairs that end in one (`"all","pixels":bool`).
+        let mut end = b + 1;
+        let mut k = n;
+        loop {
+            let rest = doc.get(end..).unwrap_or("");
+            if rest.starts_with(':') {
+                keys.push(word);
+                break;
+            }
+            let Some(after) = rest.strip_prefix(',') else { break };
+            let Some(&(na, nb)) = quoted.get(k + 1) else { break };
+            if na != end + 2 || after.as_bytes().first() != Some(&b'"') {
+                break;
+            }
+            end = nb + 1;
+            k += 1;
+        }
+    }
+    Some(keys)
+}
+
+/// Err when `params` has a key the command does not document (only for commands in [`STRICT`]).
+pub(crate) fn check(spec: &CommandSpec, params: &Value) -> Result<()> {
+    if !STRICT.contains(&spec.id) {
+        return Ok(());
+    }
+    let Some(map) = params.as_object() else { return Ok(()) };
+    let Some(keys) = documented_keys(spec.params) else { return Ok(()) };
+    for key in map.keys() {
+        if UNIVERSAL.contains(&key.as_str()) || keys.contains(&key.as_str()) {
+            continue;
+        }
+        let expected = if keys.is_empty() { "no parameters".to_string() } else { format!("expected: {}", keys.join(", ")) };
+        return Err(EngineError::BadParams { cmd: spec.id.to_string(), msg: format!("unknown parameter `{key}` ({expected})") });
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+    use crate::Session;
+
+    #[test]
+    fn documented_keys_reads_keys_and_stops_at_open_docs() {
+        assert_eq!(documented_keys(r##"{"layer":id?} (shows them instead)"##), Some(vec!["layer"]));
+        assert_eq!(documented_keys(r##"{"locks":{"all","pixels":bool}?,"name":str?}"##), Some(vec!["locks", "all", "pixels", "name"]));
+        assert_eq!(documented_keys("{}"), Some(vec![]));
+        assert_eq!(documented_keys(r##"{"layer":id?, …params of that kind}"##), None);
+    }
+
+    #[test]
+    fn strict_commands_have_closed_docs() {
+        for id in STRICT {
+            let spec = crate::commands::find(id).expect("strict command exists");
+            assert!(documented_keys(spec.params).is_some_and(|k| !k.is_empty()), "{id}: params doc must list its keys");
+        }
+    }
+
+    #[test]
+    fn unknown_param_is_an_error_naming_the_key_and_the_accepted_ones() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
+        let a = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+        let visible = |s: &Session| s.active().unwrap().doc.layer(photocraft_doc::LayerId(a)).unwrap().visible;
+        for cmd in ["layer.hideLayers", "layer.showLayers"] {
+            let err = s.execute(cmd, json!({"ids": [a]})).unwrap_err().to_string();
+            assert!(err.contains("unknown parameter `ids`") && err.contains("expected: layer"), "{err}");
+            assert!(visible(&s), "{cmd}: nothing ran");
+        }
+        s.execute("layer.hideLayers", json!({"layer": a, "coalesce": "k"})).unwrap();
+        assert!(!visible(&s));
+    }
+}
diff --git a/crates/engine/src/pattern_cmds.rs b/crates/engine/src/pattern_cmds.rs
index 21bee1283c..0cb9052ceb 100644
--- a/crates/engine/src/pattern_cmds.rs
+++ b/crates/engine/src/pattern_cmds.rs
@@ -268,8 +268,12 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn import(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "pattern.import";
-    let path = p.get("path").and_then(Value::as_str).ok_or_else(|| bad(cmd, "missing `path` (.pat file)"))?;
-    let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+    // A file on disk, or its bytes (a dropped file, the web build).
+    let bytes = match (p.get("path").and_then(Value::as_str), p.get("data").and_then(Value::as_str)) {
+        (Some(path), _) => std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?,
+        (None, Some(b64)) => photocraft_paint::tile::b64_decode(b64).ok_or_else(|| bad(cmd, "`data` is not base64"))?,
+        (None, None) => return Err(bad(cmd, "missing `path` (.pat file) or `data`")),
+    };
     let pats = photocraft_io::pattern_map::read_pat(&bytes).map_err(EngineError::Other)?;
     let mut ids = Vec::new();
     for pat in pats {
@@ -279,7 +283,7 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
             None => s.patterns.items.push(pat),
         }
     }
-    Ok(json!({"imported": ids}))
+    Ok(json!({"imported": ids, "count": ids.len()}))
 }
 
 fn export(s: &mut Session, p: &Value) -> Result<Value> {
@@ -326,8 +330,12 @@ fn new_fill_layer(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn brush_texture(s: &mut Session, p: &Value) -> Result<Value> {
     let pat = resolve_param(s, "brush.texturePattern", p)?;
+    let n = pat.is_paintable().then(|| usize::try_from(pat.pixel_count()).ok()).flatten();
+    let Some(n) = n else {
+        return Err(bad("brush.texturePattern", "the pattern is empty or too large to paint"));
+    };
     // Brush textures are grey: luminance of the composite over white.
-    let mut px = vec![[0.0f32; 4]; (pat.width * pat.height) as usize];
+    let mut px = vec![[0.0f32; 4]; n];
     pat.surface.read_rgba_into(pat.rect(), &mut px);
     let lum: Vec<f32> = px
         .iter()
@@ -348,8 +356,11 @@ fn brush_texture(s: &mut Session, p: &Value) -> Result<Value> {
 
 /// A swatch colour for UIs (average of the tile), straight RGB.
 pub fn average_color(p: &Pattern) -> Color {
-    let mut px = vec![[0.0f32; 4]; (p.width * p.height) as usize];
-    p.surface.read_rgba_into(p.rect(), &mut px);
+    // A pattern too large to paint is averaged over its paintable top-left corner.
+    let side = photocraft_doc::pattern::MAX_PAINT_PIXELS.isqrt() as u32;
+    let (w, h) = (p.width.min(side), p.height.min(side));
+    let mut px = vec![[0.0f32; 4]; w as usize * h as usize];
+    p.surface.read_rgba_into(Rect::new(0, 0, w as i32, h as i32), &mut px);
     let n = px.len().max(1) as f32;
     let s = px.iter().fold([0.0f32; 3], |a, q| [a[0] + q[0], a[1] + q[1], a[2] + q[2]]);
     Color::rgb(s[0] / n, s[1] / n, s[2] / n)
@@ -402,7 +413,7 @@ pub fn specs() -> Vec<CommandSpec> {
             label: "Import Patterns…",
             menu: &[],
             shortcut: None,
-            params: r##"{"path":".pat file"}"##,
+            params: r##"{"path":".pat file"?,"data":base64 bytes? (instead of a path)} → {imported:[ids],count}"##,
             enabled: always,
             journal: true,
             run: import,
@@ -493,8 +504,17 @@ mod tests {
         let v = s.execute("pattern.import", json!({"path": path})).unwrap();
         assert!(v["imported"].as_array().unwrap().iter().any(|x| x == id.as_str()));
         assert_eq!(resolve(&s, &id).unwrap().surface.read_region(Rect::new(0, 0, 5, 4)), pat.surface.read_region(Rect::new(0, 0, 5, 4)));
+        // The same file as bytes (a dropped file, the web build).
+        let bytes = std::fs::read(path).unwrap();
+        s.execute("pattern.delete", json!({"pattern": "Crimson"})).unwrap();
+        let v = s.execute("pattern.import", json!({"data": photocraft_paint::tile::b64_encode(&bytes)})).unwrap();
+        assert_eq!(v["count"], v["imported"].as_array().unwrap().len());
+        assert_eq!(resolve(&s, "Crimson").unwrap().id, id);
         std::fs::remove_dir_all(dir).ok();
         assert!(s.execute("pattern.import", json!({"path": "/nonexistent.pat"})).is_err());
+        for bad in [json!({}), json!({"data": "not base64!"}), json!({"data": "aGVsbG8="})] {
+            assert!(s.execute("pattern.import", bad.clone()).is_err(), "{bad}");
+        }
     }
 
     #[test]
@@ -560,4 +580,14 @@ mod tests {
         assert!(s.tools.brush.texture.enabled);
         assert!(matches!(s.tools.brush.texture.pattern, photocraft_paint::Pattern::Tile(_)));
     }
+
+    #[test]
+    fn a_pattern_too_large_to_paint_is_refused_not_allocated() {
+        // width × height overflows u32: this panicked (debug) or wrapped (release).
+        let mut s = session(8);
+        let huge = Pattern { id: "huge".into(), name: "Huge".into(), width: 65_536, height: 65_536, surface: Surface::new(PixelFormat::RGBA8) };
+        s.patterns.items.push(huge);
+        let e = s.execute("brush.texturePattern", json!({"pattern": "huge"})).unwrap_err();
+        assert!(e.to_string().contains("too large"), "{e}");
+    }
 }
diff --git a/crates/engine/src/perspective_crop_cmds.rs b/crates/engine/src/perspective_crop_cmds.rs
index c8881e6f70..8acaf42ce2 100644
--- a/crates/engine/src/perspective_crop_cmds.rs
+++ b/crates/engine/src/perspective_crop_cmds.rs
@@ -14,7 +14,7 @@
 
 use photocraft_algo::transform::{Homography, Interp, convex_quad, quad_size, quad_to_rect, warp_surface_clipped};
 use photocraft_color::PixelFormat;
-use photocraft_doc::{Document, Layer, LayerContent, Size};
+use photocraft_doc::{Document, Layer, LayerContent, LayerId, Size};
 use photocraft_geom::{Affine, Rect};
 use photocraft_raster::Surface;
 use serde_json::{Value, json};
@@ -154,12 +154,13 @@ fn warp_gray(s: &Surface, h: &Homography, interp: Interp, clip: Rect) -> Result<
 }
 
 /// Maps every layer's pixels and masks through `h` into `clip`.
-fn warp_layers(layers: &mut [Layer], h: &Homography, interp: Interp, clip: Rect, bg: &[f32]) -> Result<()> {
+/// `background_id` is the id of the document's Background, if it has one.
+fn warp_layers(layers: &mut [Layer], h: &Homography, interp: Interp, clip: Rect, bg: &[f32], background_id: Option<LayerId>) -> Result<()> {
     for l in layers {
         crate::allocation::checkpoint("a perspective crop")?;
-        let background = crate::extra_cmds::is_background(l);
+        let background = background_id == Some(l.id);
         match &mut l.content {
-            LayerContent::Group(g) => warp_layers(&mut g.children, h, interp, clip, bg)?,
+            LayerContent::Group(g) => warp_layers(&mut g.children, h, interp, clip, bg, None)?,
             LayerContent::Raster(surf) => {
                 let warped = warp_surface_clipped(surf, surf.content_bounds(), h, interp, clip)?;
                 *surf = if background {
@@ -188,7 +189,8 @@ fn apply(doc: &mut Document, q: &[[f64; 2]; 4], h: &Homography, size: (u32, u32)
     let (w, ht) = size;
     let clip = Rect::from_xywh(0, 0, w, ht);
     let bg = photocraft_raster::from_rgba(&doc.pixel_format(), bg);
-    warp_layers(&mut doc.layers, h, interp, clip, &bg)?;
+    let background_id = doc.background().map(|l| l.id);
+    warp_layers(&mut doc.layers, h, interp, clip, &bg, background_id)?;
     for ch in doc.channels.iter_mut().chain(doc.quick_mask.as_mut()) {
         ch.surface = warp_gray(&ch.surface, h, interp, clip)?;
     }
diff --git a/crates/engine/src/pick_cmds.rs b/crates/engine/src/pick_cmds.rs
index ccb3b4ca11..c40e15e9b8 100644
--- a/crates/engine/src/pick_cmds.rs
+++ b/crates/engine/src/pick_cmds.rs
@@ -61,11 +61,8 @@ fn layers_hit(doc: &Document, x: i32, y: i32, type_bounds: bool) -> Vec<LayerId>
                 None => 0.0,
             },
         };
-        let mask = l.mask.as_ref().filter(|m| m.enabled).map_or(1.0, |m| {
-            let mut v = [0.0f32];
-            m.surface.read_pixel(x, y, &mut v);
-            v[0]
-        });
+        // As the compositor sees it: density applied, all ones when the mask is disabled.
+        let mask = l.mask.as_ref().map_or(1.0, |m| m.value(x, y));
         if alpha * mask > 0.0 {
             out.push(l.id);
         }
@@ -95,9 +92,9 @@ fn pick(s: &mut Session, p: &Value) -> Result<Value> {
     let x = p.get("x").and_then(Value::as_f64).ok_or_else(|| EngineError::BadParams { cmd: "layer.pickAt".into(), msg: "missing `x`".into() })?.floor() as i32;
     let y = p.get("y").and_then(Value::as_f64).ok_or_else(|| EngineError::BadParams { cmd: "layer.pickAt".into(), msg: "missing `y`".into() })?.floor() as i32;
     let doc = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
-    // The right-click list names the layers with pixels under the pointer.
+    // The right-click list includes type layers between glyphs, like Auto-Select.
     if p.get("list").and_then(Value::as_bool).unwrap_or(false) {
-        let hits = layers_hit(&doc, x, y, false);
+        let hits = layers_hit(&doc, x, y, true);
         let names: Vec<Value> = hits.iter().filter_map(|id| doc.layer(*id)).map(|l| json!({"layer": l.id.0, "name": l.name})).collect();
         return Ok(json!({ "layers": names }));
     }
@@ -126,7 +123,7 @@ pub fn layers_in_rect(doc: &Document, r: Rect, group: bool) -> Vec<LayerId> {
     let canvas = doc.bounds();
     for (path, _, l) in doc.walk().iter().rev() {
         if matches!(l.content, LayerContent::Group(_) | LayerContent::Adjustment(_))
-            || crate::layer_multi_cmds::is_locked_background(l)
+            || doc.is_background(l.id)
             || doc.effective_locks(l.id).all
             || !(1..=path.len()).all(|n| doc.layer_at(&path[..n]).is_some_and(|a| a.visible))
         {
@@ -193,7 +190,7 @@ pub fn specs() -> Vec<CommandSpec> {
             label: "Auto-Select Layer",
             menu: &[],
             shortcut: None,
-            params: r##"{"x":px,"y":px,"target":"layer|group"="layer","select":bool=true,"mode":"replace|toggle|add"="replace","list":bool=false (return every layer with pixels there, topmost first)} → {layer} | {layers}"##,
+            params: r##"{"x":px,"y":px,"target":"layer|group"="layer","select":bool=true,"mode":"replace|toggle|add"="replace","list":bool=false (return visible layers at the point, including text bounds, topmost first)} → {layer} | {layers}"##,
             enabled: has_doc,
             journal: false,
             run: pick,
@@ -375,9 +372,10 @@ mod tests {
         assert_eq!(pick(&mut s, 12, 15), t.0, "on a glyph");
         assert_eq!(pick(&mut s, 17, 15), t.0, "between the glyphs: the type layer, not the one under it");
         assert_eq!(pick(&mut s, 17, 20), bg.0, "below the text bounds");
-        // The right-click list still names only the layers with pixels under the pointer.
+        // The context menu also reaches this type layer between the glyphs (#4259).
         let list = s.execute("layer.pickAt", json!({"x": 17, "y": 15, "list": true})).unwrap();
-        assert_eq!(list["layers"].as_array().unwrap().len(), 1);
+        assert_eq!(list["layers"][0]["layer"], t.0);
+        assert_eq!(list["layers"][1]["layer"], bg.0);
     }
 
     #[test]
@@ -401,6 +399,9 @@ mod tests {
         let Some(x) = gap else { return };
         assert_eq!(layers_at(&doc, x, y), vec![bg], "no type pixels at the gap");
         assert_eq!(s.execute("layer.pickAt", json!({"x": x, "y": y, "select": false})).unwrap()["layer"], t);
+        let menu = s.execute("layer.pickAt", json!({"x": x, "y": y, "list": true})).unwrap();
+        assert_eq!(menu["layers"][0]["layer"], t, "type layer stays above its background in the menu");
+        assert_eq!(menu["layers"][1]["layer"], bg.0);
     }
 
     #[test]
@@ -445,4 +446,24 @@ mod tests {
         let mut empty = Session::new();
         assert!(empty.execute("layer.pickAt", json!({"x": 1, "y": 1})).is_err());
     }
+
+    /// A hide-all mask at density 0 hides nothing (the compositor applies density through
+    /// `LayerMask::value`), so the layer stays pickable; at full density it is clicked through.
+    #[test]
+    fn mask_density_is_honoured_when_picking() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 20, "height": 20})).unwrap();
+        let bg = s.active().unwrap().doc.layers[0].id;
+        s.execute("layer.new.layer", json!({"name": "Red"})).unwrap();
+        s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+        let red = s.active().unwrap().active_layer.unwrap();
+        s.execute("layer.layerMask.hideAll", json!({})).unwrap();
+        // Full density: the mask hides the layer, so the click reaches the Background.
+        assert_eq!(s.execute("layer.pickAt", json!({"x": 5, "y": 5, "select": false})).unwrap()["layer"], bg.0);
+        s.execute("layer.layerMask.edit", json!({"density": 0})).unwrap();
+        assert_eq!(s.execute("layer.pickAt", json!({"x": 5, "y": 5, "select": false})).unwrap()["layer"], red.0);
+        let list = s.execute("layer.pickAt", json!({"x": 5, "y": 5, "list": true})).unwrap();
+        let ids: Vec<_> = list["layers"].as_array().unwrap().iter().map(|l| l["layer"].clone()).collect();
+        assert_eq!(ids, vec![json!(red.0), json!(bg.0)]);
+    }
 }
diff --git a/crates/engine/src/pixels.rs b/crates/engine/src/pixels.rs
index 323d6ccdad..cde7fa41db 100644
--- a/crates/engine/src/pixels.rs
+++ b/crates/engine/src/pixels.rs
@@ -21,32 +21,11 @@ pub fn composite_layers(solo: &Document, format: photocraft_color::PixelFormat,
         .reduce(|a, b| a.union(&b))
         .unwrap_or(Rect::EMPTY)
         .intersect(&canvas);
-    let mut surface = Surface::new(format);
     if area.is_empty() {
-        return surface;
+        return Surface::new(format);
     }
-
-    let channels = format.channels();
-    let mut data = Vec::new();
-    let _ = photocraft_compose::render_bands(solo, area, 0, |mut band| -> Result<(), ()> {
-        if let Some(color) = background {
-            for pixel in &mut band.px {
-                let alpha = pixel[3];
-                for channel in 0..3 {
-                    pixel[channel] = pixel[channel] * alpha + color[channel] * (1.0 - alpha);
-                }
-                pixel[3] = 1.0;
-            }
-        }
-        data.resize(band.px.len() * channels, 0.0);
-        for (pixel, encoded) in band.px.iter().zip(data.chunks_exact_mut(channels)) {
-            photocraft_raster::from_rgba_into(&format, *pixel, encoded);
-        }
-        surface.write_region(band.rect, &data);
-        Ok(())
-    });
-    surface.prune();
-    surface
+    // Also keeps a plain CMYK stack in its ink values (#3778).
+    photocraft_compose::composite_to_surface(solo, area, format, background)
 }
 
 /// Apply an adjustment destructively to a surface, weighted by an optional selection.
@@ -77,6 +56,9 @@ pub fn adjust_surface(s: &mut Surface, adj: &Adjustment, selection: Option<&Surf
     s.put_tiles(done);
 }
 
+#[cfg(test)]
+#[path = "flatten_cmyk_tests.rs"]
+mod flatten_cmyk_tests;
 #[cfg(test)]
 #[path = "pixels_tests.rs"]
 mod tests;
@@ -109,6 +91,9 @@ pub fn adjust_mask(s: &mut Surface, adj: &Adjustment, selection: Option<&Surface
 /// `s`'s pixels over `r` (untouched ones included) with `adj` applied through the selection, encoded.
 fn adjusted(s: &Surface, r: Rect, adj: &Adjustment, selection: Option<&Surface>, mode: photocraft_color::ColorMode) -> Vec<f32> {
     let fmt = s.format();
+    if fmt.mode == mode && matches!(mode, photocraft_color::ColorMode::Lab | photocraft_color::ColorMode::Cmyk) && adjust::stored_channel_adjustment(adj) {
+        return adjusted_channels(s, r, adj, selection);
+    }
     let n = fmt.channels();
     let raw = s.read_region(r);
     let mut buf = Buffer { rect: r, px: raw.chunks_exact(n).map(|p| to_rgba(&fmt, p)).collect() };
@@ -116,15 +101,66 @@ fn adjusted(s: &Surface, r: Rect, adj: &Adjustment, selection: Option<&Surface>,
     // 32-bit documents get the float behaviour of an adjustment layer there (Levels doesn't clip);
     // integer depths keep the unrounded, clipped curves.
     let depth = (fmt.sample == photocraft_color::SampleType::F32).then_some(fmt.sample);
-    adjust::apply_depth(adj, &mut buf, adjust::Transfer::for_document(mode, fmt.sample), depth);
-    let w = r.width() as usize;
-    let mut out = Vec::with_capacity(raw.len());
-    for (i, (a, o)) in buf.px.iter().zip(&orig.px).enumerate() {
-        let k = selection.map_or(1.0, |sel| sel.sample_channel(r.x0 + (i % w) as i32, r.y0 + (i / w) as i32, 0));
-        let mixed: [f32; 4] = std::array::from_fn(|c| o[c] + (a[c] - o[c]) * k);
-        let mut enc = [0.0f32; 8];
-        let m = photocraft_raster::from_rgba_into(&fmt, mixed, &mut enc);
-        out.extend_from_slice(&enc[..m]);
+    adjust::apply_in(adj, &mut buf, adjust::Transfer::for_document(mode, fmt.sample), depth, mode);
+    mix_through_selection(&fmt, r, &orig.px, &buf.px, selection)
+}
+
+/// [`adjusted`] for an adjustment Photoshop applies to a Lab or CMYK layer's own channels
+/// (`adjust::stored_channels`): exact on the stored values, with no trip through RGB, and mixed
+/// through the selection on those values (alpha untouched).
+fn adjusted_channels(s: &Surface, r: Rect, adj: &Adjustment, selection: Option<&Surface>) -> Vec<f32> {
+    let fmt = s.format();
+    let (n, colors) = (fmt.channels(), fmt.mode.color_channels());
+    let mut raw = s.read_region(r);
+    let w = (r.width() as usize).max(1);
+    let mut coverage = vec![1.0f32; w];
+    for (j, row) in raw.chunks_mut(w * n).enumerate() {
+        if let Some(sel) = selection {
+            sel.sample_row_strided(r.y0.saturating_add(j as i32), r.x0, 1, 0, &mut coverage);
+        }
+        for (px, &k) in row.chunks_exact_mut(n).zip(&coverage) {
+            if k <= 0.0 {
+                continue;
+            }
+            let p = to_rgba(&fmt, px);
+            let gray = photocraft_color::convert::rgb_to_gray([p[0], p[1], p[2]]);
+            let Some(ch) = px.get_mut(..colors) else { continue };
+            let mut out = [0.0f32; 4];
+            let Some(out) = out.get_mut(..colors) else { continue };
+            out.copy_from_slice(ch);
+            adjust::stored_channels(adj, fmt.mode, Some(fmt.sample), out, gray);
+            for (v, o) in ch.iter_mut().zip(out.iter()) {
+                *v += (o - *v) * k;
+            }
+        }
+    }
+    raw
+}
+
+/// `edited` mixed back over `orig` (straight RGBA over `r`, row-major) by the selection's
+/// coverage, encoded in `fmt`: what a destructive edit writes back through a selection.
+pub(crate) fn mix_through_selection(
+    fmt: &photocraft_color::PixelFormat,
+    r: Rect,
+    orig: &[[f32; 4]],
+    edited: &[[f32; 4]],
+    selection: Option<&Surface>,
+) -> Vec<f32> {
+    let w = (r.width() as usize).max(1);
+    let mut out = Vec::with_capacity(orig.len() * fmt.channels());
+    // The selection's coverage (channel 0) one row at a time, each of its tiles looked up once
+    // per row rather than once per pixel.
+    let mut coverage = vec![1.0f32; w];
+    for (j, (edited_row, orig_row)) in edited.chunks(w).zip(orig.chunks(w)).enumerate() {
+        if let Some(sel) = selection {
+            sel.sample_row_strided(r.y0.saturating_add(j as i32), r.x0, 1, 0, &mut coverage);
+        }
+        for ((a, o), k) in edited_row.iter().zip(orig_row).zip(&coverage) {
+            let mixed: [f32; 4] = std::array::from_fn(|c| o[c] + (a[c] - o[c]) * k);
+            let mut enc = [0.0f32; 8];
+            let m = photocraft_raster::from_rgba_into(fmt, mixed, &mut enc);
+            out.extend_from_slice(&enc[..m]);
+        }
     }
     out
 }
@@ -296,9 +332,12 @@ pub fn remap_surface(s: &Surface, map: impl Fn(i32, i32) -> (i32, i32)) -> Surfa
 }
 
 /// Merge `upper` onto `lower` producing a raster layer (Layer → Merge Down).
-pub fn merge_down(doc_bounds: Rect, lower: &Layer, upper: &Layer, format: photocraft_color::PixelFormat) -> Layer {
+pub fn merge_down(doc: &Document, lower: &Layer, upper: &Layer) -> Layer {
+    let format = doc.pixel_format();
     let stack = vec![lower.clone(), upper.clone()];
-    let mut tmp = Document::new("merge", doc_bounds.size(), format.mode, format.sample);
+    let mut tmp = Document::new("merge", doc.size, format.mode, format.sample);
+    // The pair is read (and a CMYK one separated again) through the document's own profile.
+    tmp.icc_profile = doc.icc_profile.clone();
     tmp.layers = stack;
     let s = composite_layers(&tmp, format, None);
     let mut merged = Layer::new(lower.name.clone(), LayerContent::Raster(s));
diff --git a/crates/engine/src/pixels_tests.rs b/crates/engine/src/pixels_tests.rs
index 0da4880106..965544307a 100644
--- a/crates/engine/src/pixels_tests.rs
+++ b/crates/engine/src/pixels_tests.rs
@@ -241,3 +241,111 @@ fn benchmark_clear_large_selection() {
         println!("#3463 clear 8000x6000, background {background}, feather {feather}: {:?}", t.elapsed());
     }
 }
+
+/// Image › Adjustments › Invert in a Lab document mirrors L, a and b, at every depth: 8-bit bytes
+/// become 255 - v (a lands one step past the mirror), 16 bits mirror a and b around neutral.
+#[test]
+fn invert_in_a_lab_document_mirrors_l_a_and_b() {
+    use photocraft_color::convert::{lab_to_srgb, srgb_to_lab};
+    let c = lab_to_srgb([30.0, 12.0, -18.0]);
+    for depth in SampleType::ALL {
+        let fmt = PixelFormat { mode: ColorMode::Lab, sample: depth, alpha: true };
+        let mut s = Surface::new(fmt);
+        let r = Rect::new(0, 0, 2, 2);
+        s.write_region(r, &(0..4).flat_map(|_| from_rgba(&fmt, [c[0], c[1], c[2], 1.0])).collect::<Vec<_>>());
+        adjust_surface(&mut s, &Adjustment::Invert, None, ColorMode::Lab);
+        let px = s.read_region(Rect::new(1, 1, 2, 2));
+        let rgba = photocraft_raster::to_rgba(&fmt, &px);
+        let got = srgb_to_lab([rgba[0], rgba[1], rgba[2]]);
+        let want = if depth == SampleType::U8 { [70.0, -13.0, 17.0] } else { [70.0, -12.0, 18.0] };
+        assert!(got.iter().zip(want).all(|(g, w)| (g - w).abs() < 0.5), "{depth:?}: {got:?}");
+    }
+}
+
+#[test]
+fn mixing_through_a_selection_matches_sampling_it_per_pixel() {
+    // A rectangle across tile edges (negative x included), a selection with fractional
+    // coverage, untouched tiles (default coverage) and a 16-bit as well as an 8-bit layer.
+    let r = Rect::new(-300, 200, 330, 290);
+    let gray32 = PixelFormat { mode: ColorMode::Grayscale, sample: SampleType::F32, alpha: false };
+    for sel_fmt in [PixelFormat::GRAY8, PixelFormat::GRAYA8, gray32] {
+        let mut sel = Surface::new(sel_fmt);
+        sel.fill_rect(Rect::new(-260, 210, 40, 280), &vec![0.6; sel_fmt.channels()]);
+        for x in 0..120 {
+            sel.write_pixel(x * 2, 230 + x % 40, &vec![x as f32 / 119.0; sel_fmt.channels()]);
+        }
+        for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA16] {
+            let n = (r.width() * r.height()) as usize;
+            let orig: Vec<[f32; 4]> = (0..n).map(|i| [(i % 7) as f32 / 7.0, 0.5, (i % 13) as f32 / 13.0, 0.25 + (i % 3) as f32 / 4.0]).collect();
+            let edited: Vec<[f32; 4]> = orig.iter().map(|p| [1.0 - p[0], p[1] * 0.5, p[2], 1.0]).collect();
+            let w = r.width() as usize;
+            let mut expected = Vec::new();
+            for (i, (a, o)) in edited.iter().zip(&orig).enumerate() {
+                let k = sel.sample_channel(r.x0 + (i % w) as i32, r.y0 + (i / w) as i32, 0);
+                let mixed: [f32; 4] = std::array::from_fn(|c| o[c] + (a[c] - o[c]) * k);
+                let mut enc = [0.0f32; 8];
+                let m = photocraft_raster::from_rgba_into(&fmt, mixed, &mut enc);
+                expected.extend_from_slice(&enc[..m]);
+            }
+            assert_eq!(mix_through_selection(&fmt, r, &orig, &edited, Some(&sel)), expected, "{sel_fmt:?} over {fmt:?}");
+        }
+    }
+    // Without a selection the edit is taken whole; an empty rectangle mixes nothing.
+    let px = [[0.1, 0.2, 0.3, 1.0]];
+    let fmt = PixelFormat::RGBA8;
+    let mut enc = [0.0f32; 8];
+    let m = photocraft_raster::from_rgba_into(&fmt, px[0], &mut enc);
+    assert_eq!(mix_through_selection(&fmt, Rect::new(0, 0, 1, 1), &[[0.0; 4]], &px, None), enc[..m].to_vec());
+    assert!(mix_through_selection(&fmt, Rect::EMPTY, &[], &[], None).is_empty());
+}
+
+/// One `fmt` pixel holding `ch`, after `adj` through an optional `k`-strength selection.
+fn adjusted_pixel(fmt: PixelFormat, ch: &[f32], adj: &Adjustment, k: Option<f32>) -> Vec<f32> {
+    let unit = Rect::new(0, 0, 1, 1);
+    let mut s = Surface::new(fmt);
+    s.write_region(unit, ch);
+    let mut sel = Surface::new(PixelFormat::GRAY8);
+    if let Some(k) = k {
+        sel.write_region(unit, &[k]);
+    }
+    adjust_surface(&mut s, adj, k.map(|_| &sel), fmt.mode);
+    s.read_region(unit)
+}
+
+fn assert_levels(got: &[f32], want_255: &[f32], what: &str) {
+    let want: Vec<f32> = want_255.iter().map(|v| v / 255.0).collect();
+    assert!(got.iter().zip(&want).all(|(g, w)| (g - w).abs() < 1e-4), "{what}: got {:?}, want {want_255:?}", got.iter().map(|v| v * 255.0).collect::<Vec<_>>());
+}
+
+/// Image › Adjustments › Invert, Posterize and Threshold change a Lab or CMYK layer's stored
+/// channels exactly as Photoshop's do (photoshop corpus lab8, lab16, cmyk8 and cmyk16 invert,
+/// posterize-4 and threshold-128 follow these rules on every pixel), with no trip through RGB.
+#[test]
+fn invert_posterize_and_threshold_change_lab_and_cmyk_channels_as_stored() {
+    let f = |v: [f32; 4]| v.map(|x| x / 255.0);
+    let cmyk = PixelFormat::new(ColorMode::Cmyk, SampleType::U8, true);
+    let ink = [51.0, 102.0, 153.0, 26.0, 255.0].map(|x| x / 255.0);
+    assert_levels(&adjusted_pixel(cmyk, &ink, &Adjustment::Invert, None), &[204.0, 153.0, 102.0, 229.0, 255.0], "CMYK invert");
+    assert_levels(&adjusted_pixel(cmyk, &ink, &Adjustment::Posterize { levels: 4 }, None), &[0.0, 85.0, 170.0, 0.0, 255.0], "CMYK posterize");
+    // Threshold: the black ink alone, or paper.
+    let dark = [200.0, 180.0, 180.0, 200.0, 255.0].map(|x| x / 255.0);
+    assert_levels(&adjusted_pixel(cmyk, &dark, &Adjustment::Threshold { level: 0.5 }, None), &[0.0, 0.0, 0.0, 255.0, 255.0], "CMYK threshold dark");
+    let paper = [0.0, 0.0, 0.0, 0.0, 1.0];
+    assert_levels(&adjusted_pixel(cmyk, &paper, &Adjustment::Threshold { level: 0.5 }, None), &[0.0, 0.0, 0.0, 0.0, 255.0], "CMYK threshold paper");
+    // A half-strength selection mixes the stored inks.
+    let half = adjusted_pixel(cmyk, &paper, &Adjustment::Invert, Some(0.5));
+    assert!(half.iter().take(4).all(|v| (v - 0.5).abs() < 0.01) && half[4] == 1.0, "{half:?}");
+
+    let lab8 = PixelFormat::new(ColorMode::Lab, SampleType::U8, true);
+    let lab16 = PixelFormat::new(ColorMode::Lab, SampleType::U16, true);
+    let px = f([77.0, 128.0, 200.0, 255.0]);
+    assert_levels(&adjusted_pixel(lab8, &px, &Adjustment::Invert, None), &[178.0, 127.0, 55.0, 255.0], "Lab 8-bit invert");
+    assert_levels(&adjusted_pixel(lab16, &px, &Adjustment::Invert, None), &[178.0, 128.0, 56.0, 255.0], "Lab 16-bit invert");
+    // A neutral grey posterizes warm: a and b step to +42.
+    let grey = f([128.0, 128.0, 128.0, 255.0]);
+    assert_levels(&adjusted_pixel(lab8, &grey, &Adjustment::Posterize { levels: 4 }, None), &[170.0, 170.0, 170.0, 255.0], "Lab posterize");
+    // Threshold compares L alone and keeps black and white neutral.
+    let level = Adjustment::Threshold { level: 128.0 / 255.0 };
+    assert_levels(&adjusted_pixel(lab8, &f([128.0, 30.0, 220.0, 255.0]), &level, None), &[255.0, 128.0, 128.0, 255.0], "Lab threshold light");
+    assert_levels(&adjusted_pixel(lab16, &f([127.0, 30.0, 220.0, 255.0]), &level, None), &[0.0, 128.0, 128.0, 255.0], "Lab threshold dark");
+}
diff --git a/crates/engine/src/prefs.rs b/crates/engine/src/prefs.rs
index 93a52d2d10..5e728cb546 100644
--- a/crates/engine/src/prefs.rs
+++ b/crates/engine/src/prefs.rs
@@ -55,10 +55,10 @@ choice!(TypeUnit { Points = "points", Pixels = "pixels", Millimeters = "mm" } de
 choice!(PointSize { PostScript = "postScript", Traditional = "traditional" } default PostScript);
 choice!(Interpolation { BicubicAutomatic = "bicubicAutomatic", Nearest = "nearestNeighbor", Bilinear = "bilinear", Bicubic = "bicubic", BicubicSmoother = "bicubicSmoother", BicubicSharper = "bicubicSharper", PreserveDetails = "preserveDetails" } default BicubicAutomatic);
 choice!(ColorPicker { Adobe = "adobe", System = "system" } default Adobe);
-choice!(Theme { Pro = "pro", ProMedium = "proMedium", ProLightGray = "proLightGray", ProLight = "proLight", Studio = "studio", StudioLight = "studioLight", Classic = "classic", SolarizedDark = "solarizedDark", Adwaita = "adwaita", AdwaitaDark = "adwaitaDark", BreezeLight = "breezeLight", BreezeDark = "breezeDark" } default ProMedium);
+choice!(Theme { Pro = "pro", ProMedium = "proMedium", ProLightGray = "proLightGray", ProLight = "proLight", Studio = "studio", StudioLight = "studioLight", Classic = "classic", SolarizedDark = "solarizedDark", Adwaita = "adwaita", AdwaitaDark = "adwaitaDark", BreezeLight = "breezeLight", BreezeDark = "breezeDark", SoftDark = "softDark", SoftLight = "softLight" } default ProMedium);
 choice!(AppearanceMode { Auto = "auto", Dark = "dark", Light = "light" } default Dark);
-choice!(DarkTheme { Pro = "pro", ProMedium = "proMedium", Studio = "studio", SolarizedDark = "solarizedDark", AdwaitaDark = "adwaitaDark", BreezeDark = "breezeDark" } default ProMedium);
-choice!(LightTheme { StudioLight = "studioLight", ProLightGray = "proLightGray", ProLight = "proLight", Classic = "classic", Adwaita = "adwaita", BreezeLight = "breezeLight" } default StudioLight);
+choice!(DarkTheme { Pro = "pro", ProMedium = "proMedium", Studio = "studio", SolarizedDark = "solarizedDark", AdwaitaDark = "adwaitaDark", BreezeDark = "breezeDark", SoftDark = "softDark" } default ProMedium);
+choice!(LightTheme { ProLight = "proLight", ProLightGray = "proLightGray", StudioLight = "studioLight", Classic = "classic", Adwaita = "adwaita", BreezeLight = "breezeLight", SoftLight = "softLight" } default ProLight);
 choice!(CanvasColor { Default = "default", Black = "black", DarkGray = "darkGray", MediumGray = "mediumGray", LightGray = "lightGray", Custom = "custom" } default Default);
 choice!(CanvasBorder { DropShadow = "dropShadow", Line = "line", None = "none" } default DropShadow);
 choice!(UiScale { Auto = "auto", P75 = "75", P80 = "80", P85 = "85", P90 = "90", P95 = "95", P100 = "100", P125 = "125", P150 = "150", P175 = "175", P200 = "200", P250 = "250", P300 = "300" } default Auto);
@@ -293,7 +293,7 @@ impl Default for Interface {
             theme: Theme::ProMedium,
             appearance_mode: AppearanceMode::Dark,
             dark_theme: DarkTheme::ProMedium,
-            light_theme: LightTheme::StudioLight,
+            light_theme: LightTheme::ProLight,
             favorite_themes: Vec::new(),
             canvas_color: CanvasColor::Default,
             canvas_custom_color: "#282828".into(),
@@ -341,6 +341,14 @@ impl Default for Workspace {
     }
 }
 
+impl Workspace {
+    /// Preferences ▸ Workspace ▸ Enable Narrow Options Bar: the options bar drops to its compact
+    /// height, as in Photoshop, so the document gets more room (see `panels::options_bar`).
+    pub fn narrow_options_bar(&self) -> bool {
+        self.enable_narrow_options_bar
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct Tools {
@@ -869,6 +877,15 @@ impl Default for TypePrefs {
     }
 }
 
+impl TypePrefs {
+    /// Preferences ▸ Type ▸ Missing Glyph Protection: with it on (the default, as in Photoshop),
+    /// glyphs the chosen face lacks fall back through the coverage fonts (#1909). The text engine
+    /// applies this in `Session::apply_prefs`.
+    pub fn missing_glyph_protection(&self) -> bool {
+        self.missing_glyph_protection
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct EnhancedControls {
@@ -990,10 +1007,18 @@ pub struct Preferences {
     /// the footer slider's card scale, saved as the user changes them and restored at launch.
     /// JSON owned by the shell.
     pub brush_picker: Value,
+    /// The brush the tool was last using (settings and tip references, never the full bitmaps;
+    /// shaped by `brush_cmds::remembered_brush`), restored at launch so the tool starts where it
+    /// was left. Written only when `ToolState::brush_rev` moves.
+    pub last_brush: Value,
     /// The tools' options-bar settings (Move › Auto-Select, marquee Feather, tolerance, …) that
     /// differ from their defaults, saved as the user changes them and restored at launch, as
     /// Photoshop remembers each tool's options between sessions. JSON owned by the shell.
     pub tool_options: Value,
+    /// View › Extras, the View › Show items (Pixel Grid, Grid, Guides, …) and the View › Snap To
+    /// targets that differ from their defaults, saved as the user toggles them and restored at
+    /// launch, as Photoshop keeps them between sessions (#3762). JSON owned by the shell.
+    pub view_extras: Value,
     /// File › Scripts › Script Events Manager: event → script bindings.
     pub script_events: crate::automate_cmds::ScriptEvents,
 }
@@ -1030,12 +1055,9 @@ pub const HIDDEN_UNTIL_IMPLEMENTED: &[&str] = &[
     "general.colorPicker",
     "general.animatedZoom",
     "general.zoomResizesWindows",
-    "workspace.autoCollapseIconPanels",
     "workspace.autoShowHiddenPanels",
     "workspace.enableFloatingDocumentWindowDocking",
-    "workspace.enableNarrowOptionsBar",
     "fileHandling.saveInBackground",
-    "fileHandling.maximizePsdCompatibility",
     "performance.cacheLevels",
     "performance.effectCacheMb",
     "performance.legacyCompositing",
@@ -1045,7 +1067,6 @@ pub const HIDDEN_UNTIL_IMPLEMENTED: &[&str] = &[
     "plugIns.showExtensionPanels",
     "plugIns.allowScriptsToConnect",
     "plugIns.generatorEnabled",
-    "type.missingGlyphProtection",
     "type.textEngine",
     "type.recentFonts",
     "enhancedControls.scrubbySliderAcceleration",
@@ -1480,8 +1501,8 @@ impl Session {
         r
     }
 
-    /// Push engine-relevant preferences into live state: every document's history limit and
-    /// the layer-effect cache budget.
+    /// Push engine-relevant preferences into live state: every document's history limit, the
+    /// layer-effect cache budget and the text engine's missing-glyph protection.
     pub fn apply_prefs(&mut self) {
         let n = self.prefs().performance.history_states.max(1) as usize;
         let bytes = self.prefs().performance.history_budget_bytes();
@@ -1492,6 +1513,8 @@ impl Session {
             st.history.trim(&st.doc);
         }
         photocraft_compose::set_effect_cache_budget(budget << 20);
+        // Without waiting for the system font scan: this runs on the UI thread at launch.
+        photocraft_text::set_shared_missing_glyph_protection(self.prefs().type_.missing_glyph_protection());
         crate::plugin_cmds::sync_prefs(self);
     }
 
@@ -1522,8 +1545,12 @@ impl Session {
             && let Some(theme) = interface.get("theme").and_then(Value::as_str).and_then(Theme::parse)
         {
             let (mode, slot) = match theme {
-                Theme::Pro | Theme::ProMedium | Theme::Studio | Theme::SolarizedDark | Theme::AdwaitaDark | Theme::BreezeDark => ("dark", "darkTheme"),
-                Theme::StudioLight | Theme::ProLightGray | Theme::ProLight | Theme::Classic | Theme::Adwaita | Theme::BreezeLight => ("light", "lightTheme"),
+                Theme::Pro | Theme::ProMedium | Theme::Studio | Theme::SolarizedDark | Theme::AdwaitaDark | Theme::BreezeDark | Theme::SoftDark => {
+                    ("dark", "darkTheme")
+                }
+                Theme::StudioLight | Theme::ProLightGray | Theme::ProLight | Theme::Classic | Theme::Adwaita | Theme::BreezeLight | Theme::SoftLight => {
+                    ("light", "lightTheme")
+                }
             };
             interface.insert("appearanceMode".into(), json!(mode));
             interface.insert(slot.into(), json!(theme.name()));
@@ -1553,7 +1580,9 @@ impl Session {
     }
 
     /// Set one dotted path, routing `colorSettings.*` to the colour state.
-    fn set_pref(&mut self, path: &str, value: Value) -> std::result::Result<(), String> {
+    /// Batches defer colour validation until their complete candidate is staged. Returns
+    /// whether colour settings were touched, including whole-section/root-object updates.
+    fn set_pref(&mut self, path: &str, value: Value, validate_color: bool) -> std::result::Result<bool, String> {
         if let Some(rest) = path.strip_prefix("colorSettings") {
             let mut cur = serde_json::to_value(&self.color.settings).map_err(|e| e.to_string())?;
             let rest = rest.trim_start_matches('.');
@@ -1562,19 +1591,23 @@ impl Session {
             } else {
                 set_path(&mut cur, rest, value)?;
             }
-            self.color.settings = serde_json::from_value(cur).map_err(|e| format!("invalid value for `{path}`: {e}"))?;
-            crate::color_cmds::validate_settings(&self.color.settings)?;
+            let next = serde_json::from_value(cur).map_err(|e| format!("invalid value for `{path}`: {e}"))?;
+            if validate_color {
+                crate::color_cmds::validate_settings(&next)?;
+            }
+            self.color.settings = next;
             self.prefs.edit(|_| ());
-            return Ok(());
+            return Ok(true);
         }
         let mut next = self.prefs().clone();
+        let mut color_changed = false;
         if path.is_empty() || SECTIONS.iter().any(|(id, _)| *id == path) || matches!(path, "shortcuts" | "menus" | "toolbar") {
             // Whole section (or everything): merge the object key by key so each value is checked.
             let obj = value.as_object().ok_or_else(|| format!("`{path}` needs an object"))?;
             for (k, v) in obj {
                 let p = if path.is_empty() { k.clone() } else { format!("{path}.{k}") };
                 if path.is_empty() && k == "colorSettings" {
-                    self.set_pref("colorSettings", v.clone())?;
+                    color_changed |= self.set_pref("colorSettings", v.clone(), validate_color)?;
                     continue;
                 }
                 if v.is_object() && !p.starts_with("shortcuts") && !p.ends_with(".colors") && next.get(&p).is_some_and(|c| c.is_object()) {
@@ -1640,10 +1673,18 @@ impl Session {
                     next.interface.light_theme = LightTheme::BreezeLight;
                     next.interface.appearance_mode = AppearanceMode::Light;
                 }
+                Theme::SoftDark => {
+                    next.interface.dark_theme = DarkTheme::SoftDark;
+                    next.interface.appearance_mode = AppearanceMode::Dark;
+                }
+                Theme::SoftLight => {
+                    next.interface.light_theme = LightTheme::SoftLight;
+                    next.interface.appearance_mode = AppearanceMode::Light;
+                }
             }
         }
         self.prefs.edit(|p| *p = next);
-        Ok(())
+        Ok(color_changed)
     }
 }
 
@@ -1677,13 +1718,22 @@ fn prefs_set(s: &mut Session, p: &Value) -> Result<Value> {
     }
     // All or nothing: validate against a scratch copy first.
     let (saved_prefs, saved_color) = (s.prefs().clone(), s.color.settings.clone());
+    let mut color_changed = false;
     for (path, v) in &changes {
-        if let Err(e) = s.set_pref(path, v.clone()) {
-            s.prefs.edit(|p| *p = saved_prefs);
-            s.color.settings = saved_color;
-            return Err(bad(cmd, e));
+        match s.set_pref(path, v.clone(), false) {
+            Ok(touched) => color_changed |= touched,
+            Err(e) => {
+                s.prefs.edit(|p| *p = saved_prefs);
+                s.color.settings = saved_color;
+                return Err(bad(cmd, e));
+            }
         }
     }
+    if color_changed && let Err(e) = crate::color_cmds::validate_settings(&s.color.settings) {
+        s.prefs.edit(|p| *p = saved_prefs);
+        s.color.settings = saved_color;
+        return Err(bad(cmd, e));
+    }
     // `colorSettings.blendTextGamma` lives in the compositor too, as `edit.colorSettings` sets it.
     photocraft_compose::psblend::set_text_gamma(s.color.settings.blend_text_gamma);
     s.apply_prefs();
@@ -1702,7 +1752,7 @@ fn prefs_reset(s: &mut Session, p: &Value) -> Result<Value> {
             let defaults = serde_json::to_value(crate::color_cmds::ColorSettings::default()).map_err(|e| bad("prefs.reset", e.to_string()))?;
             let key = path.strip_prefix("colorSettings.").unwrap_or(path);
             let def = get_path(&defaults, key).cloned().ok_or_else(|| bad("prefs.reset", format!("unknown preference `{path}`")))?;
-            s.set_pref(path, def).map_err(|e| bad("prefs.reset", e))?;
+            s.set_pref(path, def, true).map_err(|e| bad("prefs.reset", e))?;
         }
         None => {
             s.color.settings = Default::default();
diff --git a/crates/engine/src/prefs/tests.rs b/crates/engine/src/prefs/tests.rs
index 6bb34a9706..36a5b69abc 100644
--- a/crates/engine/src/prefs/tests.rs
+++ b/crates/engine/src/prefs/tests.rs
@@ -55,9 +55,9 @@ fn appearance_defaults_and_legacy_theme_migrate() {
     // New users keep Photoshop's default; following the system is opt-in.
     assert_eq!(p.interface.appearance_mode, AppearanceMode::Dark);
     assert_eq!(p.interface.dark_theme, DarkTheme::ProMedium);
-    assert_eq!(p.interface.light_theme, LightTheme::StudioLight);
+    assert_eq!(p.interface.light_theme, LightTheme::ProLight);
     for (theme, mode, dark, light) in
-        [("pro", AppearanceMode::Dark, DarkTheme::Pro, LightTheme::StudioLight), ("classic", AppearanceMode::Light, DarkTheme::ProMedium, LightTheme::Classic)]
+        [("pro", AppearanceMode::Dark, DarkTheme::Pro, LightTheme::ProLight), ("classic", AppearanceMode::Light, DarkTheme::ProMedium, LightTheme::Classic)]
     {
         let mut s = Session::new();
         s.load_prefs_json(&json!({"interface": {"theme": theme}}).to_string()).unwrap();
diff --git a/crates/engine/src/preset_import_cmds.rs b/crates/engine/src/preset_import_cmds.rs
index 37b375cea2..e6bff8eb6b 100644
--- a/crates/engine/src/preset_import_cmds.rs
+++ b/crates/engine/src/preset_import_cmds.rs
@@ -106,6 +106,7 @@ fn add_abr_presets(s: &mut Session, p: &Value, group: String, imp: photocraft_io
         let mut b = pr.brush.clone().picked_over(&s.tools.brush);
         s.load_brush_tips(&mut b).map_err(|e| bad("brush.presets.importAbr", e))?;
         s.tools.brush = b;
+        s.tools.brush_changed();
     }
     // Distinct folder paths the file brought (its Photoshop folders, nested inside `group`).
     let folders: std::collections::BTreeSet<&[String]> =
diff --git a/crates/engine/src/preset_store.rs b/crates/engine/src/preset_store.rs
index 02138b637f..83cb16a838 100644
--- a/crates/engine/src/preset_store.rs
+++ b/crates/engine/src/preset_store.rs
@@ -44,7 +44,7 @@ use std::io::Read;
 use std::sync::{Arc, Mutex, PoisonError};
 
 use photocraft_paint::tile::PREVIEW_SIDE;
-use photocraft_paint::{BrushPreset, BrushSettings, GrayTile, Pattern, StoredTile, TipShape};
+use photocraft_paint::{BrushPreset, BrushSettings, GrayTile, Pattern, PresetCaptures, StoredTile, TipShape};
 use serde::{Deserialize, Serialize};
 
 use crate::Session;
@@ -299,7 +299,7 @@ fn decode_tip_max(bytes: &[u8], max_side: u32) -> Result<GrayTile, String> {
     }
     let data: Vec<u16> =
         if bits == 8 { raw.iter().map(|&v| u16::from(v) * 257).collect() } else { raw.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect() };
-    Ok(GrayTile { width: w, height: h, data })
+    Ok(GrayTile { width: w, height: h, data: data.into() })
 }
 
 // ------------------------------------------------------------------ group files
@@ -333,6 +333,9 @@ struct StoredPreset {
     /// before #1851, which load with every preset directly in its group.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     folder: Vec<String>,
+    /// [`BrushPreset::captures`]; missing for presets saved without the New Brush Preset dialog.
+    #[serde(default, skip_serializing_if = "PresetCaptures::is_default")]
+    captures: PresetCaptures,
 }
 
 /// What a group file records about each tip it references, so loading needs only the preview.
@@ -669,7 +672,14 @@ pub fn open(backend: Box<dyn PresetBackend>) -> Opened {
                             hashes.push(i.preview.clone());
                         }
                     }
-                    items.push(BrushPreset { name: sp.name, brush, builtin: false, group: g.group.clone(), folder: sanitize_folder(sp.folder) });
+                    items.push(BrushPreset {
+                        name: sp.name,
+                        brush,
+                        builtin: false,
+                        group: g.group.clone(),
+                        folder: sanitize_folder(sp.folder),
+                        captures: sp.captures,
+                    });
                 }
                 None => missing += 1,
             }
@@ -1006,7 +1016,13 @@ impl PresetStore {
             }
             let key = |r: &Option<StoredTile>| r.as_ref().map(|t| t.key.clone());
             let tips = TipRefs { tip: key(&refs[0]), dual_tip: key(&refs[1]), texture: key(&refs[2]) };
-            stored.push(StoredPreset { name: p.name.clone(), brush: settings_only(&mut p.brush), tips, folder: p.folder.clone() });
+            stored.push(StoredPreset {
+                name: p.name.clone(),
+                brush: settings_only(&mut p.brush),
+                tips,
+                folder: p.folder.clone(),
+                captures: p.captures.clone(),
+            });
             tiles.push(refs);
         }
         let gf = GroupFile { format: GROUP_FORMAT.into(), version: 1, group: group.to_string(), presets: stored, tips: infos };
@@ -1109,6 +1125,11 @@ impl Session {
         }
         self.brush_presets_changed();
         self.sync_preset_store();
+        // A brush remembered from the previous run (or picked before the store loaded) may be
+        // painting with previews; load the full tips now (a missing one keeps its preview).
+        let mut brush = std::mem::take(&mut self.tools.brush);
+        let _ = self.load_brush_tips(&mut brush);
+        self.tools.brush = brush;
         if let Some(st) = self.preset_store.as_mut() {
             warnings.extend(st.take_warnings());
         }
@@ -1123,7 +1144,11 @@ impl Session {
             if st.synced_rev != Some(rev) {
                 st.sync(&mut self.tools.presets);
                 st.synced_rev = Some(rev);
-                link_stored_tips(st, &mut self.tools.brush);
+                if link_stored_tips(st, &mut self.tools.brush) {
+                    // An embedded tip became a store reference: what the last-brush
+                    // persistence would write changed without a command touching the brush.
+                    self.tools.brush_changed();
+                }
             }
             st.sync_actions(&self.actions.list, actions_rev);
         }
@@ -1156,7 +1181,7 @@ impl Session {
 /// After a sync, an embedded bitmap of the tool's brush that the store now holds (the brush was
 /// just saved as a preset) becomes the stored tile, keeping its bitmap: the brush then matches its
 /// preset (Brushes panel highlight) like a preset picked from the library.
-fn link_stored_tips(st: &PresetStore, b: &mut BrushSettings) {
+fn link_stored_tips(st: &PresetStore, b: &mut BrushSettings) -> bool {
     let link = |g: &GrayTile| -> Option<StoredTile> {
         if !g.is_valid() {
             return None;
@@ -1164,24 +1189,29 @@ fn link_stored_tips(st: &PresetStore, b: &mut BrushSettings) {
         let h = tip_hash(g);
         st.tips.contains_key(&h).then(|| StoredTile { key: h, width: g.width, height: g.height, preview: Arc::new(g.preview(PREVIEW_SIDE)), full: None })
     };
+    let mut linked = false;
     if let TipShape::Sampled(g) = &b.tip
         && let Some(r) = link(g)
         && let TipShape::Sampled(g) = std::mem::take(&mut b.tip)
     {
         b.tip = TipShape::Stored(StoredTile { full: Some(Arc::new(g)), ..r });
+        linked = true;
     }
     if let TipShape::Sampled(g) = &b.dual_brush.tip
         && let Some(r) = link(g)
         && let TipShape::Sampled(g) = std::mem::take(&mut b.dual_brush.tip)
     {
         b.dual_brush.tip = TipShape::Stored(StoredTile { full: Some(Arc::new(g)), ..r });
+        linked = true;
     }
     if let Pattern::Tile(g) = &b.texture.pattern
         && let Some(r) = link(g)
         && let Pattern::Tile(g) = std::mem::take(&mut b.texture.pattern)
     {
         b.texture.pattern = Pattern::Stored(StoredTile { full: Some(Arc::new(g)), ..r });
+        linked = true;
     }
+    linked
 }
 
 #[cfg(test)]
diff --git a/crates/engine/src/preset_store/tests.rs b/crates/engine/src/preset_store/tests.rs
index b7f175867c..860ebd4fc3 100644
--- a/crates/engine/src/preset_store/tests.rs
+++ b/crates/engine/src/preset_store/tests.rs
@@ -45,7 +45,7 @@ fn tip16(w: u32, h: u32, seed: u32) -> GrayTile {
 
 fn sampled(name: &str, group: &str, tip: GrayTile) -> BrushPreset {
     let brush = BrushSettings { size: 42.0, spacing: 0.1, tip: TipShape::Sampled(tip), ..Default::default() };
-    BrushPreset { name: name.into(), brush, builtin: false, group: group.into(), folder: Vec::new() }
+    BrushPreset { name: name.into(), brush, builtin: false, group: group.into(), folder: Vec::new(), captures: Default::default() }
 }
 
 fn user(s: &Session) -> Vec<BrushPreset> {
@@ -168,6 +168,22 @@ fn commands_persist_and_delete_removes_from_disk() {
     assert!(photocraft_paint::presets::find(&t.tools.presets, "Doodle").is_none());
 }
 
+/// The New Brush Preset dialog's boxes (#4490) are saved with the preset and come back with it;
+/// a preset saved without them reloads with the default captures and writes no field for them.
+#[test]
+fn preset_captures_persist() {
+    let dir = TempDir::new("captures");
+    let (mut s, _) = session(&dir);
+    s.execute("brush.presets.save", json!({"name": "Bare", "captureSize": false, "toolSettings": false, "color": true})).unwrap();
+    s.execute("brush.presets.save", json!({"name": "Plain"})).unwrap();
+    let (t, _) = session(&dir);
+    let find = |n: &str| photocraft_paint::presets::find(&t.tools.presets, n).expect("reloads").captures.clone();
+    assert_eq!(find("Bare"), PresetCaptures { size: false, tool_settings: false, color: true });
+    assert!(find("Plain").is_default());
+    let written: String = dir.files().iter().filter(|f| !f.starts_with("tips/")).map(|f| std::fs::read_to_string(dir.0.join(f)).unwrap_or_default()).collect();
+    assert_eq!(written.matches("\"captures\"").count(), 1, "only the preset with boxes records them");
+}
+
 #[test]
 fn imported_abr_group_persists() {
     let dir = TempDir::new("abr");
@@ -624,6 +640,40 @@ fn imported_abr_folders_persist_and_old_stores_load_flat() {
     assert!(photocraft_paint::presets::find(&d.tools.presets, "Blank").unwrap().folder.is_empty());
 }
 
+/// Moving a group into another group's folder rewrites the target group's file and removes the
+/// moved group's; moving a folder out to the top level makes a group file for it (#2014).
+#[test]
+fn folders_moved_into_other_folders_persist() {
+    let dir = TempDir::new("folder-into");
+    let (mut s, _) = session(&dir);
+    let set = abr_with_folders(&[("Kit Loose", &[]), ("Kit Pen", &["Inks"]), ("Kit Nib", &["Inks", "Fine"])]);
+    let other = abr_with_folders(&[("Pack Chalk", &["Dry"])]);
+    s.execute("brush.presets.importAbr", json!({"data": photocraft_paint::tile::b64_encode(&set), "group": "Kit"})).unwrap();
+    s.execute("brush.presets.importAbr", json!({"data": photocraft_paint::tile::b64_encode(&other), "group": "Pack"})).unwrap();
+    let group_files = |d: &TempDir| -> Vec<String> { d.files().into_iter().filter(|f| f.ends_with(".pcbrushes")).collect() };
+    let mut both = vec![group_file_name("Kit"), group_file_name("Pack")];
+    both.sort();
+    assert_eq!(group_files(&dir), both);
+    s.execute("brush.presets.moveGroup", json!({"group": "Pack", "into": {"group": "Kit", "folder": ["Inks"]}})).unwrap();
+    assert_eq!(group_files(&dir), [group_file_name("Kit")]);
+    let (t, w) = session(&dir);
+    assert!(w.is_empty(), "{w:?}");
+    assert_eq!(user(&t), user(&s));
+    let folder = |s: &Session, n: &str| {
+        let p = photocraft_paint::presets::find(&s.tools.presets, n).unwrap();
+        format!("{}:{}", p.group, p.folder.join("/"))
+    };
+    assert_eq!(folder(&t, "Pack Chalk"), "Kit:Inks/Pack/Dry");
+    // Out to the top level: a group (and file) of its own.
+    s.execute("brush.presets.moveGroup", json!({"group": "Kit", "folder": ["Inks", "Pack"], "into": {}})).unwrap();
+    let mut both = vec![group_file_name("Kit"), group_file_name("Pack")];
+    both.sort();
+    assert_eq!(group_files(&dir), both);
+    let (t, _) = session(&dir);
+    assert_eq!(folder(&t, "Pack Chalk"), "Pack:Dry");
+    assert_eq!(folder(&t, "Kit Nib"), "Kit:Inks/Fine");
+}
+
 #[test]
 fn a_group_file_that_failed_to_load_is_not_overwritten() {
     // e.g. written by a newer PhotoCraft: skipped on load, so a save must not replace it.
diff --git a/crates/engine/src/presets/patterns.rs b/crates/engine/src/presets/patterns.rs
index f4ecb15c3c..2425dd0900 100644
--- a/crates/engine/src/presets/patterns.rs
+++ b/crates/engine/src/presets/patterns.rs
@@ -125,13 +125,32 @@ fn edit(s: &mut Session, p: &Value) -> Result<Value> {
         "rename" => super::call(s, "pattern.rename", json!({"pattern": req_str(p, "preset", CMD)?, "name": req_str(p, "name", CMD)?}))?,
         "delete" => {
             let keys: Vec<String> = match p.get("preset") {
-                Some(Value::Array(a)) => a.iter().filter_map(Value::as_str).map(str::to_string).collect(),
+                Some(Value::Array(a)) => a
+                    .iter()
+                    .map(|v| v.as_str().map(str::to_string).ok_or_else(|| bad(CMD, "`preset` must contain only pattern ids or names")))
+                    .collect::<Result<_>>()?,
                 _ => vec![req_str(p, "preset", CMD)?.to_string()],
             };
-            for k in &keys {
-                super::call(s, "pattern.delete", json!({"pattern": k}))?;
+            if keys.is_empty() {
+                return Err(bad(CMD, "missing `preset`"));
             }
-            json!({"deleted": keys.len()})
+            // Resolve every reference first. Deleting as we go left the library partly
+            // removed when a later name was missing, and Undo cannot put a preset back (#4103).
+            let mut ids = Vec::new();
+            for k in &keys {
+                // Only library patterns can be deleted here; a document-only pattern must
+                // fail the whole batch up front rather than midway through it.
+                let id = photocraft_doc::pattern::find(&s.patterns.items, k, k)
+                    .map(|q| q.id.clone())
+                    .ok_or_else(|| bad(CMD, format!("no library pattern \"{k}\"")))?;
+                if !ids.contains(&id) {
+                    ids.push(id);
+                }
+            }
+            for id in &ids {
+                super::call(s, "pattern.delete", json!({"pattern": id}))?;
+            }
+            json!({"deleted": ids.len()})
         }
         "deleteGroup" => {
             // Deleting a folder deletes its patterns, as in Photoshop.
diff --git a/crates/engine/src/presets/styles.rs b/crates/engine/src/presets/styles.rs
index a8c60d6a4c..ee4607cf86 100644
--- a/crates/engine/src/presets/styles.rs
+++ b/crates/engine/src/presets/styles.rs
@@ -191,13 +191,9 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
         let mode = doc.mode;
         let effects: Vec<_> = effects.iter().cloned().map(|e| e.in_mode(mode)).collect();
         for id in &ids {
-            let l = doc.layer_mut(*id).ok_or(EngineError::NoLayer(*id))?;
             // Styles can't sit on the Background: Photoshop turns it into a normal layer first.
-            if l.name == "Background" && l.locks.transparency && l.locks.position && matches!(l.content, photocraft_doc::LayerContent::Raster(_)) {
-                l.name = "Layer 0".into();
-                l.locks.transparency = false;
-                l.locks.position = false;
-            }
+            crate::extra_cmds::background_to_layer(doc, *id);
+            let l = doc.layer_mut(*id).ok_or(EngineError::NoLayer(*id))?;
             if add {
                 l.effects.items.extend(effects.iter().cloned());
             } else {
diff --git a/crates/engine/src/presets/swatches.rs b/crates/engine/src/presets/swatches.rs
index f46aad32da..eb666e1ec5 100644
--- a/crates/engine/src/presets/swatches.rs
+++ b/crates/engine/src/presets/swatches.rs
@@ -166,7 +166,14 @@ impl SwatchColor {
             .and_then(Value::as_array)
             .ok_or("a colour needs `values`")?
             .iter()
-            .map(|x| x.as_f64().filter(|f| f.is_finite()).map(|f| f as f32).ok_or("colour values must be finite numbers"))
+            // Beyond f32 range a value turns into inf as f32 (an HSB hue then wraps to NaN, which
+            // the prefs file can't store), so reject it here.
+            .map(|x| {
+                x.as_f64()
+                    .filter(|f| f.is_finite() && f.abs() <= f64::from(f32::MAX))
+                    .map(|f| f as f32)
+                    .ok_or("colour values must be finite numbers within f32 range")
+            })
             .collect::<Result<_, _>>()?;
         let need = |n: usize| if vals.len() == n { Ok(()) } else { Err(format!("a {model} colour has {n} values, got {}", vals.len())) };
         let pct = |v: f32| (v / 100.0).clamp(0.0, 1.0);
@@ -281,7 +288,9 @@ pub fn hex(c: [f32; 3]) -> String {
 
 // ------------------------------------------------------------------ defaults
 
-/// The default library: 40 colours in four groups (our own palette).
+/// The default library: 46 colours in five groups. "RGB" holds the exact primaries and
+/// secondaries (#FF0000, #00FF00, ...) as Photoshop's RGB group does; the other four are our own
+/// palette, whose "Pure" hues are vivid but not the pure channel values (#4302).
 pub fn builtin() -> Vec<Group<Swatch>> {
     let rgb = |n: &str, c: [u8; 3]| Swatch::new(n, SwatchColor::Rgb(c.map(|v| f32::from(v) / 255.0)));
     let grays = [
@@ -326,8 +335,19 @@ pub fn builtin() -> Vec<Group<Swatch>> {
     let row = |prefix: &str, cs: [[u8; 3]; 10]| -> Vec<Swatch> {
         hues.iter().zip(cs).map(|(h, c)| rgb(&if prefix.is_empty() { (*h).to_string() } else { format!("{prefix} {h}") }, c)).collect()
     };
+    // Right after Grays, near the top of the panel (Grays stays first: new swatches land there).
+    // Photoshop's order: red, yellow, green, cyan, blue, magenta.
+    let exact: [(&str, [u8; 3]); 6] = [
+        ("RGB Red", [255, 0, 0]),
+        ("RGB Yellow", [255, 255, 0]),
+        ("RGB Green", [0, 255, 0]),
+        ("RGB Cyan", [0, 255, 255]),
+        ("RGB Blue", [0, 0, 255]),
+        ("RGB Magenta", [255, 0, 255]),
+    ];
     vec![
         Group::new("Grays", grays.iter().map(|(n, v)| rgb(n, [*v; 3])).collect()),
+        Group::new("RGB", exact.iter().map(|(n, c)| rgb(n, *c)).collect()),
         Group::new("Pastel", row("Pastel", pastel)),
         Group::new("Pure", row("", pure)),
         Group::new("Dark", row("Dark", dark)),
@@ -339,15 +359,27 @@ mod tests {
     use super::*;
 
     #[test]
-    fn default_library_has_the_forty_colours() {
+    fn default_library_has_the_forty_six_colours() {
         let b = builtin();
-        assert_eq!(b.iter().map(|g| g.items.len()).sum::<usize>(), 40);
+        assert_eq!(b.iter().map(|g| g.items.len()).sum::<usize>(), 46);
         let names: Vec<&str> = b.iter().flat_map(|g| g.items.iter().map(|s| s.name.as_str())).collect();
         let mut uniq = names.clone();
         uniq.sort_unstable();
         uniq.dedup();
-        assert_eq!(uniq.len(), 40, "names are unique: {names:?}");
-        assert_eq!(b[2].items[0].color, SwatchColor::Rgb([230.0 / 255.0, 40.0 / 255.0, 40.0 / 255.0]));
+        assert_eq!(uniq.len(), 46, "names are unique: {names:?}");
+        assert_eq!(b[3].name, "Pure");
+        assert_eq!(b[3].items[0].color, SwatchColor::Rgb([230.0 / 255.0, 40.0 / 255.0, 40.0 / 255.0]));
+    }
+
+    #[test]
+    fn the_rgb_group_holds_exact_primaries_and_secondaries() {
+        // #4302: picking green should give #00FF00, as in Photoshop's RGB group.
+        let b = builtin();
+        let g = &b[1];
+        assert_eq!(g.name, "RGB");
+        let conv = SwatchConv::builtin();
+        let hexes: Vec<String> = g.items.iter().map(|s| hex(conv.rgb(&s.color))).collect();
+        assert_eq!(hexes, ["#ff0000", "#ffff00", "#00ff00", "#00ffff", "#0000ff", "#ff00ff"]);
     }
 
     #[test]
@@ -403,6 +435,8 @@ mod tests {
             json!({"model": "rgb", "values": ["a", 2, 3]}),
             json!({"model": "xyz", "values": [1, 2, 3]}),
             json!({"model": "gray", "values": []}),
+            json!({"model": "hsb", "values": [1e39, 100, 100]}),
+            json!({"model": "rgb", "values": [0, -1e39, 0]}),
         ] {
             assert!(SwatchColor::from_param(&bad).is_err(), "{bad}");
         }
diff --git a/crates/engine/src/presets/tests.rs b/crates/engine/src/presets/tests.rs
index 7ebf2145b1..dcfc4e94d8 100644
--- a/crates/engine/src/presets/tests.rs
+++ b/crates/engine/src/presets/tests.rs
@@ -385,6 +385,43 @@ fn pattern_groups_select_apply_and_sync() {
     assert!(crate::pattern_cmds::resolve(&s, "Weave").is_none());
 }
 
+#[test]
+fn pattern_batch_delete_keeps_the_library_when_one_name_is_missing() {
+    let mut s = session(8);
+    let before = s.execute("pattern.presets.list", json!({})).unwrap();
+    let err = s.execute("pattern.presets.edit", json!({"action": "delete", "preset": ["Bricks", "missing"]})).unwrap_err();
+    assert!(err.to_string().contains("missing"), "{err}");
+    assert_eq!(s.execute("pattern.presets.list", json!({})).unwrap(), before);
+    assert!(crate::pattern_cmds::resolve(&s, "Bricks").is_some());
+}
+
+#[test]
+fn pattern_batch_delete_rejects_non_string_members_without_deleting() {
+    for invalid in [json!(null), json!(7), json!({})] {
+        let mut s = session(8);
+        let before = s.execute("pattern.presets.list", json!({})).unwrap();
+        assert!(s.execute("pattern.presets.edit", json!({"action": "delete", "preset": ["Bricks", invalid]})).is_err());
+        assert_eq!(s.execute("pattern.presets.list", json!({})).unwrap(), before);
+    }
+}
+
+#[test]
+fn pattern_batch_delete_refuses_a_document_only_pattern_up_front() {
+    let mut s = session(8);
+    let added = s.execute("edit.definePattern", json!({"name": "Document Only"})).unwrap();
+    let id = added["pattern"].as_str().unwrap().to_string();
+    let pattern = s.patterns.items.iter().find(|p| p.id == id).unwrap().clone();
+    s.edit("Embed pattern fixture", |doc, _| {
+        doc.patterns.push(pattern.clone());
+        Ok(())
+    })
+    .unwrap();
+    s.execute("pattern.delete", json!({"pattern": id})).unwrap();
+    let before = s.patterns.items.clone();
+    assert!(s.execute("pattern.presets.edit", json!({"action": "delete", "preset": ["Bricks", id]})).is_err());
+    assert_eq!(s.patterns.items, before, "nothing is deleted when one entry is not in the library");
+}
+
 // ------------------------------------------------------------------ styles
 
 #[test]
diff --git a/crates/engine/src/print_cmds.rs b/crates/engine/src/print_cmds.rs
index a6acb95a4c..73324711d9 100644
--- a/crates/engine/src/print_cmds.rs
+++ b/crates/engine/src/print_cmds.rs
@@ -4,9 +4,9 @@
 //! scale, colour handling with printer profile / intent / black-point compensation, corner and
 //! centre crop marks, registration marks, description and label) with a small PDF writer
 //! (ISO 32000: one page, a Flate-compressed image XObject, vector marks, Helvetica text), then
-//! hands it to the system spooler with `lp` (CUPS, macOS and Linux). `"dryRun": true` stops
-//! before spooling and reports the command line. Without an explicit PDF output, the spool file
-//! is private and removed when `lp` finishes; dry runs do not create one.
+//! hands its bytes to `craft-print` (CUPS on macOS/Linux, Windows PDF printing on Windows).
+//! `"dryRun": true` reports the backend command without spooling; a PDF is kept only at an
+//! explicit output path. Shared spooler transport files are private and automatically removed.
 //!
 //! Paths to Illustrator writes the document's paths as an Adobe Illustrator 3 compatible
 //! PostScript file (`m`/`L`/`C` path construction, `n`/`N` unpainted closed/open paths, `*u`/`*U`
@@ -327,28 +327,9 @@ pub fn layout(doc: &Document, p: &Value, cmd: &str) -> Result<PrintLayout> {
     Ok(PrintLayout { paper: (pw, ph), rect: (x, y, w, h), scale, marks, emulsion_down })
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-fn private_spool_pdf(pdf: &[u8]) -> Result<tempfile::NamedTempFile> {
-    private_spool_pdf_in(pdf, &std::env::temp_dir())
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-fn private_spool_pdf_in(pdf: &[u8], dir: &std::path::Path) -> Result<tempfile::NamedTempFile> {
-    // tempfile creates a random name with create_new semantics and mode 0600 on Unix.
-    // Keeping this handle alive prevents a symlink at a guessed path from redirecting the write.
-    let mut file = tempfile::Builder::new().prefix("photocraft-print-").suffix(".pdf").tempfile_in(dir).map_err(other)?;
-    file.write_all(pdf).map_err(other)?;
-    file.flush().map_err(other)?;
-    Ok(file)
-}
-
 /// Lays out, renders and (unless dry-run) spools a print. Shared by Print and Print One Copy.
 fn do_print(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
-    do_print_with_spooler(s, p, cmd, spool_pdf)
-}
-
-fn do_print_with_spooler(s: &mut Session, p: &Value, cmd: &str, spooler: impl FnOnce(&[String]) -> Result<String>) -> Result<Value> {
-    let output = p.get("output").and_then(Value::as_str).filter(|v| !v.is_empty()).map(str::to_string);
+    let output = p.get("output").and_then(Value::as_str).filter(|v| !v.is_empty());
     let send = p.get("send").and_then(Value::as_bool).unwrap_or(output.is_none());
     let dry = p.get("dryRun").and_then(Value::as_bool).unwrap_or(false);
     if !dry && !send && output.is_none() {
@@ -356,8 +337,46 @@ fn do_print_with_spooler(s: &mut Session, p: &Value, cmd: &str, spooler: impl Fn
     }
     let d = s.active().ok_or(EngineError::NoDocument)?;
     let doc = d.doc.clone();
-    let PrintLayout { paper: (pw, ph), rect: (x, y, w, h), scale, marks, emulsion_down } = layout(&doc, p, cmd)?;
-    let (img, color) = print_image(&doc, p, cmd)?;
+    let doc_id = doc.id;
+    let params = p.clone();
+    let worker_params = params.clone();
+    let command = cmd.to_string();
+    if send && !dry {
+        // Session::execute remains synchronous; the desktop's Session::start snapshots here
+        // and runs PDF composition and the potentially slow driver on a worker.
+        return crate::jobs::run(
+            s,
+            "Print",
+            false,
+            move |ctx| {
+                ctx.progress(0.0, "Print");
+                render_and_spool(&doc, &worker_params, &command)
+            },
+            move |s, result| {
+                remember_print(s, &params);
+                // A user can switch tabs while printing. Hooks belong to the source document;
+                // a closed source has no document left to modify, as for background saves.
+                let viewed = s.active().map(|st| st.doc.id);
+                if let Some(index) = s.documents().iter().position(|st| st.doc.id == doc_id) {
+                    s.set_active(index);
+                    crate::automate_cmds::fire_event(s, "print");
+                    if let Some(index) = viewed.and_then(|id| s.documents().iter().position(|st| st.doc.id == id)) {
+                        s.set_active(index);
+                    }
+                }
+                Ok(result)
+            },
+        );
+    }
+    let result = render_and_spool(&doc, p, cmd)?;
+    remember_print(s, p);
+    crate::automate_cmds::fire_event(s, "print");
+    Ok(result)
+}
+
+fn render_and_spool(doc: &Document, p: &Value, cmd: &str) -> Result<Value> {
+    let PrintLayout { paper: (pw, ph), rect: (x, y, w, h), scale, marks, emulsion_down } = layout(doc, p, cmd)?;
+    let (img, color) = print_image(doc, p, cmd)?;
     let description = p
         .get("description")
         .and_then(Value::as_bool)
@@ -365,43 +384,43 @@ fn do_print_with_spooler(s: &mut Session, p: &Value, cmd: &str, spooler: impl Fn
         .then(|| crate::file_cmds::read_file_info(doc.metadata.xmp.as_deref())["description"].as_str().unwrap_or_default().to_string());
     let label = p.get("labels").and_then(Value::as_bool).unwrap_or(false).then(|| doc.name.clone());
     let page = PrintPage { paper: (pw, ph), image: img, rect: (x, y, w, h), marks, description, label, emulsion_down };
+    let output = p.get("output").and_then(Value::as_str).filter(|v| !v.is_empty()).map(str::to_string);
+    let send = p.get("send").and_then(Value::as_bool).unwrap_or(output.is_none());
+    let copies = crate::commands::int(p, "copies").unwrap_or(1).clamp(1, 999) as u32;
+    let dry = p.get("dryRun").and_then(Value::as_bool).unwrap_or(false);
     let pdf = print_pdf(&page);
-    if let Some(path) = &output {
-        // An explicit output is the caller's requested artifact, including for dry runs.
-        write_file(path, &pdf)?;
-    }
-    #[cfg(not(target_arch = "wasm32"))]
-    let spool_file = if output.is_none() && send && !dry { Some(private_spool_pdf(&pdf)?) } else { None };
-    #[cfg(target_arch = "wasm32")]
-    if output.is_none() && send && !dry {
-        return Err(other("printing needs the desktop app"));
-    }
-    // Dry-run commands use a descriptive placeholder because no spool file exists.
-    let command_path = output.clone();
-    #[cfg(not(target_arch = "wasm32"))]
-    let command_path = command_path.or_else(|| spool_file.as_ref().map(|f| f.path().to_string_lossy().into_owned()));
-    let command_path = command_path.unwrap_or_else(|| "<temporary PDF>".into());
-    let copies = crate::commands::int(p, "copies").unwrap_or(1).clamp(1, 999);
-    let mut argv: Vec<String> = vec!["lp".into()];
-    if let Some(pr) = p.get("printer").and_then(Value::as_str).filter(|v| !v.is_empty()) {
-        argv.extend(["-d".into(), pr.to_string()]);
-    }
-    if copies > 1 {
-        argv.extend(["-n".into(), copies.to_string()]);
-    }
-    argv.extend(["-t".into(), doc.name.clone(), command_path]);
+    let job = craft_print::Job {
+        printer: p.get("printer").and_then(Value::as_str).filter(|v| !v.is_empty()).map(str::to_string),
+        copies,
+        title: doc.name.clone(),
+        // PhotoCraft already placed and scaled the image on its physical sheet. Scaling again
+        // in the driver would change the preview, print resolution and crop-mark positions.
+        scaling: craft_print::Scaling::Exact,
+        ..Default::default()
+    };
+    let command = if send { json!(craft_print::command_preview(&job).map_err(other)?) } else { Value::Null };
+    let pdf_path = match output {
+        Some(path) => {
+            write_file(&path, &pdf)?;
+            Some(path)
+        }
+        None => None,
+    };
     let mut sent = false;
     let mut spool = Value::Null;
     if send && !dry {
-        spool = json!(spooler(&argv)?);
+        // The last line of defence: a test or fuzz run must never print a page (`dryRun` still
+        // renders and reports the command).
+        if printing_disabled() {
+            return Err(other(
+                "printing is disabled in this process (photocraft_engine::print_cmds::disable_printing or PHOTOCRAFT_NO_PRINT); use dryRun: true",
+            ));
+        }
+        spool = json!(craft_print::submit(&pdf, &job).map_err(other)?);
         sent = true;
     }
-    #[cfg(not(target_arch = "wasm32"))]
-    drop(spool_file);
-    remember_print(s, p);
-    crate::automate_cmds::fire_event(s, "print");
     Ok(
-        json!({"pdf": output, "bytes": pdf.len(), "paper": [pw, ph], "imageRect": [x, y, w, h], "emulsionDown": emulsion_down, "scale": scale * 100.0, "copies": copies, "command": if send { json!(argv) } else { Value::Null }, "sent": sent, "spooler": spool, "color": color}),
+        json!({"pdf": pdf_path, "bytes": pdf.len(), "paper": [pw, ph], "imageRect": [x, y, w, h], "emulsionDown": emulsion_down, "scale": scale * 100.0, "copies": copies, "command": command, "sent": sent, "spooler": spool, "color": color}),
     )
 }
 
@@ -411,24 +430,33 @@ fn remember_print(s: &mut Session, p: &Value) {
     if let Some(o) = remembered.as_object_mut() {
         o.remove("output");
         o.remove("dryRun");
-        // A send override can depend on the output or dry-run choice. Neither is remembered,
-        // so replay and the next Print dialog must derive the default from their own output.
+        // Output and dry-run choices are not remembered, so a send override must not survive them.
         o.remove("send");
     }
     s.file_menu.last_print = Some(remembered);
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-fn spool_pdf(argv: &[String]) -> Result<String> {
-    let out = std::process::Command::new(&argv[0]).args(&argv[1..]).output().map_err(|e| other(format!("could not run `lp` (CUPS): {e}")))?;
-    if !out.status.success() {
-        return Err(other(format!("lp failed: {}", String::from_utf8_lossy(&out.stderr).trim())));
-    }
-    Ok(String::from_utf8_lossy(&out.stdout).trim().to_string())
+/// Set once by test harnesses (the panic hunt) so no command in the process can reach a printer.
+static PRINTING_DISABLED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+
+/// Refuse to spool anything from this process from now on (tests, fuzzing). The
+/// `PHOTOCRAFT_NO_PRINT` environment variable does the same for a whole shell (CI).
+pub fn disable_printing() {
+    PRINTING_DISABLED.store(true, std::sync::atomic::Ordering::Relaxed);
 }
-#[cfg(target_arch = "wasm32")]
-fn spool_pdf(_: &[String]) -> Result<String> {
-    Err(other("printing needs the desktop app"))
+
+/// Whether spooling is blocked by [`disable_printing`] or `PHOTOCRAFT_NO_PRINT`.
+pub fn printing_disabled() -> bool {
+    PRINTING_DISABLED.load(std::sync::atomic::Ordering::Relaxed) || std::env::var_os("PHOTOCRAFT_NO_PRINT").is_some_and(|v| !v.is_empty() && v != "0")
+}
+
+/// The printers the system spooler knows (Print's Printer menu): CUPS queues and driverless
+/// destinations on macOS and Linux, `Win32_Printer` on Windows, none in the browser.
+fn printers(_: &mut Session, _: &Value) -> Result<Value> {
+    let list = craft_print::printers();
+    let default = list.iter().find(|p| p.default).map(|p| p.name.clone());
+    let printers: Vec<Value> = list.into_iter().map(|p| json!({"name": p.name, "default": p.default})).collect();
+    Ok(json!({"printers": printers, "default": default}))
 }
 
 fn print(s: &mut Session, p: &Value) -> Result<Value> {
@@ -599,9 +627,19 @@ pub fn specs() -> Vec<CommandSpec> {
             CommandSpec { id: $id, label: $label, menu: $menu, shortcut: $sc, params: $params, enabled: $enabled, journal: true, run: $run }
         };
     }
-    const PRINT_PARAMS: &str = r##"{"printer":name? (default printer),"copies":1..999=1,"paper":"letter|legal|tabloid|a3|a4|a5|4x6|5x7"|[w,h] pt="letter","orientation":"portrait|landscape"="portrait","center":bool=true,"top":in?,"left":in?,"scale":%=100,"scaleToFit":bool=false,"colorHandling":"printerManages|photocraftManages|noColorManagement"="printerManages","printerProfile":profile? (photocraftManages),"intent":"perceptual|relative|saturation|absolute"="relative","bpc":bool=true,"cornerCropMarks":bool,"centerCropMarks":bool,"registrationMarks":bool,"description":bool,"labels":bool,"emulsionDown":bool=false (mirror the page left to right, for sublimation and other transfer printing),"output":pdf path? (print to PDF; then "send" defaults to false),"send":bool?,"dryRun":bool=false (render the PDF, report the lp command, don't spool; no temporary PDF is written)} → {pdf:explicit output path or null, imageRect, command, sent}"##;
+    const PRINT_PARAMS: &str = r##"{"printer":name? (default printer),"copies":1..999=1,"paper":"letter|legal|tabloid|a3|a4|a5|4x6|5x7"|[w,h] pt="letter","orientation":"portrait|landscape"="portrait","center":bool=true,"top":in?,"left":in?,"scale":%=100,"scaleToFit":bool=false,"colorHandling":"printerManages|photocraftManages|noColorManagement"="printerManages","printerProfile":profile? (photocraftManages),"intent":"perceptual|relative|saturation|absolute"="relative","bpc":bool=true,"cornerCropMarks":bool,"centerCropMarks":bool,"registrationMarks":bool,"description":bool,"labels":bool,"emulsionDown":bool=false (mirror the page left to right, for sublimation and other transfer printing),"output":pdf path? (print to PDF; then "send" defaults to false),"send":bool?,"dryRun":bool=false (render the PDF, report the backend command, don't spool; write a PDF only at an explicit output path)} → {pdf:path|null (null without explicit output), imageRect, command:diagnostic array|null, sent}"##;
     vec![
         spec!("file.print", "Print…", &["File"], Some("Cmd+P"), PRINT_PARAMS, native_doc, print),
+        CommandSpec {
+            id: "file.printers",
+            label: "Printers",
+            menu: &[],
+            shortcut: None,
+            params: r##"{} → {printers:[{name, default}], default:name|null} (the system spooler's printers; a name is Print's "printer")"##,
+            enabled: crate::commands::always,
+            journal: false,
+            run: printers,
+        },
         spec!(
             "file.printOneCopy",
             "Print One Copy",
diff --git a/crates/engine/src/print_cmds/tests.rs b/crates/engine/src/print_cmds/tests.rs
index ab2e8c3789..bf5f1e3857 100644
--- a/crates/engine/src/print_cmds/tests.rs
+++ b/crates/engine/src/print_cmds/tests.rs
@@ -33,7 +33,7 @@ fn pdf_image(pdf: &[u8]) -> (u32, u32, String, Vec<u8>) {
 }
 
 #[test]
-fn print_dry_run_renders_a_pdf_and_reports_lp() {
+fn print_dry_run_renders_a_pdf_and_reports_the_platform_backend() {
     let dir = tmp("print");
     for depth in [8, 16, 32] {
         let mut s = session("rgb", depth);
@@ -45,8 +45,14 @@ fn print_dry_run_renders_a_pdf_and_reports_lp() {
             )
             .unwrap();
         let cmd: Vec<String> = serde_json::from_value(r["command"].clone()).unwrap();
-        assert_eq!(&cmd[..5], &["lp", "-d", "Office", "-n", "2"]);
-        assert_eq!(cmd.last(), Some(&out));
+        #[cfg(unix)]
+        {
+            assert_eq!(&cmd[..5], &["lp", "-d", "Office", "-n", "2"]);
+            assert!(cmd.contains(&"fit-to-page=false".into()));
+            assert!(!cmd.contains(&out), "PDF bytes are streamed instead of passing a path");
+        }
+        #[cfg(windows)]
+        assert!(cmd.last().unwrap().contains("craft-print PDF spooler"));
         assert_eq!(r["sent"], false);
         assert_eq!(r["pdf"], out);
         let pdf = std::fs::read(&out).unwrap();
@@ -174,107 +180,13 @@ fn print_one_copy_repeats_the_last_settings() {
     assert_eq!(r["paper"], json!([419.53, 595.28]));
     assert_eq!(r["scale"], 50.0);
     let cmd: Vec<String> = serde_json::from_value(r["command"].clone()).unwrap();
-    assert!(!cmd.contains(&"-n".to_string()));
-    assert_eq!(cmd.last().map(String::as_str), Some("<temporary PDF>"));
+    #[cfg(unix)]
+    assert_eq!(&cmd[..3], &["lp", "-n", "1"]);
+    #[cfg(windows)]
+    assert!(cmd.last().unwrap().contains("craft-print PDF spooler"));
     assert!(r["pdf"].is_null());
 }
 
-#[test]
-fn print_without_output_keeps_private_pdf_only_during_spooling() {
-    let mut s = session("rgb", 8);
-    let mut temporary_path = None;
-    let result = do_print_with_spooler(&mut s, &json!({}), "file.print", |argv| {
-        let path = std::path::PathBuf::from(argv.last().unwrap());
-        let data = std::fs::read(&path).unwrap();
-        assert!(data.starts_with(b"%PDF-1.4"));
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::PermissionsExt;
-            assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o077, 0);
-        }
-        temporary_path = Some(path);
-        Ok("request id 1".into())
-    })
-    .unwrap();
-    assert_eq!(result["sent"], true);
-    assert!(result["pdf"].is_null(), "the temporary path must not be advertised as a retained PDF");
-    assert!(!temporary_path.unwrap().exists(), "spool PDF survives after lp returns");
-}
-
-#[test]
-fn print_spool_error_removes_private_pdf() {
-    let mut s = session("rgb", 8);
-    let mut temporary_path = None;
-    let result = do_print_with_spooler(&mut s, &json!({}), "file.print", |argv| {
-        let path = std::path::PathBuf::from(argv.last().unwrap());
-        assert!(path.is_file());
-        temporary_path = Some(path);
-        Err(other("spooler unavailable"))
-    });
-    assert!(result.is_err());
-    assert!(!temporary_path.unwrap().exists(), "spool PDF survives a failed lp call");
-}
-
-#[cfg(unix)]
-#[test]
-fn private_spool_pdf_does_not_follow_a_guessed_symlink() {
-    let dir = tmp("symlink");
-    let dir = std::path::Path::new(&dir);
-    let victim = dir.join("victim.pdf");
-    let link = dir.join("photocraft-print-AAAAAA.pdf");
-    std::fs::write(&victim, b"keep this").unwrap();
-    std::os::unix::fs::symlink(&victim, &link).unwrap();
-
-    let file = private_spool_pdf_in(b"%PDF-private", dir).unwrap();
-    assert_ne!(file.path(), link);
-    assert_eq!(std::fs::read(&victim).unwrap(), b"keep this");
-    assert_eq!(std::fs::read(file.path()).unwrap(), b"%PDF-private");
-    assert!(std::fs::symlink_metadata(file.path()).unwrap().file_type().is_file());
-    let path = file.path().to_path_buf();
-    drop(file);
-    assert!(!path.exists());
-    assert!(std::fs::symlink_metadata(&link).unwrap().file_type().is_symlink());
-}
-
-#[test]
-fn print_dry_run_without_output_creates_no_spool_pdf() {
-    let mut s = session("rgb", 8);
-    let result = do_print_with_spooler(&mut s, &json!({"dryRun": true}), "file.print", |_| Err(other("dry run invoked spooler"))).unwrap();
-    assert!(result["pdf"].is_null());
-    assert_eq!(result["sent"], false);
-    assert_eq!(result["command"].as_array().unwrap().last().unwrap(), "<temporary PDF>");
-    assert!(result["bytes"].as_u64().unwrap() > 100);
-}
-
-#[test]
-fn print_without_sending_requires_an_output_unless_dry_run() {
-    let mut s = session("rgb", 8);
-    let before = s.file_menu.last_print.clone();
-    let err = do_print_with_spooler(&mut s, &json!({"send": false}), "file.print", |_| Err(other("unexpected spooler call"))).unwrap_err();
-    assert!(err.to_string().contains("needs an output path"), "{err}");
-    assert_eq!(s.file_menu.last_print, before, "a rejected print must not become a remembered successful print");
-    assert!(do_print_with_spooler(&mut s, &json!({"send": false, "dryRun": true}), "file.print", |_| Err(other("dry run invoked spooler"))).is_ok());
-    assert!(s.file_menu.last_print.as_ref().unwrap().get("send").is_none());
-
-    let output = format!("{}/export.pdf", tmp("non-sending-export"));
-    do_print_with_spooler(&mut s, &json!({"output": output, "send": false}), "file.print", |_| Err(other("non-sending export invoked spooler"))).unwrap();
-    assert!(std::path::Path::new(&output).is_file());
-    let mut repeat = s.file_menu.last_print.clone().unwrap();
-    assert!(repeat.get("send").is_none(), "a removed output must not leave send: false in remembered settings");
-    repeat["copies"] = json!(1);
-    let replay = do_print_with_spooler(&mut s, &repeat, "file.printOneCopy", |argv| {
-        assert!(std::path::Path::new(argv.last().unwrap()).is_file());
-        Ok("request id 2".into())
-    })
-    .unwrap();
-    assert_eq!(replay["sent"], true);
-    assert_eq!(replay["copies"], 1);
-
-    let both = format!("{}/print-and-export.pdf", tmp("sending-export"));
-    do_print_with_spooler(&mut s, &json!({"output": both, "send": true, "dryRun": true}), "file.print", |_| Err(other("dry run invoked spooler"))).unwrap();
-    assert!(s.file_menu.last_print.as_ref().unwrap().get("send").is_none(), "a removed output must not leave send: true in remembered settings");
-}
-
 #[test]
 fn package_copies_links_and_relinks() {
     let dir = tmp("package");
@@ -337,3 +249,134 @@ fn paths_export_as_illustrator_postscript() {
     assert_eq!(r["paths"], 1);
     assert!(s.execute("file.export.pathsToIllustrator", json!({"paths": "Nope"})).is_err());
 }
+
+#[test]
+fn print_dry_run_without_output_retains_no_pdf() {
+    let mut s = session("rgb", 8);
+    let result = s.execute("file.print", json!({"dryRun": true})).unwrap();
+    assert!(result["pdf"].is_null());
+    assert_eq!(result["sent"], false);
+    assert!(result["bytes"].as_u64().unwrap() > 100);
+    assert!(result["command"].is_array());
+    assert!(s.file_menu.last_print.as_ref().unwrap().get("dryRun").is_none());
+}
+
+#[test]
+fn print_without_sending_requires_output_unless_dry_run_and_forgets_send_override() {
+    let mut s = session("rgb", 8);
+    let before = s.file_menu.last_print.clone();
+    let err = s.execute("file.print", json!({"send": false})).unwrap_err();
+    assert!(err.to_string().contains("needs an output path"), "{err}");
+    assert_eq!(s.file_menu.last_print, before);
+    let result = s.execute("file.print", json!({"send": false, "dryRun": true})).unwrap();
+    assert!(result["pdf"].is_null());
+    assert!(result["command"].is_null());
+    assert!(s.file_menu.last_print.as_ref().unwrap().get("send").is_none());
+    let out = format!("{}/export.pdf", tmp("non-sending-export"));
+    let result = s.execute("file.print", json!({"output": out, "send": false})).unwrap();
+    assert_eq!(result["sent"], false);
+    assert!(std::fs::read(&out).unwrap().starts_with(b"%PDF-1.4"));
+    assert!(s.file_menu.last_print.as_ref().unwrap().get("send").is_none());
+    s.execute("file.print", json!({"output": out, "send": true, "dryRun": true})).unwrap();
+    assert!(s.file_menu.last_print.as_ref().unwrap().get("send").is_none());
+}
+/// parallel tests are untouched, and the real spool boundary still consumes the PDF bytes.
+#[cfg(unix)]
+#[test]
+fn spool_transport_streams_pdf_and_propagates_refusal() {
+    const CHILD: &str = "PHOTOCRAFT_TEST_PRINT_TRANSPORT";
+    if let Ok(dir) = std::env::var(CHILD) {
+        let mut s = session("rgb", 8);
+        let source = s.active().unwrap().doc.id;
+        s.execute("file.scripts.scriptEventsManager", json!({"add": {"event": "print", "steps": [["image.imageRotation.90cw", {}]]}})).unwrap();
+        let crate::jobs::Started::Job(job) = s.start("file.print", json!({"printer": "Office", "copies": 3, "paper": "a4", "scale": 50})).unwrap() else {
+            panic!("desktop printing must start on a worker");
+        };
+        assert!(!s.cancel_job(job), "queue side effects must not be reported as cancelled");
+        assert_eq!(s.execute("jobs.cancel", json!({})).unwrap()["cancelled"], 0);
+        assert!(s.execute("jobs.cancel", json!({"job": job.0})).unwrap_err().to_string().contains("system print queue"));
+        s.execute("file.new", json!({"width": 40, "height": 10})).unwrap();
+        let viewed = s.active().unwrap().doc.id;
+        let journal_before_completion = s.journal.len();
+        let out = s.wait_job(job).unwrap();
+        assert_eq!(s.journal.len(), journal_before_completion + 1, "print hooks must not become duplicate recorded action steps");
+        assert_eq!(s.journal.last().unwrap().0, "file.print");
+        assert_eq!(s.active().unwrap().doc.id, viewed, "completion keeps the user's tab");
+        assert_eq!(s.active().unwrap().doc.size.width, 40, "print hook must not act on the newly viewed document");
+        let printed = &s.documents().iter().find(|st| st.doc.id == source).unwrap().doc;
+        assert_eq!((printed.size.width, printed.size.height), (150, 300), "print hook ran on the source document");
+        assert_eq!(out["sent"], true);
+        assert_eq!(out["spooler"], "request id is Office-42");
+        assert!(out["pdf"].is_null(), "spool-only printing leaves no diagnostic PDF");
+        let pdf = std::fs::read(format!("{dir}/received.pdf")).unwrap();
+        assert!(pdf.starts_with(b"%PDF-1.4"));
+        assert!(String::from_utf8_lossy(&pdf).contains("/MediaBox [0 0 595.28 841.89]"));
+        let args = std::fs::read_to_string(format!("{dir}/args")).unwrap();
+        assert!(args.contains("fit-to-page=false"));
+        assert!(args.contains("-n\n3\n"));
+        assert!(!args.contains(".pdf"));
+        let remembered = s.file_menu.last_print.clone();
+        let explicit = format!("{dir}/saved.pdf");
+        let err = s.execute("file.print", json!({"printer": "Refuse", "output": explicit, "send": true})).unwrap_err();
+        assert!(err.to_string().contains("queue refused"), "{err}");
+        assert!(std::fs::read(&explicit).unwrap().starts_with(b"%PDF-1.4"), "explicit export survives a spool refusal");
+        assert_eq!(s.file_menu.last_print, remembered, "failed printing does not replace repeat settings");
+        // Export-only choices must not disable submission when Print One Copy repeats settings.
+        let export = format!("{dir}/export-only.pdf");
+        s.execute("file.print", json!({"printer": "Office", "output": export, "send": false})).unwrap();
+        let remembered = s.file_menu.last_print.as_ref().unwrap();
+        assert!(remembered.get("send").is_none() && remembered.get("output").is_none());
+        let repeat = s.execute("file.printOneCopy", json!({})).unwrap();
+        assert_eq!(repeat["sent"], true);
+        assert_eq!(repeat["copies"], 1);
+        assert!(repeat["pdf"].is_null());
+        assert!(!std::fs::read_to_string(format!("{dir}/args")).unwrap().contains(".pdf"));
+        return;
+    }
+    use std::os::unix::fs::PermissionsExt;
+    let dir = tempfile::tempdir().unwrap();
+    let script = dir.path().join("lp");
+    std::fs::write(
+        &script,
+        b"#!/bin/sh\nif [ \"$2\" = Refuse ]; then echo 'queue refused' >&2; exit 1; fi\nprintf '%s\\n' \"$@\" > \"$PHOTOCRAFT_TEST_PRINT_TRANSPORT/args\"\n/bin/cat > \"$PHOTOCRAFT_TEST_PRINT_TRANSPORT/received.pdf\"\necho 'request id is Office-42 (0 file(s))'\n",
+    ).unwrap();
+    std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o700)).unwrap();
+    let result = std::process::Command::new(std::env::current_exe().unwrap())
+        .args(["--exact", "print_cmds::tests::spool_transport_streams_pdf_and_propagates_refusal", "--nocapture"])
+        .env(CHILD, dir.path())
+        .env("PATH", dir.path())
+        // The child spools into the fake `lp` above, so a shell that blocks real printing
+        // (`PHOTOCRAFT_NO_PRINT`, see `disabled_printing_never_spools`) must not stop it.
+        .env_remove("PHOTOCRAFT_NO_PRINT")
+        .output()
+        .unwrap();
+    assert!(result.status.success(), "{}\n{}", String::from_utf8_lossy(&result.stdout), String::from_utf8_lossy(&result.stderr));
+    assert!(String::from_utf8_lossy(&result.stdout).contains("1 passed"), "child must select the transport test");
+}
+
+#[test]
+fn disabled_printing_never_spools() {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
+    super::disable_printing();
+    assert!(super::printing_disabled());
+    let e = s.execute("file.print", json!({})).unwrap_err().to_string();
+    assert!(e.contains("printing is disabled"), "{e}");
+    assert!(s.execute("file.printOneCopy", json!({})).is_err());
+    // A dry run still renders and reports the command it would have run.
+    let r = s.execute("file.print", json!({"dryRun": true})).unwrap();
+    assert_eq!(r["sent"], false);
+    assert!(r["command"].is_array(), "{r}");
+}
+
+#[test]
+fn printers_lists_the_spooler_destinations_without_a_document() {
+    let mut s = Session::new();
+    let r = s.execute("file.printers", json!({})).unwrap();
+    let list = r["printers"].as_array().unwrap();
+    assert!(list.iter().all(|p| p["name"].is_string() && p["default"].is_boolean()));
+    match r["default"].as_str() {
+        Some(d) => assert!(list.iter().any(|p| p["name"] == d && p["default"] == true)),
+        None => assert!(list.iter().all(|p| p["default"] == false)),
+    }
+}
diff --git a/crates/engine/src/retouch_cmds.rs b/crates/engine/src/retouch_cmds.rs
index 9923f7a3dd..9ea7fd5975 100644
--- a/crates/engine/src/retouch_cmds.rs
+++ b/crates/engine/src/retouch_cmds.rs
@@ -26,7 +26,9 @@ use crate::{EngineError, Result, Session};
 mod content_aware_move;
 mod patch;
 mod pattern_stamp;
+mod periodic;
 mod remove;
+pub use content_aware_move::{ContentAwarePreview, preview as content_aware_move_preview};
 pub use patch::preview as patch_preview;
 
 fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
@@ -145,7 +147,7 @@ fn damage_json(r: Rect) -> Value {
 
 /// Which pixels Clone Stamp / Healing Brush sample.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum SampleLayers {
+pub(crate) enum SampleLayers {
     Current,
     CurrentAndBelow,
     All,
@@ -162,7 +164,7 @@ fn sample_layers(p: &Value, cmd: &str) -> Result<SampleLayers> {
 
 /// Composite pixels of `rect` in `fmt` (native channels): the whole document, or the target layer
 /// and everything below it.
-fn composite_region(pre: &Document, id: Option<LayerId>, which: SampleLayers, rect: Rect, fmt: PixelFormat) -> Region {
+pub(crate) fn composite_region(pre: &Document, id: Option<LayerId>, which: SampleLayers, rect: Rect, fmt: PixelFormat) -> Region {
     let mut doc = pre.clone();
     if which == SampleLayers::CurrentAndBelow
         && let Some(id) = id
@@ -205,6 +207,7 @@ fn clone_mapping(s: &mut Session, p: &Value, stroke: &Stroke, cmd: &str) -> Resu
 
 /// Source pixels for destination `rect`: a translated read, or a bilinear resample when the
 /// clone source is scaled, rotated or flipped.
+#[allow(clippy::too_many_arguments)]
 fn clone_sample(
     pre: &Document,
     id: Option<LayerId>,
@@ -212,8 +215,12 @@ fn clone_sample(
     which: SampleLayers,
     rect: Rect,
     map: &crate::presets::clone_source::Mapping,
+    wrap: bool,
     cmd: &str,
 ) -> Result<Region> {
+    let read = |rect| {
+        if wrap { periodic::sample(pre, id, surf, which, rect, cmd) } else { Ok(sample(pre, id, surf, which, rect)) }
+    };
     if map.is_translation() {
         let off = map.offset();
         let src = rect.translate(off.0, off.1);
@@ -222,17 +229,28 @@ fn clone_sample(
         if src.width() != rect.width() || src.height() != rect.height() {
             return Err(bad(cmd, format!("source offset [{}, {}] is too far: the sample window leaves the coordinate range", off.0, off.1)));
         }
-        let mut r = sample(pre, id, surf, which, src);
+        let mut r = read(src)?;
         r.rect = rect;
         return Ok(r);
     }
-    let src = sample(pre, id, surf, which, map.source_rect(rect));
+    let src = read(map.source_rect(rect))?;
     Ok(crate::presets::clone_source::resample(&src, rect, map, alpha_index(&surf.format())))
 }
 
 /// Read-only clone overlay. Shares the stroke sampler without anchoring a source or editing history.
 /// Both destination and transformed source allocations are bounded for interactive use.
 pub fn clone_preview(s: &Session, rect: Rect, map: &crate::presets::clone_source::Mapping, sample_layer: &str) -> Result<photocraft_compose::Buffer> {
+    clone_preview_periodic(s, rect, map, sample_layer, false)
+}
+
+/// Clone-source overlay with optional source repetition for View > Pattern Preview.
+pub fn clone_preview_periodic(
+    s: &Session,
+    rect: Rect,
+    map: &crate::presets::clone_source::Mapping,
+    sample_layer: &str,
+    wrap: bool,
+) -> Result<photocraft_compose::Buffer> {
     if ![map.source.0, map.source.1, map.anchor.0, map.anchor.1].into_iter().chain(map.m).all(|v| v.is_finite() && v.abs() < 1_000_000.0) {
         return Err(bad("clone.preview", "invalid preview mapping"));
     }
@@ -252,7 +270,7 @@ pub fn clone_preview(s: &Session, rect: Rect, map: &crate::presets::clone_source
     let id = d.active_layer.ok_or_else(|| bad("clone.preview", "no active layer"))?;
     let surf = d.doc.layer(id).and_then(|l| l.surface()).ok_or_else(|| bad("clone.preview", "no pixel surface"))?;
     let which = sample_layers(&json!({"sampleLayer": sample_layer}), "clone.preview")?;
-    let region = clone_sample(&d.doc, Some(id), surf, which, rect, map, "clone.preview")?;
+    let region = clone_sample(&d.doc, Some(id), surf, which, rect, map, wrap, "clone.preview")?;
     let px = region.data.chunks_exact(surf.format().channels()).map(|p| to_rgba(&surf.format(), p)).collect();
     Ok(photocraft_compose::Buffer { rect, px })
 }
@@ -297,15 +315,37 @@ fn clone_stamp(s: &mut Session, p: &Value) -> Result<Value> {
     let which = sample_layers(p, CMD)?;
     let mode = blend_param(p, CMD)?;
     let aligned = flag(p, "aligned", true);
+    // The live stroke the canvas already drew for exactly this commit: take its pixels instead of
+    // rendering the stroke again (the hitch on release).
+    let live = s.live_commit.take().filter(|l| l.matches(s, CMD, p, &stroke.points));
+    let from_live = live.is_some();
     let map = clone_mapping(s, p, &stroke, CMD)?;
     let off = map.offset();
-    let dmg = run_stroke(s, "Clone Stamp", id, p, |pre, surf, sel, lock| {
-        let (bounds, cov) = stroke_coverage(&stroke);
-        // Samples come from the pre-stroke state, so pixels painted earlier in the stroke are never re-cloned.
-        let paint = clone_sample(pre, id, surf, which, bounds, &map, CMD)?;
-        Ok(apply_coverage(surf, bounds, &cov, stroke.brush.opacity, sel, lock, &paint, mode))
-    })?;
-    Ok(clone_result(dmg, off, aligned, p, &stroke))
+    let dmg =
+        run_stroke(s, "Clone Stamp", id, p, |pre, surf, sel, lock| {
+            if let Some(l) = live {
+                *surf = l.surface;
+                return Ok(l.bounds);
+            }
+            if flag(p, "wrap", false) {
+                let mut renderer = photocraft_paint::StrokeRenderer::new(&stroke.brush, None, 1.0);
+                renderer.push(&stroke.points);
+                renderer.finish();
+                let before = surf.clone();
+                let bounds = renderer.bounds();
+                return periodic::Composite { target: surf, before: &before, tile: pre.bounds(), opacity: stroke.brush.opacity, selection: sel, lock, mode }
+                    .draw(bounds, &stroke.brush, &stroke.points, |r| clone_sample(pre, id, &before, which, r, &map, true, CMD));
+            }
+            let (bounds, cov) = stroke_coverage(&stroke);
+            // Samples come from the pre-stroke state, so pixels painted earlier in the stroke are never re-cloned.
+            let paint = clone_sample(pre, id, surf, which, bounds, &map, flag(p, "wrap", false), CMD)?;
+            Ok(apply_coverage(surf, bounds, &cov, stroke.brush.opacity, sel, lock, &paint, mode))
+        })?;
+    let mut r = clone_result(dmg, off, aligned, p, &stroke);
+    if from_live {
+        r["fromLive"] = json!(true);
+    }
+    Ok(r)
 }
 
 /// What a live retouching stroke paints through its coverage.
@@ -337,6 +377,11 @@ pub struct LiveRetouch {
     /// Where the doc shows what finishing the stroke now would add (a lone first dab, the
     /// smoothing catch-up), redrawn on every step as the Brush's live stroke does.
     tail: Rect,
+    /// The document and revision the stroke started on.
+    base: (photocraft_doc::DocId, u64),
+    brush: Box<BrushSettings>,
+    /// Every point rendered so far, in order.
+    points: Vec<StrokePoint>,
 }
 
 impl LiveRetouch {
@@ -358,7 +403,8 @@ impl LiveRetouch {
             "paint.historyBrush" => LivePaint::History(history_source(s, id, p, cmd)?),
             other => return Err(bad(other, "live retouching strokes are the Clone Stamp, Healing Brush and History Brush")),
         };
-        let pre = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
+        let st = s.active().ok_or(EngineError::NoDocument)?;
+        let (pre, base) = (st.doc.clone(), (st.doc.id, st.revision));
         let mut doc = (*pre).clone();
         let sel = doc.selection.clone();
         let (surf, lock) = crate::channel_cmds::target_surface(&mut doc, id, p)?;
@@ -366,6 +412,7 @@ impl LiveRetouch {
         // As `stroke_coverage`, which the commit uses.
         let renderer = photocraft_paint::StrokeRenderer::new(&stroke.brush, None, 1.0);
         let opacity = stroke.brush.opacity;
+        let brush = Box::new(stroke.brush.clone());
         let paint = match paint {
             LivePaint::History(src) if src.format() != pre_surf.format() => LivePaint::History(src.convert(pre_surf.format())),
             other => other,
@@ -384,6 +431,9 @@ impl LiveRetouch {
             sel,
             lock,
             tail: Rect::EMPTY,
+            base,
+            brush,
+            points: Vec::new(),
         };
         live.push(&stroke.points)?;
         Ok(live)
@@ -391,7 +441,40 @@ impl LiveRetouch {
 
     /// Everything the stroke has touched so far.
     pub fn bounds(&self) -> Rect {
-        self.renderer.bounds().union(&self.tail)
+        let bounds = self.renderer.bounds().union(&self.tail);
+        if self.cmd == "paint.cloneStamp" && flag(&self.params, "wrap", false) {
+            periodic::project(bounds, self.pre.bounds()).into_iter().fold(Rect::EMPTY, |a, b| a.union(&b))
+        } else {
+            bounds
+        }
+    }
+
+    /// Every point rendered so far, in order.
+    pub fn points(&self) -> &[StrokePoint] {
+        &self.points
+    }
+
+    /// The finished stroke as its commit would take it over ([`Session::offer_live_retouch`]).
+    /// Only the Clone Stamp and History Brush draw what they commit (the Healing Brush blends on
+    /// release), and only while the brush, layer and clone source are still the ones the stroke
+    /// started with: the document revision doesn't cover those.
+    pub(crate) fn into_commit(mut self, s: &Session) -> Result<crate::brush_cmds::LiveCommit> {
+        let (stroke, id) = parse_brush(s, &self.params, &self.cmd)?;
+        let source_unchanged = match &self.paint {
+            LivePaint::Clone { map, .. } if self.cmd == "paint.cloneStamp" => {
+                let f = stroke.points.first().ok_or_else(|| bad(&self.cmd, "`points` is empty"))?;
+                crate::presets::clone_source::resolve(s, &self.params, (f.x, f.y), &self.cmd)?.0 == *map
+            }
+            LivePaint::History(_) if self.cmd == "paint.historyBrush" => true,
+            _ => return Err(bad(&self.cmd, "only Clone Stamp and History Brush strokes commit their live pixels")),
+        };
+        if !source_unchanged || *self.brush != stroke.brush || id != self.id {
+            return Err(bad(&self.cmd, "the brush, layer or clone source changed during the stroke"));
+        }
+        let bounds = self.bounds();
+        let (surf, _) = crate::channel_cmds::target_surface(std::sync::Arc::make_mut(&mut self.doc), self.id, &self.params)?;
+        let surface = surf.clone();
+        Ok(crate::brush_cmds::LiveCommit { cmd: self.cmd, base: self.base, params: self.params, seed: None, points: self.points, surface, bounds })
     }
 
     /// Render more points; returns the rectangle that changed. Each changed area is redrawn from
@@ -400,9 +483,15 @@ impl LiveRetouch {
     /// the stroke now would add is drawn too (a lone first dab shows on the press), and redrawn on
     /// every step.
     /// Invalid coordinates reject the whole batch without changing the preview.
+    /// Only the position and pressure of `pts` are used: the commands take no tilt or times.
     pub fn push(&mut self, pts: &[StrokePoint]) -> Result<Rect> {
         crate::brush_cmds::check_coords(pts, &self.cmd)?;
-        self.renderer.push(pts);
+        let pts: Vec<_> = pts.iter().map(|q| StrokePoint::new(q.x, q.y, q.pressure)).collect();
+        self.points.extend_from_slice(&pts);
+        self.renderer.push(&pts);
+        if self.cmd == "paint.cloneStamp" && flag(&self.params, "wrap", false) {
+            return self.push_periodic();
+        }
         let old = std::mem::replace(&mut self.tail, Rect::EMPTY);
         let mut dmg = Rect::EMPTY;
         if !old.is_empty() {
@@ -424,13 +513,36 @@ impl LiveRetouch {
         Ok(dmg)
     }
 
+    fn push_periodic(&mut self) -> Result<Rect> {
+        let mut dirty = self.renderer.take_dirty_rect().union(&self.tail);
+        let mut tail = self.renderer.tail_preview();
+        self.tail = tail.as_mut().map_or(Rect::EMPTY, |t| t.take_dirty_rect());
+        dirty = dirty.union(&self.tail);
+        let LivePaint::Clone { which, map, cmd } = &self.paint else {
+            return Err(bad(&self.cmd, "periodic painting requires a clone source"));
+        };
+        let (surf, _) = crate::channel_cmds::target_surface(std::sync::Arc::make_mut(&mut self.doc), self.id, &self.params)?;
+        periodic::Composite {
+            target: surf,
+            before: &self.pre_surf,
+            tile: self.pre.bounds(),
+            opacity: self.opacity,
+            selection: self.sel.as_ref(),
+            lock: self.lock,
+            mode: self.mode,
+        }
+        .draw(dirty, &self.brush, &self.points, |r| clone_sample(&self.pre, self.id, &self.pre_surf, *which, r, map, true, cmd))
+    }
+
     /// Redraw `r` from the pre-stroke pixels with the clone source through coverage `cov`.
     fn composite(&mut self, r: Rect, cov: &[f32]) -> Result<Rect> {
         if r.is_empty() {
             return Ok(r);
         }
         let paint = match &self.paint {
-            LivePaint::Clone { which, map, cmd } => clone_sample(&self.pre, self.id, &self.pre_surf, *which, r, map, cmd)?,
+            LivePaint::Clone { which, map, cmd } => {
+                clone_sample(&self.pre, self.id, &self.pre_surf, *which, r, map, *cmd == "paint.cloneStamp" && flag(&self.params, "wrap", false), cmd)?
+            }
             LivePaint::History(src) => Region::read(src, r),
         };
         let (surf, _) = crate::channel_cmds::target_surface(std::sync::Arc::make_mut(&mut self.doc), self.id, &self.params)?;
@@ -489,7 +601,7 @@ fn healing_brush(s: &mut Session, p: &Value) -> Result<Value> {
         let (bounds, cov) = stroke_coverage(&stroke);
         let (g, cov) = pad_coverage(bounds, &cov, 2);
         let fmt = surf.format();
-        let src = clone_sample(pre, id, surf, which, g, &map, CMD)?;
+        let src = clone_sample(pre, id, surf, which, g, &map, false, CMD)?;
         // The destination the texture is fitted to: the layer itself, or what the user sees when
         // sampling several layers (so healing onto an empty layer matches the composite).
         let dst = if which == SampleLayers::Current { Region::read(surf, g) } else { composite_region(pre, id, which, g, fmt) };
@@ -519,15 +631,25 @@ fn history_brush(s: &mut Session, p: &Value) -> Result<Value> {
     const CMD: &str = "paint.historyBrush";
     let (stroke, id) = parse_brush(s, p, CMD)?;
     let mode = blend_param(p, CMD)?;
+    let live = s.live_commit.take().filter(|l| l.matches(s, CMD, p, &stroke.points));
+    let from_live = live.is_some();
     let src_surface = history_source(s, id, p, CMD)?;
     let dmg = run_stroke(s, "History Brush", id, p, |_, surf, sel, lock| {
+        if let Some(l) = live {
+            *surf = l.surface;
+            return Ok(l.bounds);
+        }
         let fmt = surf.format();
         let src = if src_surface.format() == fmt { src_surface } else { src_surface.convert(fmt) };
         let (bounds, cov) = stroke_coverage(&stroke);
         let paint = Region::read(&src, bounds);
         Ok(apply_coverage(surf, bounds, &cov, stroke.brush.opacity, sel, lock, &paint, mode))
     })?;
-    Ok(json!({ "damage": damage_json(dmg) }))
+    let mut r = json!({ "damage": damage_json(dmg) });
+    if from_live {
+        r["fromLive"] = json!(true);
+    }
+    Ok(r)
 }
 
 // ---------------------------------------------------------------------------------------------
@@ -1104,7 +1226,7 @@ pub fn specs() -> Vec<CommandSpec> {
             menu: &[],
             shortcut: None,
             params: brush_params!(
-                r#","source":[sx,sy] (sampled under the first point) | "offset":[dx,dy],"aligned":bool=true,"sampleLayer":"current|currentAndBelow|all"="current","mode":"normal|multiply|…"="normal" → {"damage","offset","aligned","nextSource"}"#
+                r#","source":[sx,sy] (sampled under the first point) | "offset":[dx,dy],"aligned":bool=true,"sampleLayer":"current|currentAndBelow|all"="current","mode":"normal|multiply|…"="normal","wrap":bool=false (repeat source and stroke at document edges for Pattern Preview) → {"damage","offset","aligned","nextSource"}"#
             ),
             enabled: has_pixel_layer,
             run: clone_stamp,
@@ -1170,7 +1292,7 @@ pub fn specs() -> Vec<CommandSpec> {
             menu: &[],
             shortcut: None,
             params: brush_params!(
-                r#","closeLoops":bool=true (a stroke around an object removes what it encloses),"sampleAllLayers":bool=false → {"damage"} (a background job)"#
+                r#","strokes":[[[x,y,pressure?],…],…]? (several strokes removed together, as one job and one undo step; else "points"),"closeLoops":bool=true (a stroke around an object removes what it encloses),"sampleAllLayers":bool=false,"newLayer":bool=false (the fill goes to a new layer above the target, which stays as it was) → {"damage","layer"?} (a background job)"#
             ),
             enabled: has_pixel_layer,
             run: remove::remove,
diff --git a/crates/engine/src/retouch_cmds/content_aware_move.rs b/crates/engine/src/retouch_cmds/content_aware_move.rs
index 120c8b7c02..ddca9c6e0f 100644
--- a/crates/engine/src/retouch_cmds/content_aware_move.rs
+++ b/crates/engine/src/retouch_cmds/content_aware_move.rs
@@ -96,6 +96,8 @@ struct Plan {
     mode: Mode,
     structure: u8,
     color: u8,
+    /// Most pixels the fills may sample around the content ([`MAX_MARGIN`], less for a preview).
+    margin: i32,
 }
 
 /// Transform On Drop's `scaleX` / `scaleY` (%) and `rotate` (degrees): the map from a source point
@@ -193,7 +195,7 @@ fn landed_mask(cov: &[f32], area: Rect, inv: &Homography, rect: Rect) -> Vec<boo
         .collect()
 }
 
-fn plan(s: &Session, p: &Value) -> Result<Plan> {
+fn plan(s: &Session, p: &Value, margin: i32) -> Result<Plan> {
     let mode = match string(p, "mode", "move") {
         "move" => Mode::Move,
         "extend" => Mode::Extend,
@@ -242,7 +244,7 @@ fn plan(s: &Session, p: &Value) -> Result<Plan> {
         }
     };
     let all_layers = flag(p, "sampleAllLayers", false) && targets_pixels(p);
-    Ok(Plan { target: Target { id, all_layers }, canvas, area, offset: (dx, dy), map, dest, mode, structure, color })
+    Ok(Plan { target: Target { id, all_layers }, canvas, area, offset: (dx, dy), map, dest, mode, structure, color, margin })
 }
 
 /// Width in pixels of the edge band re-synthesised at the new place, for Structure 1..7 and content
@@ -293,7 +295,12 @@ fn erode(w: usize, h: usize, m: &[bool], r: usize) -> Vec<bool> {
 /// Where a fill samples from around `r`: Photoshop's Content-Aware window
 /// ([`crate::fill_cmds::sampling_window`]), at most [`MAX_MARGIN`] pixels around `r`.
 pub(super) fn window(r: Rect, canvas: Rect) -> Rect {
-    crate::fill_cmds::sampling_window(r, canvas).intersect(&r.inflate(MAX_MARGIN))
+    window_within(r, canvas, MAX_MARGIN)
+}
+
+/// [`window`] with at most `margin` pixels around `r`.
+fn window_within(r: Rect, canvas: Rect, margin: i32) -> Rect {
+    crate::fill_cmds::sampling_window(r, canvas).intersect(&r.inflate(margin))
 }
 
 /// The pixels a step works on: the targeted surface, or with Sample All Layers the visible
@@ -433,7 +440,7 @@ fn run_move(doc: &mut Document, sel: &Surface, plan: &Plan, p: &Value, ctx: &cra
 
     // 1. The content at its new place: the content with its original surroundings laid over the
     // window there; never sampling the content's old place.
-    let win = window(plan.dest, plan.canvas);
+    let win = window_within(plan.dest, plan.canvas, plan.margin);
     let (content, moved) = match &inv {
         None => {
             let mut content = read(doc, plan.target, p, win.translate(-dx, -dy))?;
@@ -443,7 +450,7 @@ fn run_move(doc: &mut Document, sel: &Surface, plan: &Plan, p: &Value, ctx: &cra
         Some(inv) => {
             // Only the content and a ring around it (the colour fit's reference) matter: read
             // the source behind that, a few pixels past the area, and resample it.
-            let src = mapped_bounds(inv, plan.dest.inflate(8)).intersect(&plan.area.inflate(MAX_MARGIN)).intersect(&plan.canvas);
+            let src = mapped_bounds(inv, plan.dest.inflate(8)).intersect(&plan.area.inflate(plan.margin)).intersect(&plan.canvas);
             let src = if src.is_empty() { plan.area } else { src };
             (resample(&read(doc, plan.target, p, src)?, inv, win), landed_mask(&cov, plan.area, inv, win))
         }
@@ -454,7 +461,7 @@ fn run_move(doc: &mut Document, sel: &Surface, plan: &Plan, p: &Value, ctx: &cra
     // 2. Move: fill the place the content left (where the content didn't land on it).
     if plan.mode == Mode::Move {
         ctx.check()?;
-        let win = window(plan.area, plan.canvas);
+        let win = window_within(plan.area, plan.canvas, plan.margin);
         let (w, h) = (win.width() as usize, win.height() as usize);
         let img = read(doc, plan.target, p, win)?;
         let landed = match &inv {
@@ -478,7 +485,7 @@ fn run_move(doc: &mut Document, sel: &Surface, plan: &Plan, p: &Value, ctx: &cra
 }
 
 pub(super) fn content_aware_move(s: &mut Session, p: &Value) -> Result<Value> {
-    let plan = plan(s, p)?;
+    let plan = plan(s, p, MAX_MARGIN)?;
     let label = if plan.mode == Mode::Move { "Content-Aware Move" } else { "Content-Aware Extend" };
     let d = s.active().ok_or(EngineError::NoDocument)?;
     let doc = d.doc.clone();
@@ -520,3 +527,40 @@ pub(super) fn content_aware_move(s: &mut Session, p: &Value) -> Result<Value> {
         },
     )
 }
+
+/// Largest selection (bounding box, in pixels) the live preview computes.
+const PREVIEW_MAX_PIXELS: u64 = 256 * 256;
+/// Sampling margin of a preview: a fraction of the command's, so a preview is a small solve.
+const PREVIEW_MARGIN: i32 = 48;
+
+/// A live preview of `paint.contentAwareMove` that can run on any thread: the document as of
+/// [`preview`], with the move's params. Cheaper than the command (a small sampling margin, and
+/// only small selections), so the result is close to, not the same as, what the command makes.
+pub struct ContentAwarePreview {
+    doc: std::sync::Arc<Document>,
+    plan: Plan,
+    params: Value,
+}
+
+impl ContentAwarePreview {
+    /// The active document with the move applied (nothing is recorded, the session is not
+    /// touched) and the rectangle it changed. Stops with `Cancelled` once `ctx` is cancelled.
+    pub fn run(&self, ctx: &crate::jobs::JobCtx) -> Result<(Document, Rect)> {
+        let mut work = (*self.doc).clone();
+        let sel = self.doc.selection.as_ref().ok_or_else(|| bad(CMD, "select the area to move first"))?;
+        let (_, damage, _) = run_move(&mut work, sel, &self.plan, &self.params, ctx, "Content-Aware Move preview")?;
+        Ok((work, damage))
+    }
+}
+
+/// Prepare the preview of `paint.contentAwareMove` with params `p` on the active document. Errors
+/// like the command does, and for a selection larger than a preview takes.
+pub fn preview(s: &Session, p: &Value) -> Result<ContentAwarePreview> {
+    let plan = plan(s, p, PREVIEW_MARGIN)?;
+    let pixels = u64::from(plan.area.width()) * u64::from(plan.area.height());
+    if pixels > PREVIEW_MAX_PIXELS {
+        return Err(bad(CMD, format!("the selection is too large to preview ({pixels} pixels, at most {PREVIEW_MAX_PIXELS})")));
+    }
+    let d = s.active().ok_or(EngineError::NoDocument)?;
+    Ok(ContentAwarePreview { doc: d.doc.clone(), plan, params: p.clone() })
+}
diff --git a/crates/engine/src/retouch_cmds/pattern_stamp.rs b/crates/engine/src/retouch_cmds/pattern_stamp.rs
index cb9e0adfe9..0dc9f102ac 100644
--- a/crates/engine/src/retouch_cmds/pattern_stamp.rs
+++ b/crates/engine/src/retouch_cmds/pattern_stamp.rs
@@ -45,7 +45,7 @@ pub(super) fn run(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad(CMD, "`points` is empty"));
     };
     let phase = stamp_phase(p, CMD, aligned, first)?;
-    let tile = Tile::new(&pat).ok_or_else(|| bad(CMD, "the pattern is empty"))?;
+    let tile = Tile::new(&pat).ok_or_else(|| bad(CMD, "the pattern is empty or too large to paint"))?;
     reject_huge_stroke(CMD, &stroke)?;
 
     let seed = p.get("seed").and_then(Value::as_u64).unwrap_or_else(|| {
diff --git a/crates/engine/src/retouch_cmds/periodic.rs b/crates/engine/src/retouch_cmds/periodic.rs
new file mode 100644
index 0000000000..f31542fb5a
--- /dev/null
+++ b/crates/engine/src/retouch_cmds/periodic.rs
@@ -0,0 +1,272 @@
+//! Bounded reads from the repeating document tile used by Pattern Preview.
+
+use super::*;
+
+/// At most four disjoint rectangles in the document tile. Projecting the dirty area separately
+/// from the stroke bounds avoids scanning the whole document when a small dab crosses a seam.
+pub(super) fn project(rect: Rect, tile: Rect) -> Vec<Rect> {
+    if rect.is_empty() || tile.is_empty() {
+        return Vec::new();
+    }
+    let axis = |a: i32, b: i32, lo: i32, hi: i32| {
+        let period = i64::from(hi) - i64::from(lo);
+        let length = i64::from(b) - i64::from(a);
+        if length >= period {
+            return vec![(lo, hi)];
+        }
+        let start = i64::from(lo) + (i64::from(a) - i64::from(lo)).rem_euclid(period);
+        let end = start + length;
+        if end <= i64::from(hi) { vec![(start as i32, end as i32)] } else { vec![(start as i32, hi), (lo, (i64::from(lo) + end - i64::from(hi)) as i32)] }
+    };
+    let xs = axis(rect.x0, rect.x1, tile.x0, tile.x1);
+    let ys = axis(rect.y0, rect.y1, tile.y0, tile.y1);
+    ys.into_iter().flat_map(|(y0, y1)| xs.iter().map(move |&(x0, x1)| Rect::new(x0, y0, x1, y1))).collect()
+}
+
+/// Composite periodic copies of one stroke, restoring each dirty patch from pre-stroke pixels.
+/// Each dab wraps once, then builds flow towards its opacity ceiling. Stroke opacity and
+/// selection are applied once after all dabs, including repeated visits through other tiles.
+pub(super) struct Composite<'a> {
+    pub target: &'a mut Surface,
+    pub before: &'a Surface,
+    pub tile: Rect,
+    pub opacity: f32,
+    pub selection: Option<&'a Surface>,
+    pub lock: bool,
+    pub mode: BlendMode,
+}
+
+impl Composite<'_> {
+    pub fn draw(&mut self, dirty: Rect, brush: &BrushSettings, points: &[StrokePoint], mut paint: impl FnMut(Rect) -> Result<Region>) -> Result<Rect> {
+        let ctx = photocraft_paint::BrushContext::new(brush);
+        let mut generator = photocraft_paint::dynamics::DabGenerator::new(brush, 1.0);
+        let (mut primary, mut dual) = (Vec::new(), Vec::new());
+        generator.push(points, &mut primary, &mut dual);
+        generator.finish(&mut primary, &mut dual);
+        let primary: Vec<_> = primary
+            .into_iter()
+            .map(|d| {
+                let r = ctx.dab_rect(&d, false);
+                (d, r)
+            })
+            .collect();
+        let dual: Vec<_> = dual
+            .into_iter()
+            .map(|d| {
+                let r = ctx.dab_rect(&d, true);
+                (d, r)
+            })
+            .collect();
+        let mut damage = Rect::EMPTY;
+        let mut work = 0_u64;
+        for rect in project(dirty, self.tile) {
+            let mut y = rect.y0;
+            while y < rect.y1 {
+                let y1 = y.saturating_add(64).min(rect.y1);
+                let mut x = rect.x0;
+                while x < rect.x1 {
+                    let x1 = x.saturating_add(64).min(rect.x1);
+                    let dst = Rect::new(x, y, x1, y1);
+                    let mut stroke = PatchStroke::new(dst, self.target.channels());
+                    let mut dual_stroke = PatchStroke::new(dst, 1);
+                    let alpha = alpha_index(&self.target.format());
+                    for (dab, bounds) in &primary {
+                        if !project(*bounds, self.tile).iter().any(|r| !r.intersect(&dst).is_empty()) {
+                            continue;
+                        }
+                        let footprint = self.fold_dab(&ctx, dab, *bounds, dst, false, &mut paint, &mut work)?;
+                        stroke.accumulate(dab, &footprint, alpha);
+                    }
+                    for (dab, bounds) in &dual {
+                        if !project(*bounds, self.tile).iter().any(|r| !r.intersect(&dst).is_empty()) {
+                            continue;
+                        }
+                        let footprint = self.fold_dab(&ctx, dab, *bounds, dst, true, &mut paint, &mut work)?;
+                        let mut dab = *dab;
+                        dab.opacity = 1.0;
+                        dual_stroke.accumulate(&dab, &footprint, None);
+                    }
+                    stroke.normalize(alpha);
+                    for py in dst.y0..dst.y1 {
+                        for px in dst.x0..dst.x1 {
+                            let i = stroke.paint.index(px, py);
+                            let depth = brush.wet_edges.then(|| stroke.depth.get(i).copied().unwrap_or(0.0));
+                            let dual = brush.dual_brush.enabled.then(|| dual_stroke.coverage.get(i).copied().unwrap_or(0.0));
+                            if let Some(c) = stroke.coverage.get_mut(i) {
+                                *c = ctx.stroke_mask_wet(*c, depth, dual, px, py);
+                            }
+                        }
+                    }
+                    self.target.write_region(dst, &self.before.read_region(dst));
+                    apply_coverage(self.target, dst, &stroke.coverage, self.opacity, self.selection, self.lock, &stroke.paint, self.mode);
+                    damage = damage.union(&dst);
+                    x = x1;
+                }
+                y = y1;
+            }
+        }
+        Ok(damage)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn fold_dab(
+        &self,
+        ctx: &photocraft_paint::BrushContext,
+        dab: &photocraft_paint::Dab,
+        bounds: Rect,
+        dst: Rect,
+        dual: bool,
+        paint: &mut impl FnMut(Rect) -> Result<Region>,
+        work: &mut u64,
+    ) -> Result<PatchStroke> {
+        let mut result = PatchStroke::new(dst, if dual { 1 } else { self.target.channels() });
+        let (w, h) = (i64::from(self.tile.width()), i64::from(self.tile.height()));
+        let nx0 = (i64::from(bounds.x0) - i64::from(dst.x1)).div_euclid(w) + 1;
+        let nx1 = (i64::from(bounds.x1) - 1 - i64::from(dst.x0)).div_euclid(w);
+        let ny0 = (i64::from(bounds.y0) - i64::from(dst.y1)).div_euclid(h) + 1;
+        let ny1 = (i64::from(bounds.y1) - 1 - i64::from(dst.y0)).div_euclid(h);
+        let (mut values, mut depths) = (Vec::new(), Vec::new());
+        let wet = ctx.brush.wet_edges && !dual;
+        for ny in ny0..=ny1 {
+            for nx in nx0..=nx1 {
+                let (dx, dy) = (nx * w, ny * h);
+                let r = Rect::new(
+                    (i64::from(dst.x0) + dx).max(i64::from(bounds.x0)) as i32,
+                    (i64::from(dst.y0) + dy).max(i64::from(bounds.y0)) as i32,
+                    (i64::from(dst.x1) + dx).min(i64::from(bounds.x1)) as i32,
+                    (i64::from(dst.y1) + dy).min(i64::from(bounds.y1)) as i32,
+                );
+                *work = work.saturating_add(r.width() as u64 * r.height() as u64);
+                if *work > 64 * 1024 * 1024 {
+                    return Err(bad("paint.cloneStamp", "wrapped stroke exceeds its coverage budget"));
+                }
+                ctx.rasterize_into(dab, dual, r, &mut values, wet.then_some(&mut depths));
+                let mut sampled = None;
+                for sy in r.y0..r.y1 {
+                    for sx in r.x0..r.x1 {
+                        let source_index = ((sy - r.y0) as usize) * r.width() as usize + (sx - r.x0) as usize;
+                        let value = values.get(source_index).copied().unwrap_or(0.0);
+                        if value <= 0.0 {
+                            continue;
+                        }
+                        let (tx, ty) = ((i64::from(sx) - dx) as i32, (i64::from(sy) - dy) as i32);
+                        let i = result.paint.index(tx, ty);
+                        if let Some(depth) = result.depth.get_mut(i) {
+                            *depth = depth.max(depths.get(source_index).copied().unwrap_or(0.0));
+                        }
+                        let Some(previous) = result.coverage.get_mut(i) else { continue };
+                        if value <= *previous {
+                            continue;
+                        }
+                        if !dual {
+                            if sampled.is_none() {
+                                sampled = Some(paint(r)?);
+                            }
+                            if let Some(source) = &sampled {
+                                result.paint.px_mut(tx, ty).copy_from_slice(source.px(sx, sy));
+                            }
+                        }
+                        *previous = value;
+                    }
+                }
+            }
+        }
+        Ok(result)
+    }
+}
+
+struct PatchStroke {
+    coverage: Vec<f32>,
+    depth: Vec<f32>,
+    // Native colours weighted by coverage and source alpha; alpha weighted by coverage.
+    paint: Region,
+}
+
+impl PatchStroke {
+    fn new(rect: Rect, channels: usize) -> Self {
+        let len = rect.width() as usize * rect.height() as usize;
+        Self { coverage: vec![0.0; len], depth: vec![0.0; len], paint: Region::new(rect, channels) }
+    }
+
+    fn accumulate(&mut self, dab: &photocraft_paint::Dab, footprint: &PatchStroke, alpha: Option<usize>) {
+        let rect = self.paint.rect;
+        for y in rect.y0..rect.y1 {
+            for x in rect.x0..rect.x1 {
+                let i = self.paint.index(x, y);
+                let Some(c) = self.coverage.get_mut(i) else { continue };
+                let value = footprint.coverage.get(i).copied().unwrap_or(0.0);
+                if value <= 0.0 {
+                    continue;
+                }
+                if let Some(depth) = self.depth.get_mut(i) {
+                    *depth = depth.max(footprint.depth.get(i).copied().unwrap_or(0.0));
+                }
+                if dab.opacity <= *c {
+                    continue;
+                }
+                let next = *c + value * (dab.opacity - *c);
+                let weight = next - *c;
+                let source = footprint.paint.px(x, y);
+                let sa = alpha.and_then(|a| source.get(a)).copied().unwrap_or(1.0);
+                for (channel, (dst, src)) in self.paint.px_mut(x, y).iter_mut().zip(source).enumerate() {
+                    *dst += if Some(channel) == alpha { weight * sa } else { weight * sa * src };
+                }
+                *c = next;
+            }
+        }
+    }
+
+    fn normalize(&mut self, alpha: Option<usize>) {
+        let rect = self.paint.rect;
+        for y in rect.y0..rect.y1 {
+            for x in rect.x0..rect.x1 {
+                let i = self.paint.index(x, y);
+                let coverage = self.coverage.get(i).copied().unwrap_or(0.0);
+                let px = self.paint.px_mut(x, y);
+                let weight = alpha.and_then(|a| px.get(a)).copied().unwrap_or(coverage);
+                for (channel, value) in px.iter_mut().enumerate() {
+                    let denominator = if Some(channel) == alpha { coverage } else { weight };
+                    *value = if denominator > 0.0 { *value / denominator } else { 0.0 };
+                }
+            }
+        }
+    }
+}
+
+pub(super) fn sample(pre: &Document, id: Option<LayerId>, surf: &Surface, which: SampleLayers, rect: Rect, cmd: &str) -> Result<Region> {
+    let tile = pre.bounds();
+    if tile.is_empty() {
+        return Err(bad(cmd, "cannot repeat an empty document"));
+    }
+    if rect.is_empty() {
+        return Ok(Region::new(Rect::EMPTY, surf.channels()));
+    }
+    let (w, h, n) = (rect.width() as usize, rect.height() as usize, surf.channels());
+    let len = w
+        .checked_mul(h)
+        .and_then(|v| v.checked_mul(n))
+        .filter(|&v| v <= 16 * 1024 * 1024)
+        .ok_or_else(|| bad(cmd, "periodic source window exceeds its 64 MiB budget"))?;
+    let mut out = Region { rect, ch: n, data: vec![0.0; len] };
+    // Split at tile seams. Read only the required rectangles, including the bilinear apron,
+    // rather than allocating or compositing the entire document for a small clone dab.
+    let mut dy = 0;
+    while dy < h {
+        let sy = (i64::from(rect.y0) + dy as i64 - i64::from(tile.y0)).rem_euclid(i64::from(tile.height())) as i32 + tile.y0;
+        let rows = (h - dy).min((tile.y1 - sy) as usize);
+        let mut dx = 0;
+        while dx < w {
+            let sx = (i64::from(rect.x0) + dx as i64 - i64::from(tile.x0)).rem_euclid(i64::from(tile.width())) as i32 + tile.x0;
+            let cols = (w - dx).min((tile.x1 - sx) as usize);
+            let part = super::sample(pre, id, surf, which, Rect::new(sx, sy, sx + cols as i32, sy + rows as i32));
+            for (dst, src) in out.data.chunks_exact_mut(w * n).skip(dy).take(rows).zip(part.data.chunks_exact(cols * n)) {
+                if let Some(dst) = dst.get_mut(dx * n..(dx + cols) * n) {
+                    dst.copy_from_slice(src);
+                }
+            }
+            dx += cols;
+        }
+        dy += rows;
+    }
+    Ok(out)
+}
diff --git a/crates/engine/src/retouch_cmds/remove.rs b/crates/engine/src/retouch_cmds/remove.rs
index 889cd2c1d3..4e256fb7fc 100644
--- a/crates/engine/src/retouch_cmds/remove.rs
+++ b/crates/engine/src/retouch_cmds/remove.rs
@@ -7,10 +7,17 @@
 //! selection, when there is one, limits what changes. Large holes take seconds, so the command
 //! runs as a background job (#210): with progress, cancellable, and the document unchanged until
 //! it applies, in one undo step.
+//!
+//! Several strokes can go in one removal (`strokes`): Photoshop's *Remove after each stroke*
+//! off, where the strokes collect and are applied together, so the fill sees every hole at once
+//! instead of sampling from an area the next stroke is about to remove. With `newLayer` the fill
+//! lands on a new layer above the target, only where the hole is, and the target stays as it was
+//! (Photoshop's *Create a new layer*; with Sample All Layers it fills from the composite).
 
 use super::content_aware_move::{Target, replace};
 use super::patch::coverage;
 use super::*;
+use photocraft_doc::Layer;
 
 const CMD: &str = "paint.remove";
 
@@ -38,11 +45,14 @@ fn sampling_margin(area: Rect) -> i32 {
 /// What a removal does, checked before any work starts.
 struct Plan {
     id: Option<LayerId>,
-    stroke: Stroke,
-    /// Where the fill samples from: the stroke plus a margin, on the canvas.
+    /// One stroke (`points`), or several applied together (`strokes`).
+    strokes: Vec<Stroke>,
+    /// Where the fill samples from: the strokes plus a margin, on the canvas.
     window: Rect,
     close_loops: bool,
     all_layers: bool,
+    /// The fill goes to a new layer above the target instead of into it.
+    new_layer: bool,
 }
 
 /// The stroke's bounding box (points ± the brush radius), before any coverage is rendered.
@@ -56,11 +66,37 @@ fn stroke_bounds(stroke: &Stroke) -> Rect {
     Rect::new((x0 - r).floor() as i32, (y0 - r).floor() as i32, (x1 + r).ceil() as i32, (y1 + r).ceil() as i32)
 }
 
+/// The strokes of the request: `strokes` (several, each a list of points, sharing the brush
+/// and the target) or the one in `points`.
+fn parse_strokes(s: &Session, p: &Value) -> Result<(Vec<Stroke>, Option<LayerId>)> {
+    let Some(list) = p.get("strokes") else {
+        let (stroke, id) = parse_brush(s, p, CMD)?;
+        return Ok((vec![stroke], id));
+    };
+    let list = list.as_array().ok_or_else(|| bad(CMD, "`strokes` is a list of point lists"))?;
+    if list.is_empty() {
+        return Err(bad(CMD, "`strokes` is empty"));
+    }
+    let mut strokes = Vec::with_capacity(list.len());
+    let mut id = None;
+    for points in list {
+        let mut one = p.clone();
+        if let Some(o) = one.as_object_mut() {
+            o.remove("strokes");
+            o.insert("points".into(), points.clone());
+        }
+        let (stroke, layer) = parse_brush(s, &one, CMD)?;
+        strokes.push(stroke);
+        id = layer;
+    }
+    Ok((strokes, id))
+}
+
 fn plan(s: &Session, p: &Value) -> Result<Plan> {
-    let (stroke, id) = parse_brush(s, p, CMD)?;
+    let (strokes, id) = parse_strokes(s, p)?;
     let d = s.active().ok_or(EngineError::NoDocument)?;
     let canvas = d.doc.bounds();
-    let bounds = stroke_bounds(&stroke);
+    let bounds = strokes.iter().map(stroke_bounds).reduce(|a, b| a.union(&b)).ok_or_else(|| bad(CMD, "`strokes` is empty"))?;
     let pixels = u64::from(bounds.width()) * u64::from(bounds.height());
     if pixels > MAX_PIXELS {
         return Err(bad(CMD, format!("the stroke is too large to remove ({pixels} pixels, at most {MAX_PIXELS})")));
@@ -72,23 +108,27 @@ fn plan(s: &Session, p: &Value) -> Result<Plan> {
     let window = area.inflate(sampling_margin(area).min(MAX_MARGIN)).intersect(&canvas);
     let close_loops = flag(p, "closeLoops", true);
     let all_layers = flag(p, "sampleAllLayers", false) && targets_pixels(p);
-    Ok(Plan { id, stroke, window, close_loops, all_layers })
+    // A mask or channel has no "above": the fill goes where the stroke went.
+    let new_layer = flag(p, "newLayer", false) && targets_pixels(p);
+    Ok(Plan { id, strokes, window, close_loops, all_layers, new_layer })
 }
 
-/// The hole over the plan's window: the stroke's footprint, its enclosed areas and a margin,
+/// The hole over the plan's window: the strokes' footprints, their enclosed areas and a margin,
 /// limited to the selection. Empty when nothing would change.
 fn hole(plan: &Plan, sel: Option<&Surface>) -> Vec<bool> {
     let win = plan.window;
     let (w, h) = (win.width() as usize, win.height() as usize);
-    let (bounds, cov) = stroke_coverage(&plan.stroke);
     let mut m = vec![false; w * h];
-    let bw = bounds.width() as usize;
-    for (i, c) in cov.iter().enumerate() {
-        let (x, y) = (bounds.x0 + (i % bw.max(1)) as i32, bounds.y0 + (i / bw.max(1)) as i32);
-        if *c > 0.0 && win.contains(x, y) {
-            let j = (y - win.y0) as usize * w + (x - win.x0) as usize;
-            if let Some(v) = m.get_mut(j) {
-                *v = true;
+    for stroke in &plan.strokes {
+        let (bounds, cov) = stroke_coverage(stroke);
+        let bw = bounds.width() as usize;
+        for (i, c) in cov.iter().enumerate() {
+            let (x, y) = (bounds.x0 + (i % bw.max(1)) as i32, bounds.y0 + (i / bw.max(1)) as i32);
+            if *c > 0.0 && win.contains(x, y) {
+                let j = (y - win.y0) as usize * w + (x - win.x0) as usize;
+                if let Some(v) = m.get_mut(j) {
+                    *v = true;
+                }
             }
         }
     }
@@ -135,6 +175,34 @@ fn run_remove(doc: &mut Document, plan: &Plan, p: &Value, ctx: &crate::jobs::Job
     Ok(Some((Region { rect: win, ch: img.ch, data }, hole)))
 }
 
+/// The fill on a new layer above `id`: the hole's pixels (opaque where the source had no alpha),
+/// transparent elsewhere. Returns the damage and the new layer.
+fn fill_to_new_layer(doc: &mut Document, id: Option<LayerId>, out: &Region, hole: &[bool]) -> Result<(Rect, LayerId)> {
+    let base = doc.pixel_format();
+    let fmt = PixelFormat::new(base.mode, base.sample, true);
+    let n = fmt.channels();
+    let colours = n.saturating_sub(1);
+    if out.ch != n && out.ch != colours {
+        return Err(EngineError::Other("internal error: the fill's channels don't match the document".into()));
+    }
+    let mut data = vec![0.0f32; hole.len().saturating_mul(n)];
+    for ((dst, src), m) in data.chunks_exact_mut(n).zip(out.data.chunks_exact(out.ch)).zip(hole) {
+        if !*m {
+            continue;
+        }
+        for (d, s) in dst.iter_mut().zip(src.iter().take(colours)) {
+            *d = *s;
+        }
+        if let Some(a) = dst.last_mut() {
+            *a = if out.ch == n { src.last().copied().unwrap_or(1.0) } else { 1.0 };
+        }
+    }
+    let mut l = Layer::raster(doc.next_layer_name("Layer"), fmt);
+    crate::pixels_mut(&mut l)?.write_region(out.rect, &data);
+    let nid = doc.insert_above(id, l);
+    Ok((out.rect, nid))
+}
+
 pub(super) fn remove(s: &mut Session, p: &Value) -> Result<Value> {
     let plan = plan(s, p)?;
     let label = "Remove";
@@ -142,6 +210,7 @@ pub(super) fn remove(s: &mut Session, p: &Value) -> Result<Value> {
     let doc = d.doc.clone();
     let p = p.clone();
     let id = plan.id;
+    let new_layer = plan.new_layer;
     crate::jobs::run(
         s,
         label,
@@ -156,6 +225,17 @@ pub(super) fn remove(s: &mut Session, p: &Value) -> Result<Value> {
         },
         move |s, filled| {
             let Some((out, hole)) = filled else { return Ok(json!({"changed": false})) };
+            if new_layer {
+                let (damage, nid) = s.edit(label, |doc, active| {
+                    let r = fill_to_new_layer(doc, id, &out, &hole)?;
+                    *active = Some(r.1);
+                    Ok(r)
+                })?;
+                if let Some(st) = s.active_mut() {
+                    st.last_damage = Some(damage);
+                }
+                return Ok(json!({ "damage": damage_json(damage), "layer": nid.0 }));
+            }
             let damage = s.edit(label, |doc, _| replace(doc, Target { id, all_layers: false }, &p, &out, &hole))?;
             if let Some(st) = s.active_mut() {
                 st.last_damage = Some(damage);
diff --git a/crates/engine/src/retouch_cmds/tests.rs b/crates/engine/src/retouch_cmds/tests.rs
index 7104c69aa9..9a0ae22f08 100644
--- a/crates/engine/src/retouch_cmds/tests.rs
+++ b/crates/engine/src/retouch_cmds/tests.rs
@@ -3,6 +3,171 @@ use photocraft_color::ColorMode;
 
 const DEPTHS: [u64; 3] = [8, 16, 32];
 
+#[test]
+fn periodic_clone_large_footprint_applies_opacity_once_and_respects_destination_masks() {
+    for depth in DEPTHS {
+        for lock in [false, true] {
+            let mut s = session(8, 8, depth, "rgb");
+            paint_layer(&mut s, |x, _| {
+                if x < 4 {
+                    [1.0, 0.0, 0.0, 1.0]
+                } else if x == 7 {
+                    [0.0; 4]
+                } else {
+                    [1.0; 4]
+                }
+            });
+            s.edit("lock", |doc, active| {
+                doc.layer_mut(active.unwrap()).unwrap().locks.transparency = lock;
+                Ok(())
+            })
+            .unwrap();
+            s.execute("select.rect", json!({"x":5,"y":0,"width":3,"height":8})).unwrap();
+            s.execute("paint.cloneStamp", json!({"points":[[6,4]],"offset":[4,0],"size":32,"hardness":100,"opacity":50,"wrap":true})).unwrap();
+            assert_eq!(rgba(&s, 4, 4), [1.0; 4], "selection is evaluated at the wrapped destination");
+            let opaque = rgba(&s, 6, 4);
+            assert!((opaque[1] - 0.5).abs() <= tol(depth), "overlapping tile copies must not multiply opacity: {opaque:?}");
+            let transparent = rgba(&s, 7, 4);
+            if lock {
+                assert_eq!(transparent[3], 0.0, "locked transparent destination stays transparent");
+            } else {
+                assert!((transparent[3] - 0.5).abs() <= tol(depth), "unlocked transparent destination receives one stroke: {transparent:?}");
+                assert_eq!(transparent[0], 1.0);
+            }
+        }
+    }
+}
+
+#[test]
+fn periodic_clone_selection_uses_native_cmyk_pixels_across_seam() {
+    let mut s = session(64, 32, 8, "cmyk");
+    paint_layer(&mut s, |x, _| if x < 32 { [0.0, 0.0, 1.0, 1.0] } else { [1.0, 1.0, 0.0, 1.0] });
+    s.execute("select.rect", json!({"x":0,"y":0,"width":4,"height":32})).unwrap();
+    s.execute("paint.cloneStamp", json!({"points":[[63,16]],"offset":[-23,0],"size":16,"hardness":100,"wrap":true})).unwrap();
+    let (inside, outside) = (rgba(&s, 1, 16), rgba(&s, 5, 16));
+    assert!(inside[0] > 0.8 && inside[2] < 0.3, "selected wrapped destination becomes yellow: {inside:?}");
+    assert!(outside[2] > outside[0] + 0.2, "unselected neighbour remains blue: {outside:?}");
+}
+
+#[test]
+fn periodic_clone_projection_is_disjoint_and_matches_pixel_modulo() {
+    use std::collections::HashSet;
+    let tile = Rect::new(0, 0, 8, 6);
+    for rect in [Rect::new(-2, -3, 3, 2), Rect::new(-10, -9, 19, 14), Rect::new(7, 5, 10, 8), Rect::new(i32::MIN, i32::MIN, i32::MIN + 3, i32::MIN + 2)] {
+        let expected: HashSet<_> = (rect.y0..rect.y1).flat_map(|y| (rect.x0..rect.x1).map(move |x| (x.rem_euclid(8), y.rem_euclid(6)))).collect();
+        let mut actual = HashSet::new();
+        for r in periodic::project(rect, tile) {
+            for y in r.y0..r.y1 {
+                for x in r.x0..r.x1 {
+                    assert!(actual.insert((x, y)), "projected rectangles overlap");
+                }
+            }
+        }
+        assert_eq!(actual, expected);
+    }
+}
+
+#[test]
+fn periodic_clone_preview_interpolates_across_transformed_source_seam() {
+    use crate::presets::clone_source::Mapping;
+    for depth in DEPTHS {
+        let mut s = session(32, 24, depth, "rgb");
+        paint_layer(&mut s, |x, _| if x == 0 { [1.0, 0.0, 0.0, 1.0] } else { [0.0, 0.0, 1.0, 1.0] });
+        let before = s.active().unwrap().doc.clone();
+        // A rotated mapping samples halfway between the last and first columns.
+        let map = Mapping { source: (31.5, 10.0), anchor: (0.0, 0.0), m: [0.0, 1.0, -1.0, 0.0] };
+        let r = Rect::new(0, 0, 1, 1);
+        let wrapped = clone_preview_periodic(&s, r, &map, "current", true).unwrap();
+        assert_eq!(wrapped.px, [[0.5, 0.0, 0.5, 1.0]]);
+        let ordinary = clone_preview(&s, r, &map, "current").unwrap();
+        assert_eq!(ordinary.px, [[0.0, 0.0, 1.0, 0.5]]);
+        assert_eq!(s.active().unwrap().doc, before);
+    }
+}
+
+#[test]
+fn periodic_clone_destination_wraps_edges_and_undoes_at_every_depth() {
+    for depth in DEPTHS {
+        for wrap in [false, true] {
+            let mut s = session(100, 60, depth, "rgb");
+            paint_layer(&mut s, |x, y| if x < 24 && y < 24 { [1.0, 0.0, 0.0, 1.0] } else { [1.0; 4] });
+            let before = s.active().unwrap().doc.clone();
+            s.execute("paint.cloneStamp", json!({"points":[[98,30]],"source":[10,10],"size":16,"hardness":100,"opacity":50,"wrap":wrap})).unwrap();
+            for x in [98, 1] {
+                let expected = if x == 98 || wrap { [1.0, 0.5, 0.5, 1.0] } else { [1.0; 4] };
+                let actual = rgba(&s, x, 30);
+                for (a, b) in actual.into_iter().zip(expected) {
+                    assert!((a - b).abs() <= tol(depth), "depth={depth} wrap={wrap} x={x}: {actual:?}");
+                }
+            }
+            assert!(s.undo());
+            assert_eq!(s.active().unwrap().doc, before, "one undo restores the whole wrapped stroke");
+        }
+    }
+}
+
+#[test]
+fn periodic_clone_live_matches_commit_through_a_corner() {
+    for depth in DEPTHS {
+        let mut s = session(32, 24, depth, "rgb");
+        paint_layer(&mut s, texture);
+        let before = s.active().unwrap().doc.clone();
+        let mut params = json!({"points":[[30,22]],"source":[10,10],"size":16,"hardness":70,"opacity":45,"flow":60,"wrap":true});
+        let mut live = LiveRetouch::begin(&s, "paint.cloneStamp", &params).unwrap();
+        let mut points = vec![json!([30, 22])];
+        for next in [None, Some([34.0, 26.0]), Some([38.0, 28.0]), Some([30.0, 22.0])] {
+            if let Some([x, y]) = next {
+                live.push(&[StrokePoint::new(x, y, 1.0)]).unwrap();
+                points.push(json!([x, y]));
+            }
+            params["points"] = json!(points);
+            let mut committed = Session::new();
+            committed.add_document((*before).clone(), None);
+            committed.execute("paint.cloneStamp", params.clone()).unwrap();
+            let id = s.active().unwrap().active_layer.unwrap();
+            let actual = live.doc.layer(id).unwrap().surface().unwrap().read_region(before.bounds());
+            let expected = committed.active().unwrap().doc.layer(id).unwrap().surface().unwrap().read_region(before.bounds());
+            assert_eq!(actual, expected, "live versus committed pixels at depth {depth}, points {points:?}");
+        }
+    }
+}
+
+#[test]
+fn periodic_clone_source_repeats_both_axes_at_every_depth() {
+    for depth in DEPTHS {
+        let mut s = session(6, 4, depth, "rgb");
+        paint_layer(&mut s, |x, y| [x as f32 / 6.0, y as f32 / 4.0, 0.25, 1.0]);
+        let st = s.active().unwrap();
+        let surf = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap();
+        let r = Rect::new(-8, -6, 15, 11);
+        for which in [SampleLayers::Current, SampleLayers::CurrentAndBelow, SampleLayers::All] {
+            let result = periodic::sample(&st.doc, st.active_layer, surf, which, r, "test").unwrap();
+            for y in r.y0..r.y1 {
+                for x in r.x0..r.x1 {
+                    let expected = surf.rgba(x.rem_euclid(6), y.rem_euclid(4));
+                    let actual = to_rgba(&surf.format(), result.px(x, y));
+                    for (a, b) in actual.into_iter().zip(expected) {
+                        assert!((a - b).abs() <= tol(depth), "{depth}-bit ({x},{y}): {actual:?} != {expected:?}");
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn periodic_clone_source_bounds_allocations_and_accepts_far_coordinates() {
+    let s = session(6, 4, 8, "rgb");
+    let st = s.active().unwrap();
+    let surf = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap();
+    assert!(periodic::sample(&st.doc, st.active_layer, surf, SampleLayers::Current, Rect::new(0, 0, 100_000, 100_000), "test").is_err());
+    for r in [Rect::new(i32::MIN, i32::MIN, i32::MIN + 3, i32::MIN + 2), Rect::new(i32::MAX - 3, i32::MAX - 2, i32::MAX, i32::MAX)] {
+        let result = periodic::sample(&st.doc, st.active_layer, surf, SampleLayers::Current, r, "test").unwrap();
+        assert_eq!(result.data.len(), 3 * 2 * surf.channels());
+        assert!(result.data.iter().all(|v| *v == 1.0));
+    }
+}
+
 #[test]
 fn proximity_match_reads_original_pixels_for_overlapping_offsets() {
     // Shifting source one pixel to the left overlaps the destination in a
@@ -917,6 +1082,31 @@ fn content_aware_move_moves_the_object_and_fills_its_place_at_all_depths() {
     }
 }
 
+#[test]
+fn content_aware_move_preview_shows_the_result_without_touching_the_session() {
+    use crate::jobs::JobCtx;
+    let mut s = session(128, 64, 8, "rgb");
+    paint_layer(&mut s, with_object(20, 26));
+    s.execute("select.rect", json!({"x": 16, "y": 22, "width": 20, "height": 20})).unwrap();
+    let before = s.active().unwrap().revision;
+    let p = json!({"offset": [70, 0]});
+    let (doc, damage) = content_aware_move_preview(&s, &p).unwrap().run(&JobCtx::new()).unwrap();
+    let px = |d: &Document, x, y| d.layers[0].surface().unwrap().rgba(x, y);
+    assert!(is_object(px(&doc, 95, 31)) && !is_object(px(&doc, 25, 31)), "the preview shows the move");
+    assert!(damage.contains(95, 31) && damage.contains(25, 31), "{damage:?}");
+    // The session is untouched.
+    assert!(is_object(rgba(&s, 25, 31)) && !is_object(rgba(&s, 95, 31)));
+    assert_eq!(s.active().unwrap().revision, before);
+    // A cancelled preview stops; a selection past the preview's size and bad params are errors.
+    let ctx = JobCtx::new();
+    ctx.cancel();
+    assert!(matches!(content_aware_move_preview(&s, &p).unwrap().run(&ctx), Err(EngineError::Cancelled)));
+    assert!(content_aware_move_preview(&s, &json!({"offset": [0, 0]})).is_err());
+    assert!(content_aware_move_preview(&s, &json!({"offset": [70, 0], "rotate": "x"})).is_err());
+    s.execute("select.rect", json!({"x": 0, "y": 0, "width": 300, "height": 300})).unwrap();
+    assert!(content_aware_move_preview(&s, &json!({"offset": [1, 0]})).is_err());
+}
+
 #[test]
 fn content_aware_move_transform_on_drop_scales_and_rotates_the_content() {
     // A horizontal 16×6 bar in a 36×36 selection, dropped 80 px right and turned 90° with 125%
@@ -1397,14 +1587,18 @@ fn live_dodge_matches_the_commit_across_cells() {
         for x in 0..200 {
             let (got, want) = (a.rgba(x, y), b.rgba(x, y));
             changed |= (want[0] - texture(x, y)[0]).abs() > 0.02;
-            // The commit also lays the stroke's last dab, which the live stroke shows on release.
-            if (x - 150).pow(2) + (y - 70).pow(2) > 25 * 25 {
+            // The commit also lays the stroke's last dab, which the live stroke shows on release
+            // (a soft tip reaches past its 20 px radius).
+            let reach = photocraft_paint::tip_reach(20.0, 0.3).ceil() as i32 + 2;
+            if (x - 150).pow(2) + (y - 70).pow(2) > reach * reach {
                 worst = (0..4).map(|c| (got[c] - want[c]).abs()).fold(worst, f32::max);
             }
         }
     }
     assert!(changed);
-    assert!(worst <= 1e-4, "live and commit differ by {worst}");
+    // A soft tip's footprint spans more live cells, so sums land in a different order: within
+    // 2e-4 (a twentieth of an 8-bit level).
+    assert!(worst <= 2e-4, "live and commit differ by {worst}");
 }
 
 #[test]
@@ -1580,3 +1774,283 @@ fn spot_healing_keeps_film_grain_through_overlapping_strokes() {
         }
     }
 }
+
+#[test]
+fn remove_several_strokes_apply_as_one_job_and_one_undo_step() {
+    let mut s = square_session(8, "rgb");
+    let bg = rgba(&s, 10, 10);
+    let past = s.active().unwrap().history.past_len();
+    // Each stroke covers half of the square; together they remove it.
+    let r = s.execute("paint.remove", json!({"strokes": [[[38, 30], [45, 30]], [[47, 30], [54, 30]]], "size": 16})).unwrap();
+    assert!(r["damage"].is_array(), "{r}");
+    for (x, y) in [(41, 30), (46, 30), (51, 30)] {
+        assert!(near(rgba(&s, x, y), bg, 0.03), "({x}, {y}): {:?} vs {bg:?}", rgba(&s, x, y));
+    }
+    assert_eq!(s.active().unwrap().history.past_len(), past + 1, "one undo step for both strokes");
+    for p in [
+        json!({"strokes": [], "size": 16}),
+        json!({"strokes": "x", "size": 16}),
+        json!({"strokes": [[]], "size": 16}),
+        json!({"strokes": [[[1, 1]], "x"], "size": 16}),
+    ] {
+        assert!(s.execute("paint.remove", p).is_err());
+    }
+}
+
+#[test]
+fn remove_to_a_new_layer_leaves_the_target_untouched() {
+    let mut s = square_session(8, "rgb");
+    let target = s.active().unwrap().active_layer.unwrap();
+    let bg = rgba(&s, 10, 10);
+    let square = rgba(&s, 46, 30);
+    let past = s.active().unwrap().history.past_len();
+    let r = s.execute("paint.remove", json!({"points": [[38, 30], [54, 30]], "size": 16, "newLayer": true})).unwrap();
+    let nid = LayerId(r["layer"].as_u64().expect("the new layer's id"));
+    let d = s.active().unwrap();
+    assert_eq!(d.active_layer, Some(nid), "the new layer is active");
+    assert_ne!(nid, target);
+    let order: Vec<LayerId> = d.doc.walk().into_iter().map(|(_, _, l)| l.id).collect();
+    assert_eq!(order, vec![target, nid], "the new layer sits above the target");
+    assert_eq!(d.doc.layer(nid).unwrap().name, "Layer 1");
+    // The target keeps its pixels; the new layer carries the fill inside the hole only.
+    let old = d.doc.layer(target).unwrap().surface().unwrap();
+    assert!(near(old.rgba(46, 30), square, 0.001));
+    let new = d.doc.layer(nid).unwrap().surface().unwrap();
+    assert!(near(new.rgba(46, 30), bg, 0.03), "{:?}", new.rgba(46, 30));
+    assert_eq!(new.rgba(10, 10)[3], 0.0, "transparent away from the hole");
+    assert_eq!(d.history.past_len(), past + 1);
+    s.execute("edit.undo", json!({})).unwrap();
+    let d = s.active().unwrap();
+    assert!(d.doc.layer(nid).is_none(), "undo removes the layer");
+    assert_eq!(d.active_layer, Some(target));
+    // On an empty layer with Sample All Layers, the composite is what gets filled, onto a new layer.
+    s.execute("layer.new.layer", json!({})).unwrap();
+    let empty = s.active().unwrap().active_layer.unwrap();
+    let r = s.execute("paint.remove", json!({"points": [[38, 30], [54, 30]], "size": 16, "sampleAllLayers": true, "newLayer": true})).unwrap();
+    let nid = LayerId(r["layer"].as_u64().unwrap());
+    let d = s.active().unwrap();
+    let order: Vec<LayerId> = d.doc.walk().into_iter().map(|(_, _, l)| l.id).collect();
+    assert_eq!(order, vec![target, empty, nid]);
+    assert!(near(d.doc.layer(nid).unwrap().surface().unwrap().rgba(46, 30), bg, 0.03));
+    assert!(near(d.doc.layer(target).unwrap().surface().unwrap().rgba(46, 30), square, 0.001));
+}
+
+/// A Clone Stamp or History Brush stroke drawn live and offered to its commit: the commit takes
+/// the live pixels, and they are what running the command afresh paints, bit for bit, at every
+/// depth, with and without a feathered selection.
+#[test]
+fn a_live_clone_or_history_stroke_commits_its_own_pixels() {
+    let all = [[30.0, 30.0], [50.0, 34.0], [70.0, 28.0], [90.0, 40.0], [60.0, 50.0], [35.0, 44.0], [36.0, 45.0]];
+    let pts = |v: &[[f64; 2]]| v.iter().map(|q| StrokePoint::new(q[0], q[1], 1.0)).collect::<Vec<_>>();
+    for depth in DEPTHS {
+        for (cmd, extra) in [("paint.cloneStamp", json!({"source": [20, 15], "mode": "multiply"})), ("paint.historyBrush", json!({"state": 1}))] {
+            for selected in [false, true] {
+                let setup = || {
+                    let mut s = session(120, 70, depth, "rgb");
+                    paint_layer(&mut s, texture);
+                    s.execute("paint.stroke", json!({"points": [[0, 40], [120, 40]], "size": 20, "hardness": 1.0, "color": "#c03030"})).unwrap();
+                    if selected {
+                        s.execute("select.rect", json!({"x": 40, "y": 20, "width": 50, "height": 40, "ellipse": true, "feather": 3})).unwrap();
+                    }
+                    s
+                };
+                let params = |v: &[[f64; 2]]| {
+                    let mut p = json!({"points": v, "size": 14, "hardness": 40, "opacity": 70});
+                    for (k, x) in extra.as_object().unwrap() {
+                        p[k] = x.clone();
+                    }
+                    p
+                };
+                let mut s = setup();
+                let mut live = LiveRetouch::begin(&s, cmd, &params(&all[..1])).unwrap();
+                live.push(&pts(&all[1..3])).unwrap();
+                live.push(&pts(&all[3..4])).unwrap();
+                live.push(&pts(&all[4..])).unwrap();
+                s.offer_live_retouch(live).unwrap();
+                let r = s.execute(cmd, params(&all)).unwrap();
+                s.clear_live_stroke();
+                assert_eq!(r["fromLive"], true, "{cmd} {depth}-bit selected={selected}");
+                let mut fresh = setup();
+                let r = fresh.execute(cmd, params(&all)).unwrap();
+                assert!(r.get("fromLive").is_none());
+                let (a, b) = (s.active().unwrap(), fresh.active().unwrap());
+                let bounds = a.doc.bounds();
+                let got = a.doc.layer(a.active_layer.unwrap()).unwrap().surface().unwrap().read_region(bounds);
+                let want = b.doc.layer(b.active_layer.unwrap()).unwrap().surface().unwrap().read_region(bounds);
+                let diff = got.iter().zip(&want).position(|(x, y)| x.to_bits() != y.to_bits());
+                assert!(diff.is_none(), "{cmd} {depth}-bit selected={selected}: first difference at value {diff:?}");
+                assert_eq!(a.history.past_len(), b.history.past_len());
+            }
+        }
+    }
+}
+
+/// An offered live stroke is taken only by the commit it was drawn for, and only once.
+#[test]
+fn a_live_retouch_offer_is_taken_only_by_its_own_commit() {
+    let mut s = session(96, 64, 8, "rgb");
+    paint_layer(&mut s, texture);
+    let all = [[50.0, 30.0], [60.0, 34.0], [70.0, 30.0]];
+    let params = |v: &[[f64; 2]], opacity: u32| json!({"points": v, "source": [20, 20], "size": 12, "hardness": 50, "opacity": opacity});
+    let offer = |s: &mut Session| {
+        let live = LiveRetouch::begin(s, "paint.cloneStamp", &params(&all, 70)).unwrap();
+        s.offer_live_retouch(live).unwrap();
+    };
+    let from_live = |r: Value| r.get("fromLive").is_some();
+    // Other points, other params, another command: rendered afresh.
+    offer(&mut s);
+    assert!(!from_live(s.execute("paint.cloneStamp", params(&all[..2], 70)).unwrap()));
+    s.execute("edit.undo", json!({})).unwrap();
+    offer(&mut s);
+    assert!(!from_live(s.execute("paint.cloneStamp", params(&all, 60)).unwrap()));
+    s.execute("edit.undo", json!({})).unwrap();
+    offer(&mut s);
+    let mut history = params(&all, 70);
+    history.as_object_mut().unwrap().remove("source");
+    assert!(!from_live(s.execute("paint.historyBrush", history).unwrap()));
+    s.execute("edit.undo", json!({})).unwrap();
+    // The document changed after the stroke started.
+    offer(&mut s);
+    s.execute("paint.stroke", json!({"points": [[5, 5], [9, 9]], "size": 4})).unwrap();
+    assert!(!from_live(s.execute("paint.cloneStamp", params(&all, 70)).unwrap()));
+    s.execute("edit.undo", json!({})).unwrap();
+    s.execute("edit.undo", json!({})).unwrap();
+    // A withdrawn offer, and an offer used once.
+    offer(&mut s);
+    s.clear_live_stroke();
+    assert!(!from_live(s.execute("paint.cloneStamp", params(&all, 70)).unwrap()));
+    s.execute("edit.undo", json!({})).unwrap();
+    offer(&mut s);
+    assert!(from_live(s.execute("paint.cloneStamp", params(&all, 70)).unwrap()));
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(!from_live(s.execute("paint.cloneStamp", params(&all, 70)).unwrap()));
+    // The Healing Brush blends on release: it has no live pixels to offer.
+    let healing = LiveRetouch::begin(&s, "paint.healingBrush", &params(&all, 70)).unwrap();
+    assert!(s.offer_live_retouch(healing).is_err());
+    // The brush changed during the stroke (the document revision doesn't show it).
+    let live = LiveRetouch::begin(&s, "paint.cloneStamp", &params(&all, 70)).unwrap();
+    s.execute("tools.setBrush", json!({"brush": {"spacing": 0.5}})).unwrap();
+    assert!(s.offer_live_retouch(live).is_err());
+}
+
+/// The live stroke renders only the position and pressure of its points, as its commit parses
+/// them: a pen's tilt and the times don't change what it shows.
+#[test]
+fn a_live_retouch_stroke_ignores_tilt_and_times() {
+    let mut s = session(64, 48, 8, "rgb");
+    paint_layer(&mut s, texture);
+    let p = json!({"points": [[20, 20]], "source": [8, 8], "size": 10, "hardness": 50});
+    let mut plain = LiveRetouch::begin(&s, "paint.cloneStamp", &p).unwrap();
+    let mut pen = LiveRetouch::begin(&s, "paint.cloneStamp", &p).unwrap();
+    let pts = [[30.0, 24.0], [44.0, 30.0]];
+    plain.push(&pts.map(|q| StrokePoint::new(q[0], q[1], 0.8))).unwrap();
+    pen.push(&pts.map(|q| {
+        let mut sp = StrokePoint::new(q[0], q[1], 0.8);
+        (sp.tilt_x, sp.tilt_y, sp.rotation, sp.time) = (40.0, -20.0, 90.0, 120.0);
+        sp
+    }))
+    .unwrap();
+    assert_eq!(plain.points(), pen.points());
+    let id = s.active().unwrap().active_layer.unwrap();
+    let b = s.active().unwrap().doc.bounds();
+    let read = |l: &LiveRetouch| l.doc.layer(id).unwrap().surface().unwrap().read_region(b);
+    assert_eq!(read(&plain), read(&pen));
+}
+
+#[test]
+fn periodic_clone_low_flow_revisits_accumulate_across_tile_aliases() {
+    // Independent oracle: paint the same continuous stroke over two physical copies of a
+    // tile, then combine the two coverage values using the brush's flow accumulation rule.
+    let setup = |width| {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width":width,"height":24,"depth":32})).unwrap();
+        for x in (8..width).step_by(32) {
+            s.execute("paint.pencil", json!({"points":[[x,12]],"size":16,"color":"#ff0000"})).unwrap();
+        }
+        s
+    };
+    let params = |wrap| json!({"points":[[22,12],[54,12]],"offset":[-18,0],"size":2,"hardness":100,"flow":20,"opacity":100,"wrap":wrap});
+    let green = |s: &Session, x| {
+        let st = s.active().unwrap();
+        st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().rgba(x, 12)[1]
+    };
+    let mut physical = setup(64);
+    physical.execute("paint.cloneStamp", params(false)).unwrap();
+    let (a, b) = (green(&physical, 22), green(&physical, 54));
+    assert!(a > 0.0 && a < 1.0 && b > 0.0 && b < 1.0, "oracle needs two partial visits: {a}, {b}");
+    let expected = a * b;
+    let mut periodic = setup(32);
+    periodic.execute("paint.cloneStamp", params(true)).unwrap();
+    let actual = green(&periodic, 22);
+    assert!((actual - expected).abs() < 0.0001, "repeated visits should build flow: actual green={actual}, expected={expected}, physical copies={a},{b}");
+}
+
+#[test]
+fn periodic_clone_live_offer_commits_and_undoes_the_same_pixels_as_replay() {
+    for depth in [8, 16, 32] {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width":32,"height":24,"depth":depth})).unwrap();
+        s.execute("paint.pencil", json!({"points":[[8,8]],"size":12,"color":"#d03060"})).unwrap();
+        let before = s.active().unwrap().doc.clone();
+        let id = s.active().unwrap().active_layer.unwrap();
+        let params = json!({"points":[[30,22],[34,26],[38,28],[30,22]],"source":[8,8],"size":16,"hardness":70,"opacity":45,"flow":60,"wrap":true});
+        let live = LiveRetouch::begin(&s, "paint.cloneStamp", &params).unwrap();
+        let shown = live.doc.layer(id).unwrap().surface().unwrap().read_region(before.bounds());
+        s.offer_live_retouch(live).unwrap();
+        let result = s.execute("paint.cloneStamp", params.clone()).unwrap();
+        assert_eq!(result["fromLive"], true);
+        let read = |s: &Session| s.active().unwrap().doc.layer(id).unwrap().surface().unwrap().read_region(before.bounds());
+        assert_eq!(read(&s), shown, "offered preview at depth {depth}");
+        let mut replay = Session::new();
+        replay.add_document((*before).clone(), None);
+        replay.execute("paint.cloneStamp", params).unwrap();
+        assert_eq!(read(&s), read(&replay), "command replay at depth {depth}");
+        assert!(s.undo());
+        assert_eq!(s.active().unwrap().doc, before, "one undo at depth {depth}");
+    }
+}
+#[test]
+fn periodic_clone_interior_matches_ordinary_brush_masks_and_transparency() {
+    let cases = [
+        json!({"wetEdges":true}),
+        json!({"dualBrush":{"enabled":true,"size":7,"hardness":0.5,"spacing":0.2}}),
+        json!({"texture":{"enabled":true,"eachTip":false,"depth":0.6}}),
+        json!({"pressureOpacity":true,"pressureSize":false}),
+        json!({"wetEdges":true,"dualBrush":{"enabled":true,"size":7},"pressureOpacity":true}),
+    ];
+    for depth in DEPTHS {
+        for brush in &cases {
+            let setup = || {
+                let mut s = session(96, 64, depth, "rgb");
+                paint_layer(&mut s, |x, y| {
+                    let mut px = texture(x, y);
+                    px[3] = if x < 40 { 0.4 } else { 0.75 };
+                    px
+                });
+                s.execute("tools.setBrush", json!({"brush":brush})).unwrap();
+                s.execute("select.rect", json!({"x":48,"y":16,"width":36,"height":36,"feather":2})).unwrap();
+                s
+            };
+            let mut ordinary = setup();
+            let mut periodic = setup();
+            let mut p = json!({"points":[[55,30,0.4],[65,34,0.8],[72,30,0.3]],"source":[20,20],"size":12,"hardness":65,"flow":35,"opacity":60});
+            ordinary.execute("paint.cloneStamp", p.clone()).unwrap();
+            p["wrap"] = json!(true);
+            periodic.execute("paint.cloneStamp", p).unwrap();
+            let read = |s: &Session| {
+                let st = s.active().unwrap();
+                st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().read_region(st.doc.bounds())
+            };
+            let (a, b) = (read(&ordinary), read(&periodic));
+            let tolerance = if depth == 8 {
+                1.1 / 255.0
+            } else if depth == 16 {
+                1.1 / 65535.0
+            } else {
+                0.00001
+            };
+            let error = a.iter().zip(&b).map(|(a, b)| (a - b).abs()).fold(0.0_f32, f32::max);
+            assert!(error <= tolerance, "depth={depth}, brush={brush}, max native-channel error={error}");
+        }
+    }
+}
diff --git a/crates/engine/src/sampler_cmds.rs b/crates/engine/src/sampler_cmds.rs
index 38c355071c..472ecb672a 100644
--- a/crates/engine/src/sampler_cmds.rs
+++ b/crates/engine/src/sampler_cmds.rs
@@ -24,8 +24,11 @@ fn has_doc(s: &Session) -> std::result::Result<(), String> {
     s.active().map(|_| ()).ok_or_else(|| "no document open".into())
 }
 
-/// Naive device CMYK (no ICC profile), in percent, as the Info panel shows it.
+/// Naive device CMYK (no ICC profile), in percent, as the Info panel shows it. 32-bit samples can
+/// lie outside 0..1, so each channel is clamped first (NaN reads as 0), like the RGB readout.
 pub fn device_cmyk(r: f32, g: f32, b: f32) -> [i32; 4] {
+    let unit = |v: f32| if v.is_nan() { 0.0 } else { v.clamp(0.0, 1.0) };
+    let (r, g, b) = (unit(r), unit(g), unit(b));
     let k = 1.0 - r.max(g).max(b);
     let f = |v: f32| if k >= 1.0 { 0.0 } else { (1.0 - v - k) / (1.0 - k) };
     [f(r), f(g), f(b), k].map(|v| (v * 100.0).round() as i32)
@@ -418,6 +421,36 @@ mod tests {
         assert_eq!(device_cmyk(0.5, 0.5, 0.5), [0, 0, 0, 50]);
     }
 
+    /// 32-bit samples can lie outside 0..1 (or be NaN); the CMYK readout clamps them like the RGB
+    /// readout does instead of reporting K:-50% or C:120% (#4191).
+    #[test]
+    fn device_cmyk_clamps_out_of_range_and_nan_samples() {
+        assert_eq!(device_cmyk(1.5, 1.5, 1.5), [0, 0, 0, 0]);
+        assert_eq!(device_cmyk(2.0, 0.0, 0.0), [0, 100, 100, 0]);
+        let in_range = |c: [i32; 4]| c.iter().all(|v| (0..=100).contains(v));
+        for (r, g, b) in [(-0.2, 0.5, 0.5), (-1.0, -1.0, -1.0), (f32::NAN, 0.5, 0.5), (f32::NAN, f32::NAN, f32::NAN), (f32::INFINITY, f32::NEG_INFINITY, 0.5)] {
+            let c = device_cmyk(r, g, b);
+            assert!(in_range(c), "{r} {g} {b} -> {c:?}");
+        }
+        assert_eq!(device_cmyk(f32::NAN, f32::NAN, f32::NAN), [0, 0, 0, 100]);
+    }
+
+    #[test]
+    fn hdr_pixel_on_a_32_bit_document_reads_in_range() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 8, "height": 8, "depth": 32, "background": "white"})).unwrap();
+        s.edit("paint", |doc, _| {
+            let surf = doc.layers[0].surface_mut().unwrap();
+            let hdr = photocraft_raster::from_rgba(&surf.format(), [2.0, 2.0, 2.0, 1.0]);
+            surf.fill_rect(Rect::new(3, 3, 4, 4), &hdr);
+            Ok(())
+        })
+        .unwrap();
+        let r = s.execute("view.colorSamplers.add", json!({"x": 3, "y": 3})).unwrap();
+        assert_eq!(r["point"]["rgb"], json!([255, 255, 255]));
+        assert_eq!(r["point"]["cmyk"], json!([0, 0, 0, 0]));
+    }
+
     #[test]
     fn points_work_at_every_depth_and_mode() {
         for (mode, depth) in [("rgb", 8), ("rgb", 16), ("rgb", 32), ("grayscale", 8), ("cmyk", 8), ("lab", 8)] {
diff --git a/crates/engine/src/select_extra_cmds.rs b/crates/engine/src/select_extra_cmds.rs
index e2c9e70591..5feae1a75f 100644
--- a/crates/engine/src/select_extra_cmds.rs
+++ b/crates/engine/src/select_extra_cmds.rs
@@ -195,6 +195,7 @@ fn transform_selection(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let selected = s.edit("Transform Selection", |doc, _| {
         if let Some(sel) = &doc.selection {
+            crate::transform_cmds::check_budget(sel.content_bounds(), &h, "selection")?;
             doc.selection = Some(crate::transform_cmds::warp_gray(sel, &h, interp)?).filter(|s| !s.content_bounds().is_empty());
         }
         Ok(doc.selection.is_some())
diff --git a/crates/engine/src/selection_cmds.rs b/crates/engine/src/selection_cmds.rs
index e92a8fd5c7..8efb8d7b94 100644
--- a/crates/engine/src/selection_cmds.rs
+++ b/crates/engine/src/selection_cmds.rs
@@ -5,6 +5,7 @@
 use photocraft_algo::selection::{self as sel, SelectionMode};
 use photocraft_doc::Document;
 use photocraft_geom::Rect;
+use photocraft_raster::Surface;
 use serde_json::{Value, json};
 
 use crate::commands::CommandSpec;
@@ -360,6 +361,10 @@ fn color_range(s: &mut Session, p: &Value) -> Result<Value> {
     let invert = b(p, "invert", false);
     let selection_mode = mode(p);
     let fuzz = |d: f32| f(p, "fuzziness", d).max(0.0);
+    // Photoshop's Detect Faces needs a face detector, which there is none of yet (#4455).
+    if b(p, "detectFaces", false) {
+        return Err(bad("detectFaces: face detection isn't available yet; select without it".into()));
+    }
     let (area, mut mask) = match preset {
         "sampledColors" => {
             let (area, px) = sample_pixels(s, b(p, "sampleAllLayers", true))?;
@@ -385,6 +390,10 @@ fn color_range(s: &mut Session, p: &Value) -> Result<Value> {
             let (area, px) = sample_pixels(s, b(p, "sampleAllLayers", true))?;
             (area, sel::hue_range(&px, center))
         }
+        "skinTones" => {
+            let (area, px) = sample_pixels(s, b(p, "sampleAllLayers", true))?;
+            (area, sel::skin_tones(&px, fuzz(40.0).min(200.0)))
+        }
         "highlights" | "midtones" | "shadows" => {
             // Range in levels (Highlights / Shadows: one value, Midtones: [low, high]); Fuzziness
             // is a percentage of the tonal scale.
@@ -418,7 +427,7 @@ fn color_range(s: &mut Session, p: &Value) -> Result<Value> {
         }
         other => {
             return Err(bad(format!(
-                "unknown select `{other}` (sampledColors, reds, yellows, greens, cyans, blues, magentas, highlights, midtones, shadows, outOfGamut)"
+                "unknown select `{other}` (sampledColors, reds, yellows, greens, cyans, blues, magentas, highlights, midtones, shadows, skinTones, outOfGamut)"
             )));
         }
     };
@@ -595,11 +604,51 @@ pub(crate) fn polygon_selection(s: &mut Session, cmd: &str, label: &str, pts: &[
         return Err(EngineError::BadParams { cmd: cmd.into(), msg: "feather must be a number in 0..1000".into() });
     }
     let area = s.active().ok_or(EngineError::NoDocument)?.doc.bounds();
-    let mut mask = sel::polygon(pts, area, b(p, "antiAlias", true));
     if feather > 0.0 {
+        // The blur spreads past the polygon and isn't bit-identical over a smaller window.
+        let mut mask = sel::polygon(pts, area, b(p, "antiAlias", true));
         mask = sel::feather(&mask, area.width() as usize, area.height() as usize, feather);
+        return set_selection(s, label, area, mask, mode(p));
     }
-    set_selection(s, label, area, mask, mode(p))
+    // Only the rows the polygon spans (#4532): rows outside it are empty, and full-width rows
+    // keep `polygon`'s coverage bit-identical (its x arithmetic is relative to the area's left
+    // edge; its y samples are whole rows plus the same sub-row fractions).
+    let band = polygon_rows(pts, area);
+    let mask = sel::polygon(pts, band, b(p, "antiAlias", true));
+    let m = mode(p);
+    let selected = s.edit(label, |doc, _| {
+        doc.selection = combine_band(doc.selection.as_ref(), &mask, band, m);
+        Ok(doc.selection.is_some())
+    })?;
+    Ok(json!({ "selected": selected }))
+}
+
+/// The full-width rows of `area` that points `pts` span (empty when none are finite).
+fn polygon_rows(pts: &[(f32, f32)], area: Rect) -> Rect {
+    let ys = pts.iter().map(|p| p.1).filter(|y| y.is_finite());
+    let (lo, hi) = ys.fold((f32::INFINITY, f32::NEG_INFINITY), |(lo, hi), y| (lo.min(y), hi.max(y)));
+    if lo > hi {
+        return Rect::EMPTY;
+    }
+    let clamp = |v: f32| v.clamp(area.y0 as f32, area.y1 as f32) as i32;
+    let (y0, y1) = (clamp(lo.floor()), clamp(hi.ceil() + 1.0));
+    if y0 >= y1 { Rect::EMPTY } else { Rect::new(area.x0, y0, area.x1, y1) }
+}
+
+/// [`sel::combine`] of a mask covering only `band` (zero elsewhere), giving exactly what the
+/// whole-canvas combine gives: Replace and Intersect are empty outside the band, and Add and
+/// Subtract keep the old selection there.
+fn combine_band(old: Option<&Surface>, mask: &[f32], band: Rect, m: SelectionMode) -> Option<Surface> {
+    let inside = sel::combine(old, mask, band, m);
+    let Some(old) = old.filter(|_| matches!(m, SelectionMode::Add | SelectionMode::Subtract)) else { return inside };
+    if band.is_empty() {
+        return Some(old.clone());
+    }
+    let values = inside.map_or_else(|| vec![0.0; band.width() as usize * band.height() as usize], |w| w.read_region(band));
+    let mut s = old.clone();
+    s.write_region(band, &values);
+    s.prune();
+    (s.tile_count() > 0).then_some(s)
 }
 
 macro_rules! spec {
@@ -623,7 +672,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "select.colorRange",
             "Color Range…",
             ["Select"],
-            r##"{"select":"sampledColors|reds|yellows|greens|cyans|blues|magentas|highlights|midtones|shadows|outOfGamut"="sampledColors","color":"#rrggbb"=foreground,"colors":["#rrggbb",…]?,"points":[[x,y],…]? (eyedropper samples),"subtractPoints":[[x,y],…]? (minus eyedropper),"order":["+"|"-",…]? (click order of points and subtractPoints; default all points first),"fuzziness":0..200=40 (tones: 0..100 %=20),"localized":bool=false,"range":0..100=100 (% of the longer side),"tonalRange":level|[lo,hi] (shadows 65, highlights 190, midtones [105,150]),"invert":bool=false,"sampleAllLayers":bool=true,"mode":"replace|add|subtract|intersect"="replace"}"##,
+            r##"{"select":"sampledColors|reds|yellows|greens|cyans|blues|magentas|highlights|midtones|shadows|skinTones|outOfGamut"="sampledColors","color":"#rrggbb"=foreground,"colors":["#rrggbb",…]?,"points":[[x,y],…]? (eyedropper samples),"subtractPoints":[[x,y],…]? (minus eyedropper),"order":["+"|"-",…]? (click order of points and subtractPoints; default all points first),"fuzziness":0..200=40 (tones: 0..100 %=20),"detectFaces":bool=false (not available yet: refused),"localized":bool=false,"range":0..100=100 (% of the longer side),"tonalRange":level|[lo,hi] (shadows 65, highlights 190, midtones [105,150]),"invert":bool=false,"sampleAllLayers":bool=true,"mode":"replace|add|subtract|intersect"="replace"}"##,
             has_doc,
             color_range
         ),
@@ -692,6 +741,30 @@ mod tests {
         }
     }
 
+    #[test]
+    fn color_range_skin_tones_selects_skin_not_cream_and_refuses_detect_faces() {
+        let mut s = session();
+        let rgb = |c: [u8; 3]| [f32::from(c[0]) / 255.0, f32::from(c[1]) / 255.0, f32::from(c[2]) / 255.0, 1.0];
+        s.edit("paint", |doc, _| {
+            let bg = doc.layers[0].surface_mut().unwrap();
+            bg.fill_rect(Rect::new(0, 0, 40, 30), &rgb([252, 253, 247]));
+            bg.fill_rect(Rect::new(5, 5, 15, 15), &rgb([183, 119, 81]));
+            bg.fill_rect(Rect::new(25, 5, 35, 15), &rgb([231, 225, 202]));
+            Ok(())
+        })
+        .unwrap();
+        s.execute("select.colorRange", json!({"select": "skinTones"})).unwrap();
+        assert!(coverage(&s, 10, 10) > 0.95, "skin");
+        assert!(coverage(&s, 30, 10) < 0.05, "cream");
+        assert!(coverage(&s, 2, 2) < 0.05, "near-white background");
+        // Subtracting skin from a selection of both squares keeps only the cream one.
+        s.execute("select.rect", json!({"x": 5, "y": 5, "width": 30, "height": 10})).unwrap();
+        s.execute("select.colorRange", json!({"select": "skinTones", "mode": "subtract"})).unwrap();
+        assert!(coverage(&s, 10, 10) < 0.05 && coverage(&s, 30, 10) > 0.95, "{} {}", coverage(&s, 10, 10), coverage(&s, 30, 10));
+        let err = s.execute("select.colorRange", json!({"select": "skinTones", "detectFaces": true})).unwrap_err();
+        assert!(err.to_string().contains("detectFaces"), "{err}");
+    }
+
     #[test]
     fn color_range_replace_is_bounded_by_existing_selection() {
         for params in [json!({"color": "#ff0000", "fuzziness": 0}), json!({"select": "reds"})] {
@@ -1238,4 +1311,35 @@ mod tests {
             }
         }
     }
+
+    /// The lasso over the polygon's rows gives exactly the whole-canvas result (#4532): random
+    /// polygons, partly off the canvas, with and without anti-aliasing, in every mode over an
+    /// existing selection.
+    #[test]
+    fn lasso_over_its_rows_matches_the_whole_canvas() {
+        let mut seed = 0x2545_f491_u32;
+        let mut rnd = |lo: f32, hi: f32| {
+            seed ^= seed << 13;
+            seed ^= seed >> 17;
+            seed ^= seed << 5;
+            lo + (seed % 10_000) as f32 / 10_000.0 * (hi - lo)
+        };
+        for case in 0..24 {
+            let mut s = Session::new();
+            s.execute("file.new", json!({"width": 300, "height": 520})).unwrap();
+            s.execute("select.rect", json!({"x": 40, "y": 60, "width": 200, "height": 300})).unwrap();
+            let n = 3 + case % 7;
+            let pts: Vec<(f32, f32)> = (0..n).map(|_| (rnd(-30.0, 330.0), rnd(100.0, 420.0))).collect();
+            let aa = case % 2 == 0;
+            let m = ["replace", "add", "subtract", "intersect"][case % 4];
+            let doc = s.active().unwrap().doc.clone();
+            let area = doc.bounds();
+            let want = sel::combine(doc.selection.as_ref(), &sel::polygon(&pts, area, aa), area, SelectionMode::parse(m));
+            let points: Vec<[f32; 2]> = pts.iter().map(|p| [p.0, p.1]).collect();
+            s.execute("select.lasso", json!({"points": points, "antiAlias": aa, "mode": m})).unwrap();
+            let got = s.active().unwrap().doc.selection.clone();
+            let read = |x: &Option<Surface>| x.as_ref().map(|s| s.read_region(area));
+            assert_eq!(read(&got), read(&want), "case {case}: {m}, anti-alias {aa}, {pts:?}");
+        }
+    }
 }
diff --git a/crates/engine/src/slice_cmds.rs b/crates/engine/src/slice_cmds.rs
index 0d3cceb6f0..959f132927 100644
--- a/crates/engine/src/slice_cmds.rs
+++ b/crates/engine/src/slice_cmds.rs
@@ -50,7 +50,7 @@ fn has_layer_for_slice(s: &Session) -> std::result::Result<(), String> {
     if matches!(l.content, LayerContent::Adjustment(_)) {
         return Err("adjustment layers have no bounds to slice".into());
     }
-    if d.doc.layers.first().is_some_and(|b| b.id == id && b.name == "Background" && b.locks.transparency && b.locks.position) {
+    if d.doc.is_background(id) {
         return Err("the Background layer can't have a layer-based slice".into());
     }
     if d.doc.slices.list.iter().any(|s| s.layer == Some(id)) {
diff --git a/crates/engine/src/smart_cmds.rs b/crates/engine/src/smart_cmds.rs
index 5678a8b7d9..295b845df0 100644
--- a/crates/engine/src/smart_cmds.rs
+++ b/crates/engine/src/smart_cmds.rs
@@ -387,6 +387,20 @@ fn place(name: &str, bytes: &[u8], fmt: PixelFormat, sm: &SmartObject) -> Result
     })
 }
 
+/// The box of a smart object's source in source pixels (what its warp's `us`/`vs` span), or `None`
+/// when the source can't be read.
+pub(crate) fn source_box(doc: &Document, sm: &SmartObject) -> Option<[f64; 4]> {
+    let (name, bytes) = source_bytes(&doc.metadata, &sm.source)?;
+    let fmt = doc.pixel_format();
+    let img = match sm.stack_mode {
+        Some(mode) => stack_image(&name, &bytes, fmt, mode),
+        None => source_image(&name, &bytes, fmt),
+    }
+    .ok()?;
+    let r = img.bounds;
+    Some([f64::from(r.x0), f64::from(r.y0), f64::from(r.x1), f64::from(r.y1)])
+}
+
 /// Renders a smart object from its source. `Ok(None)` when the source is unavailable (a missing
 /// linked file, or a PSD placed layer without embedded data): callers keep the existing cache.
 pub fn render(doc: &Document, sm: &SmartObject) -> Result<Option<Surface>> {
@@ -666,7 +680,7 @@ fn any_layer(l: &Layer, f: &dyn Fn(&Layer) -> bool) -> bool {
 /// blend mode, clipping and label stay on the smart layer. The cache is the exact composite, so
 /// the document looks the same before and after.
 pub fn layer_to_smart(doc: &Document, l: &Layer) -> Result<Layer> {
-    let background = l.name == "Background" && l.locks.position;
+    let background = doc.is_background(l.id);
     let mut inner = l.clone();
     inner.visible = true;
     inner.opacity = 1.0;
@@ -848,12 +862,28 @@ pub fn contents_of(doc: &Document, id: LayerId) -> Result<(String, Arc<Vec<u8>>)
     source_bytes(&doc.metadata, &smart(doc, id)?.source).ok_or_else(|| other("the smart object's contents are unavailable"))
 }
 
+/// Writes the smart object's file as it is. To a path with another extension (a `.png` for
+/// `.psb` or `.pcraft` contents) the contents are opened and exported in that format instead.
 fn export_contents(s: &mut Session, p: &Value) -> Result<Value> {
     let path = path_param("layer.smartObjects.exportContents", p)?;
     let id = layer_param(s, p)?;
     let (name, bytes) = contents_of(&s.active().ok_or(EngineError::NoDocument)?.doc, id)?;
-    crate::file_cmds::write_file(path, &bytes)?;
-    Ok(json!({"path": path, "fileName": name, "bytes": bytes.len()}))
+    let ext = |f: &str| {
+        let e = std::path::Path::new(f).extension().and_then(|e| e.to_str()).map(str::to_ascii_lowercase);
+        e.map(|e| match e.as_str() {
+            "jpeg" => "jpg".to_string(),
+            "tiff" => "tif".to_string(),
+            _ => e,
+        })
+    };
+    if ext(path).is_none() || ext(path) == ext(&name) {
+        crate::file_cmds::write_file(path, &bytes)?;
+        return Ok(json!({"path": path, "fileName": name, "bytes": bytes.len(), "converted": false}));
+    }
+    let contents = decode_source(&name, &bytes)?;
+    let r = photocraft_io::export(&contents, path, &Default::default()).map_err(|e| other(format!("can't export the contents as {}: {e}", base_name(path))))?;
+    crate::file_cmds::write_file(path, &r.bytes)?;
+    Ok(json!({"path": path, "fileName": name, "bytes": r.bytes.len(), "converted": true, "warnings": r.warnings}))
 }
 
 fn edit_contents(s: &mut Session, p: &Value) -> Result<Value> {
@@ -1055,6 +1085,73 @@ fn move_filter(s: &mut Session, p: &Value) -> Result<Value> {
     })
 }
 
+/// Dragging smart filters onto another smart object in the Layers panel (#4271): they move there,
+/// or are copied with `copy` (⌥-drag in Photoshop). One filter (`filter`) lands on top of the
+/// target's filters; all of them (the Smart Filters row) are added on top too, with the filter
+/// mask when the target has none. Both smart objects are re-rendered in one undo step.
+fn transfer_filters(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "layer.smartFilter.transfer";
+    let id_of = |key: &str| p.get(key).and_then(Value::as_u64).map(LayerId).ok_or_else(|| bad(CMD, format!("`{key}` must be a layer id")));
+    let (from, to) = (id_of("from")?, id_of("to")?);
+    if from == to {
+        return Err(bad(CMD, "the smart filters are already on that layer"));
+    }
+    // The other `layer.smartFilter.*` commands name a filter `index`; here a guessed `index`
+    // would otherwise be dropped and every filter moved.
+    if p.get("index").is_some() {
+        return Err(bad(CMD, "name the filter with `filter` (no `filter`: all of them)"));
+    }
+    let copy = p.get("copy").and_then(Value::as_bool).unwrap_or(false);
+    let doc = &s.active().ok_or(EngineError::NoDocument)?.doc;
+    let src = smart(doc, from)?;
+    smart(doc, to).map_err(|_| bad(CMD, "smart filters can only be dropped on a smart object"))?;
+    let n = src.smart_filters.len();
+    if n == 0 {
+        return Err(other("the smart object has no smart filters"));
+    }
+    let index = match p.get("filter") {
+        None | Some(Value::Null) => None,
+        Some(v) => Some(v.as_u64().map(|i| i as usize).filter(|i| *i < n).ok_or_else(|| bad(CMD, format!("`filter` must be 0..{n} (0 = bottom filter)")))?),
+    };
+    let (filters, mask) = match index {
+        Some(i) => (vec![src.smart_filters[i].clone()], None),
+        None => (src.smart_filters.clone(), src.filter_mask.clone()),
+    };
+    let label = match (copy, index.is_some()) {
+        (true, true) => "Copy Smart Filter",
+        (true, false) => "Copy Smart Filters",
+        (false, true) => "Move Smart Filter",
+        (false, false) => "Move Smart Filters",
+    };
+    crate::jobs::edit_job(
+        s,
+        label,
+        move |doc, _, ctx| {
+            let dst = smart_mut(doc, to)?;
+            dst.smart_filters.extend(filters);
+            if dst.filter_mask.is_none() {
+                dst.filter_mask = mask;
+            }
+            refresh_or_fail_in(doc, to, ctx)?;
+            if !copy {
+                let src = smart_mut(doc, from)?;
+                match index {
+                    Some(i) => {
+                        src.smart_filters.remove(i);
+                    }
+                    None => {
+                        src.smart_filters.clear();
+                        src.filter_mask = None;
+                    }
+                }
+                refresh_or_fail_in(doc, from, ctx)?;
+            }
+            Ok(())
+        },
+        move |()| json!({"from": from.0, "to": to.0}),
+    )
+}
+
 // ---------- enablement ----------
 
 fn active_smart(s: &Session) -> std::result::Result<&SmartObject, String> {
@@ -1074,6 +1171,9 @@ fn has_linked(s: &Session) -> std::result::Result<(), String> {
         _ => Err("the smart object is embedded".into()),
     }
 }
+fn has_doc(s: &Session) -> std::result::Result<(), String> {
+    s.active().map(|_| ()).ok_or_else(|| "no document open".into())
+}
 fn has_smart_filters(s: &Session) -> std::result::Result<(), String> {
     if active_smart(s)?.smart_filters.is_empty() { Err("the smart object has no smart filters".into()) } else { Ok(()) }
 }
@@ -1132,7 +1232,14 @@ pub fn specs() -> Vec<CommandSpec> {
             Ok(json!({"updated": commit_child(s, i)?}))
         }),
         spec!("layer.smartObjects.replaceContents", "Replace Contents…", SO, r##"{"layer":id?,"path":str}"##, has_smart, replace_contents),
-        spec!("layer.smartObjects.exportContents", "Export Contents…", SO, r##"{"layer":id?,"path":str}"##, has_smart, export_contents),
+        spec!(
+            "layer.smartObjects.exportContents",
+            "Export Contents…",
+            SO,
+            r##"{"layer":id?,"path":str (another extension than the contents' own exports them in that format)}"##,
+            has_smart,
+            export_contents
+        ),
         spec!("layer.smartObjects.relinkToFile", "Relink to File…", SO, r##"{"layer":id?,"path":str}"##, has_smart, |s, p| {
             let path = path_param("layer.smartObjects.relinkToFile", p)?.to_string();
             set_source(s, p, "Relink to File", false, |_, _| Ok(SmartSource::Linked { path }))
@@ -1255,6 +1362,14 @@ pub fn specs() -> Vec<CommandSpec> {
         ),
         spec!("layer.smartFilter.delete", "Delete Smart Filter", &[], r##"{"layer":id?,"index":u32?}"##, has_smart_filters, delete_filter),
         spec!("layer.smartFilter.move", "Move Smart Filter", &[], r##"{"layer":id?,"index":u32?,"to":u32}"##, has_smart_filters, move_filter),
+        spec!(
+            "layer.smartFilter.transfer",
+            "Move or Copy Smart Filters",
+            &[],
+            r##"{"from":id,"to":id,"filter":u32? (default: all, with the filter mask),"copy":bool=false}"##,
+            has_doc,
+            transfer_filters
+        ),
     ]
 }
 
diff --git a/crates/engine/src/smart_cmds/tests.rs b/crates/engine/src/smart_cmds/tests.rs
index 2ee54322bf..a764712c9f 100644
--- a/crates/engine/src/smart_cmds/tests.rs
+++ b/crates/engine/src/smart_cmds/tests.rs
@@ -247,6 +247,69 @@ fn smart_filter_commands_check_an_explicit_layer_target() {
     assert_eq!(active(&s), curves);
 }
 
+/// #4271: dragging smart filters onto another smart object moves them, ⌥-dragging copies them;
+/// one filter or all of them (with the filter mask), each in one undo step.
+#[test]
+fn smart_filters_move_or_copy_to_another_smart_object() {
+    let mut s = session(8);
+    paint(&mut s);
+    let a = convert(&mut s);
+    s.execute("select.rect", json!({"x": 0, "y": 0, "width": 16, "height": 48})).unwrap();
+    s.execute("filter.other.offset", json!({"horizontal": 5, "undefinedAreas": "transparent"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    s.execute("filter.blur.gaussianBlur", json!({"radius": 3})).unwrap();
+    s.execute("layer.new.layer", json!({})).unwrap();
+    paint(&mut s);
+    let b = convert(&mut s);
+    let pixel = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+    let so = |s: &Session, id: u64| match &s.active().unwrap().doc.layer(LayerId(id)).unwrap().content {
+        LayerContent::Smart(sm) => sm.clone(),
+        other => panic!("not smart: {}", other.kind_name()),
+    };
+    let commands = |sm: &SmartObject| sm.smart_filters.iter().map(|f| f.command.clone()).collect::<Vec<_>>();
+    let (offset, blur) = ("filter.other.offset", "filter.blur.gaussianBlur");
+    assert_eq!(commands(&so(&s, a)), [offset, blur]);
+    assert!(so(&s, a).filter_mask.is_some());
+    let before = flat(&s);
+
+    // ⌥-drag the blur: B gets a copy (re-rendered), A keeps it.
+    s.execute("layer.smartFilter.transfer", json!({"from": a, "to": b, "filter": 1, "copy": true})).unwrap();
+    assert_eq!(commands(&so(&s, b)), [blur]);
+    assert_eq!(commands(&so(&s, a)), [offset, blur]);
+    assert!(so(&s, b).filter_mask.is_none(), "one filter comes without the mask");
+    assert!(max_diff(&flat(&s), &before) > 1e-3, "B is blurred");
+    s.undo();
+    assert!(so(&s, b).smart_filters.is_empty());
+    assert_eq!(flat(&s), before);
+
+    // Drag the offset: it moves to the top of B's filters.
+    s.redo();
+    s.execute("layer.smartFilter.transfer", json!({"from": a, "to": b, "filter": 0})).unwrap();
+    assert_eq!(commands(&so(&s, a)), [blur]);
+    assert_eq!(commands(&so(&s, b)), [blur, offset]);
+
+    // Drag the Smart Filters row: all of A's filters and its filter mask move to B.
+    let mask = so(&s, a).filter_mask;
+    s.execute("layer.smartFilter.transfer", json!({"from": a, "to": b})).unwrap();
+    assert!(so(&s, a).smart_filters.is_empty() && so(&s, a).filter_mask.is_none());
+    assert_eq!(commands(&so(&s, b)), [blur, offset, blur]);
+    assert_eq!(so(&s, b).filter_mask, mask);
+    s.undo();
+    assert_eq!(so(&s, a).smart_filters.len(), 1);
+    assert_eq!(so(&s, b).smart_filters.len(), 2);
+
+    // Refused: onto itself, onto a layer that isn't a smart object, a bad index, no filters.
+    let transfer = |s: &mut Session, p: Value| s.execute("layer.smartFilter.transfer", p);
+    assert!(transfer(&mut s, json!({"from": a, "to": a})).is_err());
+    assert!(transfer(&mut s, json!({"from": a, "to": pixel})).is_err());
+    assert!(transfer(&mut s, json!({"from": a, "to": b, "filter": 5})).is_err());
+    assert!(transfer(&mut s, json!({"from": a, "to": b, "index": 0})).is_err(), "`index` isn't taken for `filter`");
+    assert!(transfer(&mut s, json!({"from": pixel, "to": b})).is_err());
+    s.execute("layer.smartFilter.clearSmartFilters", json!({"layer": a})).unwrap();
+    assert!(transfer(&mut s, json!({"from": a, "to": b})).is_err());
+    assert_eq!(so(&s, b).smart_filters.len(), 2, "nothing changed");
+}
+
 #[test]
 fn selection_becomes_the_filter_mask() {
     let mut s = session(8);
@@ -466,8 +529,18 @@ fn export_replace_and_linked_contents() {
     paint(&mut s);
     convert(&mut s);
     let out = dir.join("contents.pcraft");
-    s.execute("layer.smartObjects.exportContents", json!({"path": out.to_str().unwrap()})).unwrap();
+    let r = s.execute("layer.smartObjects.exportContents", json!({"path": out.to_str().unwrap()})).unwrap();
     assert!(photocraft_format::is_pcraft(&std::fs::read(&out).unwrap()));
+    assert_eq!(r["converted"], false);
+    // Another extension exports the contents in that format.
+    for (ext, magic) in [("png", &b"\x89PNG"[..]), ("jpeg", &b"\xFF\xD8\xFF"[..]), ("psd", &b"8BPS"[..])] {
+        let other = dir.join(format!("contents.{ext}"));
+        let r = s.execute("layer.smartObjects.exportContents", json!({"path": other.to_str().unwrap()})).unwrap();
+        assert_eq!(r["converted"], true, "{ext}");
+        assert!(std::fs::read(&other).unwrap().starts_with(magic), "{ext}");
+    }
+    let bad = dir.join("contents.nope");
+    assert!(s.execute("layer.smartObjects.exportContents", json!({"path": bad.to_str().unwrap()})).is_err());
     // Replace with a flat PNG.
     let png_doc = Document::with_background(
         "p",
@@ -622,6 +695,30 @@ fn warp_on_a_distorted_smart_object_follows_the_corners() {
     assert_eq!(after.perspective, before);
 }
 
+/// A `mesh` whose points are exactly the placement leaves a sheared smart object unchanged: its
+/// knots span the contents, not the bounding frame of the warp box seen from the contents (#4113).
+#[test]
+fn identity_mesh_on_a_skewed_smart_object_changes_nothing() {
+    let mut s = session(8);
+    paint(&mut s);
+    let id = convert(&mut s);
+    let r = active_smart(&s).cache.unwrap().content_bounds();
+    let (x0, y0, x1, y1) = (f64::from(r.x0), f64::from(r.y0), f64::from(r.x1), f64::from(r.y1));
+    let quad = [[x0, y0], [x1, y0 + 10.0], [x1, y1 + 10.0], [x0, y1]];
+    s.execute("edit.transform", json!({"layer": id, "rect": [x0, y0, x1, y1], "quad": quad})).unwrap();
+    let before = flat(&s);
+    let sm = active_smart(&s);
+    let (h, b) = (placement(&sm), crate::smart_cmds::source_box(&s.active().unwrap().doc, &sm).unwrap());
+    let place = |u: f64, v: f64| {
+        let (x, y) = h.apply(b[0] + u * (b[2] - b[0]), b[1] + v * (b[3] - b[1]));
+        [x, y]
+    };
+    let mesh = photocraft_geom::warp::BezierMesh::fit(&place, vec![0.0, 1.0], vec![0.0, 0.25, 1.0]);
+    let rect = [x0, y0, x1, y1 + 10.0];
+    s.execute("layer.smartObjects.warp", json!({"layer": id, "style": "custom", "rect": rect, "mesh": mesh})).unwrap();
+    assert!(mean_diff(&before, &flat(&s)) < 0.01, "mean diff {}", mean_diff(&before, &flat(&s)));
+}
+
 fn convert_to_layers(s: &mut Session) -> Value {
     s.execute("layer.smartObjects.convertToLayers", json!({})).unwrap()
 }
@@ -965,6 +1062,10 @@ fn inspect_reports_the_smart_source() {
     let source = |s: &Session| crate::inspect::layer(s.active().unwrap().doc.layer(s.active().unwrap().active_layer.unwrap()).unwrap())["smartSource"].clone();
     let front = source(&s);
     assert_eq!(front, json!({"kind": "linked", "path": "uuid-1"}));
+    // The document's info knows the file is embedded in the PSD (a `liFD` item) and says so,
+    // with its file name; the uuid stays its key.
+    let info = crate::inspect::document(s.active().unwrap());
+    assert_eq!(info["layers"][0]["smartSource"], json!({"kind": "embedded", "fileName": "in.png", "uuid": "uuid-1"}));
     // A duplicate shares the file; New Smart Object via Copy gets its own.
     s.execute("layer.duplicate", json!({})).unwrap();
     assert_eq!(source(&s), front, "a duplicate shares its source");
@@ -977,3 +1078,33 @@ fn inspect_reports_the_smart_source() {
     assert_eq!(source(&s)["kind"], "embedded");
     assert!(source(&s)["fileName"].is_string());
 }
+
+#[test]
+fn displace_smart_filter_reads_its_map_path_on_re_render() {
+    let dir = std::env::temp_dir().join(format!("pcraft-displace-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    // A white map displaces by the full scale; mid-grey would not move anything.
+    let white = Document::with_background(
+        "map",
+        Size::new(W as u32, H as u32),
+        photocraft_color::ColorMode::Rgb,
+        photocraft_color::SampleType::U8,
+        photocraft_color::Color::rgba(1.0, 1.0, 1.0, 1.0),
+    );
+    let map = dir.join("white.png");
+    std::fs::write(&map, photocraft_io::export(&white, "png", &Default::default()).unwrap().bytes).unwrap();
+    for depth in DEPTHS {
+        let mut s = session(depth);
+        paint(&mut s);
+        convert(&mut s);
+        let before = flat(&s);
+        s.execute("filter.distort.displace", json!({"horizontal": 8, "vertical": 8, "mapPath": map.to_str().unwrap()})).unwrap();
+        assert!(max_diff(&before, &flat(&s)) > 0.1, "the smart filter displaced the pixels at {depth}-bit");
+        // A later re-render (here: hide and show the filter) reads the map again.
+        s.execute("layer.smartFilter.setVisible", json!({"index": 0, "visible": false})).unwrap();
+        assert_eq!(max_diff(&before, &flat(&s)), 0.0, "hidden at {depth}-bit");
+        s.execute("layer.smartFilter.setVisible", json!({"index": 0, "visible": true})).unwrap();
+        assert!(max_diff(&before, &flat(&s)) > 0.1, "shown again at {depth}-bit");
+    }
+    std::fs::remove_dir_all(&dir).ok();
+}
diff --git a/crates/engine/src/smart_cmds/unpack.rs b/crates/engine/src/smart_cmds/unpack.rs
index 8ddfa3d8b5..0fdf3ac3fa 100644
--- a/crates/engine/src/smart_cmds/unpack.rs
+++ b/crates/engine/src/smart_cmds/unpack.rs
@@ -32,9 +32,10 @@ fn contents(s: &Session, doc: &Document, sm: &SmartObject, intent: Intent, bpc:
     if src.depth != doc.depth {
         crate::image_cmds::convert_layers_depth(&mut src.layers, doc.depth);
     }
+    let background_id = src.background().map(|l| l.id);
     let mut layers = std::mem::take(&mut src.layers);
     for l in &mut layers {
-        if crate::extra_cmds::is_background(l) {
+        if Some(l.id) == background_id {
             l.name = "Layer 0".into();
             l.locks = Default::default();
         }
diff --git a/crates/engine/src/smartselect_cmds.rs b/crates/engine/src/smartselect_cmds.rs
index 6c15c6be56..651db7cdc0 100644
--- a/crates/engine/src/smartselect_cmds.rs
+++ b/crates/engine/src/smartselect_cmds.rs
@@ -130,8 +130,124 @@ fn rect_param(p: &Value) -> Option<Rect> {
     Some(Rect::new(x0.floor() as i32, y0.floor() as i32, x1.ceil() as i32, y1.ceil() as i32))
 }
 
+fn point_param(p: &Value) -> Option<(f32, f32)> {
+    let a = p.get("point")?.as_array()?;
+    let (x, y) = (a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32);
+    (x.is_finite() && y.is_finite()).then_some((x, y))
+}
+
+/// The layer [`with_doc_sampler`] samples for `layer` / `all_layers`: `None` = the composite.
+pub fn sampled_target(doc: &Document, layer: Option<LayerId>, all_layers: bool) -> Option<LayerId> {
+    layer.filter(|id| !all_layers && doc.layer(*id).and_then(Layer::surface).is_some())
+}
+
+/// Object Finder (#4087): the object Object Selection would select at document point `(x, y)`,
+/// sampling `layer` (or the composite). Pure, so the UI can run it on a worker thread while the
+/// pointer hovers; `select.object` with `"point"` commits the same result.
+pub fn find_object(doc: &Document, layer: Option<LayerId>, all_layers: bool, x: f32, y: f32) -> Option<Region> {
+    with_doc_sampler(doc, layer, all_layers, |smp, doc| grabcut::object_at(smp, doc.bounds(), x, y, grabcut::OBJECT_AT_WORK_PX))
+}
+
+/// Most objects remembered by [`ObjectFinderCache`].
+pub const OBJECT_FINDER_ENTRIES: usize = 12;
+
+/// Object Finder results for one document's pixels (#4087): hovering over an object already
+/// found, or clicking it, answers at once. Keyed like [`SubjectCache`] (valid while the pixels
+/// are the same, the document held weakly) plus the sampled layer; a lookup hits any cached
+/// object that covers the point, so one computation serves the whole object.
+#[derive(Debug, Default)]
+pub struct ObjectFinderCache {
+    doc: std::sync::Weak<Document>,
+    doc_id: Option<photocraft_doc::DocId>,
+    target: Option<LayerId>,
+    regions: Vec<std::sync::Arc<Region>>,
+}
+
+impl ObjectFinderCache {
+    fn valid(&self, doc: &Document, target: Option<LayerId>) -> bool {
+        self.doc_id == Some(doc.id) && self.target == target && self.doc.upgrade().is_some_and(|old| crate::layer_multi_cmds::same_pixels(&old, doc))
+    }
+
+    /// A cached object of `doc` (sampling `target`) covering `(x, y)`.
+    pub fn lookup(&self, doc: &Document, target: Option<LayerId>, x: f32, y: f32) -> Option<std::sync::Arc<Region>> {
+        if !x.is_finite() || !y.is_finite() || !self.valid(doc, target) {
+            return None;
+        }
+        let (px, py) = (x.floor() as i32, y.floor() as i32);
+        self.regions.iter().find(|r| r.at(px, py) >= 0.5).cloned()
+    }
+
+    /// Remembers `region`, found in `doc` sampling `target`. A different document or pixels
+    /// start over; the oldest object is dropped beyond [`OBJECT_FINDER_ENTRIES`].
+    pub fn insert(&mut self, doc: &std::sync::Arc<Document>, target: Option<LayerId>, region: std::sync::Arc<Region>) {
+        if !self.valid(doc, target) {
+            self.regions.clear();
+        }
+        self.doc = std::sync::Arc::downgrade(doc);
+        self.doc_id = Some(doc.id);
+        self.target = target;
+        if self.regions.len() >= OBJECT_FINDER_ENTRIES {
+            self.regions.remove(0);
+        }
+        self.regions.push(region);
+    }
+
+    /// Number of remembered objects.
+    pub fn len(&self) -> usize {
+        self.regions.len()
+    }
+
+    /// Whether nothing is remembered.
+    pub fn is_empty(&self) -> bool {
+        self.regions.is_empty()
+    }
+
+    /// Forget the results if they were computed from the document `id` (it is closing).
+    pub(crate) fn forget_doc(&mut self, id: photocraft_doc::DocId) {
+        if self.doc_id == Some(id) {
+            *self = Self::default();
+        }
+    }
+
+    /// Follows `doc` past a selection-only edit (same pixels), so the next lookup still hits.
+    fn follow(&mut self, doc: &std::sync::Arc<Document>) {
+        if self.doc_id == Some(doc.id) && self.doc.upgrade().is_some_and(|old| crate::layer_multi_cmds::same_pixels(&old, doc)) {
+            self.doc = std::sync::Arc::downgrade(doc);
+        }
+    }
+}
+
+/// `select.object` with `"point"`: the Object Finder's object under the point (cached).
+fn object_at_point(s: &mut Session, p: &Value, (x, y): (f32, f32)) -> Result<Value> {
+    let all_layers = b(p, "sampleAllLayers", false);
+    let d = s.active().ok_or(EngineError::NoDocument)?;
+    let target = sampled_target(&d.doc, d.active_layer, all_layers);
+    let region = match s.object_finder.lookup(&d.doc, target, x, y) {
+        Some(r) => Some(r),
+        None => {
+            let doc = std::sync::Arc::clone(&d.doc);
+            let found = find_object(&doc, d.active_layer, all_layers, x, y).map(std::sync::Arc::new);
+            if let Some(r) = &found {
+                s.object_finder.insert(&doc, target, std::sync::Arc::clone(r));
+            }
+            found
+        }
+    };
+    let out = apply(s, "Object Selection", region.as_deref(), mode(p, "replace"))?;
+    if let Some(d) = s.active() {
+        let doc = std::sync::Arc::clone(&d.doc);
+        s.object_finder.follow(&doc);
+    }
+    Ok(out)
+}
+
 fn object_selection(s: &mut Session, p: &Value) -> Result<Value> {
-    let rect = rect_param(p).ok_or_else(|| bad("select.object", "needs \"rect\": [x, y, w, h]"))?;
+    if p.get("rect").is_none()
+        && let Some(pt) = point_param(p)
+    {
+        return object_at_point(s, p, pt);
+    }
+    let rect = rect_param(p).ok_or_else(|| bad("select.object", "needs \"rect\": [x, y, w, h] or \"point\": [x, y]"))?;
     let region = with_sampler(s, b(p, "sampleAllLayers", false), |smp, doc| grabcut::object_select(smp, doc.bounds(), rect, 160_000))?;
     apply(s, "Object Selection", region.as_ref(), mode(p, "replace"))
 }
@@ -281,7 +397,8 @@ fn refine_edge(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let region = with_sampler(s, b(p, "sampleAllLayers", false), |smp, doc| {
         let mask_surf = active.and_then(|id| doc.layer(id)).and_then(|l| l.mask.as_ref()).map(|m| &m.surface);
-        let sel = doc.selection.as_ref().or(mask_surf)?;
+        let target_mask = p.get("target").and_then(Value::as_str) == Some("mask");
+        let sel = if target_mask { mask_surf.or(doc.selection.as_ref()) } else { doc.selection.as_ref().or(mask_surf) }?;
         let brush = matting::EdgeBrush::new(&strokes, doc.bounds());
         matting::refine_mask_brushed(smp, &matting::surface_reader(sel), sel.content_bounds(), doc.bounds(), &params, brush.as_ref())
     })?;
@@ -300,7 +417,8 @@ fn refine_edge(s: &mut Session, p: &Value) -> Result<Value> {
             s.edit("Select and Mask", |doc, _| {
                 let surface =
                     region.as_ref().map(matting::region_surface).unwrap_or_else(|| photocraft_raster::Surface::new(photocraft_color::PixelFormat::GRAY8));
-                doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?.mask = Some(LayerMask { surface, ..LayerMask::reveal_all() });
+                let existing = doc.layer(id).and_then(|l| l.mask.as_ref()).cloned().unwrap_or_else(LayerMask::reveal_all);
+                doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?.mask = Some(LayerMask { surface, ..existing });
                 doc.selection = None;
                 Ok(())
             })?;
@@ -373,7 +491,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "select.object",
             "Object Selection",
             [],
-            r##"{"rect":[x,y,w,h],"mode":"replace|add|subtract|intersect"="replace","sampleAllLayers":bool=false}"##,
+            r##"{"rect":[x,y,w,h] | "point":[x,y],"mode":"replace|add|subtract|intersect"="replace","sampleAllLayers":bool=false} (point: the Object Finder's object under the point, as hovering previews it)"##,
             has_doc,
             object_selection
         ),
@@ -544,6 +662,59 @@ mod tests {
         assert!(cov(&s, 10, 10) >= 0.99);
     }
 
+    #[test]
+    fn object_selection_point_selects_the_object_under_it() {
+        for depth in [8, 16, 32] {
+            let (mut s, inside) = disc(depth);
+            let r = s.execute("select.object", json!({"point": [100, 80]})).unwrap();
+            assert_eq!(r["changed"], true, "depth {depth}");
+            let v = sel_iou(&s, 200, 160, &inside);
+            assert!(v > 0.9, "depth {depth}: IoU {v}");
+        }
+        // The background is no object: nothing changes.
+        let (mut s, _) = disc(8);
+        let r = s.execute("select.object", json!({"point": [3, 3]})).unwrap();
+        assert_eq!(r["changed"], false);
+        assert!(s.active().unwrap().doc.selection.is_none());
+        assert!(s.execute("select.object", json!({"point": ["a", 1]})).is_err());
+    }
+
+    #[test]
+    fn object_selection_point_honours_the_modes() {
+        let (mut s, _) = disc(8);
+        s.execute("select.all", json!({})).unwrap();
+        s.execute("select.object", json!({"point": [100, 80], "mode": "subtract"})).unwrap();
+        assert!(cov(&s, 100, 80) < 0.5 && cov(&s, 3, 3) >= 0.5);
+        s.execute("select.object", json!({"point": [100, 80], "mode": "add"})).unwrap();
+        assert!(cov(&s, 100, 80) >= 0.5 && cov(&s, 3, 3) >= 0.5);
+        s.execute("select.object", json!({"point": [100, 80], "mode": "intersect"})).unwrap();
+        assert!(cov(&s, 100, 80) >= 0.5 && cov(&s, 3, 3) < 0.5);
+    }
+
+    #[test]
+    fn object_finder_cache_serves_the_whole_object_until_pixels_change() {
+        let (mut s, _) = disc(8);
+        let d = s.active().unwrap();
+        let doc = std::sync::Arc::clone(&d.doc);
+        let target = sampled_target(&doc, d.active_layer, false);
+        assert!(s.object_finder.lookup(&doc, target, 100.0, 80.0).is_none());
+        let r = std::sync::Arc::new(find_object(&doc, d.active_layer, false, 100.0, 80.0).unwrap());
+        s.object_finder.insert(&doc, target, std::sync::Arc::clone(&r));
+        // Any point on the object hits; the background and another target miss.
+        assert!(std::sync::Arc::ptr_eq(&s.object_finder.lookup(&doc, target, 120.0, 90.0).unwrap(), &r));
+        assert!(s.object_finder.lookup(&doc, target, 3.0, 3.0).is_none());
+        assert!(s.object_finder.lookup(&doc, Some(LayerId(9999)), 100.0, 80.0).is_none());
+        // The click reuses it, and a selection-only edit keeps it.
+        s.execute("select.object", json!({"point": [110, 70]})).unwrap();
+        assert_eq!(s.object_finder.len(), 1);
+        s.execute("select.deselect", json!({})).unwrap();
+        let d = s.active().unwrap();
+        assert!(s.object_finder.lookup(&std::sync::Arc::clone(&d.doc), target, 100.0, 80.0).is_some());
+        // A pixel edit drops it.
+        s.execute("paint.pencil", json!({"points": [[5, 5], [30, 5]], "size": 4, "color": "#000000"})).unwrap();
+        assert!(s.object_finder.is_empty());
+    }
+
     #[test]
     fn object_selection_disc() {
         for depth in [8, 16, 32] {
@@ -652,6 +823,31 @@ mod tests {
         assert!(s.active().unwrap().doc.layers[0].mask.is_none());
         assert!(s.active().unwrap().doc.selection.is_some());
 
+        // Existing mask settings (density, feather, linked) are preserved
+        s.edit("set mask", |doc, _| {
+            doc.layers[0].mask = Some(photocraft_doc::LayerMask {
+                surface: photocraft_raster::Surface::new(photocraft_color::PixelFormat::GRAY8),
+                density: 0.75,
+                feather: 3.5,
+                linked: false,
+                enabled: true,
+            });
+            Ok(())
+        })
+        .unwrap();
+        let r = s.execute("select.refineEdge", json!({"radius": 8, "output": "layerMask"})).unwrap();
+        let l = s.active().unwrap().doc.layer(photocraft_doc::LayerId(r["layer"].as_u64().unwrap())).unwrap();
+        let m = l.mask.as_ref().unwrap();
+        assert_eq!(m.density, 0.75);
+        assert_eq!(m.feather, 3.5);
+        assert!(!m.linked);
+        s.execute("edit.undo", json!({})).unwrap();
+        s.edit("clear mask", |doc, _| {
+            doc.layers[0].mask = None;
+            Ok(())
+        })
+        .unwrap();
+
         // New layer: pixels with the refined alpha; the source is hidden.
         let r = s.execute("select.refineEdge", json!({"radius": 8, "feather": 1, "output": "newLayer"})).unwrap();
         let d = s.active().unwrap();
diff --git a/crates/engine/src/swatch_cmds.rs b/crates/engine/src/swatch_cmds.rs
index 72b0c783b7..7844124bdb 100644
--- a/crates/engine/src/swatch_cmds.rs
+++ b/crates/engine/src/swatch_cmds.rs
@@ -600,8 +600,18 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
     // Names stay unique across the library (agents address swatches by name).
     let mut next: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
     let mut taken: std::collections::HashSet<String> = lib.iter().flat_map(|g| g.items.iter().map(|i| i.name.clone())).collect();
+    // Group names are numbered from 1 as in `unique_group` ("Grays 1"), and the numbering
+    // resumes per base name.
+    let mut group_next: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
+    let mut group_taken: std::collections::HashSet<String> = lib.iter().map(|g| g.name.clone()).collect();
     for mut g in groups {
-        g.name = unique_group(&lib, &g.name);
+        if group_taken.contains(&g.name) {
+            let from = group_next.get(&g.name).copied().unwrap_or(1);
+            let (i, n) = (from..).map(|i| (i, format!("{} {i}", g.name))).find(|(_, n)| !group_taken.contains(n)).unwrap_or((from, g.name.clone()));
+            group_next.insert(g.name.clone(), i + 1);
+            g.name = n;
+        }
+        group_taken.insert(g.name.clone());
         for sw in &mut g.items {
             if taken.contains(&sw.name) {
                 // Resume numbering per base name, so a file of identical names stays linear.
diff --git a/crates/engine/src/swatch_cmds/tests.rs b/crates/engine/src/swatch_cmds/tests.rs
index 4a92441b71..2a3e8e7ddb 100644
--- a/crates/engine/src/swatch_cmds/tests.rs
+++ b/crates/engine/src/swatch_cmds/tests.rs
@@ -14,10 +14,11 @@ fn export_bytes(s: &mut Session, p: Value) -> Vec<u8> {
 fn defaults_and_listing() {
     let mut s = Session::new();
     let r = s.execute("swatches.list", json!({})).unwrap();
-    assert_eq!(r["count"], 40);
+    assert_eq!(r["count"], 46);
     assert_eq!(r["groups"][0]["name"], "Grays");
     assert_eq!(r["groups"][0]["swatches"][0], json!({"name": "Black", "model": "rgb", "values": [0.0, 0.0, 0.0], "hex": "#000000"}));
-    assert_eq!(r["groups"][2]["swatches"][0]["hex"], "#e62828");
+    assert_eq!(r["groups"][1]["swatches"][2]["hex"], "#00ff00", "RGB Green is exact (#4302)");
+    assert_eq!(r["groups"][3]["swatches"][0]["hex"], "#e62828");
 }
 
 #[test]
@@ -67,7 +68,7 @@ fn rename_delete_move_and_groups() {
     assert_eq!(s.presets.swatches[0].items[0].name, "White");
     let r = s.execute("swatches.move", json!({"swatch": "White", "to": "Dark", "position": 1})).unwrap();
     assert_eq!(r, json!({"group": "Dark", "position": 1}));
-    assert_eq!(s.presets.swatches[3].items[1].name, "White");
+    assert_eq!(s.presets.swatches[4].items[1].name, "White");
     // Out-of-range positions clamp.
     let r = s.execute("swatches.move", json!({"swatch": "White", "position": 999_999})).unwrap();
     assert_eq!(r["position"], 10);
@@ -80,21 +81,21 @@ fn rename_delete_move_and_groups() {
     assert!(s.execute("swatches.renameGroup", json!({"group": "Favourites", "name": "Dark"})).is_err());
     let r = s.execute("swatches.deleteGroup", json!({"group": "Favourites", "keepSwatches": true})).unwrap();
     assert_eq!(r["kept"], 2);
-    assert!(s.presets.swatches[3].items.iter().any(|i| i.name == "Red"), "kept in the group above");
+    assert!(s.presets.swatches[4].items.iter().any(|i| i.name == "Red"), "kept in the group above");
     s.execute("swatches.deleteGroup", json!({"group": "Mine 1"})).unwrap();
     // Delete several by name, and one by index.
     let r = s.execute("swatches.delete", json!({"swatch": ["Red", "Blue", "Red"]})).unwrap();
     assert_eq!(r["deleted"].as_array().unwrap().len(), 2);
     let r = s.execute("swatches.delete", json!({"index": 0})).unwrap();
     assert_eq!(r["deleted"], json!(["Ink Black"]));
-    assert_eq!(names(&s).len(), 37);
+    assert_eq!(names(&s).len(), 43);
     // Reset restores the defaults; append adds them again with unique names.
     s.execute("swatches.reset", json!({})).unwrap();
-    assert_eq!(names(&s).len(), 40);
+    assert_eq!(names(&s).len(), 46);
     s.execute("swatches.reset", json!({"append": true})).unwrap();
-    assert_eq!(names(&s).len(), 80);
+    assert_eq!(names(&s).len(), 92);
     assert!(names(&s).contains(&"Black 2".to_string()));
-    assert_eq!(s.presets.swatches[4].name, "Grays 1");
+    assert_eq!(s.presets.swatches[5].name, "Grays 1");
 }
 
 #[test]
@@ -220,7 +221,7 @@ fn bad_params_fail_gracefully() {
         ("swatches.delete", json!({"swatch": "Nope"})),
         ("swatches.delete", json!({"swatch": ["Red", 5]})),
         ("swatches.delete", json!({"swatch": ["Red", "Nope"]})),
-        ("swatches.delete", json!({"index": 40})),
+        ("swatches.delete", json!({"index": 46})),
         ("swatches.delete", json!({"index": "0"})),
         ("swatches.delete", json!({"swatch": "Red", "group": "Grays"})),
         ("swatches.rename", json!({"swatch": "Red"})),
@@ -264,7 +265,7 @@ fn bad_params_fail_gracefully() {
     assert_eq!(s.presets.swatches, before, "failed commands change nothing");
     // Empty library: the swatch commands are disabled, not crashing.
     s.execute("swatches.delete", json!({"swatch": names(&s)})).unwrap();
-    for g in ["Grays", "Pastel", "Pure", "Dark"] {
+    for g in ["Grays", "RGB", "Pastel", "Pure", "Dark"] {
         s.execute("swatches.deleteGroup", json!({"group": g})).unwrap();
     }
     for id in ["swatches.delete", "swatches.rename", "swatches.move", "swatches.use", "swatches.export", "swatches.renameGroup", "swatches.deleteGroup"] {
@@ -289,3 +290,74 @@ fn library_limits() {
     assert_eq!(total(&g), MAX_SWATCHES);
     assert_eq!(g[0].name.chars().count(), MAX_NAME);
 }
+
+/// Groups without a name take the import's group name. The import used to number each repeated
+/// group name by searching the library once for every number it tried, so importing about 10,000
+/// unnamed groups took minutes. The test fails when the import takes more than 20 seconds.
+#[test]
+fn unnamed_groups_are_numbered_in_linear_time() {
+    let (tx, rx) = std::sync::mpsc::channel();
+    std::thread::spawn(move || {
+        let mut s = Session::new();
+        s.execute("swatches.newGroup", json!({"name": "Ink 2"})).unwrap();
+        let n = MAX_GROUPS - s.presets.swatches.len();
+        let paper = AseSwatch { name: "Paper".into(), color: AseColor::Gray(1.0), kind: AseKind::Process };
+        let mut entries = vec![AseEntry::Group { name: String::new(), swatches: Vec::new() }; n];
+        entries[0] = AseEntry::Group { name: String::new(), swatches: vec![paper] };
+        let file = b64_encode(&photocraft_psd::ase::write(&AseFile { entries }).unwrap());
+        let r = s.execute("swatches.import", json!({"data": file, "group": "Ink"})).unwrap();
+        assert_eq!(s.presets.swatches.len(), MAX_GROUPS);
+        let names: Vec<String> = r["groups"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
+        let _ = tx.send(names);
+    });
+    let names = match rx.recv_timeout(std::time::Duration::from_secs(20)) {
+        Ok(names) => names,
+        Err(std::sync::mpsc::RecvTimeoutError::Timeout) => panic!("importing the groups did not finish"),
+        Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => panic!("the import thread panicked"),
+    };
+    // Numbering starts at 1 and skips the number the library already uses.
+    assert_eq!(names[..4], ["Ink", "Ink 1", "Ink 3", "Ink 4"]);
+    assert_eq!(names.last(), Some(&format!("Ink {}", names.len())));
+    assert_eq!(names.iter().collect::<std::collections::HashSet<_>>().len(), names.len());
+}
+
+#[test]
+fn repeated_group_names_take_the_first_free_number() {
+    let mut s = Session::new();
+    for name in ["Brand", "Brand 2"] {
+        s.execute("swatches.newGroup", json!({"name": name})).unwrap();
+    }
+    let paper = AseSwatch { name: "Paper".into(), color: AseColor::Gray(1.0), kind: AseKind::Process };
+    let entries = ["Brand", "Brand", "Brand", "Brand 1"].into_iter().map(|name| AseEntry::Group { name: name.into(), swatches: vec![paper.clone()] }).collect();
+    let file = b64_encode(&photocraft_psd::ase::write(&AseFile { entries }).unwrap());
+    let r = s.execute("swatches.import", json!({"data": file})).unwrap();
+    // The file's "Brand 1" comes after the first "Brand" took that name.
+    assert_eq!(r["groups"], json!(["Brand 1", "Brand 3", "Brand 4", "Brand 1 1"]));
+}
+
+/// A value beyond f32 range used to pass the finite check, become inf as f32 and wrap to a NaN
+/// hue, which the prefs file stores as `null`; the next launch then dropped every saved preset.
+#[test]
+fn values_beyond_f32_range_are_rejected_so_presets_survive_a_restart() {
+    let mut s = Session::new();
+    s.execute("swatches.add", json!({"name": "Keep me", "color": {"model": "lab", "values": [40, 12.5, -7.25]}})).unwrap();
+    let before = s.presets.swatches.clone();
+    for (model, values) in [
+        ("hsb", json!([1e39, 100, 100])),
+        ("hsb", json!([-1e39, 100, 100])),
+        ("rgb", json!([1e39, 0, 0])),
+        ("cmyk", json!([0, 0, 0, -1e300])),
+        ("lab", json!([50, 1e39, 0])),
+        ("gray", json!([1e39])),
+    ] {
+        let r = s.execute("swatches.add", json!({"name": "Bad", "color": {"model": model, "values": values}}));
+        assert!(matches!(r, Err(crate::EngineError::BadParams { .. })), "{model} {values}: {r:?}");
+    }
+    assert_eq!(s.presets.swatches, before, "a rejected colour leaves the library unchanged");
+    // The largest f32 hue is still accepted and stays finite.
+    s.execute("swatches.add", json!({"name": "Big hue", "color": {"model": "hsb", "values": [f64::from(f32::MAX), 100, 100]}})).unwrap();
+    let mut t = Session::new();
+    t.load_prefs_json(&s.prefs_to_json()).unwrap();
+    assert_eq!(t.presets.swatches, s.presets.swatches, "user swatches survive a save and reload");
+    assert!(names(&t).contains(&"Keep me".to_string()));
+}
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index e4cbfe57a5..08e17bd39c 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -767,6 +767,33 @@ fn command_list_reports_enablement() {
     assert_eq!(find("layer.new.layer")["enabled"], false);
 }
 
+/// With no document open, a document command says so instead of only `enabled: false` (#3664).
+#[test]
+fn command_list_tells_no_document_from_other_preconditions() {
+    let mut s = Session::new();
+    let list = s.execute("command.list", json!({})).unwrap();
+    let find = |list: &Value, id: &str| list.as_array().unwrap().iter().find(|c| c["id"] == id).unwrap().clone();
+    for id in ["paint.stroke", "layer.new.layer", "filter.blur.gaussianBlur"] {
+        let c = find(&list, id);
+        assert_eq!((c["enabled"].clone(), c["needsDocument"].clone()), (json!(false), json!(true)), "{id}: {c}");
+        assert!(c["disabledReason"].as_str().is_some_and(|r| r.starts_with("no document")), "{id}: {c}");
+    }
+    let new = find(&list, "file.new");
+    assert_eq!((new["enabled"].clone(), new["needsDocument"].clone(), new["disabledReason"].clone()), (json!(true), json!(false), Value::Null));
+    // A precondition that isn't the missing document keeps its own reason.
+    let paste = find(&list, "file.newFromClipboard");
+    assert_eq!((paste["enabled"].clone(), paste["needsDocument"].clone()), (json!(false), json!(false)));
+    assert_eq!(paste["disabledReason"], "the clipboard is empty");
+    // With a document, the same commands run; a missing selection is not a missing document.
+    let mut s = session_with_doc();
+    let list = s.execute("command.list", json!({})).unwrap();
+    assert_eq!(find(&list, "paint.stroke")["needsDocument"], false);
+    assert_eq!(find(&list, "paint.stroke")["disabledReason"], Value::Null);
+    let deselect = find(&list, "select.deselect");
+    assert_eq!((deselect["enabled"].clone(), deselect["needsDocument"].clone()), (json!(false), json!(false)));
+    assert_eq!(deselect["disabledReason"], "no selection");
+}
+
 #[test]
 fn translate_moves_pixels_and_respects_locks() {
     let mut s = session_with_doc();
@@ -1442,3 +1469,41 @@ fn delete_layer_preserves_an_unaffected_active_layer_and_last_layer_guard() {
     assert_eq!(s.active().unwrap().active_layer, Some(other));
     assert_eq!(s.active().unwrap().history.past_len(), before);
 }
+
+#[test]
+fn merge_down_on_a_group_merges_the_group() {
+    // #3832: with a group selected, Merge Down is Photoshop's Merge Group (⌘E): the group's
+    // contents become one layer in its place, named after it, and the layer below is untouched.
+    let mut s = session_with_doc();
+    let below = s.execute("layer.new.layer", json!({"name": "Below"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("edit.fill", json!({"color": "#00ff00"})).unwrap();
+    let a = s.execute("layer.new.layer", json!({"name": "A"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("select.rect", json!({"x": 0, "y": 0, "width": 10, "height": 48})).unwrap();
+    s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    let b = s.execute("layer.new.layer", json!({"name": "B"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("select.rect", json!({"x": 20, "y": 0, "width": 10, "height": 48})).unwrap();
+    s.execute("edit.fill", json!({"color": "#0000ff"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    s.execute("layer.select", json!({"layer": b})).unwrap();
+    s.execute("layer.select", json!({"layer": a, "mode": "add"})).unwrap();
+    let group = s.execute("layer.groupLayers", json!({"name": "Badge"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setProps", json!({"layer": group, "opacity": 0.5})).ok();
+    let before = [px(&mut s, 5, 5), px(&mut s, 25, 5), px(&mut s, 50, 5)];
+    let layers = s.active().unwrap().doc.layer_count();
+    s.execute("layer.select", json!({"layer": group})).unwrap();
+    s.execute("layer.mergeLayers", json!({})).unwrap();
+    let st = s.active().unwrap();
+    let merged = st.doc.layer(st.active_layer.unwrap()).unwrap().clone();
+    assert_eq!(merged.name, "Badge");
+    assert!(matches!(merged.content, photocraft_doc::LayerContent::Raster(_)), "one pixel layer");
+    assert!(st.doc.layer(photocraft_doc::LayerId(below)).is_some(), "the layer below stays");
+    assert_eq!(st.doc.layer_count(), layers - 2, "group and its two layers became one");
+    let after = [px(&mut s, 5, 5), px(&mut s, 25, 5), px(&mut s, 50, 5)];
+    for (a, b) in before.iter().zip(&after) {
+        assert!(a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1.0 / 255.0), "{before:?} -> {after:?}");
+    }
+    // Undo brings the group back.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(s.active().unwrap().doc.layer(photocraft_doc::LayerId(group)).is_some());
+}
diff --git a/crates/engine/src/transform_cmds.rs b/crates/engine/src/transform_cmds.rs
index 44ea2e189c..bcf97126cc 100644
--- a/crates/engine/src/transform_cmds.rs
+++ b/crates/engine/src/transform_cmds.rs
@@ -1,10 +1,10 @@
 //! Edit › Free Transform / Transform: projective transforms of layers (and the selection).
 
-use photocraft_algo::transform::{Homography, Interp, warp_surface};
+use photocraft_algo::transform::{Homography, Interp, warp_output_bounds, warp_surface, warp_surface_with};
 use photocraft_color::PixelFormat;
 use photocraft_doc::{Document, Layer, LayerContent, LayerId, Locks};
 use photocraft_geom::{Affine, Rect};
-use photocraft_raster::Surface;
+use photocraft_raster::{Interrupt, Surface};
 use serde_json::{Value, json};
 
 use crate::commands::CommandSpec;
@@ -29,18 +29,22 @@ pub fn moves_whole(layer: &Layer) -> bool {
 /// content within the selection, or all of it for a layer that [`moves_whole`] (#2630).
 /// Content scans are cached per tile: snapping asks for every layer's bounds per Move drag.
 pub fn transform_bounds(doc: &Document, layer: &Layer) -> Rect {
-    let content = match &layer.content {
-        LayerContent::Group(g) => g.children.iter().map(|l| transform_bounds(doc, l)).fold(Rect::EMPTY, |a, b| a.union(&b)),
-        _ => layer.surface().map_or(Rect::EMPTY, photocraft_compose::bounds::content_bounds),
-    };
-    let content =
-        if content.is_empty() { layer.mask.as_ref().map_or(Rect::EMPTY, |m| photocraft_compose::bounds::content_bounds(&m.surface)) } else { content };
+    let content = whole_layer_bounds(layer);
     match &doc.selection {
         Some(sel) if !moves_whole(layer) => content.intersect(&sel.content_bounds()),
         _ => content,
     }
 }
 
+/// A group moves all its descendants, so its frame must not clip raster children to the selection.
+fn whole_layer_bounds(layer: &Layer) -> Rect {
+    let content = match &layer.content {
+        LayerContent::Group(g) => g.children.iter().map(whole_layer_bounds).fold(Rect::EMPTY, |a, b| a.union(&b)),
+        _ => layer.surface().map_or(Rect::EMPTY, photocraft_compose::bounds::content_bounds),
+    };
+    if content.is_empty() { layer.mask.as_ref().map_or(Rect::EMPTY, |m| photocraft_compose::bounds::content_bounds(&m.surface)) } else { content }
+}
+
 /// Warp a surface whose pixels outside the content read as `default` (masks, selections):
 /// warp the content with alpha, then flatten back onto the default value.
 pub(crate) fn warp_gray(s: &Surface, h: &Homography, interp: Interp) -> Result<Surface> {
@@ -201,10 +205,10 @@ pub(crate) fn group_locks(doc: &Document, id: LayerId) -> Locks {
 }
 
 /// The locks a transform of `l` meets: its own and `group`'s (those it inherits). The Background's
-/// position lock doesn't count: Photoshop turns it into a normal layer first ([`transform_layer`]).
-fn transform_locks(l: &Layer, group: Locks) -> Locks {
+/// position lock doesn't count: Photoshop turns it into a normal layer first.
+fn transform_locks(l: &Layer, group: Locks, background: bool) -> Locks {
     let mut own = l.locks;
-    if own.position && l.name == "Background" {
+    if background {
         own.position = false;
         own.transparency = false;
     }
@@ -217,36 +221,125 @@ fn transform_locks(l: &Layer, group: Locks) -> Locks {
 pub fn locked_for_transform(doc: &Document, id: LayerId) -> bool {
     let Some(l) = doc.layer(id) else { return false };
     // An explicit stack rather than recursion: documents can nest deeply.
-    let mut stack = vec![(l, group_locks(doc, id))];
-    while let Some((l, group)) = stack.pop() {
-        let locks = transform_locks(l, group);
+    let mut stack = vec![(l, group_locks(doc, id), doc.is_background(id))];
+    while let Some((l, group, background)) = stack.pop() {
+        let locks = transform_locks(l, group, background);
         if locks.position || locks.all {
             return true;
         }
         if let LayerContent::Group(g) = &l.content {
-            stack.extend(g.children.iter().map(|c| (c, locks)));
+            stack.extend(g.children.iter().map(|c| (c, locks, false)));
         }
     }
     false
 }
 
-/// `group` holds the locks `l` inherits from the groups around it ([`group_locks`]).
-pub(crate) fn transform_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut Layer, h: &Homography, affine: Option<Affine>, interp: Interp) -> Result<()> {
-    crate::allocation::checkpoint("transforming pixels")?;
-    let locks = transform_locks(l, group);
-    // Photoshop turns the Background into a normal layer before transforming it.
-    if l.locks.position && l.name == "Background" {
-        l.locks.position = false;
-        l.locks.transparency = false;
-        l.name = "Layer 0".into();
+/// The largest result (px) a single Free Transform warp may build: 2³⁰, the bound Puppet Warp uses
+/// too ([`photocraft_algo::puppet::MAX_WARP_PIXELS`]). Only the size of the result counts, not
+/// where it lands, so moving a layer far off the canvas stays allowed. A scale past it is refused
+/// rather than clipped (#3773): the warp would otherwise fill every tile of a result up to 2²¹ px
+/// on a side before anything could fail.
+pub const MAX_TRANSFORM_PIXELS: u64 = 1 << 30;
+
+/// Tests use a far lower budget, so proving a refusal never comes near allocating the real one.
+#[cfg(not(test))]
+const BUDGET: u64 = MAX_TRANSFORM_PIXELS;
+#[cfg(test)]
+const BUDGET: u64 = 1 << 20;
+
+/// Refuse a warp of the content inside `src` by `h` whose result would exceed the pixel budget,
+/// before anything is built. `what` names the surface in the message.
+pub(crate) fn check_budget(src: Rect, h: &Homography, what: &str) -> Result<()> {
+    let Some(b) = warp_output_bounds(src, h) else { return Ok(()) };
+    let (w, ht) = (u64::from(b.width()), u64::from(b.height()));
+    if w.saturating_mul(ht) > BUDGET {
+        let detail = format!("the transformed {what} would be {w} x {ht} px, more than the {BUDGET} px limit");
+        return Err(crate::allocation::error("transforming pixels", &detail));
     }
+    Ok(())
+}
+
+/// [`check_budget`] for every warp [`transform_layer`] would make of `l` (for a group, of every
+/// layer inside it), so a transform that doesn't fit is refused before any layer is built and a
+/// group that partly fits isn't half-transformed.
+fn check_layer_budget(doc_sel: Option<&Surface>, l: &Layer, h: &Homography) -> Result<()> {
+    if h.is_identity() {
+        return Ok(());
+    }
+    // An explicit stack rather than recursion: documents can nest deeply.
+    let mut stack = vec![(l, doc_sel)];
+    while let Some((l, sel)) = stack.pop() {
+        match &l.content {
+            LayerContent::Group(g) => stack.extend(g.children.iter().map(|c| (c, None))),
+            LayerContent::Text(_) | LayerContent::Shape(_) => {}
+            LayerContent::Smart(sm) => {
+                if let Some(c) = &sm.cache {
+                    check_budget(c.content_bounds(), h, "smart object")?;
+                }
+                if let Some(m) = &sm.filter_mask {
+                    check_budget(m.surface.content_bounds(), h, "smart filter mask")?;
+                }
+            }
+            _ => {
+                if let Some(surf) = l.surface() {
+                    check_budget(surf.content_bounds(), h, &format!("layer \"{}\"", l.name))?;
+                }
+            }
+        }
+        if let Some(m) = &l.mask
+            && m.linked
+        {
+            // With a selection only its region of the mask moves (`warp_gray_selected`).
+            let src = match sel.filter(|_| !moves_whole(l)) {
+                Some(sel) => sel.content_bounds(),
+                None => m.surface.content_bounds(),
+            };
+            check_budget(src, h, "layer mask")?;
+        }
+    }
+    Ok(())
+}
+
+/// `group` holds the locks `l` inherits from the groups around it ([`group_locks`]). A Background
+/// is turned into a normal layer by the caller first ([`crate::extra_cmds::background_to_layer`]).
+/// Refused, with `l` untouched, when a result would exceed [`MAX_TRANSFORM_PIXELS`].
+pub(crate) fn transform_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut Layer, h: &Homography, affine: Option<Affine>, interp: Interp) -> Result<()> {
+    transform_layer_with(doc_sel, group, l, h, affine, interp, &Interrupt::NONE)
+}
+
+/// [`transform_layer`] with progress and cancellation for the pixel warp (the slow part on a
+/// large layer, #1015).
+fn transform_layer_with(
+    doc_sel: Option<&Surface>,
+    group: Locks,
+    l: &mut Layer,
+    h: &Homography,
+    affine: Option<Affine>,
+    interp: Interp,
+    ctl: &Interrupt,
+) -> Result<()> {
+    check_layer_budget(doc_sel, l, h)?;
+    apply_transform(doc_sel, group, l, h, affine, interp, ctl)
+}
+
+fn apply_transform(
+    doc_sel: Option<&Surface>,
+    group: Locks,
+    l: &mut Layer,
+    h: &Homography,
+    affine: Option<Affine>,
+    interp: Interp,
+    ctl: &Interrupt,
+) -> Result<()> {
+    crate::allocation::checkpoint("transforming pixels")?;
+    let locks = transform_locks(l, group, false);
     if locks.position || locks.all {
         return Err(EngineError::Other(format!("layer \"{}\" is locked", l.name)));
     }
     if h.is_identity() {
         if let LayerContent::Group(g) = &mut l.content {
             for c in g.children.iter_mut() {
-                transform_layer(None, locks, c, h, affine, interp)?;
+                apply_transform(None, locks, c, h, affine, interp, ctl)?;
             }
         }
         return Ok(());
@@ -257,7 +350,7 @@ pub(crate) fn transform_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut L
     match &mut l.content {
         LayerContent::Group(g) => {
             for c in g.children.iter_mut() {
-                transform_layer(None, locks, c, h, affine, interp)?;
+                apply_transform(None, locks, c, h, affine, interp, ctl)?;
             }
         }
         LayerContent::Text(t) => {
@@ -295,12 +388,12 @@ pub(crate) fn transform_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut L
                     // Only the selected pixels move: lift them, clear them, warp and paste back.
                     Some(sel) => {
                         let (lifted, mut rest) = split_selected(surf, sel)?;
-                        let moved = warp_surface(&lifted, src, h, interp)?;
+                        let moved = warp_surface_with(&lifted, src, h, interp, ctl)?.ok_or(EngineError::Cancelled)?;
                         composite_over(&mut rest, &moved);
                         rest.prune();
                         rest
                     }
-                    None => warp_surface(surf, src, h, interp)?,
+                    None => warp_surface_with(surf, src, h, interp, ctl)?.ok_or(EngineError::Cancelled)?,
                 };
             }
         }
@@ -398,6 +491,33 @@ pub(crate) fn composite_over(dst: &mut Surface, top: &Surface) {
     dst.write_region(b, &d);
 }
 
+/// The relative form (`scaleX`, `scaleY` in percent, `rotate` in degrees clockwise, `dx`, `dy`
+/// in pixels), as Photoshop records a Free Transform: scale and rotate about the frame's
+/// centre, then move. `None` when none of them is given.
+fn relative_matrix(p: &Value, rect: [f64; 4]) -> Result<Option<Homography>> {
+    let num = |k: &str| -> Result<Option<f64>> {
+        match p.get(k) {
+            None | Some(Value::Null) => Ok(None),
+            Some(v) => v.as_f64().filter(|f| f.is_finite()).map(Some).ok_or_else(|| bad(format!("`{k}` must be a finite number"))),
+        }
+    };
+    let (sx, sy, rot, dx, dy) = (num("scaleX")?, num("scaleY")?, num("rotate")?, num("dx")?, num("dy")?);
+    if sx.is_none() && sy.is_none() && rot.is_none() && dx.is_none() && dy.is_none() {
+        return Ok(None);
+    }
+    let (sx, sy) = (sx.unwrap_or(100.0) / 100.0, sy.unwrap_or(100.0) / 100.0);
+    if sx.abs() < 1e-6 || sy.abs() < 1e-6 {
+        return Err(bad("`scaleX` and `scaleY` must not be 0"));
+    }
+    let (cx, cy) = ((rect[0] + rect[2]) / 2.0, (rect[1] + rect[3]) / 2.0);
+    let (sin, cos) = rot.unwrap_or(0.0).to_radians().sin_cos();
+    // (x, y) → translate(-c) → scale → rotate → translate(c + d).
+    let (a, b, c, d) = (sx * cos, sx * sin, -sy * sin, sy * cos);
+    let e = cx + dx.unwrap_or(0.0) - a * cx - c * cy;
+    let f = cy + dy.unwrap_or(0.0) - b * cx - d * cy;
+    Ok(Some(Homography([a, c, e, b, d, f, 0.0, 0.0, 1.0])))
+}
+
 fn quad_param(p: &Value) -> Option<[[f64; 2]; 4]> {
     let a = p.get("quad")?.as_array()?;
     if a.len() != 4 {
@@ -427,10 +547,7 @@ fn with_panel_target(s: &Session, p: &Value) -> Value {
 fn transform(s: &mut Session, p: &Value) -> Result<Value> {
     let p = &with_panel_target(s, p);
     let st = s.active().ok_or(EngineError::NoDocument)?;
-    let id = match p.get("layer").and_then(Value::as_u64) {
-        Some(v) => Some(LayerId(v)),
-        None => st.active_layer,
-    };
+    let id = crate::commands::explicit_layer(s, p)?.or(st.active_layer);
     let lone = lone_target(&st.doc, id, p)?;
     let id = match (id, lone.is_some() && crate::channel_cmds::is_channel_target(p)) {
         (_, true) => None,
@@ -463,8 +580,10 @@ fn transform(s: &mut Session, p: &Value) -> Result<Value> {
         }
         // Affine [a b c d e f] maps (x, y) → (a·x + c·y + e, b·x + d·y + f).
         Homography([v[0], v[2], v[4], v[1], v[3], v[5], 0.0, 0.0, 1.0])
+    } else if let Some(m) = relative_matrix(p, rect)? {
+        m
     } else {
-        return Err(bad("pass `quad` (where the rect's corners go) or `matrix`"));
+        return Err(bad("pass `quad` (where the rect's corners go), `matrix`, or `scaleX`/`scaleY`/`rotate`/`dx`/`dy`"));
     };
     if h.inverse().is_none() {
         return Err(bad("the transform collapses the layer"));
@@ -474,41 +593,69 @@ fn transform(s: &mut Session, p: &Value) -> Result<Value> {
         (m[6].abs() < 1e-12 && m[7].abs() < 1e-12).then(|| Affine { m: [m[0] / m[8], m[3] / m[8], m[1] / m[8], m[4] / m[8], m[2] / m[8], m[5] / m[8]] });
     let interp = Interp::parse(p.get("interpolation").and_then(Value::as_str).unwrap_or("bicubic"));
     let lone = lone.is_some();
-    s.edit("Free Transform", |doc, _| {
-        let sel = doc.selection.clone();
-        if lone {
-            // A targeted unlinked mask, alpha channel or Quick Mask transforms by itself.
-            if !h.is_identity() {
-                let (surf, _) = crate::channel_cmds::target_surface(doc, id, p)?;
-                *surf = match &sel {
-                    Some(sel) => warp_gray_selected(surf, sel, &h, interp)?,
-                    None => warp_gray(surf, &h, interp)?,
-                };
-                if let Some(sel) = &doc.selection {
-                    doc.selection = Some(warp_gray(sel, &h, Interp::Bilinear)?).filter(|s| !s.content_bounds().is_empty());
-                }
-            }
-            return Ok(());
-        }
-        let id = id.ok_or_else(|| EngineError::Other("no active layer".into()))?;
-        let is_group = doc.layer(id).is_some_and(Layer::is_group);
-        let group = group_locks(doc, id);
-        let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
-        transform_layer(if is_group { None } else { sel.as_ref() }, group, l, &h, affine, interp)?;
+    let p = p.clone();
+    // A background job when started with `Session::start` (#1015): the warp of a large layer runs
+    // on a worker with progress, and can be cancelled.
+    crate::jobs::edit_job(
+        s,
+        "Free Transform",
+        move |doc, _, ctx| ctx.stage(0.0, 1.0, "Transforming", |ctl| transform_doc(doc, id, &p, lone, &h, affine, interp, ctl)),
+        move |()| json!({"rect": rect}),
+    )
+}
+
+/// The edit of [`transform`]: the layer (or a lone mask or channel) and the selection outline.
+#[allow(clippy::too_many_arguments)]
+fn transform_doc(
+    doc: &mut Document,
+    id: Option<LayerId>,
+    p: &Value,
+    lone: bool,
+    h: &Homography,
+    affine: Option<Affine>,
+    interp: Interp,
+    ctl: &Interrupt,
+) -> Result<()> {
+    let sel = doc.selection.clone();
+    // The selection outline moves too: price it before anything is built.
+    if let Some(sel) = sel.as_ref().filter(|_| !h.is_identity()) {
+        check_budget(sel.content_bounds(), h, "selection")?;
+    }
+    if lone {
+        // A targeted unlinked mask, alpha channel or Quick Mask transforms by itself.
         if !h.is_identity() {
-            // Type layers re-render from their new transform.
-            let snapshot = doc.clone();
-            if let Some(l) = doc.layer_mut(id) {
-                refresh_text(&snapshot, l);
-            }
-            // The selection outline moves with the pixels.
+            let (surf, _) = crate::channel_cmds::target_surface(doc, id, p)?;
+            let src = sel.as_ref().map_or_else(|| surf.content_bounds(), Surface::content_bounds);
+            check_budget(src, h, "mask or channel")?;
+            *surf = match &sel {
+                Some(sel) => warp_gray_selected(surf, sel, h, interp)?,
+                None => warp_gray(surf, h, interp)?,
+            };
             if let Some(sel) = &doc.selection {
-                doc.selection = Some(warp_gray(sel, &h, Interp::Bilinear)?).filter(|s| !s.content_bounds().is_empty());
+                doc.selection = Some(warp_gray(sel, h, Interp::Bilinear)?).filter(|s| !s.content_bounds().is_empty());
             }
         }
-        Ok(())
-    })?;
-    Ok(json!({"rect": rect}))
+        return Ok(());
+    }
+    let id = id.ok_or_else(|| EngineError::Other("no active layer".into()))?;
+    let is_group = doc.layer(id).is_some_and(Layer::is_group);
+    let group = group_locks(doc, id);
+    // Photoshop turns the Background into a normal layer before transforming it.
+    crate::extra_cmds::background_to_layer(doc, id);
+    let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
+    transform_layer_with(if is_group { None } else { sel.as_ref() }, group, l, h, affine, interp, ctl)?;
+    if !h.is_identity() {
+        // Type layers re-render from their new transform.
+        let snapshot = doc.clone();
+        if let Some(l) = doc.layer_mut(id) {
+            refresh_text(&snapshot, l);
+        }
+        // The selection outline moves with the pixels.
+        if let Some(sel) = &doc.selection {
+            doc.selection = Some(warp_gray(sel, h, Interp::Bilinear)?).filter(|s| !s.content_bounds().is_empty());
+        }
+    }
+    Ok(())
 }
 
 pub fn specs() -> Vec<CommandSpec> {
@@ -517,7 +664,7 @@ pub fn specs() -> Vec<CommandSpec> {
         label: "Free Transform",
         menu: &[],
         shortcut: None,
-        params: r##"{"layer":id?,"rect":[x0,y0,x1,y1]? (source frame; default = layer content ∩ selection),"quad":[[x,y]×4]? (where the frame's corners go, clockwise from top-left),"matrix":[a,b,c,d,e,f]? (affine alternative),"interpolation":"bicubic|bilinear|nearest"="bicubic","target":"pixels"|"mask"|"quickMask"|{"channel":i}=Channels panel target (an unlinked mask, an alpha channel or the Quick Mask transforms alone; a linked mask moves with its layer)}"##,
+        params: r##"{"layer":id?,"rect":[x0,y0,x1,y1]? (source frame; default = layer content ∩ selection),"quad":[[x,y]×4]? (where the frame's corners go, clockwise from top-left),"matrix":[a,b,c,d,e,f]? (affine alternative),"scaleX":%?,"scaleY":%?,"rotate":deg?,"dx":px?,"dy":px? (relative alternative: scale and rotate about the frame's centre, then move, as a Photoshop action records a Free Transform),"interpolation":"bicubic|bilinear|nearest"="bicubic","target":"pixels"|"mask"|"quickMask"|{"channel":i}=Channels panel target (an unlinked mask, an alpha channel or the Quick Mask transforms alone; a linked mask moves with its layer)}"##,
         enabled: has_layer,
         journal: true,
         run: transform,
@@ -529,8 +676,12 @@ mod tests {
     use super::*;
 
     fn session() -> Session {
+        session_depth(8)
+    }
+
+    fn session_depth(depth: u32) -> Session {
         let mut s = Session::new();
-        s.execute("file.new", json!({"width": 100, "height": 100})).unwrap();
+        s.execute("file.new", json!({"width": 100, "height": 100, "depth": depth})).unwrap();
         s.execute("layer.new.layer", json!({})).unwrap();
         s.edit("paint", |doc, active| {
             let l = doc.layer_mut(active.unwrap()).unwrap();
@@ -546,6 +697,112 @@ mod tests {
         st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().content_bounds()
     }
 
+    // ---- Pixel budget (#3773). Tests run with a 2²⁰ px budget, so nothing here comes near the real one. ----
+
+    /// A 16 x 16 document whose active layer is a 1 x 8 column at x = 10.
+    fn column() -> Session {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 16, "height": 16})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.edit("paint", |doc, active| {
+            doc.layer_mut(active.unwrap()).unwrap().surface_mut().unwrap().fill_rect(Rect::new(10, 2, 11, 10), &[1.0, 0.0, 0.0, 1.0]);
+            Ok(())
+        })
+        .unwrap();
+        s
+    }
+
+    /// Stretch x by `k` about x = 10 (the column's left edge).
+    fn stretch(k: f64) -> Value {
+        json!({"matrix": [k, 0, 0, 1, -10.0 * k, 0], "interpolation": "nearest"})
+    }
+
+    #[test]
+    fn a_scale_past_the_pixel_budget_is_refused_and_changes_nothing() {
+        let mut s = column();
+        let st = s.active().unwrap();
+        let (before, revision, steps) = (st.doc.clone(), st.revision, st.history.past_len());
+        // 200000 x 10 px of output: twice the test budget.
+        let err = s.execute("edit.transform", stretch(2e5)).unwrap_err().to_string();
+        assert!(err.starts_with("not enough memory for transforming pixels"), "{err}");
+        assert!(err.contains("would be 200002 x 10 px") && err.ends_with("the document was not changed"), "{err}");
+        let st = s.active().unwrap();
+        assert!(st.doc == before, "the document is untouched");
+        assert_eq!((st.revision, st.history.past_len()), (revision, steps));
+        // Within the budget the same stretch still works, nothing clipped.
+        s.execute("edit.transform", stretch(1e4)).unwrap();
+        assert_eq!(active_bounds(&s), Rect::new(0, 2, 10_000, 10));
+    }
+
+    #[test]
+    fn a_group_with_one_layer_past_the_budget_is_not_half_transformed() {
+        let mut s = column();
+        let wide = s.active().unwrap().active_layer.unwrap();
+        // Over the column: a 1 px dot, which fits the budget stretched by the same amount.
+        s.execute("layer.new.layer", json!({})).unwrap();
+        let dot = s.active().unwrap().active_layer.unwrap();
+        s.edit("paint", |doc, _| {
+            doc.layer_mut(dot).unwrap().surface_mut().unwrap().fill_rect(Rect::new(10, 12, 11, 13), &[0.0, 1.0, 0.0, 1.0]);
+            // Widen the column to 8 px (x 2..10), so it alone needs 400002 x 10 px.
+            doc.layer_mut(wide).unwrap().surface_mut().unwrap().fill_rect(Rect::new(2, 2, 10, 10), &[1.0, 0.0, 0.0, 1.0]);
+            Ok(())
+        })
+        .unwrap();
+        s.execute("layer.select", json!({"layer": wide.0})).unwrap();
+        s.execute("layer.select", json!({"layer": dot.0, "mode": "add"})).unwrap();
+        let group = LayerId(s.execute("layer.groupLayers", json!({})).unwrap()["layer"].as_u64().unwrap());
+        let st = s.active().unwrap();
+        assert!(matches!(&st.doc.layer(group).unwrap().content, LayerContent::Group(g) if g.children.len() == 2));
+        let (before, revision) = (st.doc.clone(), st.revision);
+        let k = 5e4;
+        assert!(s.execute("edit.transform", json!({"layer": group.0, "matrix": [k, 0, 0, 1, -10.0 * k, 0]})).is_err());
+        let st = s.active().unwrap();
+        assert!(st.doc == before && st.revision == revision, "nothing changed");
+        // The layer-level check runs before any child is warped, so even the layer itself
+        // (not just the edit's copy of the document) is left as it was.
+        let mut l = st.doc.layer(group).unwrap().clone();
+        let h = Homography([k, 0.0, -10.0 * k, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]);
+        assert!(transform_layer(None, Locks::default(), &mut l, &h, None, Interp::Nearest).is_err());
+        assert!(&l == st.doc.layer(group).unwrap(), "no child was transformed");
+    }
+
+    #[test]
+    fn moving_a_small_layer_far_off_the_canvas_is_within_budget() {
+        let mut s = session();
+        s.execute("edit.transform", json!({"matrix": [1, 0, 0, 1, 900_000, -900_000]})).unwrap();
+        assert_eq!(active_bounds(&s), Rect::new(900_010, -899_990, 900_030, -899_980));
+        s.execute("edit.transform", json!({"matrix": [1, 0, 0, 1, -900_000, 900_000]})).unwrap();
+        assert_eq!(active_bounds(&s), Rect::new(10, 10, 30, 20), "and back, every pixel kept");
+    }
+
+    #[test]
+    fn selections_masks_and_channels_have_the_same_budget() {
+        // The selection outline of a layer transform.
+        let mut s = column();
+        s.execute("select.rect", json!({"x": 10, "y": 2, "width": 1, "height": 8})).unwrap();
+        let before = s.active().unwrap().doc.clone();
+        let err = s.execute("edit.transform", stretch(2e5)).unwrap_err().to_string();
+        assert!(err.contains("transformed selection would be"), "{err}");
+        // Transform Selection.
+        let err = s.execute("select.transformSelection", stretch(2e5)).unwrap_err().to_string();
+        assert!(err.contains("transformed selection would be"), "{err}");
+        assert!(s.active().unwrap().doc == before);
+        // A targeted alpha channel.
+        let mut s = column();
+        s.execute("channel.new", json!({})).unwrap();
+        s.edit("paint channel", |doc, _| {
+            doc.channels[0].surface.fill_rect(Rect::new(10, 2, 11, 10), &[1.0]);
+            Ok(())
+        })
+        .unwrap();
+        let before = s.active().unwrap().doc.clone();
+        let mut p = stretch(2e5);
+        p["target"] = json!({"channel": 0});
+        let err = s.execute("edit.transform", p).unwrap_err().to_string();
+        assert!(err.contains("transformed mask or channel would be"), "{err}");
+        assert!(s.active().unwrap().doc == before);
+    }
+
     #[test]
     fn scale_via_quad_and_undo() {
         let mut s = session();
@@ -692,7 +949,11 @@ mod tests {
 
     /// `session()` plus a reveal-all mask with `hide` painted black (linked unless `linked` is false).
     fn masked(hide: &[Rect], linked: bool) -> Session {
-        let mut s = session();
+        masked_depth(hide, linked, 8)
+    }
+
+    fn masked_depth(hide: &[Rect], linked: bool, depth: u32) -> Session {
+        let mut s = session_depth(depth);
         s.execute("layer.layerMask.revealAll", json!({})).unwrap();
         s.edit("mask", |doc, active| {
             let m = doc.layer_mut(active.unwrap()).unwrap().mask.as_mut().unwrap();
@@ -890,6 +1151,66 @@ mod tests {
         assert_eq!(transform_bounds(&st.doc, st.doc.layer(st.active_layer.unwrap()).unwrap()), Rect::new(10, 10, 15, 20));
     }
 
+    #[test]
+    fn group_transform_ignores_selections_inside_its_children() {
+        group_transform_with_selection(Rect::new(10, 10, 15, 15));
+    }
+
+    #[test]
+    fn group_transform_ignores_selections_outside_its_children() {
+        group_transform_with_selection(Rect::new(70, 70, 80, 80));
+    }
+
+    #[test]
+    fn group_transform_presets_rotate_about_the_whole_group() {
+        for depth in [8, 16, 32] {
+            for x in [10, 70] {
+                let mut s = masked_depth(&[Rect::new(10, 10, 15, 20)], true, depth);
+                let child = s.active().unwrap().active_layer.unwrap();
+                s.execute("layer.groupLayers", json!({})).unwrap();
+                s.execute("select.rect", json!({"x": x, "y": 10, "width": 5, "height": 5})).unwrap();
+                s.execute("edit.transform.rotate180", json!({})).unwrap();
+                let layer = s.active().unwrap().doc.layer(child).unwrap();
+                assert_eq!(layer.surface().unwrap().content_bounds(), Rect::new(10, 10, 30, 20), "rotate about the group's centre, not the selection's");
+                let mask = &layer.mask.as_ref().unwrap().surface;
+                assert_eq!(mask.sample_channel(27, 15, 0), 0.0);
+                assert_eq!(mask.sample_channel(12, 15, 0), 1.0);
+            }
+        }
+    }
+
+    fn group_transform_with_selection(selection: Rect) {
+        for depth in [8, 16, 32] {
+            for nested in [false, true] {
+                let mut s = masked_depth(&[Rect::new(10, 10, 15, 20)], true, depth);
+                let child = s.active().unwrap().active_layer.unwrap();
+                s.execute("layer.groupLayers", json!({})).unwrap();
+                if nested {
+                    s.execute("layer.groupLayers", json!({})).unwrap();
+                }
+                s.execute("select.rect", json!({"x": selection.x0, "y": selection.y0, "width": selection.width(), "height": selection.height()})).unwrap();
+                let steps = s.active().unwrap().history.entries().len();
+                let result = s.execute("edit.transform", json!({"quad": [[10, 10], [50, 10], [50, 30], [10, 30]], "interpolation": "nearest"})).unwrap();
+                assert_eq!(result["rect"], json!([10.0, 10.0, 30.0, 20.0]), "frame must include the whole group (nested={nested})");
+                let st = s.active().unwrap();
+                let layer = st.doc.layer(child).unwrap();
+                assert_eq!(layer.surface().unwrap().content_bounds(), Rect::new(10, 10, 50, 30));
+                let mask = &layer.mask.as_ref().unwrap().surface;
+                assert_eq!(mask.sample_channel(19, 20, 0), 0.0, "the linked mask scales with its complete layer");
+                assert_eq!(mask.sample_channel(21, 20, 0), 1.0);
+                assert_eq!(st.history.entries().len(), steps + 1);
+                assert!(s.undo());
+                let st = s.active().unwrap();
+                let layer = st.doc.layer(child).unwrap();
+                assert_eq!(layer.surface().unwrap().content_bounds(), Rect::new(10, 10, 30, 20));
+                assert_eq!(layer.mask.as_ref().unwrap().surface.sample_channel(19, 15, 0), 1.0);
+                assert_eq!(st.doc.selection.as_ref().unwrap().content_bounds(), selection);
+                assert!(s.redo());
+                assert_eq!(s.active().unwrap().doc.layer(child).unwrap().surface().unwrap().content_bounds(), Rect::new(10, 10, 50, 30));
+            }
+        }
+    }
+
     #[test]
     fn feathered_selection_identity_transform_preserves_pixels() {
         let mut s = Session::new();
@@ -927,4 +1248,30 @@ mod tests {
         s.execute("layer.setProps", json!({"locks": {"position": true}})).unwrap();
         assert!(s.execute("edit.transform", json!({"matrix": [1, 0, 0, 1, 0, 0]})).is_err(), "locked layer refuses identity transform");
     }
+
+    #[test]
+    fn relative_params_scale_and_rotate_about_the_frame_centre() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 100, "height": 100})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("select.rect", json!({"x": 20, "y": 30, "width": 40, "height": 20})).unwrap();
+        s.execute("edit.fill", json!({"contents": "black"})).unwrap();
+        s.execute("select.deselect", json!({})).unwrap();
+        // 50% about the centre (40, 40), then 10 px right: the content ends at x 40..60, y 35..45.
+        let r = s.execute("edit.transform", json!({"scaleX": 50, "scaleY": 50, "dx": 10})).unwrap();
+        let rect: Vec<f64> = serde_json::from_value(r["rect"].clone()).unwrap();
+        assert_eq!(rect, [20.0, 30.0, 60.0, 50.0], "the reported frame is the source frame");
+        let bounds = |s: &Session| {
+            let d = s.active().unwrap();
+            let b = transform_bounds(&d.doc, d.doc.layer(d.active_layer.unwrap()).unwrap());
+            (b.x0, b.y0, b.x1, b.y1)
+        };
+        assert_eq!(bounds(&s), (40, 35, 60, 45));
+        // A quarter turn about the centre (50, 40) swaps the frame's sides.
+        s.execute("edit.transform", json!({"rotate": 90})).unwrap();
+        assert_eq!(bounds(&s), (45, 30, 55, 50));
+        for bad in [json!({"scaleX": 0}), json!({"rotate": "x"}), json!({"dx": f64::NAN})] {
+            assert!(s.execute("edit.transform", bad.clone()).is_err(), "{bad}");
+        }
+    }
 }
diff --git a/crates/engine/src/type_caret_cmds.rs b/crates/engine/src/type_caret_cmds.rs
index 528472cc25..fbc9322c62 100644
--- a/crates/engine/src/type_caret_cmds.rs
+++ b/crates/engine/src/type_caret_cmds.rs
@@ -106,9 +106,7 @@ fn topmost(doc: &Document, x: f64, y: f64) -> Option<Frame> {
     let mut ids: Vec<LayerId> = doc
         .walk()
         .into_iter()
-        .filter(|(path, _, layer)| {
-            matches!(layer.content, LayerContent::Text(_)) && (1..=path.len()).all(|n| doc.layer_at(&path[..n]).is_some_and(|ancestor| ancestor.visible))
-        })
+        .filter(|(path, _, layer)| matches!(layer.content, LayerContent::Text(_)) && doc.shown_at(path))
         .map(|(_, _, layer)| layer.id)
         .collect();
     ids.reverse();
diff --git a/crates/engine/src/type_cmds.rs b/crates/engine/src/type_cmds.rs
index 962504977b..4bf193b679 100644
--- a/crates/engine/src/type_cmds.rs
+++ b/crates/engine/src/type_cmds.rs
@@ -121,10 +121,98 @@ pub fn check_size_tracking(p: &Value) -> std::result::Result<(), String> {
     Ok(())
 }
 
+/// The PostScript name of the installed face of `family` at exactly `weight`/`italic`. A PSD names
+/// a type layer by PostScript name, and Photoshop treats a name no font has as missing (#3556).
+/// Only an exact face is named: layout picks a named face before weight and italic, so naming a
+/// nearby face would override the requested weight (a variable font's axis, a weight between two
+/// faces) or italic. Without an exact face the style keeps no name and layout matches as before.
+fn installed_postscript(family: &str, weight: u16, italic: bool) -> Option<String> {
+    let mut shared = photocraft_text::shared().lock().unwrap_or_else(|e| e.into_inner());
+    let faces = shared.fonts.faces(family);
+    let face = faces.iter().find(|f| f.italic == italic && f.weight.round() as u16 == weight)?;
+    face.postscript_name.clone()
+}
+
+/// Photoshop's leading range in points.
+pub const LEADING_MIN_PT: f32 = 0.01;
+pub const LEADING_MAX_PT: f32 = 5000.0;
+/// Photoshop's baseline shift range in points (either direction).
+pub const BASELINE_SHIFT_MAX_PT: f32 = 5000.0;
+/// The relative character steps `type.setStyle` accepts, with the largest step allowed.
+const STEP_KEYS: [(&str, f64); 3] = [("leadingBy", 5000.0), ("baselineShiftBy", 10_000.0), ("trackingBy", 11_000.0)];
+
+/// Validates the relative steps (`leadingBy`, `baselineShiftBy`, `trackingBy`): finite numbers
+/// no larger than the whole range they move through.
+pub fn check_steps(p: &Value) -> std::result::Result<(), String> {
+    for (key, max) in STEP_KEYS {
+        if let Some(v) = p.get(key) {
+            match v.as_f64() {
+                Some(by) if by.is_finite() && by.abs() <= max => {}
+                _ => return Err(format!("{key} must be a number between -{max} and {max}")),
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Relative character steps (Photoshop's ⌥↑/↓ leading, ⇧⌥↑/↓ baseline shift and ⌥←/→ tracking
+/// over a selection): every character moves from its own value, so mixed values keep their
+/// differences. Auto leading starts from the value layout uses, the paragraph's auto-leading
+/// percentage of the character's size. Results are clamped to Photoshop's ranges. Returns true
+/// if any step key was present.
+fn step_char_metrics(t: &mut TextLayer, a: usize, b: usize, p: &Value) -> bool {
+    let leading_by = f32p(p, "leadingBy").filter(|v| v.is_finite());
+    let shift_by = f32p(p, "baselineShiftBy").filter(|v| v.is_finite());
+    let tracking_by = f32p(p, "trackingBy").filter(|v| v.is_finite());
+    if leading_by.is_none() && shift_by.is_none() && tracking_by.is_none() {
+        return false;
+    }
+    let paragraphs = t.paragraph_runs();
+    let default_auto = ParagraphStyle::default().auto_leading;
+    // Each paragraph's share of `a..b`, with the auto leading it lays out with.
+    let mut pieces = Vec::new();
+    let mut at = 0usize;
+    for pr in &paragraphs {
+        let (ps, pe) = (at, at.saturating_add(pr.len));
+        at = pe;
+        let (pa, pb) = (a.clamp(ps, pe), b.clamp(ps, pe));
+        if pa < pb {
+            pieces.push((pa, pb, pr.style.auto_leading));
+        }
+    }
+    if at < b {
+        pieces.push((a.max(at), b, default_auto));
+    }
+    if t.text.is_empty() {
+        // Empty text: the step sets the style the next typed characters get.
+        pieces = vec![(0, 0, paragraphs.first().map_or(default_auto, |r| r.style.auto_leading))];
+    }
+    for (pa, pb, auto) in pieces {
+        style_range(t, pa, pb, &|st| {
+            if let Some(by) = leading_by {
+                let auto = if auto.is_finite() && auto > 0.0 { auto } else { default_auto };
+                let base = st.leading_pt.unwrap_or(auto * st.size_pt);
+                let base = if base.is_finite() { base } else { 0.0 };
+                st.leading_pt = Some((base + by).clamp(LEADING_MIN_PT, LEADING_MAX_PT));
+            }
+            if let Some(by) = shift_by {
+                let base = if st.baseline_shift_pt.is_finite() { st.baseline_shift_pt } else { 0.0 };
+                st.baseline_shift_pt = (base + by).clamp(-BASELINE_SHIFT_MAX_PT, BASELINE_SHIFT_MAX_PT);
+            }
+            if let Some(by) = tracking_by {
+                let base = if st.tracking.is_finite() { st.tracking } else { 0.0 };
+                st.tracking = (base + by).clamp(TRACKING_MIN as f32, TRACKING_MAX as f32);
+            }
+        });
+    }
+    true
+}
+
 /// Applies character-style keys from JSON. Returns true if any key was present.
 pub fn apply_char_props(s: &mut CharStyle, p: &Value) -> bool {
     let mut any = false;
     let mut hit = |b: bool| any |= b;
+    let font_key = ["font", "family", "fontStyle", "weight", "italic"].iter().any(|k| p.get(k).is_some());
     if let Some(v) = p.get("font").or_else(|| p.get("family")).and_then(Value::as_str) {
         s.font_family = v.to_string();
         s.postscript_name = None;
@@ -169,6 +257,11 @@ pub fn apply_char_props(s: &mut CharStyle, p: &Value) -> bool {
         s.postscript_name = Some(v.to_string());
         hit(true);
     }
+    // A font named by family (or a style that matched no face) has no PostScript name yet: fill in
+    // the installed face's real name, so the PSD does not invent "<Family>-Regular" (#3556).
+    if font_key && s.postscript_name.is_none() {
+        s.postscript_name = installed_postscript(&s.font_family, s.weight, s.italic);
+    }
     if let Some(v) = f32p(p, "size") {
         s.size_pt = v.max(0.01);
         hit(true);
@@ -448,17 +541,21 @@ pub fn refresh(doc: &Document, t: &mut TextLayer) {
     t.psd_raw = Some(Arc::new(photocraft_text::psd::build_tysh(t, dpi, layout.bounds())));
 }
 
+/// Refuses to change a type layer under Lock All (its own or an enclosing group's), with
+/// Photoshop's message. Every command that edits a type layer's text calls it first (#3132, #4188).
+pub(crate) fn check_text_unlocked(doc: &Document, id: LayerId) -> Result<()> {
+    let layer = doc.layer(id).ok_or(EngineError::NoLayer(id))?;
+    if doc.effective_locks(id).all {
+        return Err(EngineError::Other(format!("Could not complete your request because the layer \"{}\" is locked", layer.name)));
+    }
+    Ok(())
+}
+
 /// Runs `f` on a type layer as one undo step. `f` may set an explicit layer name (`type.edit`'s
 /// `name`), which is applied in the same step; otherwise an auto-named layer follows its text.
 fn with_text_layer<R>(s: &mut Session, p: &Value, label: &str, f: impl FnOnce(&mut TextLayer, &Document, &mut Option<String>) -> Result<R>) -> Result<R> {
     let id = layer_id(s, p)?;
-    {
-        let doc = &s.active().ok_or(EngineError::NoDocument)?.doc;
-        let layer = doc.layer(id).ok_or(EngineError::NoLayer(id))?;
-        if doc.effective_locks(id).all {
-            return Err(EngineError::Other(format!("Could not complete your request because the layer \"{}\" is locked", layer.name)));
-        }
-    }
+    check_text_unlocked(&s.active().ok_or(EngineError::NoDocument)?.doc, id)?;
     let (r, damage) = s.edit(label, |doc, _| {
         let snapshot = doc.clone();
         let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
@@ -560,7 +657,7 @@ fn shown_style_params<'a>(t: &TextLayer, p: &'a Value) -> Result<std::borrow::Co
     let scale = (m[0] * m[3] - m[1] * m[2]).abs().sqrt() as f32;
     let scale = if scale.is_finite() && scale > 1e-3 { f64::from(scale) } else { 1.0 };
     let mut params = p.clone();
-    for key in ["size", "leading"] {
+    for key in ["size", "leading", "leadingBy"] {
         if let Some(value) = p.get(key).and_then(Value::as_f64) {
             let value = value / scale;
             if !value.is_finite() || value.abs() > f64::from(f32::MAX) {
@@ -621,7 +718,8 @@ fn info(s: &Session, p: &Value) -> Result<Value> {
         .map(|ln| json!({ "start": char_at(text, ln.range.start), "end": char_at(text, ln.range.end), "baseline": ln.baseline, "x0": ln.x0, "x1": ln.x1, "ascent": ln.ascent, "descent": ln.descent }))
         .collect();
     let bounds = t.cache.as_ref().map(|c| c.content_bounds()).map(|r| json!([r.x0, r.y0, r.x1, r.y1]));
-    Ok(json!({
+    let warnings = crate::type_extra_cmds::missing_font_warnings_for_layer(t);
+    let mut out = json!({
         "layer": id.0,
         "text": text,
         "shape": t.shape,
@@ -634,7 +732,11 @@ fn info(s: &Session, p: &Value) -> Result<Value> {
         "lines": lines,
         "bounds": bounds,
         "pxPerPt": layout.px_per_pt,
-    }))
+    });
+    if !warnings.is_empty() {
+        out["warnings"] = json!(warnings);
+    }
+    Ok(out)
 }
 
 /// A type layer (not yet rendered or added) from `type.create`'s params: text, point `x`/`y` or
@@ -705,7 +807,14 @@ pub fn specs() -> Vec<CommandSpec> {
                     Ok(id)
                 })?;
                 let bounds = s.active().and_then(|d| d.doc.layer(id)).and_then(|l| l.surface()).map(|c| c.content_bounds());
-                Ok(json!({ "layer": id.0, "bounds": bounds.map(|r| [r.x0, r.y0, r.x1, r.y1]) }))
+                let mut out = json!({ "layer": id.0, "bounds": bounds.map(|r| [r.x0, r.y0, r.x1, r.y1]) });
+                if let Some(LayerContent::Text(t)) = s.active().and_then(|d| d.doc.layer(id)).map(|l| &l.content) {
+                    let warnings = crate::type_extra_cmds::missing_font_warnings_for_layer(t);
+                    if !warnings.is_empty() {
+                        out["warnings"] = json!(warnings);
+                    }
+                }
+                Ok(out)
             },
         },
         CommandSpec {
@@ -834,13 +943,14 @@ pub fn specs() -> Vec<CommandSpec> {
             menu: &[],
             shortcut: None,
             params: Box::leak(
-                format!(r##"{{"layer":id? or "layers":[id,…]? (default selected Type layers),"range":[startChar,endChar]? (single layer; default all),"metricsAsShown":bool=false (size/leading include each layer's transform scale), {CHAR_PARAMS}, paragraph keys: "align":"left|center|right|justify|justifyCenter|justifyRight|justifyAll","firstLineIndent":pt,"startIndent":pt,"endIndent":pt,"spaceBefore":pt,"spaceAfter":pt,"autoLeading":%,"direction":"auto|ltr|rtl","hyphenate":bool}}"##)
+                format!(r##"{{"layer":id? or "layers":[id,…]? (default selected Type layers),"range":[startChar,endChar]? (single layer; default all),"metricsAsShown":bool=false (size/leading/leadingBy include each layer's transform scale), {CHAR_PARAMS}, relative steps from each character's own value: "leadingBy":pt (auto leading starts from its laid-out value; result 0.01..=5000),"baselineShiftBy":pt (result -5000..=5000),"trackingBy":1/1000 em (result -1000..=10000), paragraph keys: "align":"left|center|right|justify|justifyCenter|justifyRight|justifyAll","firstLineIndent":pt,"startIndent":pt,"endIndent":pt,"spaceBefore":pt,"spaceAfter":pt,"autoLeading":%,"direction":"auto|ltr|rtl","hyphenate":bool}}"##)
                     .into_boxed_str(),
             ),
             enabled: has_doc,
             journal: true,
             run: |s, p| {
                 check_kerning(p).map_err(|m| bad("type.setStyle", m))?;
+                check_steps(p).map_err(|m| bad("type.setStyle", m))?;
                 let ids = with_text_targets(s, p, "Set Type Style", |t, (a, b)| {
                     let props = shown_style_params(t, p)?;
                     check_size_tracking(&props).map_err(|m| bad("type.setStyle", m))?;
@@ -850,6 +960,7 @@ pub fn specs() -> Vec<CommandSpec> {
                             apply_char_props(st, &props);
                         });
                     }
+                    step_char_metrics(t, a, b, &props);
                     let mut pprobe = ParagraphStyle::default();
                     if apply_para_props(&mut pprobe, p) {
                         style_paragraphs(t, a, b, &|st| {
@@ -989,14 +1100,36 @@ mod tests {
         assert_eq!(style.weight, 600);
         assert_eq!(style.postscript_name.as_deref(), Some("Inter-SemiBold"));
         apply_char_props(&mut style, &json!({"weight": 400}));
-        assert!(style.postscript_name.is_none());
+        // #3556: a style change re-resolves to the installed face instead of leaving it nameless.
+        assert_eq!(style.postscript_name.as_deref(), Some("Inter-Regular"));
         assert!(style.font_style.is_empty());
         apply_char_props(&mut style, &json!({"fontStyle": "unknown-style"}));
-        assert!(style.postscript_name.is_none());
+        assert_eq!(style.postscript_name.as_deref(), Some("Inter-Regular"));
         apply_char_props(&mut style, &json!({"fontStyle": "Regular", "postscriptName": "ExplicitFace"}));
         assert_eq!(style.postscript_name.as_deref(), Some("ExplicitFace"));
     }
 
+    /// #3556: a font named by family stores the installed face's PostScript name, so PSD export
+    /// names a real font instead of inventing "<Family>-Regular" that Photoshop calls missing.
+    #[test]
+    fn a_family_font_gets_the_installed_postscript_name() {
+        let mut style = CharStyle { font_family: "Inter".into(), ..Default::default() };
+        apply_char_props(&mut style, &json!({"font": "Inter"}));
+        assert_eq!(style.font_family, "Inter");
+        assert_eq!(style.postscript_name.as_deref(), Some("Inter-Regular"), "resolved from the font database");
+        // A weight picks that face's name.
+        apply_char_props(&mut style, &json!({"font": "Inter", "weight": 600}));
+        assert_eq!(style.postscript_name.as_deref(), Some("Inter-SemiBold"));
+        // A weight no face has (a variable font's axis, or between two faces) names no face, so
+        // layout still matches the requested weight instead of a nearby face's.
+        apply_char_props(&mut style, &json!({"weight": 650}));
+        assert!(style.postscript_name.is_none(), "{:?}", style.postscript_name);
+        // A family PhotoCraft does not have keeps no name; the export falls back as before.
+        let mut absent = CharStyle { font_family: "No Such Family 123".into(), ..Default::default() };
+        apply_char_props(&mut absent, &json!({"font": "No Such Family 123"}));
+        assert!(absent.postscript_name.is_none());
+    }
+
     /// Picking a style or weight resets the weight axis to it; other axes keep their values (#2985).
     #[test]
     fn a_style_or_weight_resets_the_weight_axis() {
@@ -1542,4 +1675,77 @@ mod tests {
             assert!(s.active().unwrap().doc.layer(LayerId(id)).is_none());
         }
     }
+
+    #[test]
+    fn missing_font_emits_warning_in_create_set_style_and_edit() {
+        let mut s = session();
+        let r = s.execute("type.create", json!({"x": 10, "y": 20, "text": "Hello", "font": "NoSuchFamily123"})).unwrap();
+        assert_eq!(r["warnings"], json!(["font 'NoSuchFamily123' is not installed; text may render using a fallback face"]));
+        let id = r["layer"].as_u64().unwrap();
+        let styled = s.execute("type.setStyle", json!({"layer": id, "font": "StillNoSuchFamily456"})).unwrap();
+        assert_eq!(styled["warnings"], json!(["font 'StillNoSuchFamily456' is not installed; text may render using a fallback face"]));
+        let edited = s.execute("type.edit", json!({"layer": id, "runs": [{"start": 0, "end": 2, "font": "AnotherMissingFont789"}]})).unwrap();
+        assert_eq!(
+            edited["warnings"],
+            json!([
+                "font 'AnotherMissingFont789' is not installed; text may render using a fallback face",
+                "font 'StillNoSuchFamily456' is not installed; text may render using a fallback face"
+            ])
+        );
+    }
+
+    /// `leadingBy`, `baselineShiftBy` and `trackingBy` step every character from its own value
+    /// (auto leading from its laid-out value), clamp to Photoshop's ranges, and reject hostile
+    /// steps without changing anything.
+    #[test]
+    fn relative_steps_move_each_character_from_its_own_value() {
+        let mut s = session();
+        let id = s.execute("type.create", json!({"x": 0, "y": 40, "text": "Hello\nworld", "size": 10})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("type.setStyle", json!({"layer": id, "range": [8, 11], "leading": 30, "tracking": 50})).unwrap();
+        s.execute("type.setStyle", json!({"layer": id, "range": [6, 11], "autoLeading": 150})).unwrap();
+        let steps = s.active().unwrap().history.entries().len();
+        s.execute("type.setStyle", json!({"layer": id, "range": [0, 11], "leadingBy": 2, "baselineShiftBy": -2, "trackingBy": 20})).unwrap();
+        assert_eq!(s.active().unwrap().history.entries().len(), steps + 1, "one history step");
+        let t = text_layer(&s, id);
+        let at = |c: usize| {
+            let byte = byte_at(&t.text, c);
+            let mut off = 0;
+            t.char_runs()
+                .into_iter()
+                .find(|r| {
+                    off += r.len;
+                    off > byte
+                })
+                .unwrap()
+                .style
+        };
+        // Auto leading 120% × 10 pt (first paragraph), 150% × 10 pt (second), and a set 30 pt.
+        assert_eq!(at(0).leading_pt, Some(14.0));
+        assert_eq!(at(6).leading_pt, Some(17.0));
+        assert_eq!(at(9).leading_pt, Some(32.0));
+        assert_eq!((at(0).baseline_shift_pt, at(9).baseline_shift_pt), (-2.0, -2.0));
+        assert_eq!((at(0).tracking, at(9).tracking), (20.0, 70.0));
+        // Clamped to the ranges.
+        s.execute("type.setStyle", json!({"layer": id, "leadingBy": -5000, "baselineShiftBy": 10000, "trackingBy": -11000})).unwrap();
+        let t = text_layer(&s, id);
+        assert!(t.char_runs().iter().all(|r| r.style.leading_pt == Some(LEADING_MIN_PT)
+            && r.style.baseline_shift_pt == BASELINE_SHIFT_MAX_PT
+            && r.style.tracking == TRACKING_MIN as f32));
+        // A collapsed range in non-empty text changes no character.
+        let before = text_layer(&s, id).char_runs();
+        s.execute("type.setStyle", json!({"layer": id, "range": [3, 3], "trackingBy": 100})).unwrap();
+        assert_eq!(text_layer(&s, id).char_runs(), before);
+        // Hostile steps are refused.
+        let steps = s.active().unwrap().history.entries().len();
+        for bad_step in [json!({"leadingBy": "up"}), json!({"trackingBy": 1e30}), json!({"baselineShiftBy": null}), json!({"leadingBy": [1]})] {
+            let mut p = bad_step.clone();
+            p["layer"] = json!(id);
+            assert!(matches!(s.execute("type.setStyle", p), Err(EngineError::BadParams { .. })), "{bad_step}");
+        }
+        assert_eq!(s.active().unwrap().history.entries().len(), steps);
+        // Empty text: the step sets the style the next typed characters get.
+        let empty = s.execute("type.create", json!({"x": 0, "y": 80, "text": "", "size": 10})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("type.setStyle", json!({"layer": empty, "range": [0, 0], "leadingBy": -2})).unwrap();
+        assert_eq!(text_layer(&s, empty).char_runs()[0].style.leading_pt, Some(10.0));
+    }
 }
diff --git a/crates/engine/src/type_extra_cmds.rs b/crates/engine/src/type_extra_cmds.rs
index 022146f113..efa2d791cc 100644
--- a/crates/engine/src/type_extra_cmds.rs
+++ b/crates/engine/src/type_extra_cmds.rs
@@ -14,7 +14,9 @@ use photocraft_text::render::PathEl;
 use serde_json::{Value, json};
 
 use crate::commands::{CommandSpec, layer_param};
-use crate::type_cmds::{format_targets, has_format_target, is_auto_named, layer_name, refresh, replace_text, style_paragraphs, style_range, with_text_targets};
+use crate::type_cmds::{
+    check_text_unlocked, format_targets, has_format_target, is_auto_named, layer_name, refresh, replace_text, style_paragraphs, style_range, with_text_targets,
+};
 use crate::{EngineError, Result, Session};
 
 /// Photoshop's Paste Lorem Ipsum filler.
@@ -42,6 +44,7 @@ fn has_point_text(s: &Session) -> std::result::Result<(), String> {
     match active_text(s)?.shape {
         TextShape::Point => Ok(()),
         TextShape::Box { .. } => Err("the type layer is already paragraph text".into()),
+        TextShape::Path { .. } => Err("detach the type layer from its path first".into()),
     }
 }
 
@@ -49,6 +52,7 @@ fn has_box_text(s: &Session) -> std::result::Result<(), String> {
     match active_text(s)?.shape {
         TextShape::Box { .. } => Ok(()),
         TextShape::Point => Err("the type layer is already point text".into()),
+        TextShape::Path { .. } => Err("the type layer is path text".into()),
     }
 }
 
@@ -67,6 +71,7 @@ fn has_defaults(s: &Session) -> std::result::Result<(), String> {
 /// Edits a type layer as one history step and re-renders it.
 fn with_text<R>(s: &mut Session, p: &Value, label: &str, f: impl FnOnce(&mut TextLayer, &Document) -> Result<R>) -> Result<R> {
     let id = layer_param(s, p)?;
+    check_text_unlocked(&s.active().ok_or(EngineError::NoDocument)?.doc, id)?;
     s.edit(label, |doc, _| {
         let snapshot = doc.clone();
         let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
@@ -276,7 +281,7 @@ fn contours(els: &[PathEl]) -> Vec<Vec<Knot>> {
 /// which reproduces the nonzero fill under Photoshop's per-subpath path operations.
 pub fn text_path(doc: &Document, t: &TextLayer) -> Path {
     let l = layout(doc, t);
-    let warp = photocraft_text::render::layout_warp(&l, t.warp.as_ref());
+    let warp = photocraft_text::render::layout_deform(&l, t);
     let mut subpaths = Vec::new();
     for glyph in photocraft_text::render::outlines(&l, &t.transform, warp.as_ref()) {
         let cs = contours(&glyph);
@@ -318,6 +323,95 @@ fn convert_to_shape(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"layer": id.0, "subpaths": n}))
 }
 
+// ---------- type on a path ----------
+
+/// Largest anchor count of a path that type can follow (a hostile document cannot make the
+/// layout walk millions of segments).
+const MAX_TYPE_PATH_KNOTS: usize = 100_000;
+
+/// The subpath `type.attachToPath` follows, in document space: the work path (default) or a
+/// shape layer's path (`"shape":id`), subpath `"subpath"` (default 0).
+fn path_source(doc: &Document, p: &Value) -> Result<Subpath> {
+    let bad = |m: &str| EngineError::BadParams { cmd: "type.attachToPath".into(), msg: m.into() };
+    let path = match p.get("shape") {
+        None | Some(Value::Null) => doc.work_path.as_ref().ok_or_else(|| bad("the document has no work path; draw a path or pass \"shape\":layerId"))?,
+        Some(v) => {
+            let id = v.as_u64().ok_or_else(|| bad("\"shape\" must be a layer id"))?;
+            match doc.layer(LayerId(id)).map(|l| &l.content) {
+                Some(LayerContent::Shape(sh)) => &sh.path,
+                Some(_) => return Err(bad("\"shape\" is not a shape layer")),
+                None => return Err(EngineError::NoLayer(LayerId(id))),
+            }
+        }
+    };
+    let index = match p.get("subpath") {
+        None | Some(Value::Null) => 0,
+        Some(v) => v.as_u64().and_then(|n| usize::try_from(n).ok()).ok_or_else(|| bad("\"subpath\" must be a non-negative index"))?,
+    };
+    let sub = path.subpaths.get(index).ok_or_else(|| bad("the path has no such subpath"))?;
+    if sub.knots.len() < 2 {
+        return Err(bad("the subpath needs at least two anchor points"));
+    }
+    if sub.knots.len() > MAX_TYPE_PATH_KNOTS {
+        return Err(bad("the subpath has too many anchor points"));
+    }
+    Ok(sub.clone())
+}
+
+fn attach_to_path(s: &mut Session, p: &Value) -> Result<Value> {
+    let bad = |m: &str| EngineError::BadParams { cmd: "type.attachToPath".into(), msg: m.into() };
+    let start = match p.get("start") {
+        None | Some(Value::Null) => 0.0,
+        Some(v) => v.as_f64().filter(|n| n.is_finite()).ok_or_else(|| bad("\"start\" must be a finite number of pixels"))? as f32,
+    };
+    let flip = match p.get("flip") {
+        None | Some(Value::Null) => false,
+        Some(v) => v.as_bool().ok_or_else(|| bad("\"flip\" must be true or false"))?,
+    };
+    let id = layer_param(s, p)?;
+    let doc = &s.active().ok_or(EngineError::NoDocument)?.doc;
+    if doc.effective_locks(id).all {
+        return Err(EngineError::Other("the type layer is locked".into()));
+    }
+    let sub = path_source(doc, p)?;
+    with_text(s, p, "Type on a Path", |t, _| {
+        // The path lives in document space; the type layer keeps it in its own text space, so
+        // the type lands on the path where it is drawn.
+        let inv = t.transform.inverse().ok_or_else(|| EngineError::Other("the type layer's transform cannot be inverted".into()))?;
+        let map = |q: Point| inv.apply(q);
+        let knots = sub.knots.iter().map(|k| Knot { anchor: map(k.anchor), in_ctrl: map(k.in_ctrl), out_ctrl: map(k.out_ctrl), smooth: k.smooth }).collect();
+        let path = Subpath { closed: sub.closed, knots, op: PathOp::Combine };
+        if !path.knots.iter().all(|k| [k.anchor, k.in_ctrl, k.out_ctrl].iter().all(|q| q.x.is_finite() && q.y.is_finite())) {
+            return Err(EngineError::Other("the path cannot be mapped into the type layer".into()));
+        }
+        t.shape = TextShape::Path { path, start, flip };
+        Ok(())
+    })?;
+    Ok(json!({"layer": id.0, "start": start, "flip": flip}))
+}
+
+fn is_path_text(s: &Session) -> std::result::Result<(), String> {
+    match active_text(s)?.shape {
+        TextShape::Path { .. } => Ok(()),
+        _ => Err("the type layer is not on a path".into()),
+    }
+}
+
+fn detach_from_path(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = layer_param(s, p)?;
+    with_text(s, p, "Release Type from Path", |t, _| {
+        if !matches!(t.shape, TextShape::Path { .. }) {
+            return Err(EngineError::Other("the type layer is not on a path".into()));
+        }
+        // Point text starts where the type started on the path.
+        let origin = photocraft_text::warp::Warp::on_path(&t.shape).map_or((0.0, 0.0), |w| w.apply(0.0, 0.0));
+        t.shape = TextShape::Point;
+        t.transform = then_translate(&t.transform, origin.0, origin.1);
+        Ok(())
+    })?;
+    Ok(json!({"layer": id.0}))
+}
+
 // ---------- warp ----------
 
 fn warp_text(s: &mut Session, p: &Value) -> Result<Value> {
@@ -415,20 +509,30 @@ fn update_all(s: &mut Session) -> Result<Value> {
     Ok(json!({"updated": n}))
 }
 
-fn installed_families() -> Vec<String> {
-    photocraft_text::shared().lock().unwrap_or_else(|e| e.into_inner()).fonts.families().into_iter().map(|f| f.to_lowercase()).collect()
+fn style_font_missing(fonts: &mut photocraft_text::FontDb, style: &photocraft_doc::text::CharStyle) -> bool {
+    if style.font_family.is_empty() || fonts.has_family(&style.font_family) {
+        return false;
+    }
+    // Match layout's choice: an exact PostScript face wins over the import-time family guess;
+    // a heuristic family is usable only when the stored family is unavailable.
+    if let Some(ps) = &style.postscript_name {
+        let resolved = fonts.resolve_postscript(ps);
+        if resolved.exact || fonts.has_family(&resolved.family) {
+            return false;
+        }
+    }
+    true
 }
 
 /// Font families used by type layers that the font database cannot supply.
 pub fn missing_fonts(doc: &Document) -> Vec<String> {
-    let have = installed_families();
+    let mut engine = photocraft_text::shared().lock().unwrap_or_else(|e| e.into_inner());
     let mut out: Vec<String> = Vec::new();
     for (_, _, l) in doc.walk() {
         if let LayerContent::Text(t) = &l.content {
             for r in t.char_runs() {
-                let f = r.style.font_family;
-                if !f.is_empty() && !have.contains(&f.to_lowercase()) && !out.contains(&f) {
-                    out.push(f);
+                if style_font_missing(&mut engine.fonts, &r.style) && !out.contains(&r.style.font_family) {
+                    out.push(r.style.font_family);
                 }
             }
         }
@@ -436,6 +540,32 @@ pub fn missing_fonts(doc: &Document) -> Vec<String> {
     out
 }
 
+/// Font families used by a type layer that the font database cannot supply.
+pub fn missing_fonts_in_layer(t: &TextLayer) -> Vec<String> {
+    let mut engine = photocraft_text::shared().lock().unwrap_or_else(|e| e.into_inner());
+    let mut out: Vec<String> = Vec::new();
+    for r in t.char_runs() {
+        if style_font_missing(&mut engine.fonts, &r.style) && !out.contains(&r.style.font_family) {
+            out.push(r.style.font_family);
+        }
+    }
+    out
+}
+
+/// Warnings for missing font families in `doc`.
+pub fn missing_font_warnings(doc: &Document) -> Vec<String> {
+    fonts_to_warnings(missing_fonts(doc))
+}
+
+/// Warnings for missing font families in `layer`.
+pub fn missing_font_warnings_for_layer(t: &TextLayer) -> Vec<String> {
+    fonts_to_warnings(missing_fonts_in_layer(t))
+}
+
+fn fonts_to_warnings(fonts: Vec<String>) -> Vec<String> {
+    fonts.into_iter().map(|font| format!("font '{font}' is not installed; text may render using a fallback face")).collect()
+}
+
 /// Replace missing families per `map` (missing → installed; unmapped ones → the default family).
 fn replace_fonts(s: &mut Session, map: &serde_json::Map<String, Value>, all: bool) -> Result<Value> {
     let d = s.active().ok_or(EngineError::NoDocument)?;
@@ -459,7 +589,11 @@ fn replace_fonts(s: &mut Session, map: &serde_json::Map<String, Value>, all: boo
                 let runs = t.char_runs();
                 let mut at = 0;
                 for r in runs {
-                    if let Some(to) = pick(&r.style.font_family) {
+                    let missing_run = {
+                        let mut engine = photocraft_text::shared().lock().unwrap_or_else(|e| e.into_inner());
+                        style_font_missing(&mut engine.fonts, &r.style)
+                    };
+                    if missing_run && let Some(to) = pick(&r.style.font_family) {
                         style_range(t, at, at + r.len, &|st| {
                             st.font_family = to.clone();
                             st.postscript_name = None;
@@ -558,6 +692,15 @@ pub fn specs() -> Vec<CommandSpec> {
             has_format_target,
             warp_text
         ),
+        spec!(
+            "type.attachToPath",
+            "Type on a Path",
+            &[],
+            r##"{"layer":id? (default active Type layer),"shape":layerId? (a shape layer; default the work path),"subpath":index=0,"start":px=0 (offset along the path),"flip":bool=false (run along the path the other way, on its other side)}"##,
+            has_text,
+            attach_to_path
+        ),
+        spec!("type.detachFromPath", "Release Type from Path", &[], LP, is_path_text, detach_from_path),
         spec!("type.updateAllTextLayers", "Update All Text Layers", &["Type"], "{}", any_text, |s, _| update_all(s)),
         spec!("type.replaceAllMissingFonts", "Replace All Missing Fonts", &["Type"], "{} (with the default family)", any_text, |s, _| replace_fonts(
             s,
diff --git a/crates/engine/src/type_extra_cmds/tests.rs b/crates/engine/src/type_extra_cmds/tests.rs
index 993ae41e8d..9f604eed1b 100644
--- a/crates/engine/src/type_extra_cmds/tests.rs
+++ b/crates/engine/src/type_extra_cmds/tests.rs
@@ -282,3 +282,119 @@ fn rasterize_type_layer() {
     assert!(matches!(s.active().unwrap().doc.layer(id).unwrap().content, LayerContent::Raster(_)));
     assert!(!s.is_enabled("type.rasterizeTypeLayer"));
 }
+
+#[test]
+fn type_attaches_to_a_path_and_releases_it() {
+    let mut s = session(8);
+    let id = text_layer(&mut s, "Hello path");
+    assert!(s.is_enabled("type.attachToPath"));
+    assert!(!s.is_enabled("type.detachFromPath"));
+    // No work path yet, a bad subpath and bad params are errors, not panics.
+    assert!(s.execute("type.attachToPath", json!({})).is_err());
+    let flat = ink(&s, id);
+    s.edit("path", |doc, _| {
+        doc.work_path = Some(Path::new(vec![Subpath::polyline(&[(150.0, 10.0), (150.0, 110.0)])]));
+        Ok(())
+    })
+    .unwrap();
+    assert!(s.execute("type.attachToPath", json!({"subpath": 5})).is_err());
+    assert!(s.execute("type.attachToPath", json!({"start": "far"})).is_err());
+    assert!(s.execute("type.attachToPath", json!({"shape": 9999})).is_err());
+    s.execute("type.attachToPath", json!({"start": 4})).unwrap();
+    assert!(matches!(text(&s, id).shape, TextShape::Path { start, .. } if start == 4.0));
+    let on_path = ink(&s, id);
+    assert!(on_path.height() > on_path.width(), "the type runs down the vertical path: {on_path:?}");
+    assert!(on_path.height() > flat.height());
+    assert!(!s.is_enabled("type.convertToPointText"));
+    s.execute("type.detachFromPath", json!({})).unwrap();
+    assert_eq!(text(&s, id).shape, TextShape::Point);
+    assert!(ink(&s, id).width() > ink(&s, id).height());
+    assert!(s.undo());
+    assert!(matches!(text(&s, id).shape, TextShape::Path { .. }));
+}
+
+#[test]
+fn all_locked_layer_rejects_paste_lorem_ipsum_without_history() {
+    // #4188: Lock All stopped type.edit (#3132) but not Paste Lorem Ipsum into the layer.
+    let mut s = session(8);
+    let id = text_layer(&mut s, "Hi");
+    s.execute("layer.setProps", json!({"layer": id.0, "locked": true})).unwrap();
+    let history = s.active().unwrap().history.past_len();
+    for params in [json!({}), json!({"layer": id.0})] {
+        let result = s.execute("type.pasteLoremIpsum", params);
+        assert!(matches!(&result, Err(EngineError::Other(message)) if message.contains("locked")), "{result:?}");
+        assert_eq!(text(&s, id).text, "Hi");
+        assert_eq!(s.active().unwrap().history.past_len(), history);
+    }
+}
+
+/// A type layer stored with a family label that is not installed, as a PSD keeps the family it
+/// guessed from a PostScript name whose face was absent when the file was opened.
+fn guessed_family_layer(s: &mut Session, text: &str, ps: Option<&str>) -> (LayerId, Value) {
+    let mut p = json!({"x": 20, "y": 70, "text": text, "font": "Imported Wrong Family"});
+    if let Some(ps) = ps {
+        p["postscriptName"] = json!(ps);
+    }
+    let r = s.execute("type.create", p).unwrap();
+    (LayerId(r["layer"].as_u64().unwrap()), r)
+}
+
+#[test]
+fn installed_postscript_face_is_not_missing_or_replaced() {
+    // Opening a PSD corrects the label when the face is installed; a run set by command, or one
+    // reopened from .pcraft after its face was installed, keeps it.
+    let mut s = session(8);
+    let (id, created) = guessed_family_layer(&mut s, "test", Some("Inter-SemiBold"));
+    let bytes = photocraft_format::save_to_bytes(&s.active().unwrap().doc, &Default::default()).unwrap();
+    let reopened = photocraft_io::import("reopened.pcraft", &bytes).unwrap().document;
+    let LayerContent::Text(t) = &reopened.layer(id).unwrap().content else { panic!("text") };
+    assert_eq!(t.char_runs()[0].style.font_family, "Imported Wrong Family", ".pcraft open keeps the stored label");
+    let on_open = missing_font_warnings(&reopened);
+    s.add_document(reopened, None);
+    let replaced = s.execute("type.replaceAllMissingFonts", json!({})).unwrap()["replaced"].clone();
+    assert_eq!((created.get("warnings"), on_open, replaced), (None, Vec::<String>::new(), json!(0)));
+}
+
+#[test]
+fn replacing_missing_family_preserves_a_resolved_run_with_the_same_label() {
+    let mut s = session(8);
+    let (good, _) = guessed_family_layer(&mut s, "good", Some("Inter-SemiBold"));
+    let (bad, _) = guessed_family_layer(&mut s, "bad", None);
+    assert_eq!(s.execute("type.replaceAllMissingFonts", json!({})).unwrap()["replaced"], 1);
+    assert_eq!(text(&s, good).char_runs()[0].style.postscript_name.as_deref(), Some("Inter-SemiBold"));
+    assert_eq!(text(&s, bad).char_runs()[0].style.font_family, "Inter");
+}
+
+/// `source` renamed in memory to `family` with the PostScript name `ps`; no font file is added.
+fn renamed_face(source: &[u8], family: &str, ps: &str) -> Vec<u8> {
+    let mut bytes = source.to_vec();
+    let count = u16::from_be_bytes([bytes[4], bytes[5]]) as usize;
+    let record = (0..count).map(|i| 12 + i * 16).find(|r| &bytes[*r..*r + 4] == b"name").unwrap();
+    let names = [(1u16, family), (2, "Regular"), (6, ps), (16, family), (17, "Regular")];
+    let mut table: Vec<u8> = [0u16, names.len() as u16, (6 + names.len() * 12) as u16].iter().flat_map(|v| v.to_be_bytes()).collect();
+    let mut strings = Vec::new();
+    for (id, value) in names {
+        let encoded: Vec<u8> = value.encode_utf16().flat_map(u16::to_be_bytes).collect();
+        for n in [3, 1, 0x409, id, encoded.len() as u16, strings.len() as u16] {
+            table.extend(n.to_be_bytes());
+        }
+        strings.extend(encoded);
+    }
+    table.extend(strings);
+    let offset = bytes.len() as u32;
+    bytes[record + 8..record + 12].copy_from_slice(&offset.to_be_bytes());
+    bytes[record + 12..record + 16].copy_from_slice(&(table.len() as u32).to_be_bytes());
+    bytes.extend(table);
+    bytes
+}
+
+#[test]
+fn exact_postscript_face_outside_the_guessed_family_is_not_missing() {
+    let mut fonts = photocraft_text::FontDb::new();
+    fonts.register_font_data(renamed_face(&photocraft_text::fonts::INTER_REGULAR, "Exact Only Test", "UnrelatedPS30"));
+    let style =
+        |ps: &str| photocraft_doc::text::CharStyle { font_family: "Imported Wrong Family".into(), postscript_name: Some(ps.into()), ..Default::default() };
+    // Neither the stored family nor the family guessed from the name is installed: only the exact face.
+    assert!(!fonts.has_family(&photocraft_text::fonts::guess_from_postscript("UnrelatedPS30").family));
+    assert_eq!((style_font_missing(&mut fonts, &style("UnrelatedPS30")), style_font_missing(&mut fonts, &style("UnrelatedPS31"))), (false, true));
+}
diff --git a/crates/engine/src/type_spell_cmds.rs b/crates/engine/src/type_spell_cmds.rs
index cbebb0664d..12a63a364c 100644
--- a/crates/engine/src/type_spell_cmds.rs
+++ b/crates/engine/src/type_spell_cmds.rs
@@ -16,7 +16,7 @@ use photocraft_text::spell::Dictionary;
 use serde_json::{Value, json};
 
 use crate::commands::{CommandSpec, layer_param};
-use crate::type_cmds::{norm_text, refresh, replace_text};
+use crate::type_cmds::{check_text_unlocked, norm_text, refresh, replace_text};
 use crate::{EngineError, Result, Session};
 
 fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
@@ -94,6 +94,7 @@ fn change(s: &mut Session, p: &Value) -> Result<Value> {
     let to = p.get("replace").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`change` needs `replace`"))?.to_string();
     let doc = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
     let t = text(&doc, id).ok_or_else(|| bad(cmd, format!("layer {} is not a type layer", id.0)))?;
+    check_text_unlocked(&doc, id)?;
     let (a, b) = (byte_at(t, start), byte_at(t, end.max(start)));
     if let Some(w) = p.get("word").and_then(Value::as_str)
         && &t[a..b] != w
@@ -199,6 +200,7 @@ fn insert_text(s: &mut Session, p: &Value) -> Result<Value> {
     let new = norm_text(&new);
     let doc = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
     let t = text(&doc, id).ok_or_else(|| bad(cmd, format!("layer {} is not a type layer", id.0)))?;
+    check_text_unlocked(&doc, id)?;
     let n = t.chars().count();
     let (a, b) = match (p.get("range").and_then(Value::as_array), p.get("at").and_then(Value::as_u64)) {
         (Some(r), _) if r.len() == 2 => {
@@ -272,6 +274,28 @@ mod tests {
         text(&s.active().unwrap().doc, LayerId(id)).unwrap().to_string()
     }
 
+    #[test]
+    fn all_locked_layer_rejects_insert_text_and_spelling_change_without_history() {
+        // #4188: Lock All stopped type.edit (#3132) but not these two text edits.
+        let (mut s, id) = session("Teh");
+        // A second, unlocked type layer keeps Check Spelling enabled.
+        s.execute("type.create", json!({"x": 10, "y": 90, "text": "zzz", "size": 12})).unwrap();
+        s.execute("layer.setProps", json!({"layer": id, "locked": true})).unwrap();
+        let history = s.active().unwrap().history.past_len();
+        for (cmd, params) in [
+            ("type.insertText", json!({"layer": id, "text": "b"})),
+            ("edit.checkSpelling", json!({"action": "change", "layer": id, "start": 0, "end": 3, "word": "Teh", "replace": "The"})),
+        ] {
+            let result = s.execute(cmd, params);
+            assert!(matches!(&result, Err(EngineError::Other(message)) if message.contains("locked")), "{cmd}: {result:?}");
+            assert_eq!(text_of(&s, id), "Teh", "{cmd}");
+            assert_eq!(s.active().unwrap().history.past_len(), history, "{cmd}");
+        }
+        s.execute("layer.setProps", json!({"layer": id, "locked": false})).unwrap();
+        s.execute("type.insertText", json!({"layer": id, "text": "b"})).unwrap();
+        assert_eq!(text_of(&s, id), "Tehb");
+    }
+
     #[test]
     fn lists_changes_and_learns_words() {
         let (mut s, id) = session("Teh quick brwon fox, teh end. Photocraft");
diff --git a/crates/engine/src/vector_cmds.rs b/crates/engine/src/vector_cmds.rs
index b732ff2629..14579e5954 100644
--- a/crates/engine/src/vector_cmds.rs
+++ b/crates/engine/src/vector_cmds.rs
@@ -1415,6 +1415,16 @@ fn vector_mask_edit(s: &mut Session, p: &Value) -> Result<Value> {
     const CMD: &str = "layer.vectorMask.edit";
     let id = layer_id(s, p)?;
     let path = p.get("path").map(parse_path).transpose().map_err(|e| bad(CMD, e))?;
+    // Same range as a pixel mask's feather (`layer.layerMask.edit`), checked before any edit (#4201).
+    let feather = p
+        .get("feather")
+        .map(|v| {
+            v.as_f64()
+                .filter(|n| n.is_finite() && (0.0..=1000.0).contains(n))
+                .map(|n| n as f32)
+                .ok_or_else(|| bad(CMD, "`feather` must be a finite number within 0..1000"))
+        })
+        .transpose()?;
     s.edit("Edit Vector Mask", |doc, _| {
         let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
         let vm = l.vector_mask.as_mut().ok_or_else(|| EngineError::Other("layer has no vector mask".into()))?;
@@ -1430,8 +1440,8 @@ fn vector_mask_edit(s: &mut Session, p: &Value) -> Result<Value> {
         if let Some(d) = f64p(p, "density") {
             vm.density = (d / 100.0).clamp(0.0, 1.0) as f32;
         }
-        if let Some(f) = f64p(p, "feather") {
-            vm.feather = f.max(0.0) as f32;
+        if let Some(f) = feather {
+            vm.feather = f;
         }
         if let Some(b) = p.get("invert").and_then(Value::as_bool)
             && b
@@ -1631,7 +1641,7 @@ fn combine_shapes(s: &mut Session, p: &Value, op: &str, label: &str) -> Result<V
 }
 
 fn selection_to_shape(s: &mut Session, p: &Value) -> Result<Value> {
-    let tol = f64p(p, "tolerance").unwrap_or(2.0).clamp(0.5, 10.0);
+    let tol = f64p(p, "tolerance").or_else(|| f64p(p, "simplifyTolerance")).unwrap_or(2.0).clamp(0.5, 10.0);
     let d = s.active().ok_or(EngineError::NoDocument)?;
     let area = d.doc.bounds();
     let mask = sel::mask_from_surface(d.doc.selection.as_ref(), area);
@@ -1821,7 +1831,9 @@ pub fn specs() -> Vec<CommandSpec> {
             "layer.vectorMask.edit",
             "Edit Vector Mask",
             [],
-            leak(format!(r##"{{"layer":id?,"path":{{…}}?,"enabled":bool?,"linked":bool?,"density":0..100?,"feather":px?,"invert":true?}}. {PATH_FORM}"##)),
+            leak(format!(
+                r##"{{"layer":id?,"path":{{…}}?,"enabled":bool?,"linked":bool?,"density":0..100?,"feather":0..1000? (pixels),"invert":true?}}. {PATH_FORM}"##
+            )),
             has_layer,
             vector_mask_edit
         ),
@@ -1884,14 +1896,7 @@ pub fn specs() -> Vec<CommandSpec> {
             has_layer,
             merge_components
         ),
-        spec!(
-            "select.convertToShape",
-            "Convert Selection to Shape",
-            [],
-            r##"{"tolerance":px=2,"fill":"#rrggbb"=foreground,"name":str?} → shape.info"##,
-            has_selection,
-            selection_to_shape
-        ),
+        spec!("select.convertToShape", "Convert to Shape", [], r##"{"tolerance":0.5..10 px=2} → shape.info"##, has_selection, selection_to_shape),
         CommandSpec {
             id: "layer.vectorMask.info",
             label: "Vector Mask Info",
diff --git a/crates/engine/src/vector_cmds/tests.rs b/crates/engine/src/vector_cmds/tests.rs
index 00cb58d8cb..4c2a9a9071 100644
--- a/crates/engine/src/vector_cmds/tests.rs
+++ b/crates/engine/src/vector_cmds/tests.rs
@@ -363,6 +363,30 @@ fn selection_to_work_path_roundtrip_iou() {
     let r = s.execute("select.convertToShape", json!({"fill": "#00ff00"})).unwrap();
     assert_eq!(r["fill"], "#00ff00");
     assert_eq!(r["path"]["subpaths"].as_array().unwrap().len(), 3);
+
+    // tolerance and simplifyTolerance parameter
+    s.execute("path.toSelection", json!({"name": "src"})).unwrap();
+    let r_fine = s.execute("select.convertToShape", json!({"tolerance": 0.5, "name": "Fine Shape"})).unwrap();
+    assert_eq!(r_fine["name"], "Fine Shape");
+    let knots = |r: &Value| r["path"]["subpaths"].as_array().unwrap().iter().map(|sp| sp["knots"].as_array().unwrap().len()).sum::<usize>();
+    let fine_knots = knots(&r_fine);
+
+    s.execute("path.toSelection", json!({"name": "src"})).unwrap();
+    let r_coarse = s.execute("select.convertToShape", json!({"simplifyTolerance": 5.0, "name": "Coarse Shape"})).unwrap();
+    assert_eq!(r_coarse["name"], "Coarse Shape");
+    let coarse_knots = knots(&r_coarse);
+    assert!(fine_knots > coarse_knots, "fine tolerance {fine_knots} must have more knots than coarse {coarse_knots}");
+
+    // Undo restores state
+    assert!(s.undo());
+    assert_eq!(s.active().unwrap().doc.layers.last().unwrap().name, "Fine Shape");
+}
+
+#[test]
+fn convert_to_shape_requires_selection() {
+    let mut s = session(100, 100, 8);
+    assert!(!s.is_enabled("select.convertToShape"));
+    assert!(s.execute("select.convertToShape", json!({})).is_err());
 }
 
 #[test]
@@ -701,6 +725,28 @@ fn vector_mask_commands_and_compositing() {
     assert!(s.execute("layer.vectorMask.revealAll", json!({})).is_err());
 }
 
+/// #4201: the vector mask's feather takes the pixel mask's range (finite 0..=1000 px); anything
+/// else is refused before the edit, so no infinite feather can block a .pcraft save.
+#[test]
+fn vector_mask_edit_rejects_out_of_range_feather() {
+    let mut s = session(32, 32, 8);
+    s.execute("layer.new.layer", json!({})).unwrap();
+    let id = s.active().unwrap().active_layer.unwrap();
+    s.execute("layer.vectorMask.revealAll", json!({})).unwrap();
+    let feather = |s: &Session| doc(s).layer(id).unwrap().vector_mask.as_ref().unwrap().feather;
+    let steps = s.active().unwrap().history.past_len();
+    for bad in [json!(1e39), json!(-1), json!(1001), json!("x"), json!(null)] {
+        assert!(s.execute("layer.vectorMask.edit", json!({"feather": bad})).is_err(), "feather {bad}");
+        assert_eq!(feather(&s), 0.0, "feather {bad}");
+        assert_eq!(s.active().unwrap().history.past_len(), steps, "feather {bad}");
+    }
+    let r = s.execute("layer.vectorMask.edit", json!({"feather": 12.5})).unwrap();
+    assert_eq!(r["feather"], 12.5);
+    assert_eq!(feather(&s), 12.5);
+    s.execute("layer.vectorMask.edit", json!({"feather": 1000})).unwrap();
+    assert_eq!(feather(&s), 1000.0);
+}
+
 #[test]
 fn translate_vectors_moves_shapes_and_masks() {
     let mut s = session(100, 100, 8);
@@ -774,6 +820,31 @@ fn shape_info_bounds_of_curved_shapes_are_exact() {
     }
 }
 
+#[test]
+fn shape_create_negative_size_rect_covers_the_ellipse_box() {
+    // Issue #4203: a rectangle with a negative width spanned x 50..70 while the ellipse and
+    // polygon with the same `rect` spanned 30..50.
+    for depth in [8, 16, 32] {
+        let mut s = session(100, 60, depth);
+        let ell = s.execute("shape.create", json!({"kind": "ellipse", "rect": [50, 10, -20, 30], "fill": "#0000ff"})).unwrap()["bounds"].clone();
+        assert_eq!(ell, json!([30, 10, 20, 30]), "{depth}-bit");
+        for params in [
+            json!({"kind": "rect", "rect": [50, 10, -20, 30], "fill": "#0000ff"}),
+            json!({"kind": "roundedRect", "rect": [50, 10, -20, 30], "radii": 5, "fill": "#0000ff"}),
+            json!({"kind": "rect", "rect": [50, 40, -20, -30], "fill": "#0000ff"}),
+        ] {
+            let r = s.execute("shape.create", params.clone()).unwrap();
+            assert_eq!(r["bounds"], ell, "{params} at {depth}-bit");
+            let sh = shape(&s, r["layer"].as_u64().unwrap());
+            let c = sh.cache.as_ref().unwrap();
+            let fmt = c.format();
+            let alpha = |x: i32, y: i32| photocraft_raster::to_rgba(&fmt, &c.read_region(photocraft_doc::Rect::from_xywh(x, y, 1, 1)))[3];
+            assert!(alpha(40, 25) > 0.99, "{params} at {depth}-bit");
+            assert!(alpha(60, 25) < 0.01, "{params} at {depth}-bit");
+        }
+    }
+}
+
 /// Two overlapping 40×40 rectangle shape layers ("Rectangle 1" black below, "Rectangle 2" grey
 /// above, overlapping by 20×20) with both selected, like the Layers panel in #2400.
 fn two_selected_rects(depth: u32) -> (Session, u64, u64) {
diff --git a/crates/engine/src/video_cmds.rs b/crates/engine/src/video_cmds.rs
index dbb51d82d2..2a9f8ae8b4 100644
--- a/crates/engine/src/video_cmds.rs
+++ b/crates/engine/src/video_cmds.rs
@@ -72,6 +72,17 @@ fn has_doc(s: &Session) -> std::result::Result<(), String> {
     s.active().map(|_| ()).ok_or_else(|| "no document".into())
 }
 
+/// Grow the timeline to at least `frames` frames (never shrink it). Only a work area that reached
+/// the old end follows the new end; a narrowed one stays where the user put it (#4170).
+fn grow_duration(t: &mut Timeline, frames: usize) {
+    let old = t.duration;
+    t.duration = t.duration.max(frames.max(1));
+    if t.work_end >= old {
+        t.work_end = t.duration;
+    }
+    t.clamp();
+}
+
 /// Edit the active video layer's [`VideoData`] at the playhead, then re-sync the displayed frame.
 fn edit_video(s: &mut Session, label: &str, f: impl FnOnce(&mut VideoData, usize) -> Result<()>) -> Result<Value> {
     let count = s.edit(label, |doc, active| {
@@ -83,9 +94,7 @@ fn edit_video(s: &mut Session, label: &str, f: impl FnOnce(&mut VideoData, usize
         f(v, cur)?;
         let n = v.frames.len();
         if let Some(t) = &mut doc.timeline {
-            t.duration = t.duration.max(n.max(1));
-            t.work_end = t.work_end.max(t.duration);
-            t.clamp();
+            grow_duration(t, n);
         }
         sync(doc);
         Ok(n)
@@ -295,8 +304,7 @@ fn new_from_file(s: &mut Session, p: &Value) -> Result<Value> {
         if doc.timeline.is_none() {
             doc.timeline = Some(Timeline::new(n, fps));
         } else if let Some(t) = &mut doc.timeline {
-            t.duration = t.duration.max(n);
-            t.clamp();
+            grow_duration(t, n);
         }
         let name = doc.next_layer_name(std::path::Path::new(&path).file_stem().and_then(|s| s.to_str()).unwrap_or("Video"));
         let mut l = Layer::raster(name, fmt);
diff --git a/crates/engine/src/video_cmds/tests.rs b/crates/engine/src/video_cmds/tests.rs
index 3380d3b9d0..22d639d49b 100644
--- a/crates/engine/src/video_cmds/tests.rs
+++ b/crates/engine/src/video_cmds/tests.rs
@@ -430,3 +430,71 @@ fn restoring_blank_video_frames_still_produces_blank_frames() {
     s.execute("layer.videoLayers.restoreFrame", json!({})).unwrap();
     assert_eq!(layer_px(&s, id)[3], 0.0);
 }
+
+fn work_area(s: &Session) -> (usize, usize, usize) {
+    let t = s.active().unwrap().doc.timeline.as_ref().unwrap();
+    (t.work_start, t.work_end, t.duration)
+}
+
+#[test]
+fn video_edits_keep_a_narrowed_work_area() {
+    // #4170: a video edit pushed the work-area end to the full duration.
+    for (cmd, params) in [
+        ("layer.videoLayers.showAlteredVideo", json!({})),
+        ("layer.videoLayers.restoreFrame", json!({})),
+        ("layer.videoLayers.interpretFootage", json!({"fps": 24})),
+    ] {
+        let mut s = session();
+        s.execute("timeline.create", json!({"duration": 30, "fps": 30})).unwrap();
+        s.execute("layer.videoLayers.newBlankVideoLayer", json!({})).unwrap();
+        s.execute("timeline.setProps", json!({"workStart": 2, "workEnd": 10})).unwrap();
+        assert_eq!(work_area(&s), (2, 10, 30));
+        s.execute(cmd, params).unwrap();
+        assert_eq!(work_area(&s), (2, 10, 30), "{cmd} moved the work area");
+    }
+}
+
+#[test]
+fn a_full_work_area_grows_with_the_duration() {
+    let mut s = session();
+    s.execute("timeline.create", json!({"duration": 30, "fps": 30})).unwrap();
+    s.execute("layer.videoLayers.newBlankVideoLayer", json!({})).unwrap();
+    assert_eq!(work_area(&s), (0, 30, 30));
+    s.execute("layer.videoLayers.insertBlankFrame", json!({})).unwrap();
+    assert_eq!(work_area(&s), (0, 31, 31));
+    // A narrowed work area stays put when the duration grows.
+    s.execute("timeline.setProps", json!({"workStart": 2, "workEnd": 10})).unwrap();
+    s.execute("layer.videoLayers.insertBlankFrame", json!({})).unwrap();
+    assert_eq!(work_area(&s), (2, 10, 32));
+}
+
+#[test]
+fn longer_footage_grows_only_a_full_work_area() {
+    let dir = tmpdir("workarea");
+    for i in 0..5 {
+        write_png(&format!("{dir}/f{i:02}.png"), 16, 12, "#808080");
+    }
+    // A work area covering everything follows the longer footage.
+    let mut s = session();
+    s.execute("timeline.create", json!({"duration": 3, "fps": 30})).unwrap();
+    s.execute("layer.videoLayers.newVideoLayerFromFile", json!({"path": dir})).unwrap();
+    assert_eq!(work_area(&s), (0, 5, 5));
+    // A narrowed one stays put.
+    let mut s = session();
+    s.execute("timeline.create", json!({"duration": 3, "fps": 30})).unwrap();
+    s.execute("timeline.setProps", json!({"workStart": 1, "workEnd": 2})).unwrap();
+    s.execute("layer.videoLayers.newVideoLayerFromFile", json!({"path": dir})).unwrap();
+    assert_eq!(work_area(&s), (1, 2, 5));
+}
+
+#[test]
+fn grow_duration_never_shrinks_and_keeps_the_work_area_valid() {
+    let mut t = Timeline::new(10, 30.0);
+    grow_duration(&mut t, 4);
+    assert_eq!((t.duration, t.work_end), (10, 10));
+    grow_duration(&mut t, 0);
+    assert_eq!((t.duration, t.work_end), (10, 10));
+    t.work_end = 6;
+    grow_duration(&mut t, 12);
+    assert_eq!((t.work_start, t.work_end, t.duration), (0, 6, 12));
+}
diff --git a/crates/engine/src/warp_cmds.rs b/crates/engine/src/warp_cmds.rs
index 49578cbb52..5142b0a940 100644
--- a/crates/engine/src/warp_cmds.rs
+++ b/crates/engine/src/warp_cmds.rs
@@ -110,21 +110,21 @@ pub fn warp_from_params(cmd: &str, p: &Value, rect: [f64; 4]) -> Result<Warp> {
     Ok(w)
 }
 
-fn warp_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut Layer, w: &Warp, rect: Rect, interp: Interp) -> Result<()> {
-    if l.locks.position && l.name == "Background" {
-        l.locks.position = false;
-        l.locks.transparency = false;
-        l.name = "Layer 0".into();
-    }
+/// A Background is turned into a normal layer by the caller first
+/// ([`crate::extra_cmds::background_to_layer`]).
+fn warp_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut Layer, w: &Warp, rect: Rect, interp: Interp, frames: Option<&Frames>) -> Result<()> {
     let locks = l.locks.union(group);
     if locks.position || locks.all {
         return Err(EngineError::Other(format!("layer \"{}\" is locked", l.name)));
     }
     let map = |x: f64, y: f64| w.map(x, y);
+    // A selection limits the linked mask exactly as it limits the pixels (#4175, as Free Transform
+    // and Perspective Warp do, #3083); a layer that moves whole takes its whole mask along.
+    let mask_sel = doc_sel.filter(|_| !crate::transform_cmds::moves_whole(l));
     match &mut l.content {
         LayerContent::Group(g) => {
             for c in g.children.iter_mut() {
-                warp_layer(None, locks, c, w, rect, interp)?;
+                warp_layer(None, locks, c, w, rect, interp, frames)?;
             }
         }
         LayerContent::Text(_) => return Err(EngineError::Other("Warp needs rasterized type (or use Type › Warp Text)".into())),
@@ -138,7 +138,14 @@ fn warp_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut Layer, w: &Warp,
             let sb = corners.iter().fold([f64::MAX, f64::MAX, f64::MIN, f64::MIN], |b, p| [b[0].min(p[0]), b[1].min(p[1]), b[2].max(p[0]), b[3].max(p[1])]);
             let src_warp = match w.style {
                 WarpStyle::None => None,
-                WarpStyle::Custom => Some(Warp::custom(w.to_mesh(1, 1).map_points(|p| hom_apply(&inv, p)), sb)),
+                WarpStyle::Custom => {
+                    let mesh = w.to_mesh(1, 1).map_points(|p| hom_apply(&inv, p));
+                    // A `mesh` parameter's knots span the contents, not the warp box's image (#4113).
+                    match frames.and_then(|f| f.get(&l.id)).and_then(|&c| content_frame_warp(&mesh, c, sb)) {
+                        Some(cw) => Some(cw),
+                        None => Some(Warp::custom(mesh, sb)),
+                    }
+                }
                 _ => Some(Warp { bounds: sb, mesh: None, ..w.clone() }),
             };
             sm.warp = src_warp.filter(|w| !w.is_identity());
@@ -177,7 +184,11 @@ fn warp_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut Layer, w: &Warp,
     if let Some(m) = l.mask.as_mut()
         && m.linked
     {
-        m.surface = warp_mesh_gray(&m.surface, &map, interp);
+        let whole = |m: &Surface| Ok(warp_mesh_gray(m, &map, interp));
+        m.surface = match mask_sel {
+            Some(sel) => crate::transform_cmds::move_gray_selected(&m.surface, sel, &|lifted, src| Ok(warp_mesh_surface(lifted, src, &map, interp)), &whole)?,
+            None => whole(&m.surface)?,
+        };
     }
     if let Some(vm) = l.vector_mask.as_mut()
         && vm.linked
@@ -187,6 +198,75 @@ fn warp_layer(doc_sel: Option<&Surface>, group: Locks, l: &mut Layer, w: &Warp,
     Ok(())
 }
 
+/// Source boxes of the smart objects under a warped layer, by layer id.
+type Frames = std::collections::HashMap<LayerId, [f64; 4]>;
+
+fn source_frames(doc: &Document, l: &Layer, out: &mut Frames) {
+    match &l.content {
+        LayerContent::Group(g) => g.children.iter().for_each(|c| source_frames(doc, c, out)),
+        LayerContent::Smart(sm) => {
+            if let Some(b) = crate::smart_cmds::source_box(doc, sm) {
+                out.insert(l.id, b);
+            }
+        }
+        _ => {}
+    }
+}
+
+/// Rescales `knots` (spanning the box starting at `c0`, `cs` long) to span the frame `t0`, `ts`
+/// (which contains it). Returns the knots and whether the frame extends past the box at the start / end.
+fn reframe_knots(knots: &[f64], c0: f64, cs: f64, t0: f64, ts: f64) -> (Vec<f64>, bool, bool) {
+    let pre = (c0 - t0) / ts > 1e-9;
+    let post = (t0 + ts - (c0 + cs)) / ts > 1e-9;
+    let mut out: Vec<f64> = Vec::with_capacity(knots.len() + 2);
+    if pre {
+        out.push(0.0);
+    }
+    out.extend(knots.iter().map(|k| (c0 + k * cs - t0) / ts));
+    if post {
+        out.push(1.0);
+    }
+    // Keep the ends exactly 0 and 1.
+    if let Some(f) = out.first_mut() {
+        *f = 0.0;
+    }
+    if let Some(l) = out.last_mut() {
+        *l = 1.0;
+    }
+    (out, pre, post)
+}
+
+/// `items` with three more copies of the first / last one at the front (`pre`) / back (`post`).
+fn pad<T: Clone>(items: &[T], pre: bool, post: bool) -> Option<Vec<T>> {
+    let mut out = Vec::with_capacity(items.len() + 6);
+    if pre {
+        out.extend(std::iter::repeat_n(items.first()?.clone(), 3));
+    }
+    out.extend_from_slice(items);
+    if post {
+        out.extend(std::iter::repeat_n(items.last()?.clone(), 3));
+    }
+    Some(out)
+}
+
+/// A stored smart-object warp from `mesh` (points in source space) whose knots span the source
+/// box `c`: the knots are re-expressed over the frame `hull(c, b)` (`b` = the warp box's image in
+/// source space), with a degenerate patch padding every side where the frame extends past `c`.
+/// The surface over `c` is exactly the mesh's (#4113).
+fn content_frame_warp(mesh: &BezierMesh, c: [f64; 4], b: [f64; 4]) -> Option<Warp> {
+    let t = [c[0].min(b[0]), c[1].min(b[1]), c[2].max(b[2]), c[3].max(b[3])];
+    let (cw, ch) = (c[2] - c[0], c[3] - c[1]);
+    if !(cw > 0.0 && ch > 0.0 && t.iter().all(|v| v.is_finite())) {
+        return None;
+    }
+    let (us, left, right) = reframe_knots(&mesh.us, c[0], cw, t[0], t[2] - t[0]);
+    let (vs, top, bottom) = reframe_knots(&mesh.vs, c[1], ch, t[1], t[3] - t[1]);
+    let rows: Vec<Vec<[f64; 2]>> = mesh.points.chunks(mesh.nx()).map(|r| pad(r, left, right)).collect::<Option<_>>()?;
+    let rows = pad(&rows, top, bottom)?;
+    let m = BezierMesh { us, vs, points: rows.into_iter().flatten().collect() };
+    m.is_valid().then(|| Warp::custom(m, t))
+}
+
 /// Largest warp frame side: far above any real layer, far below what would exhaust memory.
 const MAX_WARP_SIDE: u32 = 100_000;
 
@@ -266,12 +346,21 @@ fn apply(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
         return Ok(json!({"layer": id.0, "changed": false}));
     }
     let interp = Interp::parse(p.get("interpolation").and_then(Value::as_str).unwrap_or("bicubic"));
+    let content_knots = p.get("mesh").is_some() && p.get("warp").is_none();
     s.edit("Warp", |doc, _| {
         let sel = doc.selection.clone();
+        let frames = content_knots.then(|| {
+            let mut f = Frames::new();
+            if let Some(l) = doc.layer(id) {
+                source_frames(doc, l, &mut f);
+            }
+            f
+        });
         let is_group = doc.layer(id).is_some_and(Layer::is_group);
         let group = crate::transform_cmds::group_locks(doc, id);
+        crate::extra_cmds::background_to_layer(doc, id);
         let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
-        warp_layer(if is_group { None } else { sel.as_ref() }, group, l, &w, rect, interp)?;
+        warp_layer(if is_group { None } else { sel.as_ref() }, group, l, &w, rect, interp, frames.as_ref())?;
         let snapshot = doc.clone();
         if let Some(l) = doc.layer_mut(id) {
             crate::transform_cmds::refresh_text(&snapshot, l);
@@ -457,7 +546,7 @@ fn grid(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 pub fn specs() -> Vec<CommandSpec> {
-    const P: &str = r##"{"layer":id?,"rect":[x0,y0,x1,y1]? (warp box; default = layer content ∩ selection),"style":"custom|none|arc|arcLower|arcUpper|arch|bulge|shellLower|shellUpper|flag|wave|fish|rise|fisheye|inflate|squeeze|twist","bend":%=50,"hDistort":%,"vDistort":%,"vertical":bool,"mesh":{"us":[0,…,1],"vs":[0,…,1],"points":[[x,y]…]} ((3c+1)×(3r+1) control points, row-major, document px),"grid":[cols,rows]?,"warp":{full warp object}?,"interpolation":"bicubic|bilinear|nearest"} — on a type layer a style (or none) sets its Warp Text and the type stays editable"##;
+    const P: &str = r##"{"layer":id?,"rect":[x0,y0,x1,y1]? (warp box; default = layer content ∩ selection),"style":"custom|none|arc|arcLower|arcUpper|arch|bulge|shellLower|shellUpper|flag|wave|fish|rise|fisheye|inflate|squeeze|twist","bend":%=50,"hDistort":%,"vDistort":%,"vertical":bool,"mesh":{"us":[0,…,1],"vs":[0,…,1],"points":[[x,y]…]} ((3c+1)×(3r+1) control points, row-major, document px; on a smart object `us`/`vs` span the source contents, so points equal to the placement are an identity warp even when it is skewed),"grid":[cols,rows]?,"warp":{full warp object}?,"interpolation":"bicubic|bilinear|nearest"} — on a type layer a style (or none) sets its Warp Text and the type stays editable"##;
     const S: &str = r##"{"warp":{…}? (the warp being edited; returned split),"rect":[x0,y0,x1,y1]?,"at":[x,y]? (document point; default = middle of the patch)} — without `warp`, edits the active smart object's warp. A 1×1 custom mesh is divided at the thirds first (the guides drawn on the default grid), so splitWarpCrosswise on an identity custom warp returns a 4×4 mesh (knots at 0, 1/3, 1/2, 2/3 and 1), not a 2×2. A preset is fitted as one patch and split without that step."##;
     const G: &str = r##"{"warp":{…}? (the warp being edited; returned with the new mesh),"rect":[x0,y0,x1,y1]?,"size":n|"default"|"3"|"4"|"5" (square patches, 1..=64; 1 and "default" are the single-patch grid)} — without `warp`/`style`/`mesh`, edits the active smart object's warp. The surface is kept and the new lines are real splits at i/n."##;
     vec![
@@ -752,4 +841,54 @@ mod tests {
         let back: Warp = serde_json::from_value(r["warp"].clone()).unwrap();
         assert_eq!(back.mesh.unwrap().us.len(), 2);
     }
+
+    /// A selection limits the warp of a linked mask too, as it does the pixels (#4175; Free
+    /// Transform and Perspective Warp did this already, #3083): the moved part of the mask lines
+    /// up with the moved pixels and the unselected part stays put.
+    #[test]
+    fn linked_mask_with_a_selection_warps_only_the_selected_region() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 100, "height": 100})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("layer.layerMask.revealAll", json!({})).unwrap();
+        s.edit("paint", |doc, active| {
+            let l = doc.layer_mut(active.unwrap()).unwrap();
+            l.surface_mut().unwrap().fill_rect(Rect::new(10, 10, 30, 20), &[1.0, 0.0, 0.0, 1.0]);
+            // Hide the left quarter (selected) and the right quarter (not selected).
+            let m = l.mask.as_mut().unwrap();
+            m.surface.fill_rect(Rect::new(10, 10, 15, 20), &[0.0]);
+            m.surface.fill_rect(Rect::new(25, 10, 30, 20), &[0.0]);
+            m.linked = true;
+            Ok(())
+        })
+        .unwrap();
+        let mask_at = |s: &Session, x, y| {
+            let st = s.active().unwrap();
+            st.doc.layer(st.active_layer.unwrap()).unwrap().mask.as_ref().unwrap().surface.sample_channel(x, y, 0)
+        };
+        let alpha_at = |s: &Session, x, y| {
+            let st = s.active().unwrap();
+            st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().pixel(x, y)[3]
+        };
+        s.execute("select.rect", json!({"x": 10, "y": 10, "width": 10, "height": 10})).unwrap();
+        // A mesh that translates the selected box 50 px down.
+        let b = [10.0, 10.0, 20.0, 20.0];
+        let mesh = BezierMesh::identity(b, 1, 1).map_points(|p| [p[0], p[1] + 50.0]);
+        s.execute("edit.transform.warp", json!({"rect": [10, 10, 20, 20], "mesh": mesh})).unwrap();
+        // Moved pixels and their mask line up.
+        assert!(alpha_at(&s, 12, 65) > 0.99);
+        assert!(mask_at(&s, 12, 65) < 0.01, "selected hidden quarter moved");
+        assert!(mask_at(&s, 17, 65) > 0.99, "selected visible quarter moved");
+        // The vacated area reads as revealed, with transparent pixels.
+        assert!(alpha_at(&s, 12, 15) < 0.01);
+        assert!(mask_at(&s, 12, 15) > 0.99);
+        // The unselected part of the mask stays, aligned with the unselected pixels.
+        assert!(alpha_at(&s, 27, 15) > 0.99);
+        assert!(mask_at(&s, 27, 15) < 0.01, "unselected mask stays put");
+        assert!(mask_at(&s, 27, 65) > 0.99, "and isn't copied along");
+        for (x, y) in [(11, 61), (13, 68), (16, 61), (18, 68)] {
+            let want = if x < 15 { 0.0 } else { 1.0 };
+            assert!((mask_at(&s, x, y) - want).abs() < 0.01, "({x},{y}): {}", mask_at(&s, x, y));
+        }
+    }
 }
diff --git a/crates/engine/src/web_cmds.rs b/crates/engine/src/web_cmds.rs
index a15cb258cf..595ad21956 100644
--- a/crates/engine/src/web_cmds.rs
+++ b/crates/engine/src/web_cmds.rs
@@ -79,6 +79,10 @@ pub struct WebSettings {
     pub format: WebFormat,
     pub palette: PaletteKind,
     pub colors: usize,
+    /// Fixed opaque source palette in index order.
+    pub color_table: Option<Vec<[u8; 3]>>,
+    /// Replacements applied after quantization, preserving pixel indices.
+    pub color_table_edits: std::collections::BTreeMap<usize, [u8; 3]>,
     pub dither: Dither,
     /// 0..=1.
     pub dither_amount: f32,
@@ -104,6 +108,8 @@ impl Default for WebSettings {
             format: WebFormat::Png24,
             palette: PaletteKind::Selective,
             colors: 256,
+            color_table: None,
+            color_table_edits: Default::default(),
             dither: Dither::Diffusion,
             dither_amount: 0.88,
             transparency: true,
@@ -130,8 +136,13 @@ fn hex3(s: &str) -> Option<[f32; 3]> {
 impl WebSettings {
     /// Settings from command parameters (missing keys keep the defaults; Photoshop's preset
     /// names such as "GIF 128 Dithered" or "JPEG High" are accepted as `"preset"`).
+    ///
+    /// Without a preset there is no matte, as in Photoshop's scripted Save for Web
+    /// (`ExportOptionsSaveForWeb` left at its defaults): a GIF or PNG-8 keeps the colour of its
+    /// partly transparent pixels instead of lightening them towards white (#4115). Formats
+    /// without transparency still go over white.
     pub fn from_params(p: &Value, cmd: &str) -> Result<Self> {
-        let mut st = WebSettings::default();
+        let mut st = WebSettings { matte: None, ..WebSettings::default() };
         if let Some(preset) = p.get("preset").and_then(Value::as_str) {
             st = preset_settings(preset).ok_or_else(|| bad(cmd, format!("unknown preset `{preset}`")))?;
         }
@@ -196,6 +207,27 @@ impl WebSettings {
                 m => return Err(bad(cmd, format!("unknown metadata `{m}` (none|copyright|copyrightAndContact|all)"))),
             };
         }
+        if let Some(table) = p.get("colorTable") {
+            let table = table.as_array().filter(|a| (1..=256).contains(&a.len())).ok_or_else(|| bad(cmd, "colorTable must contain 1–256 #rrggbb colours"))?;
+            st.color_table = Some(
+                table
+                    .iter()
+                    .map(|v| v.as_str().and_then(hex3).map(|c| c.map(to8)).ok_or_else(|| bad(cmd, "colorTable entries must be #rrggbb colours")))
+                    .collect::<Result<Vec<_>>>()?,
+            );
+        }
+        if let Some(edits) = p.get("colorTableEdits") {
+            let edits = edits
+                .as_object()
+                .filter(|m| m.len() <= 256)
+                .ok_or_else(|| bad(cmd, "colorTableEdits must be an object of palette indices to #rrggbb colours"))?;
+            let table = st.color_table.as_ref().ok_or_else(|| bad(cmd, "colorTableEdits requires colorTable"))?;
+            for (index, value) in edits {
+                let index = index.parse::<usize>().ok().filter(|i| *i < table.len()).ok_or_else(|| bad(cmd, "colorTableEdits index is outside colorTable"))?;
+                let color = value.as_str().and_then(hex3).map(|c| c.map(to8)).ok_or_else(|| bad(cmd, "colorTableEdits values must be #rrggbb colours"))?;
+                st.color_table_edits.insert(index, color);
+            }
+        }
         Ok(st)
     }
 }
@@ -233,10 +265,23 @@ impl WebSettings {
             WebMetadata::All => "all",
         };
         let matte = self.matte.map_or("none".to_string(), |c| format!("#{:02x}{:02x}{:02x}", to8(c[0]), to8(c[1]), to8(c[2])));
-        json!({"format": format, "palette": palette, "colors": self.colors, "dither": dither, "ditherAmount": (self.dither_amount * 100.0).round(), "transparency": self.transparency, "matte": matte, "interlaced": self.interlaced, "webSnap": (self.web_snap * 100.0).round(), "quality": self.quality, "progressive": self.progressive, "optimized": self.optimized, "embedIcc": self.embed_icc, "metadata": metadata, "convertToSrgb": self.convert_to_srgb})
+        let mut p = json!({"format": format, "palette": palette, "colors": self.colors, "dither": dither, "ditherAmount": (self.dither_amount * 100.0).round(), "transparency": self.transparency, "matte": matte, "interlaced": self.interlaced, "webSnap": (self.web_snap * 100.0).round(), "quality": self.quality, "progressive": self.progressive, "optimized": self.optimized, "embedIcc": self.embed_icc, "metadata": metadata, "convertToSrgb": self.convert_to_srgb});
+        if let Some(table) = &self.color_table {
+            p["colorTable"] = json!(table.iter().map(|c| rgb_hex(*c)).collect::<Vec<_>>());
+        }
+        if !self.color_table_edits.is_empty() {
+            p["colorTableEdits"] =
+                json!(self.color_table_edits.iter().map(|(i, c)| (i.to_string(), rgb_hex(*c))).collect::<std::collections::BTreeMap<_, _>>());
+        }
+        p
     }
 }
 
+/// A palette colour in command/control-channel notation.
+pub fn rgb_hex(c: [u8; 3]) -> String {
+    format!("#{:02x}{:02x}{:02x}", c[0], c[1], c[2])
+}
+
 /// Save for Web's named presets.
 pub const PRESETS: [&str; 12] = [
     "GIF 128 Dithered",
@@ -324,6 +369,11 @@ pub struct Optimized {
     pub height: u32,
     /// Colours in the palette (indexed formats).
     pub colors: Option<usize>,
+    /// Opaque source palette before replacements (empty for non-indexed formats).
+    pub color_table: Vec<[u8; 3]>,
+    pub transparent_index: Option<usize>,
+    /// Indexed pixels for previews; empty for non-indexed formats or when preview is disabled.
+    pub indices: Vec<u8>,
     /// What the optimised file looks like, straight RGBA8 (for the dialog's previews).
     pub preview: Vec<u8>,
 }
@@ -359,13 +409,14 @@ pub fn web_xmp(doc: &Document, m: WebMetadata) -> Option<String> {
 /// the file looks like (the dialog's panes); exports skip it.
 #[allow(clippy::too_many_arguments)]
 pub fn optimize(px: &[[f32; 4]], bw: usize, rect: Rect, st: &WebSettings, icc: Option<&[u8]>, xmp: Option<&str>, dpi: f32, preview: bool) -> Result<Optimized> {
-    let (w, h) = (rect.width() as usize, rect.height() as usize);
-    if w == 0 || h == 0 {
-        return Err(other("empty slice"));
+    if bw == 0 || rect.x0 < 0 || rect.y0 < 0 || rect.is_empty() || rect.x1 as usize > bw || (rect.y1 as usize).checked_mul(bw).is_none_or(|end| end > px.len())
+    {
+        return Err(other("slice is outside the pixel buffer"));
     }
+    let (w, h) = (rect.width() as usize, rect.height() as usize);
     let row = |y: i32| {
         let o = y as usize * bw;
-        &px[o + rect.x0 as usize..o + rect.x1 as usize]
+        px.get(o + rect.x0 as usize..o + rect.x1 as usize).unwrap_or(&[])
     };
     let region = || (rect.y0..rect.y1).flat_map(row);
     let matte = st.matte.unwrap_or([1.0, 1.0, 1.0]);
@@ -375,6 +426,9 @@ pub fn optimize(px: &[[f32; 4]], bw: usize, rect: Rect, st: &WebSettings, icc: O
     let (ww, hh) = (w as u32, h as u32);
     let e = |e: photocraft_codecs::CodecError| other(e);
     let mut look: Vec<u8> = Vec::new();
+    let mut color_table = Vec::new();
+    let mut transparent_index = None;
+    let mut indices = Vec::new();
     let (bytes, colors) = match st.format {
         WebFormat::Png24 => {
             let alpha = st.transparency && region().any(|p| p[3] < 1.0);
@@ -451,16 +505,22 @@ pub fn optimize(px: &[[f32; 4]], bw: usize, rect: Rect, st: &WebSettings, icc: O
                 })
                 .collect();
             let room = if transparent { st.colors.saturating_sub(1).max(2) } else { st.colors };
-            // Large images: build adaptive palettes from an even ~1 MP sample (Exact needs all).
-            let n_opaque = work.iter().filter(|p| p[3] >= 0.5).count();
-            let step = if n_opaque > 1 << 20 && st.palette != PaletteKind::Exact { n_opaque / (1 << 20) + 1 } else { 1 };
-            let mut src: Vec<[f32; 4]> = work.iter().filter(|p| p[3] >= 0.5).step_by(step).copied().collect();
-            if src.is_empty() {
-                src = work.clone();
-            }
-            let mut pal = quantize::build_palette(&src, st.palette, room, Forced::None).map_err(other)?;
-            drop(src);
-            if st.web_snap > 0.0 {
+            let mut pal = if let Some(table) = &st.color_table {
+                if table.is_empty() || table.len() > if transparent { 255 } else { 256 } {
+                    return Err(other("colorTable has too many entries for this image's transparency"));
+                }
+                table.clone()
+            } else {
+                // Large images: build adaptive palettes from an even ~1 MP sample (Exact needs all).
+                let n_opaque = work.iter().filter(|p| p[3] >= 0.5).count();
+                let step = if n_opaque > 1 << 20 && st.palette != PaletteKind::Exact { n_opaque / (1 << 20) + 1 } else { 1 };
+                let mut src: Vec<[f32; 4]> = work.iter().filter(|p| p[3] >= 0.5).step_by(step).copied().collect();
+                if src.is_empty() {
+                    src = work.clone();
+                }
+                quantize::build_palette(&src, st.palette, room, Forced::None).map_err(other)?
+            };
+            if st.web_snap > 0.0 && st.color_table.is_none() {
                 let tol = (st.web_snap * 255.0) as u8;
                 for c in &mut pal {
                     let snap = c.map(|x| ((f32::from(x) / 51.0).round() * 51.0) as u8);
@@ -472,16 +532,23 @@ pub fn optimize(px: &[[f32; 4]], bw: usize, rect: Rect, st: &WebSettings, icc: O
             if transparent {
                 pal.truncate(255);
             }
+            let first = pal.first().copied().ok_or_else(|| other("empty colour table"))?;
+            color_table = pal.clone();
             let t = transparent.then(|| {
-                pal.push(pal[0]);
+                pal.push(first);
                 pal.len() - 1
             });
+            transparent_index = t;
             let idx = quantize_rows(&mut work, w, &pal, st.dither, st.dither_amount, t);
+            for (index, color) in &st.color_table_edits {
+                let slot = pal.get_mut(*index).filter(|_| Some(*index) != t).ok_or_else(|| other("colour edit is outside the opaque palette"))?;
+                *slot = *color;
+            }
             if preview {
                 look = idx
                     .iter()
                     .flat_map(|k| {
-                        let c = pal[*k as usize];
+                        let c = pal.get(*k as usize).copied().unwrap_or(first);
                         [c[0], c[1], c[2], if Some(*k as usize) == t { 0 } else { 255 }]
                     })
                     .collect();
@@ -492,10 +559,13 @@ pub fn optimize(px: &[[f32; 4]], bw: usize, rect: Rect, st: &WebSettings, icc: O
             } else {
                 photocraft_codecs::encode_png_indexed(ww, hh, &idx, &pal, tt, None).map_err(e)?
             };
+            if preview {
+                indices = idx;
+            }
             (bytes, Some(pal.len()))
         }
     };
-    Ok(Optimized { bytes, ext: st.format.ext(), width: ww, height: hh, colors, preview: look })
+    Ok(Optimized { bytes, ext: st.format.ext(), width: ww, height: hh, colors, color_table, transparent_index, indices, preview: look })
 }
 
 /// Nearest palette entry through a lazily filled 6-bit-per-channel inverse colour map: each
@@ -772,6 +842,21 @@ pub fn save_for_web_with_writer(s: &mut Session, p: &Value, write: &mut dyn FnMu
     save_for_web_impl(s, p, write, false)
 }
 
+/// Settings to seed the Save for Web dialog from on the next launch: `file_menu` is session
+/// state, so a complete export also writes the preferences' remembered dialog settings (like
+/// Fill, Liquify and the filter dialogs). The destination is per export, never remembered.
+fn remember_web_settings(s: &mut Session, cmd: &str, settings: &Value) {
+    let mut m = settings.clone();
+    if let Some(o) = m.as_object_mut() {
+        for k in ["path", "dir", "trustedSliceHtml"] {
+            o.remove(k);
+        }
+    }
+    s.prefs.edit(|p| {
+        p.dialogs.insert(cmd.to_string(), m);
+    });
+}
+
 fn save_for_web_impl(s: &mut Session, p: &Value, write: &mut dyn FnMut(&str, &[u8]) -> Result<()>, native_paths: bool) -> Result<Value> {
     let cmd = "file.export.saveForWebLegacy";
     if let Some(authorize) = s.authorize {
@@ -811,11 +896,14 @@ fn save_for_web_impl(s: &mut Session, p: &Value, write: &mut dyn FnMut(&str, &[u
     // Estimate only (the dialog's annotations): the whole image, or each chosen slice.
     if single.is_none() && dir.is_none() {
         let o = optimize(&buf.px, bw, wdoc.bounds(), &st, icc, xmp.as_deref(), dpi, false)?;
-        return Ok(json!({"format": o.ext, "bytes": o.bytes.len(), "width": o.width, "height": o.height, "colors": o.colors}));
+        return Ok(
+            json!({"format": o.ext, "bytes": o.bytes.len(), "width": o.width, "height": o.height, "colors": o.colors, "colorTable": o.color_table.iter().map(|c| rgb_hex(*c)).collect::<Vec<_>>(), "transparentIndex": o.transparent_index}),
+        );
     }
     if let Some(path) = single.filter(|_| dir.is_none() && (all.len() == 1 || p.get("slices").is_none())) {
         let o = optimize(&buf.px, bw, wdoc.bounds(), &st, icc, xmp.as_deref(), dpi, false)?;
         write(path, &o.bytes)?;
+        remember_web_settings(s, cmd, &last_web);
         s.file_menu.last_web = Some(last_web);
         crate::automate_cmds::fire_event(s, "export");
         return Ok(json!({"files": [path], "bytes": o.bytes.len(), "width": o.width, "height": o.height, "colors": o.colors}));
@@ -906,6 +994,7 @@ fn save_for_web_impl(s: &mut Session, p: &Value, write: &mut dyn FnMut(&str, &[u
         write(&web_derived_path(&dir, &format!("{base}.html"), native_paths)?, page.as_bytes())?;
         html_path = Some(hp);
     }
+    remember_web_settings(s, cmd, &last_web);
     s.file_menu.last_web = Some(last_web);
     crate::automate_cmds::fire_event(s, "export");
     Ok(json!({"files": files, "html": html_path, "bytes": total, "slices": chosen.len(), "width": wdoc.size.width, "height": wdoc.size.height}))
@@ -970,6 +1059,7 @@ fn quick_export(s: &mut Session, p: &Value) -> Result<Value> {
     );
     o.insert("convertToSrgb".into(), json!(prefs.convert_to_srgb));
     o.insert("transparency".into(), json!(true));
+    o.insert("matte".into(), json!("#ffffff"));
     match fmt.as_str() {
         "jpg" => {
             o.insert("format".into(), json!("jpeg"));
@@ -1378,7 +1468,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Save for Web (Legacy)…",
             &["File", "Export"],
             Some("Cmd+Alt+Shift+S"),
-            r##"{"preset":"GIF 128 Dithered|JPEG High|PNG-24|…"?,"format":"gif|png8|png24|jpeg|wbmp"="png24","palette":"perceptual|selective|adaptive|restrictive|exact|systemMac|systemWindows|uniform"="selective","colors":2..256=256,"dither":"none|diffusion|pattern|noise"="diffusion","ditherAmount":0..100=88,"transparency":bool=true,"matte":"#rrggbb|none"="#ffffff","interlaced":bool=false,"webSnap":0..100=0,"quality":0..100=60,"progressive":bool=false,"optimized":bool=true,"embedIcc":bool=false,"metadata":"none|copyright|copyrightAndContact|all"="copyright","convertToSrgb":bool=true,"width"|"height"|"percent"? (image size),"resample":"bicubic|bilinear|nearest"?,"path":file? (whole image),"dir":folder? (one file per slice in images/),"imagesFolder":relative-folder?="images","html":bool=false,"trustedSliceHtml":bool=false (only for trusted documents; emit raw no-image cell HTML),"slices":"all|user"="all","numbers":[n]?} → no path/dir: {bytes,width,height,colors} estimate; else {files, html, bytes}"##,
+            r##"{"preset":"GIF 128 Dithered|JPEG High|PNG-24|…"?,"format":"gif|png8|png24|jpeg|wbmp"="png24","palette":"perceptual|selective|adaptive|restrictive|exact|systemMac|systemWindows|uniform"="selective","colors":2..256=256,"colorTable":["#rrggbb",…]? (fixed opaque source palette, 1–256 entries; 255 with transparency),"colorTableEdits":{"0":"#rrggbb",…}? (replace entries after indexing; requires colorTable),"dither":"none|diffusion|pattern|noise"="diffusion","ditherAmount":0..100=88,"transparency":bool=true,"matte":"#rrggbb|none"="none" (a preset's own: white; formats without transparency go over white),"interlaced":bool=false,"webSnap":0..100=0,"quality":0..100=60,"progressive":bool=false,"optimized":bool=true,"embedIcc":bool=false,"metadata":"none|copyright|copyrightAndContact|all"="copyright","convertToSrgb":bool=true,"width"|"height"|"percent"? (image size),"resample":"bicubic|bilinear|nearest"?,"path":file? (whole image),"dir":folder? (one file per slice in images/),"imagesFolder":relative-folder?="images","html":bool=false,"trustedSliceHtml":bool=false (only for trusted documents; emit raw no-image cell HTML),"slices":"all|user"="all","numbers":[n]?} → no path/dir: {bytes,width,height,colors,colorTable,transparentIndex} estimate; else {files, html, bytes}"##,
             has_doc,
             save_for_web
         ),
diff --git a/crates/engine/src/web_cmds/color_table_tests.rs b/crates/engine/src/web_cmds/color_table_tests.rs
new file mode 100644
index 0000000000..1d319cb382
--- /dev/null
+++ b/crates/engine/src/web_cmds/color_table_tests.rs
@@ -0,0 +1,88 @@
+use super::*;
+
+#[test]
+fn color_replacement_preserves_pixel_membership_and_transparency() {
+    let px = vec![[1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0], [0.6, 0.0, 0.4, 1.0], [0.0, 0.0, 0.0, 0.0]];
+    for format in ["gif", "png8"] {
+        for dither in ["none", "diffusion", "pattern", "noise"] {
+            let p = json!({"format": format, "colorTable": ["#ff0000", "#0000ff"], "dither": dither, "matte": "none"});
+            let original = WebSettings::from_params(&p, "test").unwrap();
+            let before = optimize(&px, 4, Rect::new(0, 0, 4, 1), &original, None, None, 72.0, true).unwrap();
+            let mut edited = p.clone();
+            // Replace red with blue: re-quantization would now send all opaque pixels to blue.
+            edited["colorTableEdits"] = json!({"0": "#0000ff", "1": "#00ff00"});
+            let settings = WebSettings::from_params(&edited, "test").unwrap();
+            assert_eq!(WebSettings::from_params(&settings.to_params(), "test").unwrap(), settings);
+            let after = optimize(&px, 4, Rect::new(0, 0, 4, 1), &settings, None, None, 72.0, true).unwrap();
+            for (old, new) in before.preview.as_chunks::<4>().0.iter().zip(after.preview.as_chunks::<4>().0) {
+                if old[3] == 0 {
+                    assert_eq!(new[3], 0);
+                } else if old[..3] == [255, 0, 0] {
+                    assert_eq!(*new, [0, 0, 255, 255]);
+                } else {
+                    assert_eq!(*new, [0, 255, 0, 255]);
+                }
+            }
+            assert_eq!(before.indices, after.indices, "palette edits must not remap pixels");
+            assert_eq!(after.transparent_index, Some(2));
+            assert_eq!(after.color_table, vec![[255, 0, 0], [0, 0, 255]]);
+            let decoded = photocraft_codecs::decode(&after.bytes).unwrap().convert(photocraft_codecs::ChannelLayout::Rgba, photocraft_codecs::SampleType::U8);
+            // Transparent RGB has no significance; opaque preview pixels must equal the file.
+            for (file, preview) in decoded.data().as_chunks::<4>().0.iter().zip(after.preview.as_chunks::<4>().0) {
+                assert_eq!(file[3], preview[3]);
+                if preview[3] != 0 {
+                    assert_eq!(file, preview);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn exported_palette_edits_work_at_every_document_depth() {
+    let dir = tmp("table-edits");
+    for depth in [8, 16, 32] {
+        let mut s = session(depth);
+        let mut p = json!({"format": "gif", "colors": 16, "dither": "none"});
+        let estimate = s.execute("file.export.saveForWebLegacy", p.clone()).unwrap();
+        let table = estimate["colorTable"].as_array().unwrap();
+        let red = table.iter().position(|c| c == "#ff0000").unwrap();
+        p["colorTable"] = estimate["colorTable"].clone();
+        p["colorTableEdits"] = json!({red.to_string(): "#00ff00"});
+        let path = format!("{dir}/{depth}.gif");
+        p["path"] = json!(path);
+        let original_doc = s.active().unwrap().doc.clone();
+        s.execute("file.export.saveForWebLegacy", p).unwrap();
+        assert_eq!(s.active().unwrap().doc, original_doc, "export must not edit the document");
+        let img = decode(&path).convert(photocraft_codecs::ChannelLayout::Rgba, photocraft_codecs::SampleType::U8);
+        assert_eq!(&img.data()[(16 * 64 + 16) * 4..(16 * 64 + 16) * 4 + 4], &[0, 255, 0, 255]);
+        assert_eq!(img.data()[3], 0);
+    }
+}
+
+#[test]
+fn malformed_tables_and_out_of_bounds_slices_return_errors() {
+    for p in [
+        json!({"colorTable": []}),
+        json!({"colorTable": "bad"}),
+        json!({"colorTable": ["#ff00é"]}),
+        json!({"colorTable": vec!["#000000"; 257]}),
+        json!({"colorTable": [123]}),
+        json!({"colorTableEdits": {"0": "#ffffff"}}),
+        json!({"colorTable": ["#ff0000"], "colorTableEdits": {"-1": "#ffffff"}}),
+        json!({"colorTable": ["#ff0000"], "colorTableEdits": {"1": "#ffffff"}}),
+        json!({"colorTable": ["#ff0000"], "colorTableEdits": []}),
+    ] {
+        assert!(WebSettings::from_params(&p, "test").is_err(), "{p}");
+        let mut s = session(8);
+        let doc = s.active().unwrap().doc.clone();
+        assert!(s.execute("file.export.saveForWebLegacy", p).is_err());
+        assert_eq!(s.active().unwrap().doc, doc);
+    }
+    let settings = WebSettings::default();
+    for (bw, rect) in [(0, Rect::new(0, 0, 1, 1)), (1, Rect::new(-1, 0, 1, 1)), (1, Rect::new(0, 0, 2, 1)), (1, Rect::new(0, 0, 1, i32::MAX))] {
+        assert!(optimize(&[[0.0; 4]], bw, rect, &settings, None, None, 72.0, false).is_err());
+    }
+    let settings = WebSettings::from_params(&json!({"format": "gif", "colorTable": vec!["#000000"; 256]}), "test").unwrap();
+    assert!(optimize(&[[0.0; 4]], 1, Rect::new(0, 0, 1, 1), &settings, None, None, 72.0, true).is_err());
+}
diff --git a/crates/engine/src/web_cmds/tests.rs b/crates/engine/src/web_cmds/tests.rs
index f64e309e95..c3ffe6edce 100644
--- a/crates/engine/src/web_cmds/tests.rs
+++ b/crates/engine/src/web_cmds/tests.rs
@@ -47,6 +47,23 @@ fn estimates_preserve_last_successful_export_settings() {
     assert_eq!(s.file_menu.last_web.as_ref(), Some(&saved), "preview estimates must not replace the settings from the last successful export");
 }
 
+/// The next launch's dialog seeds from the preferences: `file_menu` is not saved, so a complete
+/// export remembers its settings in `prefs.dialogs` too, as Fill and the filter dialogs do.
+#[test]
+fn a_complete_export_remembers_its_settings_in_the_preferences() {
+    let dir = tmp("remember_settings");
+    let mut s = session(8);
+    s.execute("file.export.saveForWebLegacy", json!({"format": "jpeg", "quality": 42, "path": format!("{dir}/out.jpg")})).unwrap();
+    let saved = s.prefs().dialogs.get("file.export.saveForWebLegacy").cloned().expect("remembered");
+    assert_eq!(saved["format"], "jpeg");
+    assert_eq!(saved["quality"], 42);
+    assert!(saved.get("path").is_none(), "the destination is per export, not remembered");
+
+    // Preview estimates remember nothing, like they don't replace `file_menu`.
+    s.execute("file.export.saveForWebLegacy", json!({"format": "png24", "width": 16, "height": 12})).unwrap();
+    assert_eq!(s.prefs().dialogs.get("file.export.saveForWebLegacy").unwrap()["format"], "jpeg");
+}
+
 #[test]
 fn platform_writer_receives_resized_image_at_every_depth() {
     for depth in [8, 16, 32] {
@@ -213,6 +230,44 @@ fn gif_and_png8_keep_transparency_and_palette() {
     assert_eq!(&img.data()[..4], &[0, 255, 0, 255]);
 }
 
+/// #4115: Photoshop's scripted Save for Web has no matte unless one is asked for, so a soft black
+/// shadow exported to PNG-8 stays black (alpha only 0 or 255) instead of turning grey. A preset
+/// keeps its white matte, and a matte asked for still applies.
+#[test]
+fn png8_has_no_matte_by_default() {
+    let dir = tmp("matte");
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 256, "height": 8, "background": "transparent"})).unwrap();
+    s.edit("paint", |doc, active| {
+        let fmt = doc.pixel_format();
+        let mut l = Layer::raster("Shadow", fmt);
+        let surf = l.surface_mut().unwrap();
+        for x in 0..256 {
+            surf.fill_rect(Rect::new(x, 0, x + 1, 8), &photocraft_raster::from_rgba(&fmt, [0.0, 0.0, 0.0, 1.0 - x as f32 / 255.0]));
+        }
+        *active = Some(doc.insert_above(None, l));
+        Ok(())
+    })
+    .unwrap();
+    let export = |s: &mut Session, extra: Value| {
+        let path = format!("{dir}/{}.png", s.journal.len());
+        let mut p = json!({"format": "png8", "path": path});
+        p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
+        s.execute("file.export.saveForWebLegacy", p).unwrap();
+        let img = decode(&path).convert(photocraft_codecs::ChannelLayout::Rgba, photocraft_codecs::SampleType::U8);
+        (0..256).map(|x| img.data()[x * 4..x * 4 + 4].to_vec()).collect::<Vec<_>>()
+    };
+    let plain = export(&mut s, json!({}));
+    assert!(plain.iter().all(|p| p == &[0, 0, 0, 255] || p[3] == 0), "black or transparent: {:?}", &plain[60..70]);
+    assert_eq!(plain[64], [0, 0, 0, 255], "alpha 191 stays black");
+    assert_eq!(plain[200][3], 0);
+    // A matte asked for, or a preset's, lightens the soft pixels as before.
+    let white = export(&mut s, json!({"matte": "#ffffff"}));
+    assert!(white[64][0] > 40 && white[64][3] == 255, "{:?}", white[64]);
+    let preset = WebSettings::from_params(&json!({"preset": "PNG-8 128 Dithered"}), "x").unwrap();
+    assert_eq!(preset.matte, Some([1.0, 1.0, 1.0]));
+}
+
 #[test]
 fn jpeg_quality_progressive_and_metadata() {
     let dir = tmp("jpeg");
@@ -656,3 +711,6 @@ fn overlapping_slices_keep_the_later_slice_in_html() {
     assert_eq!(area, 64 * 48);
     assert!(files.iter().any(|f| f.ends_with("images/under_01.png")), "the covered slice is cut into pieces: {files:?}");
 }
+
+#[path = "color_table_tests.rs"]
+mod color_table_tests;
diff --git a/crates/engine/tests/brush_smoothing.rs b/crates/engine/tests/brush_smoothing.rs
index bb624daa7f..b39a7b285f 100644
--- a/crates/engine/tests/brush_smoothing.rs
+++ b/crates/engine/tests/brush_smoothing.rs
@@ -20,3 +20,37 @@ fn presets_keep_the_tool_smoothing() {
     s.execute("tools.setBrush", json!({"preset": preset, "brush": {"smoothing": {"amount": 0.0}}})).unwrap();
     assert_eq!(s.tools.brush.smoothing.amount, 0.0);
 }
+
+#[test]
+fn smoothing_switch_is_drivable_and_presets_keep_the_disabled_settings() {
+    let mut s = Session::new();
+    let params = json!({"brush": {"smoothing": {"enabled": false, "amount": 0.6, "pulledString": true, "catchUpOnEnd": false}}});
+    s.execute("tools.setBrush", params.clone()).unwrap();
+    let off = s.tools.brush.smoothing.clone();
+    assert!(!off.enabled && off.amount == 0.6 && off.pulled_string && !off.catch_up_on_end);
+    let preset = s.tools.presets[0].name.clone();
+    s.execute("tools.setBrush", json!({"preset": preset})).unwrap();
+    assert_eq!(s.tools.brush.smoothing, off);
+    s.execute("tools.setBrush", json!({"brush": {"smoothing": {"enabled": true}}})).unwrap();
+    assert!(s.tools.brush.smoothing.enabled);
+    assert_eq!(s.tools.brush.smoothing.amount, off.amount);
+    assert_eq!(s.tools.brush.smoothing.pulled_string, off.pulled_string);
+    // The same parameter patch reproduces the off state in another session (CLI/MCP path).
+    let mut other = Session::new();
+    other.execute("tools.setBrush", params).unwrap();
+    assert_eq!(other.tools.brush.smoothing, off);
+    let before = other.tools.brush.clone();
+    assert!(other.execute("tools.setBrush", json!({"brush": {"smoothing": {"enabled": "no"}}})).is_err());
+    assert_eq!(other.tools.brush, before);
+}
+
+#[test]
+fn an_explicit_stroke_smoothing_amount_overrides_the_tool_switch() {
+    let mut s = Session::new();
+    s.execute("tools.setBrush", json!({"brush": {"smoothing": {"enabled": false, "amount": 0.6}}})).unwrap();
+    let inherited = photocraft_engine::brush_cmds::resolve_brush(&s, &json!({}), "paint.stroke").unwrap();
+    assert!(!inherited.smoothing.enabled && inherited.smoothing.amount == 0.6);
+    let explicit = photocraft_engine::brush_cmds::resolve_brush(&s, &json!({"smoothing": 0.4}), "paint.stroke").unwrap();
+    assert!(explicit.smoothing.enabled && explicit.smoothing.amount == 0.4);
+    assert!(!s.tools.brush.smoothing.enabled, "a stroke override does not change the tool");
+}
diff --git a/crates/engine/tests/kra.rs b/crates/engine/tests/kra.rs
new file mode 100644
index 0000000000..8bdf10531c
--- /dev/null
+++ b/crates/engine/tests/kra.rs
@@ -0,0 +1,53 @@
+//! Krita documents opened through the session: read-only source, 16-bit layers, editable
+//! layers with history, and saving as OpenRaster or native. The files come from
+//! `tools/krita-oracles/generate.py` in https://github.com/storytold/photocraft-corpus. Run with
+//! `KRITA_TEST_DIR=<dir> cargo test -p photocraft-engine --test kra -- --ignored --nocapture`.
+use photocraft_engine::Session;
+use serde_json::json;
+
+fn open(path: &std::path::Path) -> Session {
+    let mut session = Session::new();
+    let name = path.to_string_lossy().into_owned();
+    photocraft_engine::file_cmds::open_bytes_as(&mut session, &name, &std::fs::read(path).unwrap(), None, Some(name.clone())).unwrap();
+    session
+}
+
+#[test]
+#[ignore = "requires KRITA_TEST_DIR with Krita-authored .kra files"]
+fn krita_documents_open_read_only_and_stay_editable() {
+    let dir = std::path::PathBuf::from(std::env::var("KRITA_TEST_DIR").expect("set KRITA_TEST_DIR"));
+    let path = dir.join("depth-rgba-u16.kra");
+    let mut session = open(&path);
+    let active = session.active().unwrap();
+    assert!(active.source_read_only && active.path.is_none());
+    assert_eq!(active.doc.depth, photocraft_color::SampleType::U16);
+    assert!(session.execute("file.save", json!({})).is_err());
+
+    // Krita's merged image is the composite (the corpus files carry no ICC profile, so both
+    // sides are sRGB); crates/io/tests/krita_corpus.rs compares every file.
+    let ours = photocraft_compose::flatten(&session.active().unwrap().doc);
+    let zip_bytes = std::fs::read(&path).unwrap();
+    let zip = photocraft_format::zip::ZipReader::new(&zip_bytes).unwrap();
+    let merged = photocraft_io::import("m.png", &zip.read_by_name("mergedimage.png", 1 << 28).unwrap()).unwrap().document;
+    let theirs = photocraft_compose::flatten(&merged);
+    let worst = ours.px.iter().zip(&theirs.px).map(|(a, b)| (0..4).map(|c| (a[c] * a[3] - b[c] * b[3]).abs()).fold(0.0f32, f32::max)).fold(0.0, f32::max);
+    assert!(worst <= 3.0 / 255.0, "{}", worst * 255.0);
+
+    // Imported Krita layers take the ordinary commands and history.
+    let mut session = open(&dir.join("layers-opacity-visibility.kra"));
+    let before = session.active().unwrap().doc.clone();
+    let id = before.layers.last().unwrap().id;
+    session.execute("layer.setProps", json!({"layer":id.0,"name":"Edited","opacity":0.25,"blend":"Screen"})).unwrap();
+    assert_eq!(session.active().unwrap().doc.layer(id).unwrap().blend, photocraft_color::BlendMode::Screen);
+    session.execute("layer.select", json!({"layer":id.0})).unwrap();
+    session.execute("paint.stroke", json!({"points":[[2,2],[30,30]],"size":6,"hardness":1.0,"color":"#00ff00"})).unwrap();
+    assert!(session.undo() && session.undo());
+    assert_eq!(session.active().unwrap().doc.layers, before.layers);
+    // ...and save as OpenRaster or native, never back to .kra.
+    let doc = &session.active().unwrap().doc;
+    assert!(photocraft_io::export(doc, "x.kra", &Default::default()).is_err());
+    let ora = photocraft_io::export(doc, "x.ora", &Default::default()).unwrap();
+    assert_eq!(photocraft_io::import("x.ora", &ora.bytes).unwrap().document.layers.len(), doc.layers.len());
+    let native = photocraft_io::export(doc, "x.pcraft", &Default::default()).unwrap();
+    assert_eq!(photocraft_io::import("x.pcraft", &native.bytes).unwrap().document.layers, doc.layers);
+}
diff --git a/crates/engine/tests/merge_transparent_bounds.rs b/crates/engine/tests/merge_transparent_bounds.rs
new file mode 100644
index 0000000000..c796007233
--- /dev/null
+++ b/crates/engine/tests/merge_transparent_bounds.rs
@@ -0,0 +1,146 @@
+//! Merging small layers gives a layer as big as their content in every colour mode. In CMYK and
+//! Lab, transparent pixels used to keep the colour of converted transparent black, so Merge
+//! Layers, Merge Visible, Stamp Visible and Stamp Down made layers that spanned the whole canvas:
+//! Free Transform, the Move tool and alignment then worked on the canvas instead of the content.
+
+use photocraft_doc::{Layer, LayerId};
+use photocraft_engine::Session;
+use photocraft_engine::transform_cmds::transform_bounds;
+use photocraft_geom::Rect;
+use serde_json::{Value, json};
+
+const W: u32 = 300;
+const H: u32 = 400;
+/// Two small shapes far from the canvas edges, and the box around both.
+const A: [i32; 4] = [40, 300, 20, 30];
+const B: [i32; 4] = [90, 320, 25, 20];
+const BOTH: Rect = Rect { x0: 40, y0: 300, x1: 115, y1: 340 };
+
+/// Every mode at the depths it supports (Photoshop has no 32-bit CMYK or Lab).
+const CASES: &[(&str, u32)] =
+    &[("rgb", 8), ("rgb", 16), ("rgb", 32), ("gray", 8), ("gray", 16), ("gray", 32), ("cmyk", 8), ("cmyk", 16), ("lab", 8), ("lab", 16)];
+
+fn id_of(r: &Value) -> LayerId {
+    LayerId(r["layer"].as_u64().unwrap())
+}
+
+/// A transparent document with the two shapes on their own layers.
+fn scene(mode: &str, depth: u32) -> (Session, LayerId, LayerId) {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": W, "height": H, "mode": mode, "depth": depth, "background": "transparent"})).unwrap();
+    let a = id_of(&s.execute("shape.create", json!({"kind": "rect", "rect": A, "fill": "#e07020"})).unwrap());
+    let b = id_of(&s.execute("shape.create", json!({"kind": "rect", "rect": B, "fill": "#3060c0"})).unwrap());
+    (s, a, b)
+}
+
+fn select(s: &mut Session, ids: &[LayerId]) {
+    s.execute("layer.select", json!({"layer": ids[0].0})).unwrap();
+    for id in &ids[1..] {
+        s.execute("layer.select", json!({"layer": id.0, "mode": "add"})).unwrap();
+    }
+}
+
+fn active(s: &Session) -> &Layer {
+    let st = s.active().unwrap();
+    st.doc.layer(st.active_layer.unwrap()).unwrap()
+}
+
+/// The merged layer hugs the shapes (anti-aliased edges may add a pixel) and still shows them.
+fn assert_tight(s: &Session, what: &str) {
+    let doc = &s.active().unwrap().doc;
+    let layer = active(s);
+    let b = transform_bounds(doc, layer);
+    let grown = Rect::new(BOTH.x0 - 1, BOTH.y0 - 1, BOTH.x1 + 1, BOTH.y1 + 1);
+    assert!(grown.contains_rect(&b) && b.contains_rect(&Rect::new(BOTH.x0 + 1, BOTH.y0 + 1, BOTH.x1 - 1, BOTH.y1 - 1)), "{what}: bounds {b:?}, want ~{BOTH:?}");
+    let surf = layer.surface().unwrap();
+    // Inside each shape: opaque. Between them and far away: transparent.
+    assert!(surf.rgba(A[0] + 5, A[1] + 5)[3] > 0.99, "{what}: first shape kept");
+    assert!(surf.rgba(B[0] + 5, B[1] + 5)[3] > 0.99, "{what}: second shape kept");
+    assert!(surf.rgba(70, 310)[3] < 0.01, "{what}: gap stays transparent");
+    assert!(surf.rgba(5, 5)[3] < 0.01, "{what}: corner stays transparent");
+}
+
+#[test]
+fn merge_layers_keeps_content_bounds_in_every_mode() {
+    for &(mode, depth) in CASES {
+        let (mut s, a, b) = scene(mode, depth);
+        select(&mut s, &[a, b]);
+        s.execute("layer.mergeLayers", json!({})).unwrap();
+        assert_tight(&s, &format!("Merge Layers {mode} {depth}"));
+    }
+}
+
+#[test]
+fn merge_visible_keeps_content_bounds_in_every_mode() {
+    for &(mode, depth) in CASES {
+        let (mut s, _, _) = scene(mode, depth);
+        s.execute("layer.mergeVisible", json!({})).unwrap();
+        assert_tight(&s, &format!("Merge Visible {mode} {depth}"));
+    }
+}
+
+#[test]
+fn stamps_keep_content_bounds_in_every_mode() {
+    for &(mode, depth) in CASES {
+        let (mut s, _, _) = scene(mode, depth);
+        s.execute("layer.stampVisible", json!({})).unwrap();
+        assert_tight(&s, &format!("Stamp Visible {mode} {depth}"));
+
+        let (mut s, a, b) = scene(mode, depth);
+        select(&mut s, &[a, b]);
+        s.execute("layer.stampDown", json!({})).unwrap();
+        assert_tight(&s, &format!("Stamp Down {mode} {depth}"));
+    }
+}
+
+/// A fill layer may draw anywhere, so merging one renders the whole canvas; its mask still
+/// limits the merged layer to the shapes.
+#[test]
+fn merging_a_masked_fill_layer_keeps_content_bounds_in_every_mode() {
+    let masked_scene = |mode: &str, depth: u32| {
+        let (mut s, a, _) = scene(mode, depth);
+        s.execute("select.rect", json!({"x": B[0], "y": B[1], "width": B[2], "height": B[3]})).unwrap();
+        let fill = id_of(&s.execute("layer.newFillLayer.solidColor", json!({"color": "#3060c0"})).unwrap());
+        s.execute("select.deselect", json!({})).unwrap();
+        (s, a, fill)
+    };
+    for &(mode, depth) in CASES {
+        let (mut s, a, fill) = masked_scene(mode, depth);
+        select(&mut s, &[a, fill]);
+        s.execute("layer.mergeLayers", json!({})).unwrap();
+        assert_tight(&s, &format!("Merge Layers with a fill layer {mode} {depth}"));
+
+        let (mut s, _, _) = masked_scene(mode, depth);
+        s.execute("layer.mergeVisible", json!({})).unwrap();
+        assert_tight(&s, &format!("Merge Visible with a fill layer {mode} {depth}"));
+    }
+}
+
+/// Over an opaque Background, Merge Visible still makes an opaque, canvas-sized Background.
+#[test]
+fn merge_visible_onto_a_background_stays_opaque() {
+    for &(mode, depth) in CASES {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": W, "height": H, "mode": mode, "depth": depth, "background": "white"})).unwrap();
+        s.execute("shape.create", json!({"kind": "rect", "rect": A, "fill": "#e07020"})).unwrap();
+        s.execute("layer.mergeVisible", json!({})).unwrap();
+        let what = format!("{mode} {depth}");
+        let doc = &s.active().unwrap().doc;
+        let layer = active(&s);
+        assert_eq!(layer.name, "Background", "{what}");
+        assert_eq!(transform_bounds(doc, layer), Rect::new(0, 0, W as i32, H as i32), "{what}");
+        let white = layer.surface().unwrap().rgba(5, 5);
+        assert!(white.iter().all(|c| *c > 0.98), "{what}: Background stays white, got {white:?}");
+    }
+}
+
+/// Undo restores both layers after the fixed merge.
+#[test]
+fn merge_layers_in_cmyk_is_one_undo_step() {
+    let (mut s, a, b) = scene("cmyk", 8);
+    select(&mut s, &[a, b]);
+    s.execute("layer.mergeLayers", json!({})).unwrap();
+    s.execute("edit.undo", json!({})).unwrap();
+    let doc = &s.active().unwrap().doc;
+    assert!(doc.layer(a).is_some() && doc.layer(b).is_some());
+}
diff --git a/crates/engine/tests/panic_hunt.rs b/crates/engine/tests/panic_hunt.rs
index b301b95389..c73980a2f2 100644
--- a/crates/engine/tests/panic_hunt.rs
+++ b/crates/engine/tests/panic_hunt.rs
@@ -9,6 +9,8 @@ use std::sync::mpsc;
 use std::time::Duration;
 
 fn fresh() -> Session {
+    // Belt and braces with the EXTERNAL skip below: nothing in this process may reach a printer.
+    photocraft_engine::print_cmds::disable_printing();
     let mut s = Session::new();
     s.execute("file.new", json!({"width": 24, "height": 16})).unwrap();
     s.execute("layer.new.layer", json!({})).unwrap();
@@ -58,8 +60,12 @@ fn no_command_panics_or_hangs_on_adversarial_params() {
         json!({"x": 1e5, "y": -1e5, "radius": 300, "amount": 300, "angle": 1e5, "opacity": -100, "scale": -5, "gamma": -1}),
         json!({"points": [], "from": [0, 0], "to": [0, 0], "stops": [], "matrix": [0, 0, 0, 0, 0, 0], "colors": [], "name": "", "mode": "", "style": ""}),
     ];
+    // Commands whose success reaches outside the process: `file.print` and `file.printOneCopy`
+    // spool to CUPS, so a fuzz run with `{}` printed a blank page on the default printer. Their
+    // params are validated like everyone else's; the spooling itself is not fuzzed.
+    const EXTERNAL: &[&str] = &["file.print", "file.printOneCopy"];
     let mut bad: Vec<String> = Vec::new();
-    for spec in command_specs() {
+    for spec in command_specs().iter().filter(|spec| !EXTERNAL.contains(&spec.id)) {
         for p in &params {
             if let Err(why) = run_guarded(spec.id, p) {
                 bad.push(format!("{} [{why}] <- {p}", spec.id));
diff --git a/crates/engine/tests/rasterize_psd_reopen.rs b/crates/engine/tests/rasterize_psd_reopen.rs
new file mode 100644
index 0000000000..a39005ac14
--- /dev/null
+++ b/crates/engine/tests/rasterize_psd_reopen.rs
@@ -0,0 +1,115 @@
+//! Layer › Rasterize › Fill Content / Smart Object stays rasterized after a PSD save and reopen.
+//! A fill or smart layer opened from a PSD keeps its file blocks (`SoCo`/`GdFl`/`PtFl`,
+//! `SoLd`/`PlLd`); left on the rasterized layer, they made the reopened file a fill layer or
+//! smart object again and threw the pixels away. Photoshop writes none of them for a pixel layer.
+
+use photocraft_doc::{Document, LayerContent, LayerId};
+use photocraft_engine::Session;
+use serde_json::{Value, json};
+
+fn id_of(r: Value) -> LayerId {
+    LayerId(r["layer"].as_u64().unwrap())
+}
+
+fn kind(l: &photocraft_doc::Layer) -> &'static str {
+    match &l.content {
+        LayerContent::Fill(_) => "fill",
+        LayerContent::Smart(_) => "smart",
+        LayerContent::Raster(_) => "raster",
+        _ => "other",
+    }
+}
+
+fn kind_named(doc: &Document, name: &str) -> &'static str {
+    let l = doc.walk().into_iter().map(|(_, _, l)| l).find(|l| l.name == name).unwrap_or_else(|| panic!("no layer {name}"));
+    kind(l)
+}
+
+fn reopen(doc: &Document) -> Document {
+    let out = photocraft_io::export(doc, "psd", &Default::default()).unwrap();
+    photocraft_io::import("x.psd", &out.bytes).unwrap().document
+}
+
+/// Whether the PSD written for `doc` gives the layer `name` any of `keys`.
+fn has_block(doc: &Document, name: &str, keys: &[&[u8; 4]]) -> bool {
+    let out = photocraft_io::export(doc, "psd", &Default::default()).unwrap();
+    let f = photocraft_psd::PsdFile::from_bytes(&out.bytes).unwrap();
+    let rec = f.layers().iter().find(|r| r.name() == name).unwrap();
+    keys.iter().any(|k| rec.block(k).is_some())
+}
+
+/// Rasterizes every layer named in `names` of a session opened on `doc`, then saves and reopens.
+fn rasterize_and_reopen(doc: Document, names: &[&str]) -> Document {
+    let mut s = Session::new();
+    s.add_document(doc, None);
+    for name in names {
+        let id = s.active().unwrap().doc.walk().into_iter().map(|(_, _, l)| l).find(|l| l.name == *name).unwrap().id;
+        s.execute("layer.rasterize.layer", json!({"layer": id.0})).unwrap();
+        assert_eq!(kind_named(&s.active().unwrap().doc, name), "raster");
+    }
+    reopen(&s.active().unwrap().doc)
+}
+
+#[test]
+fn rasterized_fill_and_smart_object_reopen_as_pixels() {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 48, "height": 32})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "Source"})).unwrap();
+    s.execute("paint.stroke", json!({"points": [[20, 16]], "size": 12})).unwrap();
+    let smart = id_of(s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap());
+    let fill = id_of(s.execute("layer.newFillLayer.solidColor", json!({"color": "#00ff00"})).unwrap());
+    let doc = s.active().unwrap().doc.clone();
+    let smart_name = doc.layer(smart).unwrap().name.clone();
+    let fill_name = doc.layer(fill).unwrap().name.clone();
+    assert_ne!(smart_name, fill_name);
+
+    // Opened from a PSD, both layers carry their file blocks.
+    let opened = reopen(&doc);
+    assert_eq!(kind_named(&opened, &fill_name), "fill");
+    assert_eq!(kind_named(&opened, &smart_name), "smart");
+
+    let back = rasterize_and_reopen(opened, &[&fill_name, &smart_name]);
+    assert_eq!(kind_named(&back, &fill_name), "raster");
+    assert_eq!(kind_named(&back, &smart_name), "raster");
+    assert!(!has_block(&back, &fill_name, &[b"SoCo", b"GdFl", b"PtFl"]));
+    assert!(!has_block(&back, &smart_name, &[b"SoLd", b"PlLd", b"SoLE"]));
+}
+
+/// The exporter never writes content-defining blocks for a pixel layer, whichever command made it
+/// one (a backstop for paths that swap the content without pruning `psd_blocks`).
+#[test]
+fn raster_layer_with_stale_blocks_writes_none() {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 16, "height": 16})).unwrap();
+    s.execute("layer.newFillLayer.solidColor", json!({"color": "#ff0000"})).unwrap();
+    let mut doc = reopen(&s.active().unwrap().doc);
+    let (id, name) = doc.walk().into_iter().map(|(_, _, l)| l).find(|l| kind(l) == "fill").map(|l| (l.id, l.name.clone())).unwrap();
+    let fmt = doc.pixel_format();
+    let l = doc.layer_mut(id).unwrap();
+    assert!(l.psd_blocks.iter().any(|(k, _)| k == b"SoCo"));
+    l.content = LayerContent::Raster(photocraft_raster::Surface::new(fmt));
+    l.psd_blocks.push((*b"TySh", std::sync::Arc::new(vec![0; 8])));
+    l.psd_blocks.push((*b"vscg", std::sync::Arc::new(vec![0; 8])));
+    l.psd_blocks.push((*b"levl", std::sync::Arc::new(vec![0; 8])));
+    assert!(!has_block(&doc, &name, &[b"SoCo", b"TySh", b"vstk", b"vscg", b"SoLd", b"PlLd", b"levl"]));
+    assert_eq!(kind_named(&reopen(&doc), &name), "raster");
+}
+
+/// The same through files Photoshop wrote: a gradient fill layer and a placed smart object.
+#[cfg(feature = "corpus")]
+#[test]
+fn photoshop_fill_and_smart_layers_stay_rasterized() {
+    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../corpus");
+    for (file, want) in [("psd-tools/gradient-fill.psd", "fill"), ("photoshop/smart-filters/sf-none-plain.psd", "smart")] {
+        let path = root.join(file);
+        let bytes = std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e} (run `cargo xtask corpus --all`)", path.display()));
+        let doc = photocraft_io::import(file, &bytes).unwrap().document;
+        let names: Vec<String> = doc.walk().into_iter().map(|(_, _, l)| l).filter(|l| kind(l) == want).map(|l| l.name.clone()).collect();
+        assert!(!names.is_empty(), "{file}: no {want} layer");
+        let refs: Vec<&str> = names.iter().map(String::as_str).collect();
+        let back = rasterize_and_reopen(doc, &refs);
+        for n in &names {
+            assert_eq!(kind_named(&back, n), "raster", "{file}: {n}");
+        }
+    }
+}
diff --git a/crates/engine/tests/save_keeps_encoding.rs b/crates/engine/tests/save_keeps_encoding.rs
new file mode 100644
index 0000000000..b10237fd81
--- /dev/null
+++ b/crates/engine/tests/save_keeps_encoding.rs
@@ -0,0 +1,89 @@
+//! #2399: a save writes a JPEG or WebP back the way it was opened. A JPEG keeps the quality
+//! estimated from its quantisation tables, a lossy WebP stays lossy and a lossless one lossless,
+//! unless the save asks for a quality; the remembered settings survive a .pcraft round trip.
+
+use photocraft_codecs::{ChannelLayout, EncodeOptions, Format, Image, SampleType, WebpEncoding, jpeg_quality, webp_encoding};
+use photocraft_engine::Session;
+use photocraft_engine::file_cmds::open_bytes_as;
+use serde_json::json;
+
+fn photo() -> Image {
+    let (w, h) = (48u32, 32u32);
+    let px = (0..w * h).flat_map(|i| {
+        let (x, y) = (i % w, i / w);
+        [(x * 5) as u8, (y * 7) as u8, ((x * y) % 251) as u8]
+    });
+    Image::from_raw(w, h, ChannelLayout::Rgb, SampleType::U8, px.collect()).unwrap()
+}
+
+fn tmp(name: &str) -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!("photocraft-2399-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    dir.join(name)
+}
+
+/// Opens `bytes` as `name`, saves a copy to `out` with `params`, and returns the saved file.
+fn open_and_save(name: &str, bytes: &[u8], out: &str, params: serde_json::Value) -> (Session, Vec<u8>) {
+    let mut s = Session::new();
+    open_bytes_as(&mut s, name, bytes, None, None).unwrap();
+    let path = tmp(out);
+    let mut p = params;
+    p["path"] = json!(path.to_string_lossy());
+    s.execute("file.saveACopy", p).unwrap();
+    let saved = std::fs::read(&path).unwrap();
+    (s, saved)
+}
+
+#[test]
+fn a_jpeg_saves_at_its_own_quality() {
+    for q in [35u8, 60, 77, 95] {
+        let src = photocraft_codecs::encode(&photo(), Format::Jpeg, &EncodeOptions { jpeg_quality: q, ..Default::default() }).unwrap();
+        let (s, saved) = open_and_save("in.jpg", &src, &format!("q{q}.jpg"), json!({}));
+        let remembered = s.active().unwrap().doc.file_encoding.jpeg_quality.unwrap();
+        assert!(remembered.abs_diff(q) <= 2, "opened at {q}, remembered {remembered}");
+        let est = jpeg_quality(&saved).unwrap();
+        assert!(est.abs_diff(q) <= 2, "opened at {q}, saved at {est}");
+    }
+    // A quality the save asks for still wins (Photoshop's 0–12 scale: 12 is the top).
+    let src = photocraft_codecs::encode(&photo(), Format::Jpeg, &EncodeOptions { jpeg_quality: 40, ..Default::default() }).unwrap();
+    let (_, saved) = open_and_save("in.jpg", &src, "explicit.jpg", json!({"quality": 12}));
+    assert_eq!(jpeg_quality(&saved), Some(100));
+}
+
+#[test]
+fn a_webp_stays_lossy_or_lossless() {
+    let lossy = photocraft_codecs::encode(&photo(), Format::WebP, &EncodeOptions { webp_lossless: false, webp_quality: 60, ..Default::default() }).unwrap();
+    let (s, saved) = open_and_save("in.webp", &lossy, "lossy.webp", json!({}));
+    let e = s.active().unwrap().doc.file_encoding;
+    assert_eq!(e.webp_lossless, Some(false));
+    let Some(WebpEncoding::Lossy { quality: Some(q) }) = webp_encoding(&saved) else { panic!("saved {:?}", webp_encoding(&saved)) };
+    assert!(q.abs_diff(60) <= 2, "lossy WebP at 60 saved at {q}");
+
+    let lossless = photocraft_codecs::encode(&photo(), Format::WebP, &EncodeOptions::default()).unwrap();
+    let (s, saved) = open_and_save("in.webp", &lossless, "lossless.webp", json!({}));
+    assert_eq!(s.active().unwrap().doc.file_encoding.webp_lossless, Some(true));
+    assert_eq!(webp_encoding(&saved), Some(WebpEncoding::Lossless));
+    assert_eq!(photocraft_codecs::decode(&saved).unwrap().data(), photocraft_codecs::decode(&lossless).unwrap().data(), "lossless round trip");
+}
+
+#[test]
+fn a_new_document_and_a_png_save_at_the_defaults() {
+    let png = photocraft_codecs::encode(&photo(), Format::Png, &EncodeOptions::default()).unwrap();
+    let (s, saved) = open_and_save("in.png", &png, "from-png.jpg", json!({}));
+    assert!(s.active().unwrap().doc.file_encoding.is_empty());
+    assert_eq!(jpeg_quality(&saved), Some(EncodeOptions::default().jpeg_quality));
+    let (_, saved) = open_and_save("in.png", &png, "from-png.webp", json!({}));
+    assert_eq!(webp_encoding(&saved), Some(WebpEncoding::Lossless));
+}
+
+#[test]
+fn the_remembered_encoding_survives_pcraft() {
+    let src = photocraft_codecs::encode(&photo(), Format::Jpeg, &EncodeOptions { jpeg_quality: 70, ..Default::default() }).unwrap();
+    let mut s = Session::new();
+    open_bytes_as(&mut s, "in.jpg", &src, None, None).unwrap();
+    let doc = &s.active().unwrap().doc;
+    let bytes = photocraft_format::save_to_bytes(doc, &photocraft_format::SaveOptions::default()).unwrap();
+    let back = photocraft_format::load_from_bytes(&bytes).unwrap();
+    assert_eq!(back.file_encoding, doc.file_encoding);
+    assert!(back.file_encoding.jpeg_quality.is_some());
+}
diff --git a/crates/engine/tests/smart_clipboard_sources.rs b/crates/engine/tests/smart_clipboard_sources.rs
new file mode 100644
index 0000000000..772b5f06d8
--- /dev/null
+++ b/crates/engine/tests/smart_clipboard_sources.rs
@@ -0,0 +1,399 @@
+//! Clipboard copies carry only the linked smart-object records their layers reference.
+use photocraft_doc::{Document, LayerContent, LayerId, SmartSource};
+use photocraft_engine::{Session, smart_cmds::source_bytes};
+use photocraft_geom::Rect;
+use serde_json::json;
+use std::sync::Arc;
+
+fn fixture(depth: u64) -> Document {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width": 8, "height": 6, "depth": depth})).unwrap();
+    s.execute("layer.new.layer", json!({})).unwrap();
+    s.edit("synthetic color", |doc, active| {
+        doc.layer_mut(active.unwrap()).unwrap().surface_mut().unwrap().fill_rect(Rect::new(0, 0, 8, 6), &[1.0, 0.0, 0.0, 1.0]);
+        Ok(())
+    })
+    .unwrap();
+    s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+    let bytes = photocraft_io::export(&s.active().unwrap().doc, "psd", &Default::default()).unwrap().bytes;
+    let doc = photocraft_io::import("synthetic.psd", &bytes).unwrap().document;
+    assert!(doc.walk().iter().any(|(_, _, l)| matches!(l.content, LayerContent::Smart(_))));
+    doc
+}
+fn smart_id(doc: &Document) -> LayerId {
+    doc.walk().into_iter().find_map(|(_, _, l)| matches!(l.content, LayerContent::Smart(_)).then_some(l.id)).unwrap()
+}
+fn bytes(doc: &Document, id: LayerId) -> Arc<Vec<u8>> {
+    let LayerContent::Smart(sm) = &doc.layer(id).unwrap().content else { panic!("expected smart object") };
+    source_bytes(&doc.metadata, &sm.source).unwrap().1
+}
+fn hash(bytes: &[u8]) -> (usize, String) {
+    (bytes.len(), blake3::hash(bytes).to_hex().to_string())
+}
+fn source_session(doc: Document) -> (Session, LayerId) {
+    let mut s = Session::new();
+    let id = smart_id(&doc);
+    s.add_document(doc, None);
+    s.select_layer(id).unwrap();
+    (s, id)
+}
+fn roundtrip(doc: &Document, format: &str) -> Document {
+    if format == "pcraft" {
+        photocraft_format::load_from_bytes(&photocraft_format::save_to_bytes(doc, &Default::default()).unwrap()).unwrap()
+    } else {
+        let out = photocraft_io::export(doc, format, &Default::default()).unwrap();
+        assert!(out.warnings.is_empty(), "{format}: {:?}", out.warnings);
+        photocraft_io::import(&format!("clipboard.{format}"), &out.bytes).unwrap().document
+    }
+}
+
+#[test]
+fn clipboard_valid_psd_smart_sources_open_reopen_and_undo() {
+    for depth in [8, 16, 32] {
+        for key in [*b"lnk2", *b"lnk3", *b"lnkD"] {
+            let mut doc = fixture(depth);
+            for (_, k, _) in &mut doc.metadata.psd_global_blocks {
+                if matches!(&*k, b"lnk2" | b"lnk3" | b"lnkD") {
+                    *k = key;
+                }
+            }
+            let (mut s, original) = source_session(doc);
+            let expected = bytes(&s.active().unwrap().doc, original);
+            s.execute("edit.copy", json!({})).unwrap();
+            s.execute("file.new", json!({"width": 8, "height": 6, "depth": depth})).unwrap();
+            let before = s.active().unwrap().doc.clone();
+            let pasted = LayerId(s.execute("edit.paste", json!({})).unwrap()["layer"].as_u64().unwrap());
+            assert_eq!(hash(&bytes(&s.active().unwrap().doc, pasted)), hash(&expected), "depth {depth}, key {key:?}");
+            let after = s.active().unwrap().doc.clone();
+            assert!(s.undo());
+            assert_eq!(s.active().unwrap().doc, before);
+            assert!(s.redo());
+            assert_eq!(s.active().unwrap().doc, after);
+            s.execute("layer.smartObjects.editContents", json!({"layer": pasted.0})).unwrap();
+            assert_eq!(photocraft_compose::flatten(&s.active().unwrap().doc).px[0], [1.0, 0.0, 0.0, 1.0]);
+            s.set_active(1);
+            for format in ["pcraft", "psd", "psb"] {
+                let back = roundtrip(&s.active().unwrap().doc, format);
+                let (mut reopened, id) = source_session(back);
+                reopened.execute("layer.smartObjects.editContents", json!({"layer": id.0})).unwrap();
+                assert_eq!(photocraft_compose::flatten(&reopened.active().unwrap().doc).px[0], [1.0, 0.0, 0.0, 1.0], "depth {depth}, {format}");
+            }
+        }
+    }
+}
+
+#[test]
+fn clipboard_batch_and_same_document_duplicates_keep_sources() {
+    for depth in [8, 16, 32] {
+        let (mut s, original) = source_session(fixture(depth));
+        let duplicate = s.execute("layer.duplicate", json!({"layer": original.0})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("layer.select", json!({"layer": original.0})).unwrap();
+        s.execute("layer.select", json!({"layer": duplicate, "mode": "add"})).unwrap();
+        let expected = bytes(&s.active().unwrap().doc, original);
+        let count = s.active().unwrap().doc.metadata.psd_global_blocks.len();
+        s.execute("edit.copy", json!({})).unwrap();
+        let copied = s.clipboard.as_ref().unwrap().layers.as_ref().unwrap();
+        assert!(!copied.metadata.psd_global_blocks.is_empty());
+        assert!(
+            copied.metadata.psd_global_blocks.iter().all(|(_, key, data)| s
+                .active()
+                .unwrap()
+                .doc
+                .metadata
+                .psd_global_blocks
+                .iter()
+                .any(|(_, dk, dd)| { dk == key && Arc::ptr_eq(dd, data) })),
+            "an exclusive linked block should stay shared, including large PSBs"
+        );
+        s.execute("edit.paste", json!({})).unwrap();
+        assert_eq!(s.active().unwrap().doc.metadata.psd_global_blocks.len(), count, "same-document paste shouldn't duplicate blocks");
+        for (_, _, l) in s.active().unwrap().doc.walk() {
+            if matches!(l.content, LayerContent::Smart(_)) {
+                assert_eq!(hash(&bytes(&s.active().unwrap().doc, l.id)), hash(&expected));
+            }
+        }
+        s.execute("file.new", json!({"width": 8, "height": 6, "depth": depth})).unwrap();
+        s.execute("edit.paste", json!({})).unwrap();
+        let ids: Vec<_> =
+            s.active().unwrap().doc.walk().into_iter().filter_map(|(_, _, l)| matches!(l.content, LayerContent::Smart(_)).then_some(l.id)).collect();
+        assert_eq!(ids.len(), 2);
+        for id in ids {
+            assert_eq!(hash(&bytes(&s.active().unwrap().doc, id)), hash(&expected));
+            s.execute("layer.smartObjects.editContents", json!({"layer": id.0})).unwrap();
+            assert_eq!(photocraft_compose::flatten(&s.active().unwrap().doc).px[0], [1.0, 0.0, 0.0, 1.0]);
+            s.set_active(1);
+        }
+    }
+}
+
+#[test]
+fn clipboard_converts_parent_without_losing_contents_and_disk_reopen() {
+    for mode in ["rgb", "grayscale", "cmyk", "lab"] {
+        for depth in [8, 16, 32] {
+            let (mut s, id) = source_session(fixture(16));
+            let expected = bytes(&s.active().unwrap().doc, id);
+            s.execute("edit.copy", json!({})).unwrap();
+            s.execute("file.new", json!({"width": 8, "height": 6, "depth": depth, "mode": mode})).unwrap();
+            let pasted = LayerId(s.execute("edit.paste", json!({})).unwrap()["layer"].as_u64().unwrap());
+            assert_eq!(hash(&bytes(&s.active().unwrap().doc, pasted)), hash(&expected), "{mode}, depth {depth}");
+            s.execute("layer.smartObjects.editContents", json!({"layer": pasted.0})).unwrap();
+            assert_eq!(photocraft_compose::flatten(&s.active().unwrap().doc).px[0], [1.0, 0.0, 0.0, 1.0]);
+            s.set_active(1);
+            let dir = tempfile::tempdir().unwrap();
+            let path = dir.path().join("pasted.pcraft");
+            s.execute("file.saveACopy", json!({"path": path})).unwrap();
+            let mut reopened = Session::new();
+            reopened.execute("file.openAs", json!({"path": path})).unwrap();
+            let reopened_id = smart_id(&reopened.active().unwrap().doc);
+            assert_eq!(hash(&bytes(&reopened.active().unwrap().doc, reopened_id)), hash(&expected));
+            reopened.execute("layer.smartObjects.editContents", json!({"layer": reopened_id.0})).unwrap();
+            assert_eq!(photocraft_compose::flatten(&reopened.active().unwrap().doc).px[0], [1.0, 0.0, 0.0, 1.0]);
+        }
+    }
+}
+
+#[test]
+fn clipboard_group_keeps_nested_linked_sources() {
+    let mut doc = fixture(16);
+    let id = smart_id(&doc);
+    let expected = bytes(&doc, id);
+    let child = doc.remove(id).unwrap();
+    let group = photocraft_doc::Layer::group("synthetic group", vec![child]);
+    let group_id = group.id;
+    doc.layers.push(group);
+    let (mut s, _) = source_session(doc);
+    s.select_layer(group_id).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    s.execute("file.new", json!({"width": 8, "height": 6, "depth": 16})).unwrap();
+    s.execute("edit.paste", json!({})).unwrap();
+    let pasted = smart_id(&s.active().unwrap().doc);
+    assert_eq!(hash(&bytes(&s.active().unwrap().doc, pasted)), hash(&expected));
+    s.execute("layer.smartObjects.editContents", json!({"layer": pasted.0})).unwrap();
+    assert_eq!(photocraft_compose::flatten(&s.active().unwrap().doc).px[0], [1.0, 0.0, 0.0, 1.0]);
+}
+
+#[test]
+fn copy_excludes_unselected_linked_records_from_native_save() {
+    let mut doc = fixture(8);
+    let original = smart_id(&doc);
+    let expected = bytes(&doc, original);
+    let mut unselected = doc.layer(original).unwrap().duplicate();
+    unselected.name = "Unselected private synthetic document".into();
+    unselected.visible = false;
+    let LayerContent::Smart(sm) = &mut unselected.content else { panic!("smart") };
+    sm.source = SmartSource::Linked { path: "unselected-private-source".into() };
+    doc.layers.push(unselected);
+    let mut private_child = photocraft_engine::smart_cmds::decode_source("source.psb", &expected).unwrap();
+    for layer in &mut private_child.layers {
+        if let Some(surface) = layer.surface_mut() {
+            surface.fill_rect(Rect::new(0, 0, 8, 6), &[0.0, 0.0, 1.0, 1.0]);
+        }
+    }
+    let private_bytes = photocraft_io::export(&private_child, "psb", &Default::default()).unwrap().bytes;
+    assert_ne!(hash(&expected), hash(&private_bytes));
+    let private_source =
+        photocraft_io::linked::LinkedFile { uuid: "unselected-private-source".into(), file_name: "private-synthetic.psb".into(), bytes: private_bytes.clone() };
+    // Files may put both selected and unselected entries in one global linked-layer block.
+    let (_, _, block) = doc.metadata.psd_global_blocks.iter_mut().find(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD")).unwrap();
+    let selected_record = block.clone();
+    let mut combined = block.to_vec();
+    combined.extend(photocraft_io::linked::encode_linked_file(&private_source));
+    combined.extend([0, 0, 0, 0, 0, 0, 1, 0, 9]); // unrelated unreadable tail
+    *block = Arc::new(combined);
+    let (mut s, _) = source_session(doc);
+    s.execute("edit.copy", json!({})).unwrap();
+    s.execute("file.new", json!({"width": 8, "height": 6})).unwrap();
+    s.execute("edit.paste", json!({})).unwrap();
+    let back = roundtrip(&s.active().unwrap().doc, "pcraft");
+    let retained = photocraft_io::linked::find_linked_file(&back.metadata, "unselected-private-source");
+    if let Some(file) = &retained {
+        assert_eq!(hash(&file.bytes), hash(&private_bytes));
+    }
+    assert!(retained.is_none(), "copying one selected layer must not retain another unselected smart object's embedded file in saved destination .pcraft");
+    let linked: Vec<_> = back.metadata.psd_global_blocks.iter().filter(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD" | b"lnkE")).collect();
+    assert_eq!(linked.len(), 1);
+    assert_eq!(hash(&linked[0].2), hash(&selected_record), "unidentified tail bytes must not follow the selected record");
+}
+
+#[test]
+fn copy_keeps_selected_external_alias_and_unknown_records_without_reading_their_source() {
+    for key in [*b"lnk2", *b"lnk3", *b"lnkD", *b"lnkE"] {
+        for kind in [*b"liFE", *b"liFA", *b"next"] {
+            let mut doc = fixture(8);
+            let id = smart_id(&doc);
+            let LayerContent::Smart(sm) = &doc.layer(id).unwrap().content else { panic!("smart") };
+            let source = sm.source.clone();
+            let (_, _, raw) = doc.metadata.psd_global_blocks.iter().find(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD")).unwrap();
+            let mut selected = raw.to_vec();
+            selected[8..12].copy_from_slice(&kind);
+            selected[12..16].copy_from_slice(&42u32.to_be_bytes());
+            let mut data = photocraft_io::linked::encode_linked_file(&photocraft_io::linked::LinkedFile {
+                uuid: "unselected-external".into(),
+                file_name: "unselected.psb".into(),
+                bytes: vec![9; 8],
+            });
+            data.extend(&selected);
+            doc.metadata.psd_global_blocks.retain(|(_, k, _)| !matches!(k, b"lnk2" | b"lnk3" | b"lnkD" | b"lnkE"));
+            doc.metadata.psd_global_blocks.push((*b"8BIM", key, Arc::new(data)));
+            let (mut s, _) = source_session(doc);
+            s.execute("edit.copy", json!({})).unwrap();
+            s.execute("file.new", json!({"width": 8, "height": 6})).unwrap();
+            let pasted = LayerId(s.execute("edit.paste", json!({})).unwrap()["layer"].as_u64().unwrap());
+            let LayerContent::Smart(sm) = &s.active().unwrap().doc.layer(pasted).unwrap().content else { panic!("smart") };
+            assert_eq!(sm.source, source, "source identity is retained; missing external contents aren't read during Copy");
+            let back = roundtrip(&s.active().unwrap().doc, "pcraft");
+            let linked: Vec<_> = back.metadata.psd_global_blocks.iter().filter(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD" | b"lnkE")).collect();
+            assert_eq!(linked.len(), 1);
+            assert_eq!(linked[0].1, key);
+            assert_eq!(hash(&linked[0].2), hash(&selected));
+        }
+    }
+}
+
+#[test]
+fn copy_refuses_a_truncated_selected_record_without_changing_document_or_clipboard() {
+    let (mut s, _) = source_session(fixture(8));
+    s.execute("edit.copy", json!({})).unwrap();
+    let before_clip = s.clipboard.clone().unwrap();
+    s.edit("truncate selected linked record", |doc, _| {
+        let (_, _, block) = doc.metadata.psd_global_blocks.iter_mut().find(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD")).unwrap();
+        let mut truncated = block.to_vec();
+        truncated[..8].copy_from_slice(&u64::MAX.to_be_bytes());
+        *block = Arc::new(truncated);
+        Ok(())
+    })
+    .unwrap();
+    let before_doc = s.active().unwrap().doc.clone();
+    let error = s.execute("edit.copy", json!({})).unwrap_err();
+    assert!(error.to_string().contains("truncated selected"), "{error}");
+    assert_eq!(s.active().unwrap().doc, before_doc);
+    let after_clip = s.clipboard.as_ref().unwrap();
+    assert_eq!(after_clip.bounds, before_clip.bounds);
+    assert_eq!(after_clip.layers, before_clip.layers);
+}
+
+#[test]
+fn repeated_same_document_subset_pastes_do_not_duplicate_embedded_files() {
+    let mut doc = fixture(16);
+    let original = smart_id(&doc);
+    let expected = bytes(&doc, original);
+    let (_, _, block) = doc.metadata.psd_global_blocks.iter_mut().find(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD")).unwrap();
+    let selected_record = block.clone();
+    let mut combined = block.to_vec();
+    combined.extend(photocraft_io::linked::encode_linked_file(&photocraft_io::linked::LinkedFile {
+        uuid: "unselected".into(),
+        file_name: "another.psb".into(),
+        bytes: expected.to_vec(),
+    }));
+    *block = Arc::new(combined);
+    let (mut s, _) = source_session(doc);
+    let metadata = s.active().unwrap().doc.metadata.psd_global_blocks.clone();
+    s.execute("edit.copy", json!({})).unwrap();
+    let copied = s.clipboard.as_ref().unwrap().layers.as_ref().unwrap();
+    assert_eq!(copied.metadata.psd_global_blocks.len(), 1);
+    assert_eq!(hash(&copied.metadata.psd_global_blocks[0].2), hash(&selected_record));
+    for _ in 0..3 {
+        let before = s.active().unwrap().doc.clone();
+        let pasted = LayerId(s.execute("edit.paste", json!({})).unwrap()["layer"].as_u64().unwrap());
+        assert_eq!(hash(&bytes(&s.active().unwrap().doc, pasted)), hash(&expected));
+        let after = s.active().unwrap().doc.clone();
+        assert_eq!(after.metadata.psd_global_blocks.len(), metadata.len(), "subsets should not append a second linked block");
+        for ((signature, key, bytes), (expected_signature, expected_key, expected_bytes)) in after.metadata.psd_global_blocks.iter().zip(&metadata) {
+            assert_eq!(signature, expected_signature);
+            assert_eq!(key, expected_key);
+            assert_eq!(hash(bytes), hash(expected_bytes));
+        }
+        assert!(s.undo());
+        assert_eq!(s.active().unwrap().doc, before);
+        assert!(s.redo());
+        assert_eq!(s.active().unwrap().doc, after);
+    }
+    let back = roundtrip(&s.active().unwrap().doc, "pcraft");
+    let ids: Vec<_> = back.metadata.psd_global_blocks.iter().flat_map(|(_, _, data)| photocraft_io::linked::block_uuids(data)).collect();
+    assert_eq!(ids.len(), 2, "one record per original file after native save/reopen");
+}
+
+#[test]
+fn empty_source_ids_do_not_carry_unidentified_global_files() {
+    let mut private = Session::new();
+    private.execute("file.new", json!({"width":8,"height":6,"background":"black"})).unwrap();
+    let bytes = photocraft_format::save_to_bytes(&private.active().unwrap().doc, &Default::default()).unwrap();
+    let mut source = Session::new();
+    source.execute("file.new", json!({"width":8,"height":6})).unwrap();
+    source.execute("layer.new.layer", json!({})).unwrap();
+    source.execute("edit.fill", json!({"contents":"foreground"})).unwrap();
+    source.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+    source
+        .edit("malformed empty source", |doc, active| {
+            let LayerContent::Smart(sm) = &mut doc.layer_mut(active.unwrap()).unwrap().content else { panic!("smart") };
+            sm.source = SmartSource::Linked { path: String::new() };
+            doc.metadata.psd_global_blocks.push((
+                *b"8BIM",
+                *b"lnk2",
+                Arc::new(photocraft_io::linked::encode_linked_file(&photocraft_io::linked::LinkedFile {
+                    uuid: String::new(),
+                    file_name: "unidentified-private.pcraft".into(),
+                    bytes: bytes.clone(),
+                })),
+            ));
+            Ok(())
+        })
+        .unwrap();
+    let state = source.active().unwrap();
+    let LayerContent::Smart(sm) = &state.doc.layer(state.active_layer.unwrap()).unwrap().content else { panic!("smart") };
+    assert!(photocraft_engine::smart_cmds::source_bytes(&state.doc.metadata, &sm.source).is_none(), "an empty UUID cannot reference this record");
+    source.execute("edit.copy", json!({})).unwrap();
+    source.execute("file.new", json!({"width":8,"height":6})).unwrap();
+    source.execute("edit.paste", json!({})).unwrap();
+    let saved = photocraft_format::save_to_bytes(&source.active().unwrap().doc, &Default::default()).unwrap();
+    let back = photocraft_format::load_from_bytes(&saved).unwrap();
+    assert!(back.metadata.psd_global_blocks.is_empty(), "unidentified empty-ID global bytes must not enter the copied document");
+}
+
+#[test]
+fn ambiguous_invalid_utf8_ids_do_not_replace_the_clipboard() {
+    let mut private = Session::new();
+    private.execute("file.new", json!({"width":8,"height":6,"background":"black"})).unwrap();
+    let private_bytes = photocraft_format::save_to_bytes(&private.active().unwrap().doc, &Default::default()).unwrap();
+    let mut s = Session::new();
+    s.execute("file.new", json!({"width":8,"height":6})).unwrap();
+    s.execute("layer.new.layer", json!({})).unwrap();
+    s.execute("edit.fill", json!({"contents":"foreground"})).unwrap();
+    s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    let before_clip = s.clipboard.clone().unwrap();
+    s.edit("ambiguous source IDs", |doc, active| {
+        let LayerContent::Smart(sm) = &mut doc.layer_mut(active.unwrap()).unwrap().content else { panic!("smart") };
+        let SmartSource::Embedded { bytes, .. } = &sm.source else { panic!("embedded") };
+        let mut first = photocraft_io::linked::encode_linked_file(&photocraft_io::linked::LinkedFile {
+            uuid: "x".into(),
+            file_name: "selected.pcraft".into(),
+            bytes: bytes.to_vec(),
+        });
+        let mut second = photocraft_io::linked::encode_linked_file(&photocraft_io::linked::LinkedFile {
+            uuid: "x".into(),
+            file_name: "unrelated.pcraft".into(),
+            bytes: private_bytes.clone(),
+        });
+        first[17] = 0xff;
+        second[17] = 0xfe;
+        first.extend(second);
+        sm.source = SmartSource::Linked { path: "\u{fffd}".into() };
+        doc.metadata.psd_global_blocks.push((*b"8BIM", *b"lnk2", Arc::new(first)));
+        Ok(())
+    })
+    .unwrap();
+    let before_doc = s.active().unwrap().doc.clone();
+    let copied = s.execute("edit.copy", json!({}));
+    if copied.is_ok() {
+        let data = &s.clipboard.as_ref().unwrap().layers.as_ref().unwrap().metadata.psd_global_blocks[0].2;
+        let files = photocraft_io::linked::parse_linked_files(data);
+        assert_eq!(files.len(), 2);
+        assert_eq!(files[0].uuid, files[1].uuid);
+        eprintln!("two distinct malformed raw IDs were retained under one lossy source label");
+    }
+    let error = copied.expect_err("ambiguous source identity must fail before replacing the clipboard");
+    assert!(error.to_string().contains("invalid UTF-8"), "{error}");
+    assert_eq!(s.active().unwrap().doc, before_doc);
+    assert_eq!(s.clipboard.as_ref().unwrap().layers, before_clip.layers);
+}
diff --git a/crates/engine/tests/smart_psd.rs b/crates/engine/tests/smart_psd.rs
index 8b86f2c884..f7b86048b9 100644
--- a/crates/engine/tests/smart_psd.rs
+++ b/crates/engine/tests/smart_psd.rs
@@ -403,3 +403,215 @@ fn edited_psd_smart_objects_drop_their_old_file() {
     let SmartSource::Linked { path } = &sm.source else { panic!() };
     assert_eq!(uuids, vec![path.clone()]);
 }
+
+/// A Displace smart filter from a Photoshop mockup PSD carries its displacement map embedded
+/// (`DspD`, stretched over the canvas): it re-renders displaced instead of passing the pixels
+/// through, and keeps that map through PSD export, `.pcraft` and a PSD re-import.
+#[test]
+fn displace_psd_filter_renders_with_its_embedded_map() {
+    use photocraft_psd::descriptor::{Descriptor, Id, UnicodeString, Value};
+    for depth in [8, 16, 32] {
+        let mut s = session(depth);
+        s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+        let id = photocraft_doc::LayerId(s.active().unwrap().active_layer.unwrap().0);
+        // Photoshop's layout: height, width, mode 3, horizontal plane (all right), vertical plane
+        // (neutral), padding. 128/255 is a hair over mid-grey: a sub-pixel vertical shift.
+        let (mw, mh) = (12u32, 8u32);
+        let n = (mw * mh) as usize;
+        let mut tdta = [mh.to_le_bytes().as_slice(), &mw.to_le_bytes(), &3u16.to_le_bytes()].concat();
+        tdta.extend(std::iter::repeat_n(255, n).chain(std::iter::repeat_n(128, n)).chain(std::iter::repeat_n(0, mw as usize)));
+        let e = |t: &str, v: &str| Value::Enumerated { type_id: Id::new(t), value: Id::new(v) };
+        let fltr = Descriptor::new("Dspl")
+            .with("HrzS", Value::Integer(10))
+            .with("VrtS", Value::Integer(10))
+            .with("DspM", e("DspM", "StrF"))
+            .with("UndA", e("UndA", "RptE"))
+            .with("DspF", Value::Alias(b"Macintosh HD:displace.psd".to_vec()))
+            .with("EmbF", Value::Boolean(true))
+            .with("DspD", Value::RawData(tdta));
+        let item = Descriptor::new("filterFX")
+            .with("Nm  ", Value::Text(UnicodeString::new_nul("Displace...")))
+            .with("enab", Value::Boolean(true))
+            .with("hasoptions", Value::Boolean(true))
+            .with("Fltr", Value::Descriptor(fltr))
+            .with("filterID", Value::Integer(1148416108));
+        let filter = photocraft_io::smart_map::filter_from_item(&item);
+        assert_eq!(filter.command, "filter.distort.displace");
+        s.edit("displace", |doc, _| {
+            let mut l = doc.layer(id).unwrap().clone();
+            let LayerContent::Smart(sm) = &mut l.content else { panic!("smart") };
+            sm.smart_filters.push(filter.clone());
+            assert!(refresh_layer(doc, &mut l).unwrap());
+            *doc.layer_mut(id).unwrap() = l;
+            Ok(())
+        })
+        .unwrap();
+        let doc = s.active().unwrap().doc.clone();
+        let alpha = |doc: &Document, x: i32| smart(doc).1.cache.unwrap().pixel(x, 30)[3];
+        // 10 % of 128 px at full map contrast: the content (x 8..80) is read from 12.8 px to the
+        // right, so it moves left over the canvas edge and leaves its right edge.
+        assert!(alpha(&doc, 2) > 0.99 && alpha(&doc, 75) < 0.01, "depth {depth}: {} {}", alpha(&doc, 2), alpha(&doc, 75));
+
+        let out = photocraft_io::export(&doc, "psd", &Default::default()).unwrap();
+        assert!(out.warnings.is_empty(), "{:?}", out.warnings);
+        assert_eq!(structure_errors(&out.bytes), Vec::<String>::new());
+        let back = photocraft_io::import("displace.psd", &out.bytes).unwrap().document;
+        let native = photocraft_format::load_from_bytes(&photocraft_format::save_to_bytes(&back, &Default::default()).unwrap()).unwrap();
+        for doc in [&back, &native] {
+            let (bid, after) = smart(doc);
+            assert_eq!(after.smart_filters, vec![filter.clone()], "depth {depth}");
+            let mut l = doc.layer(photocraft_doc::LayerId(bid)).unwrap().clone();
+            assert!(refresh_layer(doc, &mut l).unwrap());
+            let LayerContent::Smart(sm) = &l.content else { panic!("smart") };
+            let (a, b) = (sm.cache.as_ref().unwrap(), smart(&s.active().unwrap().doc).1.cache.unwrap());
+            assert_eq!((a.pixel(2, 30)[3], a.pixel(75, 30)[3]), (b.pixel(2, 30)[3], b.pixel(75, 30)[3]), "depth {depth}: re-render");
+        }
+    }
+}
+
+/// A version-2 `liFD` item, as in Photoshop CS2's `lnkD` block: the fields every version has, and
+/// none of the version 5–7 fields after the file data.
+fn lifd_v2(f: &photocraft_io::linked::LinkedFile) -> Vec<u8> {
+    let mut item = b"liFD".to_vec();
+    item.extend_from_slice(&2u32.to_be_bytes());
+    item.push(f.uuid.len() as u8);
+    item.extend_from_slice(f.uuid.as_bytes());
+    let name: Vec<u16> = f.file_name.encode_utf16().collect();
+    item.extend_from_slice(&(name.len() as u32).to_be_bytes());
+    item.extend(name.iter().flat_map(|u| u.to_be_bytes()));
+    item.extend_from_slice(&photocraft_io::linked::file_type(&f.bytes));
+    item.extend_from_slice(b"8BIM");
+    item.extend_from_slice(&(f.bytes.len() as u64).to_be_bytes());
+    item.push(0); // no open-file descriptor
+    item.extend_from_slice(&f.bytes);
+    let mut out = (item.len() as u64).to_be_bytes().to_vec();
+    out.extend(item);
+    out.resize(out.len().next_multiple_of(4), 0);
+    out
+}
+
+/// `doc` saved as PSD, then rewritten into Photoshop CS2's layout: no `SoLd`, and `lnkD` with
+/// version-2 items.
+fn cs2_layout(doc: &Document) -> Vec<u8> {
+    let out = photocraft_io::export(doc, "psd", &Default::default()).unwrap();
+    let mut file = photocraft_psd::PsdFile::from_bytes(&out.bytes).unwrap();
+    for rec in file.layers_mut() {
+        rec.blocks.retain(|b| !matches!(&b.key, b"SoLd" | b"SoLE"));
+    }
+    assert!(file.layers().iter().any(|l| l.block(b"PlLd").is_some()));
+    let links = file.global_blocks.iter_mut().find(|b| &b.key == b"lnk2").unwrap();
+    let files = photocraft_io::linked::parse_linked_files(&links.data);
+    assert_eq!(files.len(), 1);
+    links.key = *b"lnkD";
+    links.data = files.iter().flat_map(lifd_v2).collect();
+    file.to_bytes().unwrap()
+}
+
+/// Photoshop CS2 predates `SoLd`: its placed layers carry a `PlLd` block alone, and the embedded
+/// file sits in a global `lnkD` block of older `liFD` items. Such a smart object's contents open
+/// (they were "unavailable") and it re-renders in place from them (#2465).
+#[test]
+fn cs2_plld_only_smart_object_opens_its_contents() {
+    let mut s = session(8);
+    s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+    let id = s.active().unwrap().active_layer.unwrap().0;
+    s.execute("edit.transform", json!({"layer": id, "matrix": [0.75, 0, 0, 0.75, 10, 4]})).unwrap();
+    let doc = s.active().unwrap().doc.clone();
+    let (_, before) = smart(&doc);
+    let SmartSource::Embedded { bytes: pcraft, .. } = &before.source else { panic!("embedded") };
+    let nested = decode_source("x.pcraft", pcraft).unwrap();
+
+    let back = photocraft_io::import("cs2.psd", &cs2_layout(&doc)).unwrap().document;
+    let (bid, after) = smart(&back);
+    for (a, b) in after.transform.m.iter().zip(before.transform.m) {
+        assert!((a - b).abs() < 1e-9, "transform {:?} vs {:?}", after.transform, before.transform);
+    }
+    let (name, src) = photocraft_engine::smart_cmds::contents_of(&back, photocraft_doc::LayerId(bid)).expect("the contents are available");
+    let inner = decode_source(&name, &src).unwrap();
+    assert_eq!((inner.size, inner.layers.len()), (nested.size, nested.layers.len()));
+    // It re-renders where it was placed.
+    let mut l = back.layer(photocraft_doc::LayerId(bid)).unwrap().clone();
+    assert!(refresh_layer(&back, &mut l).unwrap());
+    let mut rerendered = back.clone();
+    *rerendered.layer_mut(photocraft_doc::LayerId(bid)).unwrap() = l;
+    let d = max_diff(&photocraft_compose::flatten(&rerendered).px, &photocraft_compose::flatten(&doc).px);
+    assert!(d <= 2.0 / 255.0, "re-render differs by {d}");
+    // And Edit Contents (the double-click) opens the nested document.
+    let mut s2 = Session::new();
+    s2.add_document(back, None);
+    s2.select_layer(photocraft_doc::LayerId(bid)).unwrap();
+    s2.execute("layer.smartObjects.editContents", json!({})).unwrap();
+    assert_eq!(s2.active().unwrap().doc.size, nested.size);
+}
+
+/// CS2 can warp a smart object, and `PlLd` keeps the warp after the corners. Now that a
+/// `PlLd`-only layer's contents are available, Free Transform, Image Size and mode changes
+/// re-render it from them: it must come back warped, not silently unwarped (#2465).
+#[test]
+fn cs2_plld_only_warped_smart_object_stays_warped() {
+    let mut s = session(8);
+    s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+    let id = s.active().unwrap().active_layer.unwrap().0;
+    s.execute("edit.transform", json!({"layer": id, "matrix": [0.75, 0, 0, 0.75, 10, 4]})).unwrap();
+    s.execute("layer.smartObjects.warp", json!({"style": "wave", "bend": 60})).unwrap();
+    let doc = s.active().unwrap().doc.clone();
+    let (_, before) = smart(&doc);
+    assert!(before.warp.is_some());
+
+    let back = photocraft_io::import("cs2.psd", &cs2_layout(&doc)).unwrap().document;
+    let (bid, after) = smart(&back);
+    assert_eq!(after.warp, before.warp);
+    assert!(photocraft_engine::smart_cmds::contents_of(&back, photocraft_doc::LayerId(bid)).is_ok(), "the contents are available");
+    // Re-rendered from its source, it is still warped where it was placed.
+    let rerender = |warp| {
+        let mut l = back.layer(photocraft_doc::LayerId(bid)).unwrap().clone();
+        let LayerContent::Smart(sm) = &mut l.content else { panic!() };
+        sm.warp = warp;
+        assert!(refresh_layer(&back, &mut l).unwrap());
+        let mut d = back.clone();
+        *d.layer_mut(photocraft_doc::LayerId(bid)).unwrap() = l;
+        max_diff(&photocraft_compose::flatten(&d).px, &photocraft_compose::flatten(&doc).px)
+    };
+    let d = rerender(after.warp.clone());
+    assert!(d <= 2.0 / 255.0, "re-render differs by {d}");
+    assert!(rerender(None) > 0.1, "an unwarped re-render would differ visibly");
+}
+
+/// A CS2 `PlLd`-only smart object is saved as it was while nothing changed it, and with its
+/// current placement once it is moved: the old record was written back unchanged, so the save
+/// reopened at the old place (#2465).
+#[test]
+fn cs2_plld_only_smart_object_saves_its_new_transform() {
+    let mut s = session(8);
+    s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+    let id = s.active().unwrap().active_layer.unwrap().0;
+    s.execute("edit.transform", json!({"layer": id, "matrix": [0.75, 0, 0, 0.75, 10, 4]})).unwrap();
+    let cs2 = cs2_layout(&s.active().unwrap().doc);
+    let plld = |bytes: &[u8]| {
+        let f = photocraft_psd::PsdFile::from_bytes(bytes).unwrap();
+        let rec = f.layers().iter().find(|l| l.block(b"PlLd").is_some()).cloned().expect("a placed layer");
+        (rec.block(b"PlLd").unwrap().data.clone(), rec.block(b"SoLd").is_some())
+    };
+    let back = photocraft_io::import("cs2.psd", &cs2).unwrap().document;
+    let (bid, _) = smart(&back);
+
+    // Unedited: the CS2 record is written back as it was.
+    let same = photocraft_io::export(&back, "psd", &Default::default()).unwrap().bytes;
+    assert_eq!(plld(&same), (plld(&cs2).0, false));
+
+    // Moved and scaled: written with the new placement, and it reopens there.
+    let mut s2 = Session::new();
+    s2.add_document(back, None);
+    s2.execute("edit.transform", json!({"layer": bid, "matrix": [0.5, 0, 0, 0.5, 20, 12]})).unwrap();
+    let edited = s2.active().unwrap().doc.clone();
+    let (_, want) = smart(&edited);
+    let saved = photocraft_io::export(&edited, "psd", &Default::default()).unwrap().bytes;
+    assert!(structure_errors(&saved).is_empty(), "{:?}", structure_errors(&saved));
+    assert_ne!(plld(&saved).0, plld(&cs2).0, "the old PlLd record was written back");
+    let again = photocraft_io::import("again.psd", &saved).unwrap().document;
+    let (aid, got) = smart(&again);
+    for (a, b) in got.transform.m.iter().zip(want.transform.m) {
+        assert!((a - b).abs() < 1e-9, "transform {:?} vs {:?}", got.transform, want.transform);
+    }
+    assert!(photocraft_engine::smart_cmds::contents_of(&again, photocraft_doc::LayerId(aid)).is_ok(), "the contents are available");
+}
diff --git a/crates/engine/tests/working_rgb_profile.rs b/crates/engine/tests/working_rgb_profile.rs
new file mode 100644
index 0000000000..82405575da
--- /dev/null
+++ b/crates/engine/tests/working_rgb_profile.rs
@@ -0,0 +1,263 @@
+//! Working RGB must support reading and editing for the configured intent.
+
+use photocraft_cms::{
+    Builtin, Curve, Intent, Profile, ProfileClass,
+    pipeline::Stage,
+    profile::{Lut, LutKind},
+};
+use photocraft_color::{Color, ColorMode, SampleType};
+use photocraft_doc::{Document, Layer};
+use photocraft_engine::Session;
+use photocraft_geom::Size;
+use serde_json::json;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+/// Repository-built, serialized profiles test capabilities without proprietary ICC fixtures
+/// or an invented inverse. The synthetic BToA table is not an appearance oracle.
+fn directional_profile(source: bool, destination: bool) -> Profile {
+    let mut p = Builtin::DisplayP3.profile().clone();
+    p.class = ProfileClass::Input;
+    p.description = "Synthetic directional RGB".into();
+    let curves = p.trc.take().unwrap().to_vec();
+    let matrix = p.matrix.take().unwrap();
+    let matrix = Stage::Matrix { rows: 3, cols: 3, m: matrix.iter().flatten().map(|v| v * 32768.0 / 65535.0).collect(), offset: vec![0.0; 3] };
+    let a2b = Lut { kind: LutKind::Ab, inputs: 3, outputs: 3, stages: vec![Stage::Curves(curves), matrix, Stage::Curves(vec![Curve::Identity; 3])] };
+    let b2a = Lut { kind: LutKind::Ab, inputs: 3, outputs: 3, stages: vec![Stage::Curves(vec![Curve::Identity; 3])] };
+    p.a2b = if source { [Some(a2b.clone()), Some(a2b.clone()), Some(a2b)] } else { Default::default() };
+    p.b2a = if destination { [Some(b2a.clone()), Some(b2a.clone()), Some(b2a)] } else { Default::default() };
+    p
+}
+
+struct ProfileFile {
+    path: std::path::PathBuf,
+    profile: Profile,
+}
+
+impl ProfileFile {
+    fn new(profile: Profile) -> Self {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        let path = std::env::temp_dir().join(format!("photocraft-working-rgb-{}-{}.icc", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
+        let bytes = profile.with_encoded_bytes().to_bytes();
+        let profile = Profile::parse(&bytes).unwrap();
+        std::fs::write(&path, &*bytes).unwrap();
+        Self { path, profile }
+    }
+    fn spec(&self) -> &str {
+        self.path.to_str().unwrap()
+    }
+}
+
+impl Drop for ProfileFile {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_file(&self.path);
+    }
+}
+
+fn reject_one_way_setting(source: bool, destination: bool, missing_direction: &str) {
+    let file = ProfileFile::new(directional_profile(source, destination));
+    for intent in Intent::ALL {
+        assert_eq!(file.profile.device_to_pcs(intent).is_ok(), source);
+        assert_eq!(file.profile.pcs_to_device(intent).is_ok(), destination);
+        let mut s = Session::new();
+        let before = s.color.settings.clone();
+        let error = s.execute("edit.colorSettings", json!({"workingRgb": file.spec(), "intent": intent.id(), "bpc": false})).unwrap_err();
+        assert!(error.to_string().contains(missing_direction), "{error}");
+        assert_eq!(s.color.settings, before, "reject the full settings update before any mutation");
+        assert!(s.execute("prefs.set", json!({"path": "colorSettings.workingRgb", "value": file.spec()})).is_err());
+        assert_eq!(s.color.settings, before, "individual preference setter also rejects atomically");
+    }
+}
+
+#[test]
+fn a_source_only_rgb_working_space_is_rejected_atomically() {
+    reject_one_way_setting(true, false, "destination");
+}
+
+#[test]
+fn a_destination_only_rgb_working_space_is_rejected_atomically() {
+    reject_one_way_setting(false, true, "source");
+}
+
+fn legacy_session(file: &ProfileFile, intent: Intent) -> Session {
+    let mut s = Session::new();
+    s.load_prefs_json(&json!({"colorSettings": {"workingRgb": file.spec(), "intent": intent.id()}}).to_string()).unwrap();
+    assert_eq!(s.color.settings.working_rgb, file.spec(), "legacy preferences still load");
+    s
+}
+
+fn display_and_copy(s: &mut Session, depth: SampleType) {
+    let target = s.active().unwrap().doc.clone();
+    let display = s.color.display_transform(&target).expect("the destination document must also be a readable display source");
+    let mut displayed = [0.0; 3];
+    display.eval(&[0.35, 0.65, 0.45], &mut displayed);
+    assert!(displayed.iter().all(|v| v.is_finite()));
+    let mut source = Document::new("Copy source", Size::new(8, 6), ColorMode::Rgb, SampleType::F32);
+    source.icc_profile = Some(Builtin::AdobeRgbCompat.profile().to_bytes());
+    let mut layer = Layer::raster("Incoming", source.pixel_format());
+    layer.surface_mut().unwrap().fill_rect(source.bounds(), &[0.35, 0.65, 0.45, 0.75]);
+    source.layers.push(layer);
+    s.add_document(source, None);
+    let source_before = s.documents()[1].doc.clone();
+    s.execute("layer.copyToDocument", json!({"document": 0})).expect("an untagged or new document must accept a converted layer");
+    assert_eq!(s.documents()[0].doc.depth, depth);
+    assert_eq!(s.documents()[0].doc.layers.len(), target.layers.len() + 1);
+    assert!(s.documents()[1].doc.as_ref() == source_before.as_ref());
+    assert!(s.undo());
+    assert!(s.active().unwrap().doc.as_ref() == target.as_ref());
+}
+
+fn legacy_untagged_workflow(source: bool, destination: bool) {
+    let file = ProfileFile::new(directional_profile(source, destination));
+    for intent in Intent::ALL {
+        for depth in SampleType::ALL {
+            let mut s = legacy_session(&file, intent);
+            let doc = Document::with_background("Untagged image", Size::new(8, 6), ColorMode::Rgb, depth, Color::rgba(0.35, 0.65, 0.45, 0.75));
+            assert!(doc.icc_profile.is_none());
+            s.open_document(doc, None);
+            display_and_copy(&mut s, depth);
+            assert_eq!(s.color.working(ColorMode::Rgb).content_hash(), Builtin::Srgb.profile().content_hash());
+            assert!(s.documents()[0].doc.icc_profile.is_none(), "the default working fallback keeps untagged documents untagged");
+        }
+    }
+}
+
+#[test]
+fn legacy_source_only_working_rgb_keeps_untagged_display_and_copy_usable() {
+    legacy_untagged_workflow(true, false);
+}
+
+#[test]
+fn legacy_destination_only_working_rgb_keeps_untagged_display_and_copy_usable() {
+    legacy_untagged_workflow(false, true);
+}
+
+#[test]
+fn legacy_one_way_working_spaces_keep_new_document_controls_usable() {
+    for (source, destination) in [(true, false), (false, true)] {
+        let file = ProfileFile::new(directional_profile(source, destination));
+        for intent in Intent::ALL {
+            for depth in SampleType::ALL {
+                let mut s = legacy_session(&file, intent);
+                let bits = match depth {
+                    SampleType::U8 => 8,
+                    SampleType::U16 => 16,
+                    SampleType::F32 => 32,
+                };
+                s.execute("file.new", json!({"width": 8, "height": 6, "depth": bits, "background": "transparent"})).unwrap();
+                display_and_copy(&mut s, depth);
+            }
+        }
+    }
+}
+
+#[test]
+fn valid_input_matrix_and_lut_working_profiles_use_the_configured_intent() {
+    let mut matrix = Builtin::DisplayP3.profile().clone();
+    matrix.class = ProfileClass::Input;
+    let mut colorimetric_lut = directional_profile(true, true);
+    colorimetric_lut.b2a[0] = None;
+    colorimetric_lut.b2a[2] = None;
+    for (profile, colorimetric_only) in [(matrix, false), (directional_profile(true, true), false), (colorimetric_lut, true)] {
+        let file = ProfileFile::new(profile);
+        for intent in Intent::ALL {
+            let supported = !colorimetric_only || matches!(intent, Intent::RelativeColorimetric | Intent::AbsoluteColorimetric);
+            let mut s = Session::new();
+            let before = s.color.settings.clone();
+            let result = s.execute("edit.colorSettings", json!({"workingRgb": file.spec(), "intent": intent.id()}));
+            assert_eq!(result.is_ok(), supported, "{intent:?}/colorimetric_only={colorimetric_only}");
+            if !supported {
+                assert_eq!(s.color.settings, before);
+            }
+            let s = legacy_session(&file, intent);
+            let expected = if supported { &file.profile } else { Builtin::Srgb.profile() };
+            assert_eq!(s.color.working(ColorMode::Rgb).content_hash(), expected.content_hash());
+        }
+    }
+}
+
+fn intent_lut(intent: Intent) -> ProfileFile {
+    let mut profile = directional_profile(true, true);
+    let i = match intent {
+        Intent::Perceptual => 0,
+        Intent::RelativeColorimetric | Intent::AbsoluteColorimetric => 1,
+        Intent::Saturation => 2,
+    };
+    for (index, lut) in profile.b2a.iter_mut().enumerate() {
+        if index != i {
+            *lut = None;
+        }
+    }
+    ProfileFile::new(profile)
+}
+
+fn colorimetric_session(file: &ProfileFile) -> Session {
+    let mut s = Session::new();
+    s.execute("edit.colorSettings", json!({"workingRgb": file.spec(), "intent": "relative"})).unwrap();
+    s
+}
+
+#[test]
+fn valid_cross_field_profile_and_intent_changes_validate_the_final_batch() {
+    let file = intent_lut(Intent::RelativeColorimetric);
+    let cases = [
+        ("edit.colorSettings", json!({"workingRgb": "display-p3", "intent": "perceptual"})),
+        ("prefs.set", json!({"values": {"colorSettings.intent": "perceptual", "colorSettings.workingRgb": "display-p3"}})),
+        (
+            "prefs.set",
+            json!({"path": "colorSettings", "value": {"workingRgb": file.spec(), "intent": "perceptual"}, "values": {"colorSettings.workingRgb": "display-p3"}}),
+        ),
+        (
+            "prefs.set",
+            json!({"path": "", "value": {"colorSettings": {"workingRgb": file.spec(), "intent": "perceptual"}}, "values": {"colorSettings.workingRgb": "display-p3"}}),
+        ),
+    ];
+    for (command, params) in cases {
+        let mut s = colorimetric_session(&file);
+        s.execute(command, params.clone()).unwrap_or_else(|e| panic!("final valid batch must succeed: {command}/{params}: {e}"));
+        assert_eq!(s.color.settings.working_rgb, "display-p3");
+        assert_eq!(s.color.settings.intent, "perceptual");
+    }
+}
+
+#[test]
+fn invalid_batches_restore_colour_and_unrelated_preferences_for_both_apis() {
+    let working = intent_lut(Intent::RelativeColorimetric);
+    let invalid = ProfileFile::new(directional_profile(true, false));
+    let cases = [
+        ("edit.colorSettings", json!({"workingRgb": invalid.spec(), "intent": "perceptual", "bpc": false})),
+        (
+            "prefs.set",
+            json!({"values": {"colorSettings.bpc": false, "colorSettings.intent": "perceptual", "colorSettings.workingRgb": invalid.spec(), "performance.historyStates": 17}}),
+        ),
+        (
+            "prefs.set",
+            json!({"values": {"colorSettings.bpc": false, "colorSettings.intent": "perceptual", "colorSettings.workingRgb": "display-p3", "performance.historyStates": 0}}),
+        ),
+    ];
+    for (command, params) in cases {
+        let mut s = colorimetric_session(&working);
+        let before = s.prefs_to_json();
+        assert!(s.execute(command, params).is_err());
+        assert!(s.prefs_to_json() == before, "failed batch must preserve both preference stores");
+    }
+}
+
+#[test]
+fn incompatible_single_intent_reset_preserves_the_original_colour_settings() {
+    let file = intent_lut(Intent::Saturation);
+    let mut s = Session::new();
+    s.execute("edit.colorSettings", json!({"workingRgb": file.spec(), "intent": "saturation"})).unwrap();
+    let before = s.prefs_to_json();
+    assert!(s.execute("prefs.reset", json!({"path": "colorSettings.intent"})).is_err());
+    assert!(s.prefs_to_json() == before, "single-setting reset must validate before assignment");
+}
+
+#[test]
+fn unrelated_preference_batches_still_work_with_legacy_invalid_colour_settings() {
+    let invalid = ProfileFile::new(directional_profile(true, false));
+    let mut s = legacy_session(&invalid, Intent::RelativeColorimetric);
+    let before = s.color.settings.clone();
+    s.execute("prefs.set", json!({"values": {"cursors.painting": "precise", "performance.historyStates": 17}})).unwrap();
+    assert_eq!(s.color.settings, before);
+    assert_eq!(s.execute("prefs.get", json!({"path": "performance.historyStates"})).unwrap(), json!(17));
+}
diff --git a/crates/format/Cargo.toml b/crates/format/Cargo.toml
index 00a41ac070..45d7a4ccf3 100644
--- a/crates/format/Cargo.toml
+++ b/crates/format/Cargo.toml
@@ -24,10 +24,15 @@ crc32fast = "1.5"
 blake3 = { version = "1.8", default-features = false, features = ["pure"] }
 ruzstd = "0.9"
 
-# A plain fsync where a file system refuses the full flush (`sync_file`, atomic.rs). Already in
-# Cargo.lock on Apple targets (cap-std), so this adds no new crate.
-[target.'cfg(target_vendor = "apple")'.dependencies]
+# Unix directory cleanup uses no-follow descriptor-relative operations; the same
+# dependency provides the plain-fsync fallback on Apple file systems.
+[target.'cfg(unix)'.dependencies]
 rustix = { version = "1.1", default-features = false, features = ["std", "fs"] }
 
+# rustix does not expose Apple's directory-search open mode. Only the named
+# constant is used; all descriptor operations remain in safe rustix APIs.
+[target.'cfg(target_vendor = "apple")'.dependencies]
+libc = "0.2"
+
 [dev-dependencies]
 proptest = { workspace = true }
diff --git a/crates/format/fuzz/.gitignore b/crates/format/fuzz/.gitignore
index d932d310fa..fc87536ae7 100644
--- a/crates/format/fuzz/.gitignore
+++ b/crates/format/fuzz/.gitignore
@@ -2,3 +2,4 @@ target/
 corpus/
 artifacts/
 Cargo.lock
+coverage/
diff --git a/crates/format/src/convert.rs b/crates/format/src/convert.rs
index d319c85a9d..51d6183baa 100644
--- a/crates/format/src/convert.rs
+++ b/crates/format/src/convert.rs
@@ -140,7 +140,7 @@ fn layer_m(l: &Layer, sink: &mut dyn Sink) -> LayerM {
             psd_raw: opt_blob(&t.psd_raw, sink),
             runs: t.runs.clone(),
             paragraphs: t.paragraphs.clone(),
-            shape: t.shape,
+            shape: t.shape.clone(),
             orientation: t.orientation,
             antialias: t.antialias,
             warp: t.warp.clone(),
@@ -230,6 +230,7 @@ pub(crate) fn doc_m(d: &Document, sink: &mut dyn Sink) -> DocM {
         layers: d.layers.iter().map(|l| layer_m(l, sink)).collect(),
         channels: d.channels.iter().map(|c| channel_m(c, sink)).collect(),
         guides: d.guides.clone(),
+        ruler_origin: d.ruler_origin,
         selection: d.selection.as_ref().map(|s| surface_m(s, sink)),
         metadata: MetadataM {
             xmp: d.metadata.xmp.clone(),
@@ -253,6 +254,7 @@ pub(crate) fn doc_m(d: &Document, sink: &mut dyn Sink) -> DocM {
         duotone: d.duotone.clone(),
         variables: d.variables.clone(),
         timeline: d.timeline.clone(),
+        file_encoding: d.file_encoding,
         layer_comps: d.layer_comps.iter().map(|c| comp_m(c, sink)).collect(),
         last_applied_comp: d.last_applied_comp,
         last_document_state: d.last_document_state.as_ref().map(|c| comp_m(c, sink)),
@@ -458,7 +460,7 @@ impl Loader<'_> {
                     psd_raw: self.opt_blob(psd_raw)?,
                     runs: runs.clone(),
                     paragraphs: paragraphs.clone(),
-                    shape: *shape,
+                    shape: shape.clone(),
                     orientation: *orientation,
                     antialias: *antialias,
                     warp: warp.clone(),
@@ -591,6 +593,15 @@ impl Loader<'_> {
         }
         let mut patterns = Vec::with_capacity(m.patterns.len());
         for p in &m.patterns {
+            // Sizes come from the file: a pattern with no tiles can claim any size, and renderers
+            // allocate per pixel.
+            let max = photocraft_doc::pattern::MAX_EDGE;
+            if p.width == 0 || p.height == 0 {
+                return Err(FormatError::corrupt(format!("pattern `{}` is {}×{} px", p.name, p.width, p.height)));
+            }
+            if p.width > max || p.height > max {
+                return Err(FormatError::LimitExceeded(format!("pattern `{}` is {}×{} px (max {max} per side)", p.name, p.width, p.height)));
+            }
             patterns.push(Pattern { id: p.id.clone(), name: p.name.clone(), width: p.width, height: p.height, surface: self.surface(&p.surface)? });
         }
         let layer_comps = m.layer_comps.iter().map(|c| self.comp(c)).collect::<Result<Vec<_>>>()?;
@@ -618,6 +629,7 @@ impl Loader<'_> {
             layers,
             channels,
             guides: m.guides.clone(),
+            ruler_origin: m.ruler_origin,
             selection: self.opt_surface(&m.selection)?,
             metadata: md,
             global_light: m.global_light,
@@ -631,6 +643,7 @@ impl Loader<'_> {
             duotone: m.duotone.clone(),
             variables: m.variables.clone(),
             timeline: m.timeline.clone(),
+            file_encoding: m.file_encoding,
             layer_comps,
             last_applied_comp: m.last_applied_comp,
             last_document_state,
diff --git a/crates/format/src/manifest.rs b/crates/format/src/manifest.rs
index 6524bfdfc8..82480e05c0 100644
--- a/crates/format/src/manifest.rs
+++ b/crates/format/src/manifest.rs
@@ -46,6 +46,9 @@ pub struct DocM {
     pub layers: Vec<LayerM>,
     pub channels: Vec<ChannelM>,
     pub guides: Guides,
+    /// The rulers' zero point in document pixels (absent in older files: the top-left).
+    #[serde(default)]
+    pub ruler_origin: [f64; 2],
     pub selection: Option<SurfaceM>,
     pub metadata: MetadataM,
     pub global_light: GlobalLight,
@@ -84,6 +87,9 @@ pub struct DocM {
     /// Window › Timeline.
     #[serde(default)]
     pub timeline: Option<photocraft_doc::Timeline>,
+    /// The JPEG quality / WebP encoding File › Save reuses.
+    #[serde(default, skip_serializing_if = "photocraft_doc::FileEncoding::is_empty")]
+    pub file_encoding: photocraft_doc::FileEncoding,
     /// Image › Analysis: measurement scale, count groups, ruler.
     #[serde(default)]
     pub measurement: photocraft_doc::Measurement,
diff --git a/crates/format/src/store.rs b/crates/format/src/store.rs
index 674c99f214..d047668cb0 100644
--- a/crates/format/src/store.rs
+++ b/crates/format/src/store.rs
@@ -30,14 +30,24 @@ fn compress(data: &[u8]) -> Vec<u8> {
     ruzstd::encoding::compress_to_vec(data, ruzstd::encoding::CompressionLevel::Fastest)
 }
 
-fn decompress(data: &[u8], expected: usize, what: &str) -> Result<Vec<u8>> {
-    let mut dec = ruzstd::decoding::StreamingDecoder::new(data).map_err(|e| FormatError::corrupt(format!("{what}: zstd: {e}")))?;
-    let mut out = Vec::with_capacity(expected.min(64 << 20));
-    (&mut dec).take(expected as u64 + 1).read_to_end(&mut out).map_err(|e| FormatError::corrupt(format!("{what}: zstd: {e}")))?;
-    if out.len() != expected {
-        return Err(FormatError::corrupt(format!("{what}: expected {expected} bytes, got {}", out.len())));
+/// Decodes a zstd frame of at most `max` bytes (`LimitExceeded` beyond). With `exact`, the
+/// decoded length must be exactly that (`Corrupt` otherwise).
+fn decompress_bounded(data: &[u8], max: usize, exact: Option<usize>, what: &str) -> Result<Vec<u8>> {
+    let zstd = |e: &dyn std::fmt::Display| FormatError::corrupt(format!("{what}: zstd: {e}"));
+    let mut dec = ruzstd::decoding::StreamingDecoder::new(data).map_err(|e| zstd(&e))?;
+    let mut out = Vec::with_capacity(exact.unwrap_or(0).min(max).min(64 << 20));
+    // `max` may be `usize::MAX`: one byte past it must not overflow.
+    let limit = u64::try_from(max).unwrap_or(u64::MAX).saturating_add(1);
+    (&mut dec).take(limit).read_to_end(&mut out).map_err(|e| zstd(&e))?;
+    match exact {
+        Some(n) if out.len() != n => Err(FormatError::corrupt(format!("{what}: expected {n} bytes, got {}", out.len()))),
+        None if out.len() > max => Err(FormatError::LimitExceeded(format!("{what} exceeds {max} bytes"))),
+        _ => Ok(out),
     }
-    Ok(out)
+}
+
+fn decompress(data: &[u8], expected: usize, what: &str) -> Result<Vec<u8>> {
+    decompress_bounded(data, expected, Some(expected), what)
 }
 
 fn hash_bytes(b: &[u8]) -> Hash {
@@ -228,12 +238,7 @@ impl Fetch for LoadFetch<'_> {
         let z = self.src.get(&path, self.opts.max_blob_bytes)?;
         // Blob length is not in the manifest; the frame header bounds it and
         // we cap at max_blob_bytes.
-        let mut dec = ruzstd::decoding::StreamingDecoder::new(&z[..]).map_err(|e| FormatError::corrupt(format!("{path}: zstd: {e}")))?;
-        let mut data = Vec::new();
-        (&mut dec).take(self.opts.max_blob_bytes as u64 + 1).read_to_end(&mut data).map_err(|e| FormatError::corrupt(format!("{path}: zstd: {e}")))?;
-        if data.len() > self.opts.max_blob_bytes {
-            return Err(FormatError::LimitExceeded(format!("{path} exceeds max_blob_bytes")));
-        }
+        let data = decompress_bounded(&z, self.opts.max_blob_bytes, None, &path)?;
         self.account(data.len())?;
         if hash_bytes(&data) != hash {
             return Err(FormatError::corrupt(format!("{path}: content does not match its hash")));
@@ -313,13 +318,7 @@ impl Sink for Collect<'_> {
             self.tiles.entry(h.clone()).or_insert_with(|| (tile.clone(), format.sample));
             return h;
         }
-        let h = if cfg!(target_endian = "big") {
-            let mut b = tile.bytes().to_vec();
-            swap_to_le(&mut b, format.sample);
-            hash_bytes(&b)
-        } else {
-            hash_bytes(tile.bytes())
-        };
+        let h = hash_bytes(&tile_le(tile, format.sample));
         if let Some(cache) = self.hash_cache.as_deref_mut() {
             cache.insert(key, (Arc::downgrade(tile), h.clone()));
         }
@@ -414,21 +413,23 @@ enum Object {
 
 impl Object {
     fn compressed(&self) -> Vec<u8> {
-        match self {
-            Object::Tile(t, s) => compress(&tile_le(t, *s)),
-            Object::Blob(b) => compress(b),
-        }
+        compress(&self.content())
     }
 
-    fn matches_content_hash(&self, compressed: &[u8], what: &str) -> bool {
-        let expected = match self {
+    /// The bytes this object stores (tiles little-endian).
+    fn content(&self) -> std::borrow::Cow<'_, [u8]> {
+        match self {
             Object::Tile(tile, sample) => tile_le(tile, *sample),
             Object::Blob(blob) => std::borrow::Cow::Borrowed(blob.as_slice()),
-        };
-        decompress(compressed, expected.len(), what).is_ok_and(|actual| hash_bytes(&actual) == hash_bytes(&expected))
+        }
     }
 }
 
+/// Whether `compressed` decodes to exactly `expected`.
+fn content_matches(expected: &[u8], compressed: &[u8], what: &str) -> bool {
+    decompress(compressed, expected.len(), what).is_ok_and(|actual| hash_bytes(&actual) == hash_bytes(expected))
+}
+
 fn file_signature(metadata: &std::fs::Metadata) -> Option<FileSignature> {
     #[cfg(unix)]
     let unix = {
@@ -569,10 +570,82 @@ fn write_bundle_file(root: &Path, path: &Path, data: &[u8]) -> Result<()> {
     result
 }
 
-fn remove_bundle_file(root: &Path, path: &Path) -> Result<()> {
+/// Keep the existing leaf/path validation and pin the actual unlink to opened
+/// directory handles on Unix. This closes the check-then-remove path-swap gap.
+fn remove_bundle_file(root: &Path, path: &Path, gc: &BundleGc) -> Result<()> {
     validate_bundle_file(root, path)?;
-    std::fs::remove_file(path)?;
-    Ok(())
+    let relative = path.strip_prefix(root).map_err(|_| unsafe_bundle_entry(path))?;
+    gc.remove(relative)
+}
+
+#[cfg(unix)]
+struct BundleGc {
+    root: rustix::fd::OwnedFd,
+    tiles: rustix::fd::OwnedFd,
+    blobs: rustix::fd::OwnedFd,
+    composite: rustix::fd::OwnedFd,
+}
+
+#[cfg(unix)]
+fn gc_directory_flags() -> rustix::fs::OFlags {
+    use rustix::fs::OFlags;
+
+    // GC needs directory traversal, not permission to read a directory listing.
+    // Both modes retain a descriptor for the directory opened here, so a later
+    // pathname replacement cannot redirect descriptor-relative cleanup.
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    let access = OFlags::PATH;
+    #[cfg(target_vendor = "apple")]
+    let access = OFlags::from_bits_retain(libc::O_SEARCH.cast_unsigned());
+    #[cfg(not(any(target_os = "linux", target_os = "android", target_vendor = "apple")))]
+    let access = OFlags::RDONLY;
+    access | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC
+}
+
+#[cfg(unix)]
+impl BundleGc {
+    fn new(root: &Path) -> Result<Self> {
+        use rustix::fs::{Mode, open, openat};
+
+        let flags = gc_directory_flags();
+        let root = open(root, flags, Mode::empty()).map_err(std::io::Error::from)?;
+        let tiles = openat(&root, "tiles", flags, Mode::empty()).map_err(std::io::Error::from)?;
+        let blobs = openat(&root, "blobs", flags, Mode::empty()).map_err(std::io::Error::from)?;
+        let composite = openat(&root, "composite", flags, Mode::empty()).map_err(std::io::Error::from)?;
+        Ok(Self { root, tiles, blobs, composite })
+    }
+
+    fn remove(&self, relative: &Path) -> Result<()> {
+        let relative = relative.to_str().ok_or_else(|| unsafe_bundle_entry(relative))?;
+        let (handle, name) = match relative {
+            THUMB => (&self.root, THUMB),
+            COMPOSITE => (&self.composite, "preview.png"),
+            _ => match relative.split_once('/') {
+                Some(("tiles", name)) if name.strip_suffix(".zst").is_some_and(is_valid_hash) => (&self.tiles, name),
+                Some(("blobs", name)) if name.strip_suffix(".zst").is_some_and(is_valid_hash) => (&self.blobs, name),
+                _ => return Err(FormatError::Unsupported(format!("invalid bundle cleanup target: {relative}"))),
+            },
+        };
+        rustix::fs::unlinkat(handle, name, rustix::fs::AtFlags::empty()).map_err(std::io::Error::from)?;
+        Ok(())
+    }
+}
+
+#[cfg(not(unix))]
+struct BundleGc {
+    root: PathBuf,
+}
+
+#[cfg(not(unix))]
+impl BundleGc {
+    fn new(root: &Path) -> Result<Self> {
+        Ok(Self { root: root.to_path_buf() })
+    }
+
+    fn remove(&self, relative: &Path) -> Result<()> {
+        std::fs::remove_file(self.root.join(relative))?;
+        Ok(())
+    }
 }
 
 fn existing_object_is_valid(path: &Path, object: &Object, what: &str) -> Result<(bool, Option<FileSignature>)> {
@@ -587,10 +660,8 @@ fn existing_object_is_valid(path: &Path, object: &Object, what: &str) -> Result<
     }
     let signature = file_signature(&metadata);
 
-    let expected_len = match object {
-        Object::Tile(tile, sample) => tile_le(tile, *sample).len(),
-        Object::Blob(blob) => blob.len(),
-    };
+    let expected = object.content();
+    let expected_len = expected.len();
     // This is the same bound used by the tile loader. It comfortably includes
     // zstd framing overhead while keeping damaged files bounded when inspected.
     let max_compressed_len = expected_len.saturating_add(expected_len / 8).saturating_add(4096);
@@ -604,7 +675,7 @@ fn existing_object_is_valid(path: &Path, object: &Object, what: &str) -> Result<
     if compressed.len() > max_compressed_len {
         return Ok((false, None));
     }
-    Ok((object.matches_content_hash(&compressed, what), signature))
+    Ok((content_matches(&expected, &compressed, what), signature))
 }
 
 /// A bundle path and its compressed bytes.
@@ -803,11 +874,14 @@ impl PcraftWriter {
         for (name, data) in &p.previews {
             write_bundle_file(dir, &dir.join(name), data)?;
         }
+        // Pin all GC directories before removing stale previews or objects.
+        // Unix cleanup then stays within these directories even if a pathname is swapped.
+        let gc = BundleGc::new(dir)?;
         for stale in [THUMB, COMPOSITE] {
             if !p.previews.iter().any(|(n, _)| *n == stale) {
                 let path = dir.join(stale);
                 validate_bundle_file(dir, &path)?;
-                match remove_bundle_file(dir, &path) {
+                match remove_bundle_file(dir, &path, &gc) {
                     Err(FormatError::Io(e)) if e.kind() == std::io::ErrorKind::NotFound => {}
                     other => other?,
                 }
@@ -819,7 +893,7 @@ impl PcraftWriter {
         // complete save into a reported failure); a leftover is retried on the next save.
         for path in existing {
             if !p.objects.contains_key(&path) {
-                if remove_bundle_file(dir, &dir.join(&path)).is_ok() {
+                if remove_bundle_file(dir, &dir.join(&path), &gc).is_ok() {
                     stats.objects_removed += 1;
                 }
                 if let Some(cache) = &mut self.verified_directory {
@@ -867,6 +941,36 @@ impl PcraftWriter {
     }
 }
 
+#[cfg(all(test, unix))]
+#[test]
+fn gc_pinned_directory_handles_resist_subdirectory_swap() {
+    use std::os::unix::fs::symlink;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static NEXT: AtomicU64 = AtomicU64::new(0);
+    let root = std::env::temp_dir().join(format!("pcraft-gc-swap-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
+    let bundle = root.join("project.pcraft");
+    let outside = root.join("outside");
+    for sub in ["tiles", "blobs", "composite"] {
+        std::fs::create_dir_all(bundle.join(sub)).unwrap();
+    }
+    std::fs::create_dir(&outside).unwrap();
+    let filename = format!("{}.zst", "c".repeat(64));
+    std::fs::write(bundle.join("tiles").join(&filename), b"stale bundle file").unwrap();
+    std::fs::write(outside.join(&filename), b"outside file must survive").unwrap();
+
+    let gc = BundleGc::new(&bundle).unwrap();
+    std::fs::rename(bundle.join("tiles"), bundle.join("old-tiles")).unwrap();
+    symlink(&outside, bundle.join("tiles")).unwrap();
+
+    // Exercise the descriptor-relative unlink directly: the public save path
+    // also validates the leaf, but that check itself cannot prevent a later swap.
+    gc.remove(Path::new(&format!("tiles/{filename}"))).unwrap();
+    assert!(!bundle.join("old-tiles").join(&filename).exists());
+    assert_eq!(std::fs::read(outside.join(&filename)).unwrap(), b"outside file must survive");
+    std::fs::remove_dir_all(root).unwrap();
+}
+
 fn list_objects(dir: &Path) -> Result<HashSet<String>> {
     let mut out = HashSet::new();
     for sub in ["tiles", "blobs"] {
@@ -879,7 +983,7 @@ fn list_objects(dir: &Path) -> Result<HashSet<String>> {
         for e in rd {
             let e = e?;
             let name = e.file_name().to_string_lossy().into_owned();
-            if name.ends_with(".zst") {
+            if name.strip_suffix(".zst").is_some_and(is_valid_hash) {
                 let path = e.path();
                 match std::fs::symlink_metadata(&path) {
                     Ok(metadata) if metadata.file_type().is_symlink() => return Err(unsafe_bundle_entry(&path)),
diff --git a/crates/format/src/zip.rs b/crates/format/src/zip.rs
index 1e296e16d1..9ec92c2fba 100644
--- a/crates/format/src/zip.rs
+++ b/crates/format/src/zip.rs
@@ -201,7 +201,12 @@ impl<'a> ZipReader<'a> {
         if e.uncompressed > max {
             return Err(FormatError::LimitExceeded(format!("zip entry `{}` is {} bytes (max {max})", e.name, e.uncompressed)));
         }
-        let raw = &self.bytes[e.data_offset..e.data_offset + e.compressed];
+        // `Entry` is public and cloneable: one from another archive must not index out of range.
+        let raw = e
+            .data_offset
+            .checked_add(e.compressed)
+            .and_then(|end| self.bytes.get(e.data_offset..end))
+            .ok_or_else(|| FormatError::corrupt(format!("zip entry `{}` out of range", e.name)))?;
         let data = match e.method {
             0 => raw.to_vec(),
             8 => {
@@ -366,6 +371,19 @@ mod tests {
         assert!(matches!(archive.read_by_name("manifest.json", usize::MAX), Err(FormatError::Corrupt(_))));
     }
 
+    #[test]
+    fn an_entry_from_another_archive_is_an_error_not_a_panic() {
+        let mut big = ZipWriter::new();
+        big.add("a", &[7; 4096]).unwrap();
+        let big = big.finish().unwrap();
+        let foreign = ZipReader::new(&big).unwrap().entries[0].clone();
+        let mut small = ZipWriter::new();
+        small.add("a", b"x").unwrap();
+        let small = small.finish().unwrap();
+        let r = ZipReader::new(&small).unwrap();
+        assert!(matches!(r.read(&foreign, usize::MAX), Err(FormatError::Corrupt(_))));
+    }
+
     #[test]
     fn offset_access_rejects_overflow() {
         assert!(u16_at(&[], usize::MAX).is_err());
diff --git a/crates/format/tests/common/mod.rs b/crates/format/tests/common/mod.rs
index ef840cfc80..8d5641d9cd 100644
--- a/crates/format/tests/common/mod.rs
+++ b/crates/format/tests/common/mod.rs
@@ -230,6 +230,7 @@ pub fn rich_doc(mode: ColorMode, depth: SampleType) -> Document {
     });
     d.guides =
         Guides { horizontal: vec![10.0, 20.5], vertical: vec![100.25], colors: vec![GuideColor { vertical: true, position: 100.25, rgb: [0x33, 0x66, 0xff] }] };
+    d.ruler_origin = [12.5, -4.25];
     let mut sel = Surface::new(PixelFormat::GRAY8);
     scribble(&mut sel, 14, false);
     d.selection = Some(sel);
diff --git a/crates/format/tests/corruption.rs b/crates/format/tests/corruption.rs
index 2f47203b3f..d293abed1e 100644
--- a/crates/format/tests/corruption.rs
+++ b/crates/format/tests/corruption.rs
@@ -419,6 +419,40 @@ fn tile_coordinates_outside_the_i32_pixel_range_are_rejected() {
     }
 }
 
+#[test]
+fn an_unlimited_blob_budget_still_loads_blobs() {
+    // `max_blob_bytes + 1` overflowed (debug panic; release read zero bytes, failing every blob).
+    let doc = rich_doc(ColorMode::Rgb, SampleType::U8);
+    let bytes = save_to_bytes(&doc, &SaveOptions::default()).unwrap();
+    let opts = LoadOptions { max_blob_bytes: usize::MAX, ..LoadOptions::default() };
+    assert_eq!(load_from_bytes_with(&bytes, &opts).unwrap(), doc);
+}
+
+/// Rewrites the first pattern's declared size (its tiles stay as saved).
+fn with_pattern_size(w: u64, h: u64) -> Vec<u8> {
+    rebuild(sample_cached(), |n, d| {
+        if n != "manifest.json" {
+            return Some(d);
+        }
+        let mut v: serde_json::Value = serde_json::from_slice(&d).unwrap();
+        let p = &mut v["document"]["patterns"][0];
+        assert!(p.is_object(), "the sample has a pattern");
+        p["width"] = w.into();
+        p["height"] = h.into();
+        Some(serde_json::to_vec(&v).unwrap())
+    })
+}
+
+#[test]
+fn pattern_sizes_from_the_file_are_checked() {
+    // A pattern can claim any size without tiles; painting it allocated per pixel (abort).
+    let huge = load_from_bytes(&with_pattern_size(65_535, 65_535));
+    assert!(matches!(huge, Err(FormatError::LimitExceeded(_))), "{huge:?}");
+    let empty = load_from_bytes(&with_pattern_size(0, 24));
+    assert!(matches!(empty, Err(FormatError::Corrupt(_))), "{empty:?}");
+    assert!(load_from_bytes(&with_pattern_size(32, 24)).is_ok());
+}
+
 /// A canvas is a few bytes of manifest JSON; one past the budget is refused before any work (#2935).
 /// The default budget is the largest canvas the app creates (300000 × 300000, as `file.new`,
 /// Canvas Size and PSB import allow), so everything a user can save reopens.
diff --git a/crates/format/tests/directory_symlinks.rs b/crates/format/tests/directory_symlinks.rs
new file mode 100644
index 0000000000..0302593f49
--- /dev/null
+++ b/crates/format/tests/directory_symlinks.rs
@@ -0,0 +1,176 @@
+//! Directory cleanup only owns content-addressed objects; unrelated files survive.
+
+mod common;
+
+use common::temp_dir;
+use photocraft_color::{ColorMode, SampleType};
+use photocraft_doc::Document;
+use photocraft_format::{PcraftWriter, SaveOptions};
+use photocraft_geom::Size;
+
+fn empty_doc() -> Document {
+    Document::new("clean", Size::new(1, 1), ColorMode::Rgb, SampleType::U8)
+}
+
+#[test]
+fn directory_cleanup_preserves_unrelated_zst_files() {
+    let root = temp_dir("unrelated-object");
+    let bundle = root.join("project.pcraft");
+    let mut writer = PcraftWriter::new();
+    writer.save_dir(&empty_doc(), &bundle, &SaveOptions::default()).unwrap();
+
+    let unrelated = bundle.join("tiles/personal-notes.zst");
+    let orphan = bundle.join("blobs").join(format!("{}.zst", "b".repeat(64)));
+    std::fs::write(&unrelated, b"unrelated file").unwrap();
+    std::fs::write(&orphan, b"unused content-addressed object").unwrap();
+
+    let stats = writer.save_dir(&empty_doc(), &bundle, &SaveOptions::default()).unwrap();
+    assert_eq!(std::fs::read(&unrelated).unwrap(), b"unrelated file");
+    assert!(!orphan.exists(), "a valid but unreferenced object is removed");
+    assert_eq!(stats.objects_removed, 1);
+    std::fs::remove_dir_all(root).unwrap();
+}
+
+#[cfg(any(target_os = "linux", target_os = "android", target_vendor = "apple"))]
+mod permissions {
+    use super::*;
+    use photocraft_format::load_path;
+    use photocraft_raster::Rgba8Image;
+    use std::os::unix::fs::{PermissionsExt, symlink};
+    use std::path::{Path, PathBuf};
+
+    struct RestoreMode {
+        path: PathBuf,
+        permissions: std::fs::Permissions,
+    }
+
+    impl RestoreMode {
+        fn set(path: &Path, mode: u32) -> Self {
+            let permissions = std::fs::metadata(path).unwrap().permissions();
+            std::fs::set_permissions(path, std::fs::Permissions::from_mode(mode)).unwrap();
+            Self { path: path.to_path_buf(), permissions }
+        }
+    }
+
+    impl Drop for RestoreMode {
+        fn drop(&mut self) {
+            let _ = std::fs::set_permissions(&self.path, self.permissions.clone());
+        }
+    }
+
+    #[test]
+    fn directory_save_without_previews_does_not_require_composite_read_permission() {
+        let root = temp_dir("composite-search-only");
+        let bundle = root.join("project.pcraft");
+        let mut writer = PcraftWriter::new();
+        writer.save_dir(&empty_doc(), &bundle, &SaveOptions::default()).unwrap();
+        let restricted = RestoreMode::set(&bundle.join("composite"), 0o300);
+        let mut changed = empty_doc();
+        changed.name = "saved without previews".into();
+        let result = writer.save_dir(&changed, &bundle, &SaveOptions::default());
+        drop(restricted);
+        result.expect("saving without previews does not read composite");
+        assert_eq!(load_path(&bundle).unwrap(), changed);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn directory_save_cleans_stale_previews_through_search_only_root_and_composite() {
+        let root = temp_dir("bundle-search-only");
+        let bundle = root.join("project.pcraft");
+        let link = root.join("linked.pcraft");
+        let mut writer = PcraftWriter::new();
+        writer.save_dir(&empty_doc(), &bundle, &SaveOptions::default()).unwrap();
+        symlink(&bundle, &link).unwrap();
+        std::fs::write(bundle.join("thumb.png"), b"stale thumbnail").unwrap();
+        std::fs::write(bundle.join("composite/preview.png"), b"stale composite").unwrap();
+        let orphan = bundle.join("blobs").join(format!("{}.zst", "a".repeat(64)));
+        std::fs::write(&orphan, b"unreferenced object").unwrap();
+        let composite_mode = RestoreMode::set(&bundle.join("composite"), 0o300);
+        let root_mode = RestoreMode::set(&bundle, 0o300);
+        let mut changed = empty_doc();
+        changed.name = "saved through linked root".into();
+        let result = writer.save_dir(&changed, &link, &SaveOptions::default());
+        drop(root_mode);
+        drop(composite_mode);
+        let stats = result.expect("cleanup needs directory traversal and write permission, not read");
+        assert_eq!(stats.objects_removed, 1);
+        assert!(!orphan.exists());
+        assert!(!bundle.join("thumb.png").exists());
+        assert!(!bundle.join("composite/preview.png").exists());
+        assert_eq!(load_path(&bundle).unwrap(), changed);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn directory_save_writes_current_preview_without_composite_read_permission() {
+        let root = temp_dir("preview-search-only");
+        let bundle = root.join("project.pcraft");
+        let mut writer = PcraftWriter::new();
+        writer.save_dir(&empty_doc(), &bundle, &SaveOptions::default()).unwrap();
+        let restricted = RestoreMode::set(&bundle.join("composite"), 0o300);
+        let mut changed = empty_doc();
+        changed.name = "saved with preview".into();
+        let opts = SaveOptions { composite: Some(Rgba8Image::new(2, 2)), ..Default::default() };
+        let result = writer.save_dir(&changed, &bundle, &opts);
+        drop(restricted);
+        result.expect("writing a preview does not require listing its directory");
+        assert!(std::fs::read(bundle.join("composite/preview.png")).unwrap().starts_with(b"\x89PNG\r\n\x1a\n"));
+        assert_eq!(load_path(&bundle).unwrap(), changed);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn denied_stale_preview_cleanup_preserves_the_previous_manifest() {
+        let root = temp_dir("denied-preview-cleanup");
+        let bundle = root.join("project.pcraft");
+        let mut writer = PcraftWriter::new();
+        let original = empty_doc();
+        writer.save_dir(&original, &bundle, &SaveOptions::default()).unwrap();
+        let preview = bundle.join("composite/preview.png");
+        std::fs::write(&preview, b"stale composite").unwrap();
+        let restricted = RestoreMode::set(&bundle.join("composite"), 0o500);
+        let permission_probe = bundle.join("composite/permission-probe");
+        if std::fs::write(&permission_probe, b"probe").is_ok() {
+            // An elevated test process may bypass directory permissions.
+            std::fs::remove_file(permission_probe).unwrap();
+            drop(restricted);
+            std::fs::remove_dir_all(root).unwrap();
+            return;
+        }
+        let mut changed = empty_doc();
+        changed.name = "must not commit".into();
+        let result = writer.save_dir(&changed, &bundle, &SaveOptions::default());
+        drop(restricted);
+        assert!(result.is_err(), "a required pre-commit cleanup failure is reported");
+        assert_eq!(std::fs::read(preview).unwrap(), b"stale composite");
+        assert_eq!(load_path(&bundle).unwrap(), original);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn denied_object_cleanup_remains_best_effort_after_manifest_commit() {
+        let root = temp_dir("denied-object-cleanup");
+        let bundle = root.join("project.pcraft");
+        let mut writer = PcraftWriter::new();
+        writer.save_dir(&empty_doc(), &bundle, &SaveOptions::default()).unwrap();
+        let orphan = bundle.join("tiles").join(format!("{}.zst", "d".repeat(64)));
+        std::fs::write(&orphan, b"unreferenced object").unwrap();
+        let restricted = RestoreMode::set(&bundle.join("tiles"), 0o500);
+        let permission_probe = bundle.join("tiles/permission-probe");
+        if std::fs::write(&permission_probe, b"probe").is_ok() {
+            std::fs::remove_file(permission_probe).unwrap();
+            drop(restricted);
+            std::fs::remove_dir_all(root).unwrap();
+            return;
+        }
+        let mut changed = empty_doc();
+        changed.name = "committed despite housekeeping failure".into();
+        let result = writer.save_dir(&changed, &bundle, &SaveOptions::default());
+        drop(restricted);
+        assert_eq!(result.unwrap().objects_removed, 0);
+        assert!(orphan.exists());
+        assert_eq!(load_path(&bundle).unwrap(), changed);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+}
diff --git a/crates/format/tests/roundtrip.rs b/crates/format/tests/roundtrip.rs
index 42dbfae5c3..8b74a00c4b 100644
--- a/crates/format/tests/roundtrip.rs
+++ b/crates/format/tests/roundtrip.rs
@@ -541,6 +541,27 @@ fn text_kerning_roundtrips_and_defaults() {
     assert!(s.contains("\"kern\":0.0"), "kern defaults to 0");
 }
 
+/// Type on a path (#218): the path, start offset and flip survive .pcraft.
+#[test]
+fn path_text_shape_roundtrips() {
+    use photocraft_doc::text::TextShape;
+    use photocraft_doc::vector::Subpath;
+    let mut doc = rich_doc(ColorMode::Rgb, SampleType::U8);
+    let path = Subpath::polyline(&[(0.0, 0.0), (50.0, 20.0), (120.0, 5.5)]);
+    let ids: Vec<LayerId> = doc.walk().into_iter().filter(|(_, _, l)| matches!(l.content, LayerContent::Text(_))).map(|(_, _, l)| l.id).collect();
+    for id in ids {
+        if let Some(LayerContent::Text(t)) = doc.layer_mut(id).map(|l| &mut l.content) {
+            t.shape = TextShape::Path { path: path.clone(), start: 12.5, flip: true };
+        }
+    }
+    let back = load_from_bytes(&save_to_bytes(&doc, &SaveOptions::default()).unwrap()).unwrap();
+    let shape = back.walk().into_iter().find_map(|(_, _, l)| match &l.content {
+        LayerContent::Text(t) => Some(t.shape.clone()),
+        _ => None,
+    });
+    assert_eq!(shape, Some(TextShape::Path { path, start: 12.5, flip: true }));
+}
+
 #[test]
 fn channel_restrictions_and_bevel_elements_roundtrip() {
     use photocraft_doc::{Bevel, BevelContour, BevelTexture, Contour, Effect};
diff --git a/crates/gpu/src/compose.wgsl b/crates/gpu/src/compose.wgsl
index c6a0edbd57..e9d1b370ca 100644
--- a/crates/gpu/src/compose.wgsl
+++ b/crates/gpu/src/compose.wgsl
@@ -51,6 +51,7 @@ const F_LAB: u32 = 65536u;      // Lab document: Normal mixes in CIELAB
 const F_HDR: u32 = 262144u;     // 32-bit float document: HDR blends and Exposure retain values above 1
 const F_QUANT: u32 = 32768u;    // lerp: A rounded to p0.x steps (adjustment results, integer docs)
 const F_ADD_DIFF: u32 = 16384u;  // lerp: A + (B - C) premultiplied (clips on pass-through groups)
+const F_BLEND_IF: u32 = 524288u; // lerp: B back towards A by the Blend If ranges in p0..p3
 const F_TEXT_GAMMA: u32 = 8192u; // blend / atop / fx merge: type layer, mix coverage at gamma p4.w
 
 @group(0) @binding(0) var<uniform> chunk: Chunk;
@@ -527,7 +528,12 @@ fn color_lookup(c: vec3<f32>, n: i32, tetra: bool) -> vec3<f32> {
 fn selective_row(r: i32, w: f32, c: vec3<f32>, relative: bool) -> vec3<f32> {
     let k = lut_at(r * 4 + 3) / 100.0;
     var d = vec3(lut_at(r * 4), lut_at(r * 4 + 1), lut_at(r * 4 + 2)) / 100.0 + k;
-    if (relative) { d = d * (1.0 - c); }
+    if (relative) {
+        d = d * (1.0 - c);
+    } else {
+        // Absolute: scaled by the room the ink has (adding: 2 × (1 − ink), removing: 2 × ink, capped at 1).
+        d = d * select(min(2.0 * (1.0 - c), vec3(1.0)), min(2.0 * c, vec3(1.0)), d > vec3(0.0));
+    }
     return select(vec3(0.0), d * w, w > 0.0);
 }
 
@@ -622,30 +628,41 @@ fn adjust(c: vec3<f32>) -> vec3<f32> {
             let hsl = rgb_to_hsl(c);
             var hh: f32;
             var ss: f32;
-            // Range edits (LUT rows indexed by the original hue, faded out towards grey).
+            // Range edits (LUT rows indexed by the original hue), in full however dull the colour.
             var dh = 0.0;
             var ds = 0.0;
             var dl = 0.0;
             if (p1.x > 0.5) {
-                let chroma = min((max(c.r, max(c.g, c.b)) - min(c.r, min(c.g, c.b))) * 4.0, 1.0);
-                dh = lut(0, hsl.x) * chroma;
-                ds = lut(1, hsl.x) * chroma;
-                dl = lut(2, hsl.x) * chroma;
+                dh = lut(0, hsl.x);
+                ds = lut(1, hsl.x);
+                dl = lut(2, hsl.x);
             }
             let sat = clamp(p0.y + ds, -1.0, 1.0);
-            let light = clamp(p0.z + dl, -1.0, 1.0);
+            let light = clamp(p0.z, -1.0, 1.0);
             if (p0.w > 0.5) {
-                hh = rem_euclid(p0.x, 360.0) / 360.0;
-                ss = min(abs(sat), 1.0);
-            } else {
-                hh = rem_euclid(hsl.x + (p0.x + dh) / 360.0, 1.0);
-                ss = clamp(hsl.y * (1.0 + sat), 0.0, 1.0);
+                // compose::adjust::hue_saturation: Colorize at the lightened / darkened lightness.
+                var ll = hsl.z * (1.0 + light);
+                if (light > 0.0) { ll = hsl.z + (1.0 - hsl.z) * light; }
+                return hsl_to_rgb(rem_euclid(p0.x, 360.0) / 360.0, min(abs(sat), 1.0), ll);
             }
-            var rgb = hsl_to_rgb(hh, ss, hsl.z);
-            if (light > 0.0) {
-                rgb = rgb + (1.0 - rgb) * light;
-            } else if (light < 0.0) {
-                rgb = rgb * (1.0 + light);
+            // Lightness first, then hue and saturation of the result.
+            var lc = c * (1.0 + light);
+            if (light > 0.0) { lc = c + (1.0 - c) * light; }
+            let lh = rgb_to_hsl(lc);
+            hh = rem_euclid(lh.x + (p0.x + dh) / 360.0, 1.0);
+            // Raising saturation divides by 1 - s; lowering it multiplies by 1 + s.
+            if (sat > 0.0) {
+                ss = clamp(lh.y / max(1.0 - sat, 1.0 / 512.0), 0.0, 1.0);
+            } else {
+                ss = clamp(lh.y * (1.0 + sat), 0.0, 1.0);
+            }
+            var rgb = hsl_to_rgb(hh, ss, lh.z);
+            // compose::adjust::range_lightness: towards the brightest channel when raised, the darkest when lowered.
+            let rl = clamp(dl, -1.0, 1.0);
+            if (rl > 0.0) {
+                rgb = rgb + (vec3(max(rgb.r, max(rgb.g, rgb.b))) - rgb) * rl;
+            } else if (rl < 0.0) {
+                rgb = rgb + (vec3(min(rgb.r, min(rgb.g, rgb.b))) - rgb) * -rl;
             }
             return rgb;
         }
@@ -686,7 +703,7 @@ fn adjust(c: vec3<f32>) -> vec3<f32> {
             if (c.b <= c.r && c.b <= c.g) { secondary = 1; } else if (c.r <= c.g) { secondary = 3; }
             let g = clamp(mn + (mid - mn) * w[secondary] / 100.0 + (mx - mid) * w[primary] / 100.0, 0.0, 1.0);
             if (p1.z > 0.5) {
-                return clamp(g * p2.rgb * 2.0, vec3(0.0), vec3(1.0)) * 0.5 + g * 0.5;
+                return clamp(set_lum(p2.rgb, g, 1.0), vec3(0.0), vec3(1.0));   // Color blend of the tint
             }
             return vec3(g);
         }
@@ -858,6 +875,21 @@ fn fs_lerp(in: VOut) -> @location(0) vec4<f32> {
         if (al <= 0.0) { return vec4(0.0); }
         return vec4(clamp(pm.rgb / al, vec3(0.0), vec3(1.0)), al);
     }
+    if ((op.flags & F_BLEND_IF) != 0u) {
+        // compose::apply_blend_if: "This Layer" is C (the layer's own content with its masks),
+        // or B itself for an adjustment layer; "Underlying Layer" is A.
+        var this_px = b;
+        if (op.p4.y < 0.5) {
+            this_px = textureLoad(tex_c, p, 0);
+        }
+        let k = blend_if_weight(this_px, a);
+        if (k >= 1.0) {
+            return b;
+        }
+        let alpha = a.a + (b.a - a.a) * k;
+        if (alpha <= 0.0) { return vec4(0.0); }
+        return vec4(clamp((a.rgb * a.a + (b.rgb * b.a - a.rgb * a.a) * k) / alpha, vec3(0.0), vec3(1.0)), alpha);
+    }
     let k = op.opacity * mask_value(doc_px(p));
     let wa = a.a * (1.0 - k);
     let wb = b.a * k;
@@ -866,6 +898,57 @@ fn fs_lerp(in: VOut) -> @location(0) vec4<f32> {
     return vec4((a.rgb * wa + b.rgb * wb) / alpha, alpha);
 }
 
+// ---- Blend If (photocraft_doc::BlendRange, compose::blend_if_weight) ---------------------------
+
+// 0 at or below `lo`, 1 at or above `hi`; a hard step at `lo` when unsplit.
+fn bi_ramp(lo: f32, hi: f32, x: f32) -> f32 {
+    if (hi <= lo) {
+        return select(0.0, 1.0, x >= lo);
+    }
+    return clamp((x - lo) / (hi - lo), 0.0, 1.0);
+}
+
+// How much of value `v` (0..255) shows through range `e` (0 = Gray, then the channels) on side
+// `s` (0 = this layer, 1 = underlying). The ranges are packed by `plan::blend_if_params`.
+fn bi_weight(e: u32, s: u32, v: f32) -> f32 {
+    var f = array<vec4<f32>, 4>(op.p0, op.p1, op.p2, op.p3);
+    let i = (e * 2u + s) * 2u;
+    let black = f[i / 4u][i % 4u];
+    let white = f[(i + 1u) / 4u][(i + 1u) % 4u];
+    let b_lo = floor(black / 256.0);
+    let b_hi = black - b_lo * 256.0;
+    let w_lo = floor(white / 256.0);
+    let w_hi = white - w_lo * 256.0;
+    return bi_ramp(b_lo, b_hi, v) * bi_ramp(255.0 - w_hi, 255.0 - w_lo, 255.0 - v);
+}
+
+// The product of every range over the layer's own colour and the colour beneath it (a side
+// without content, alpha 0, doesn't count). `p4.x` marks a one-channel document.
+fn blend_if_weight(this_px: vec4<f32>, under: vec4<f32>) -> f32 {
+    var k = 1.0;
+    for (var s = 0u; s < 2u; s = s + 1u) {
+        let px = select(this_px, under, s == 1u);
+        if (px.a <= 0.0) {
+            continue;
+        }
+        // The CPU gets 8- and 16-bit levels exactly (k / 255 × 255 = k), but GPU arithmetic can
+        // land a few millionths below, which flips a hard threshold at that level: values that
+        // close to a level are that level. Real 8/16-bit values off a level are ≥ 1/257 away.
+        let raw = clamp(px.rgb, vec3(0.0), vec3(1.0)) * 255.0;
+        let v = select(raw, round(raw), abs(raw - round(raw)) < vec3(1e-4));
+        if (op.p4.x > 0.5) {
+            k = k * bi_weight(0u, s, v.r) * bi_weight(1u, s, v.r);
+        } else {
+            let gray = 0.299 * v.r + 0.587 * v.g + 0.114 * v.b;
+            k = k * bi_weight(0u, s, gray) * bi_weight(1u, s, v.r) * bi_weight(2u, s, v.g) * bi_weight(3u, s, v.b);
+        }
+        if (k <= 0.0) {
+            return 0.0;
+        }
+    }
+    return k;
+}
+
 // ---- layer effects (compose::effects::composite_with_effects) -------------------------------
 
 const INSIDE_EPS: f32 = 0.5 / 255.0;
@@ -1152,31 +1235,33 @@ fn fs_mblur(in: VOut) -> @location(0) vec4<f32> {
     return mout(acc);
 }
 
-// Precise glow from a distance map: p0 = (solid, soft, invert).
+// Precise glow from a distance map (`effects::glow_map`): p0 = (solid, soft). Coverage is 0.5 at
+// the edge falling to 0 at `size + 1` px centre to centre (the field is 0.5 px short of that),
+// solid within the spread / choke.
 @fragment
 fn fs_mglow(in: VOut) -> @location(0) vec4<f32> {
-    let d = textureLoad(tex_a, local(in.pos), 0).r;
-    var m = clamp(1.0 - (d - op.p0.x) / op.p0.y, 0.0, 1.0);
+    let d = textureLoad(tex_a, local(in.pos), 0).r + 0.5;
+    var m = 0.5 * clamp(1.0 - (d - op.p0.x) / op.p0.y, 0.0, 1.0);
     if (d <= op.p0.x) { m = 1.0; }
-    if (op.p0.z > 0.5) { m = 1.0 - m; }
     return mout(m);
 }
 
-// Last step of a coverage map: p0 = (|A - B| (satin), 1 - v, contour (LUT row 0), × shape
-// (`layer_tex`)).
+// Last step of a coverage map: p0 = (|A - B| (satin), 1 - v (1: before the contour, 2: after it,
+// as a centre-source inner glow), contour (LUT row 0), × shape (`layer_tex`)).
 @fragment
 fn fs_mfinish(in: VOut) -> @location(0) vec4<f32> {
     let p = local(in.pos);
     var v = textureLoad(tex_a, p, 0).r;
     if (op.p0.x > 0.5) { v = abs(v - textureLoad(tex_b, p, 0).r); }
-    if (op.p0.y > 0.5) { v = 1.0 - v; }
+    if (op.p0.y > 0.5 && op.p0.y < 1.5) { v = 1.0 - v; }
     if (op.p0.z > 0.5) { v = lut(0, v); }
+    if (op.p0.y > 1.5) { v = 1.0 - v; }
     if (op.p0.w > 0.5) { v = v * textureLoad(layer_tex, p, 0).r; }
     return mout(v);
 }
 
 // Chiselled bevel height from A = dist_inside, B = dist_outside (`effects::bevel_chisel_h`):
-// p0 = (paint (0 outer, 1 both / emboss, 2 inner), size).
+// p0 = (paint (0 outer, 1 both / emboss, 2 inner), size, Chisel Soft).
 @fragment
 fn fs_mbevelh(in: VOut) -> @location(0) vec4<f32> {
     let p = local(in.pos);
@@ -1184,16 +1269,33 @@ fn fs_mbevelh(in: VOut) -> @location(0) vec4<f32> {
     let dout = textureLoad(tex_b, p, 0).r;
     let size = op.p0.y;
     var h: f32;
+    // The ramp spans size + 1 px, from half a pixel beyond the edge (`effects::bevel_chisel_h`).
+    let ramp = size + 1.0;
+    let soft = op.p0.z > 0.5;
     switch i32(op.p0.x) {
-        case 0: { h = 1.0 - clamp(dout / size, 0.0, 1.0); }
-        case 1: {
-            if (din > 0.0) {
-                h = 0.5 + 0.5 * clamp(din / (size / 2.0), 0.0, 1.0);
+        case 0: {
+            if (soft) {
+                h = select((size + 2.0) / ramp, 1.0 - clamp((dout + 0.5) / ramp, 0.0, 1.0), dout > 0.0);
             } else {
-                h = 0.5 - 0.5 * clamp(dout / (size / 2.0), 0.0, 1.0);
+                let top = (size + 2.0) / ramp;
+                h = select(top, clamp((size + 1.5 - dout) / ramp, 0.0, top), dout > 0.0);
+            }
+        }
+        case 1: {
+            let half = size / 2.0 + 0.5;
+            if (din > 0.0) {
+                h = 0.5 + 0.5 * clamp(din / half, 0.0, 1.0);
+            } else {
+                h = 0.5 - 0.5 * clamp(dout / half, 0.0, 1.0);
+            }
+        }
+        default: {
+            if (soft) {
+                h = select(0.0, clamp((din + 1.5) / ramp, 0.0, (size + 2.0) / ramp), din > 0.0);
+            } else {
+                h = select(0.0, clamp((din + 0.5) / ramp, 0.0, 1.0), din > 0.0);
             }
         }
-        default: { h = clamp(din / size, 0.0, 1.0); }
     }
     return mout(h);
 }
@@ -1207,7 +1309,8 @@ fn fs_mbevelshade(in: VOut) -> @location(0) vec4<f32> {
     // effects::bevel_maps' on_bevel: the height above BEVEL_H_EPS (emboss styles: or a
     // 4-neighbour's).
     var hmax = ra(p);
-    if (op.p1.y > 1.5) {
+    // p3.x: an outer chisel bevel, which also reaches one pixel past its ramp.
+    if (op.p1.y > 1.5 || op.p3.x > 0.5) {
         hmax = max(max(hmax, max(ra(p + vec2(1, 0)), ra(p - vec2(1, 0)))), max(ra(p + vec2(0, 1)), ra(p - vec2(0, 1))));
     }
     let outside = select(0.0, 1.0, s < 1.0 - INSIDE_EPS && hmax > 1e-5);
diff --git a/crates/gpu/src/fx.rs b/crates/gpu/src/fx.rs
index 48da34240e..2149aaa412 100644
--- a/crates/gpu/src/fx.rs
+++ b/crates/gpu/src/fx.rs
@@ -236,6 +236,19 @@ impl B {
     fn finish(&mut self, a: In, b: Option<In>, invert: bool, contour: &Contour, times_shape: bool, out: usize) {
         self.finish_lut(a, b, invert, contour_lut(contour), times_shape, out);
     }
+    /// A glow's last step: its contour over the Range, then (centre-source inner glows) the
+    /// inverse, then × the shape when inner.
+    fn finish_glow(&mut self, a: In, lut: Option<Vec<f32>>, inner: bool, center: bool) {
+        let mut s =
+            stage(Kernel::MFinish, Some(a), None, [0.0, if center { 2.0 } else { 0.0 }, f32::from(u8::from(lut.is_some())), f32::from(u8::from(inner))], 0);
+        s.lut = lut.map(Arc::new);
+        if inner {
+            s.s = Some(In::Shape);
+        }
+        s.out = Some(0);
+        self.stages.push(s);
+    }
+
     fn finish_lut(&mut self, a: In, b: Option<In>, invert: bool, lut: Option<Vec<f32>>, times_shape: bool, out: usize) {
         let flag = |v: bool| f32::from(u8::from(v));
         let mut s = stage(Kernel::MFinish, Some(a), b, [flag(b.is_some()), flag(invert), flag(lut.is_some()), flag(times_shape)], 0);
@@ -319,9 +332,9 @@ pub(crate) fn program_with(e: &Effect, light: &GlobalLight, vector_shape: bool,
                 GlowTechnique::Precise => {
                     let d = b.field(if inner { FieldKind::Inside } else { FieldKind::Outside }, g.size);
                     let solid = g.size * g.spread;
-                    let soft = (g.size - solid).max(1e-3);
-                    let m = b.push(stage(Kernel::MGlow, Some(d), None, [solid, soft, f32::from(u8::from(center)), 0.0], 0));
-                    b.finish_lut(m, None, false, photocraft_compose::effects::glow_lut(g), inner, 0);
+                    let soft = (g.size + 1.0 - solid).max(1e-3);
+                    let m = b.push(stage(Kernel::MGlow, Some(d), None, [solid, soft, 0.0, 0.0], 0));
+                    b.finish_glow(m, photocraft_compose::effects::glow_lut(g), inner, center);
                 }
                 GlowTechnique::Softer => {
                     // Inner glows (edge, and centre as 1 - the edge result) spread 1 - alpha.
@@ -333,19 +346,19 @@ pub(crate) fn program_with(e: &Effect, light: &GlobalLight, vector_shape: bool,
                         m = b.dilate(src, d, r);
                     }
                     let m = b.blur(m, bw);
-                    b.finish_lut(m, None, center, photocraft_compose::effects::glow_lut(g), inner, 0);
+                    b.finish_glow(m, photocraft_compose::effects::glow_lut(g), inner, center);
                 }
             }
             1
         }
         Effect::Satin(s) => {
             // satin_map
-            let (dx, dy) = offset(s.angle, s.distance);
+            let (dx, dy) = offset(s.angle, photocraft_compose::effects::satin_distance(s));
             let a = b.shift(In::Shape, dx, dy, 0.0, false);
             let a = b.conv(a, photocraft_compose::effects::tent_kernel(s.size));
             let c = b.shift(In::Shape, -dx, -dy, 0.0, false);
             let c = b.conv(c, photocraft_compose::effects::tent_kernel(s.size));
-            b.finish(a, Some(c), s.invert, &s.contour, true, 0);
+            b.finish_lut(a, Some(c), s.invert, photocraft_compose::effects::satin_lut(&s.contour), true, 0);
             1
         }
         Effect::BevelEmboss(bv) => {
@@ -363,8 +376,10 @@ pub(crate) fn program_with(e: &Effect, light: &GlobalLight, vector_shape: bool,
             } else {
                 let din = b.field(FieldKind::BevelInside, size);
                 let dout = b.field(FieldKind::BevelOutside, size);
-                let h = b.push(stage(Kernel::MBevelH, Some(din), Some(dout), [paint(g.paint), size, 0.0, 0.0], 0));
-                if g.chisel_soft > 0.0 { b.conv(h, photocraft_compose::effects::tent_kernel(g.chisel_soft)) } else { h }
+                let soft = g.chisel_soft > 0.0;
+                let h = b.push(stage(Kernel::MBevelH, Some(din), Some(dout), [paint(g.paint), size, f32::from(u8::from(soft)), 0.0], 0));
+                // As `effects::bevel_height`: only emboss styles blur a Chisel Soft ramp.
+                if soft && g.paint == BevelPaint::Both { b.conv(h, photocraft_compose::effects::tent_kernel(g.chisel_soft)) } else { h }
             };
             if let Some(c) = &bv.contour {
                 // Contour element: the height through the contour (`bevel_contour_lut`).
@@ -374,7 +389,7 @@ pub(crate) fn program_with(e: &Effect, light: &GlobalLight, vector_shape: bool,
                 h = b.push(st);
             }
             if let Some(t) = &bv.texture
-                && let Some(pat) = photocraft_doc::pattern::find(patterns, &t.id, &t.name).filter(|p| !p.is_empty())
+                && let Some(pat) = photocraft_doc::pattern::find(patterns, &t.id, &t.name).filter(|p| p.is_paintable())
             {
                 // Texture element (`effects::bevel_height`): luminance × depth / unit added.
                 let unit = if bv.depth.abs() > 1e-6 { (g.depth / bv.depth).abs().max(1e-3) } else { g.width.max(1.0) };
@@ -405,6 +420,7 @@ pub(crate) fn program_with(e: &Effect, light: &GlobalLight, vector_shape: bool,
                 for which in [0.0, 1.0] {
                     let mut s = stage(Kernel::MBevelShade, Some(h), None, [ca * ce, -sa * ce, se, se], 1);
                     s.p1 = [*depth, *region, which, f32::from(u8::from(lut.is_some()))];
+                    s.p3 = [f32::from(u8::from(g.paint == BevelPaint::Outer && bv.technique != BevelTechnique::Smooth)), 0.0, 0.0, 0.0];
                     s.lut = lut.clone();
                     s.s = Some(In::Shape);
                     s.out = Some(out);
@@ -418,7 +434,15 @@ pub(crate) fn program_with(e: &Effect, light: &GlobalLight, vector_shape: bool,
             // composite_with_effects' stroke bands (maps 0 outside, 1 inside)
             let (in_w, out_w) = stroke_widths(st);
             if out_w > 0.0 {
-                let d = b.field(if vector_shape { FieldKind::StrokeOutsideVector } else { FieldKind::StrokeOutside }, out_w);
+                // Narrow strokes keep the fitted chamfer, wide ones the exact transform (#3646);
+                // the CPU picks the same field by the same width (`stroke_outside_exact`).
+                let kind = match (vector_shape, photocraft_compose::effects::stroke_outside_exact(out_w)) {
+                    (true, true) => FieldKind::StrokeOutsideVector,
+                    (true, false) => FieldKind::StrokeOutsideVectorChamfer,
+                    (false, true) => FieldKind::StrokeOutsideExact,
+                    (false, false) => FieldKind::StrokeOutside,
+                };
+                let d = b.field(kind, out_w);
                 let mut s = stage(Kernel::MStroke, Some(d), None, [out_w, 0.0, 0.0, 0.0], 0);
                 s.out = Some(0);
                 b.stages.push(s);
@@ -506,7 +530,8 @@ pub(crate) fn field(kind: FieldKind, reach: i32, shape: &[f32], region: Rect, ou
 /// (the chamfer fields, a sequential sweep) the window is cut into bands that go in parallel. Without
 /// threads (wasm) there is nothing to spread over, and bands keep the memory small.
 fn threaded_inside(kind: FieldKind) -> bool {
-    !cfg!(target_arch = "wasm32") && matches!(kind, FieldKind::Outside | FieldKind::Inside | FieldKind::BevelOutside | FieldKind::BevelInside)
+    !cfg!(target_arch = "wasm32")
+        && matches!(kind, FieldKind::Outside | FieldKind::Inside | FieldKind::BevelOutside | FieldKind::BevelInside | FieldKind::StrokeOutsideExact)
 }
 
 /// [`field`] with the halo given (the tests shrink it to see that they notice).
@@ -732,7 +757,9 @@ mod tests {
             FieldKind::ChokeInside,
             FieldKind::StrokeOutside,
             FieldKind::StrokeInside,
+            FieldKind::StrokeOutsideExact,
             FieldKind::StrokeOutsideVector,
+            FieldKind::StrokeOutsideVectorChamfer,
         ] {
             let reach = 9;
             let whole = photocraft_compose::effects::distance_field(kind, shape.clone(), w, h, reach as f32);
@@ -809,4 +836,42 @@ mod tests {
         }
         assert!(too_small_noticed, "a 2 row halo went unnoticed, so this test guards nothing");
     }
+
+    /// #3646: a stroke's outer edge is the fitted 5 × 5 chamfer while it is narrow and the exact
+    /// Euclidean transform once it is wide — the chamfer's octagon facets a wide stroke. The GPU
+    /// builds it from the field its width picks (`stroke_outside_exact`), while the spread of drop
+    /// shadows and softer outer glows keeps the chamfer field (fitted to Photoshop, #224) — so
+    /// routing a wide stroke through the chamfer, or a shadow through the exact field, fails here.
+    #[test]
+    fn a_stroke_uses_the_chamfer_narrow_and_the_exact_field_wide() {
+        use photocraft_color::{BlendMode, Color};
+        use photocraft_doc::{FxCommon, FxPaint, StrokeFx, StrokePosition};
+        let light = GlobalLight::default();
+        let stroke =
+            |size, position| Effect::Stroke(StrokeFx { common: FxCommon::new(BlendMode::Normal, 1.0), size, position, paint: FxPaint::Color(Color::BLACK) });
+        // Narrow (< STROKE_CHAMFER_MAX): the chamfer, exactly as before #3646.
+        let narrow = program(&stroke(6.0, StrokePosition::Outside), &light, false);
+        assert!(narrow.fields.iter().any(|(k, _)| *k == FieldKind::StrokeOutside), "a narrow raster outside stroke keeps the chamfer: {:?}", narrow.fields);
+        assert!(!narrow.fields.iter().any(|(k, _)| *k == FieldKind::StrokeOutsideExact), "…not the exact field: {:?}", narrow.fields);
+        // Wide: the exact transform.
+        let wide = program(&stroke(40.0, StrokePosition::Outside), &light, false);
+        assert!(
+            wide.fields.iter().any(|(k, _)| *k == FieldKind::StrokeOutsideExact),
+            "a wide raster outside stroke needs the exact outer field: {:?}",
+            wide.fields
+        );
+        assert!(!wide.fields.iter().any(|(k, _)| *k == FieldKind::StrokeOutside), "…not the chamfer field: {:?}", wide.fields);
+        // A shape layer's outline stroke follows the same width rule; the inside edge keeps the chamfer.
+        let vector_narrow = program(&stroke(6.0, StrokePosition::Outside), &light, true);
+        assert!(vector_narrow.fields.iter().any(|(k, _)| *k == FieldKind::StrokeOutsideVectorChamfer), "{:?}", vector_narrow.fields);
+        let vector_wide = program(&stroke(40.0, StrokePosition::Outside), &light, true);
+        assert!(vector_wide.fields.iter().any(|(k, _)| *k == FieldKind::StrokeOutsideVector), "{:?}", vector_wide.fields);
+        let inner = program(&stroke(40.0, StrokePosition::Inside), &light, false);
+        assert!(inner.fields.iter().any(|(k, _)| *k == FieldKind::StrokeInside), "{:?}", inner.fields);
+        // The shadow / softer-glow spread is unchanged: still the chamfer.
+        let Effect::DropShadow(mut s) = Effect::default_drop_shadow() else { unreachable!() };
+        s.spread = 0.5;
+        let shadow = program(&Effect::DropShadow(s), &light, false);
+        assert!(shadow.fields.iter().any(|(k, _)| *k == FieldKind::StrokeOutside), "the shadow spread keeps the chamfer: {:?}", shadow.fields);
+    }
 }
diff --git a/crates/gpu/src/lib.rs b/crates/gpu/src/lib.rs
index 2efd7f6a49..223d4ed983 100644
--- a/crates/gpu/src/lib.rs
+++ b/crates/gpu/src/lib.rs
@@ -82,6 +82,12 @@ const FLUSH_BYTES: u64 = 512 << 20;
 /// command buffer holding a whole huge refresh can run for seconds, long enough for the OS to
 /// reset the GPU.
 const FLUSH_WORK: u64 = 1 << 30;
+/// Copies and render passes [`Compositor::render`] records before submitting. wgpu opens up to
+/// two backend command buffers for each (a render pass and its barrier pre-pass), and Metal
+/// treats more than 4096 outstanding ones as a lost device: a refresh of a document with a few
+/// hundred layers reached that inside a single page cell (P12, "pc_compose_uniforms is
+/// invalid"), where the work and byte limits above never trigger.
+const FLUSH_OPS: u32 = 1000;
 
 /// A finished chunk: straight-alpha RGBA32F pixels of `rect` (document coordinates) at the
 /// texture's origin.
@@ -99,6 +105,9 @@ pub struct Stats {
     pub slots: u32,
     pub tiles_uploaded: usize,
     pub bytes_uploaded: usize,
+    /// Tiles a new layer texture took from another layer's texture by a GPU copy (a duplicate
+    /// shares its source's tiles) instead of uploading them.
+    pub tiles_shared: usize,
     /// Effect layers whose shape was (re)rendered, fully or partially.
     pub fx_shapes: usize,
     /// Effect map programs run (one per effect whose maps were rebuilt).
@@ -169,6 +178,13 @@ type ResKey = (LayerId, Role, Cell);
 /// larger than the texture limit.
 type FxKey = (LayerId, Option<Cell>);
 
+struct CachedPattern {
+    fingerprint: u64,
+    format: PixelFormat,
+    default_bits: Vec<u32>,
+    texture: Tex,
+}
+
 struct Resident {
     texture: wgpu::Texture,
     view: wgpu::TextureView,
@@ -187,6 +203,10 @@ struct Resident {
     stamp: u64,
     /// CMYK profile the texels were converted with (`CmykSpace::id`, 0 = built-in / not CMYK).
     cmyk: u64,
+    /// Its texels were copied to or from another layer texture by the encoder, so every write
+    /// to it goes through the encoder too: a queued write lands before the encoder runs, and
+    /// would be overwritten by the copy, or leak into it.
+    ordered: bool,
 }
 
 impl Resident {
@@ -399,7 +419,7 @@ pub struct Compositor {
     prefix: prefix::Prefix,
     /// Effect temporaries (R32F, region sized) and the frame they were last used.
     temps: Vec<(Tex, u64)>,
-    patterns: HashMap<String, (u64, Tex)>,
+    patterns: HashMap<String, CachedPattern>,
     /// The colour mode of the document being encoded: patterns paint in it
     /// (`photocraft_compose::pattern::pattern_rgba`).
     pattern_mode: photocraft_color::ColorMode,
@@ -422,6 +442,8 @@ pub struct Compositor {
     stamp: u64,
     /// Bytes staged by uploads since the last submit.
     staged: u64,
+    /// Copies and render passes recorded since the last submit.
+    recorded: u32,
     acc_format: wgpu::TextureFormat,
     /// Whether the effect-map pipelines could be built (else documents with layer effects are
     /// [`Unsupported`] and use the CPU compositor).
@@ -495,6 +517,31 @@ fn grid_rects(r: Rect, step: u32) -> Vec<Rect> {
     out
 }
 
+/// Number of rectangles `grid_rects` would produce, without allocating them during preflight.
+fn grid_rect_count(r: Rect, step: u32) -> Result<usize, Unsupported> {
+    if r.is_empty() {
+        return Ok(0);
+    }
+    let s = i64::from(step.max(1));
+    let axis = |lo: i32, hi: i32| usize::try_from((i64::from(hi) - 1).div_euclid(s) - i64::from(lo).div_euclid(s) + 1).ok();
+    axis(r.x0, r.x1).and_then(|x| axis(r.y0, r.y1).and_then(|y| x.checked_mul(y))).ok_or_else(|| Unsupported("GPU compositor chunk count is too large".into()))
+}
+
+/// Host length and GPU capacity for the chunk/pass uniform records, including their u32
+/// dynamic binding offsets. Decline unsupported stacks before an invalid buffer faults the device.
+fn uniform_buffer_len(chunks: usize, passes: usize, limit: u64) -> Result<usize, Unsupported> {
+    let too_large = || Unsupported("GPU compositor uniform buffer is too large".into());
+    let records = chunks.checked_add(passes).and_then(|n| u64::try_from(n).ok()).ok_or_else(too_large)?;
+    let bytes = records.checked_mul(STRIDE).ok_or_else(too_large)?;
+    if bytes > limit {
+        return Err(Unsupported(format!("GPU compositor uniform buffer requires {bytes} bytes; device limit is {limit}")));
+    }
+    if bytes.saturating_sub(STRIDE) > u64::from(u32::MAX) {
+        return Err(Unsupported("GPU compositor uniform offsets exceed u32".into()));
+    }
+    usize::try_from(bytes).map_err(|_| too_large())
+}
+
 /// The reach up to which each distance field must be exact (the largest any program asks for).
 fn field_reaches(progs: &[fx::MapProgram]) -> HashMap<FieldKind, i32> {
     let mut want: HashMap<FieldKind, i32> = HashMap::new();
@@ -505,17 +552,18 @@ fn field_reaches(progs: &[fx::MapProgram]) -> HashMap<FieldKind, i32> {
     want
 }
 
-/// Runs `f` inside validation and internal-error scopes and returns the first error raised.
+/// Runs `f` inside GPU error scopes and returns the first error raised.
 /// Native wgpu reports errors synchronously; where they only arrive asynchronously (WebGPU) none
 /// is reported.
 fn first_error<T>(device: &wgpu::Device, f: impl FnOnce() -> T) -> (T, Option<wgpu::Error>) {
     let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
     let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
+    let memory = device.push_error_scope(wgpu::ErrorFilter::OutOfMemory);
     let out = f();
     let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
     let mut error = None;
     // Scopes pop in reverse order.
-    for pop in [internal.pop(), validation.pop()] {
+    for pop in [memory.pop(), internal.pop(), validation.pop()] {
         if let std::task::Poll::Ready(Some(e)) = std::pin::pin!(pop).poll(&mut cx) {
             error.get_or_insert(e);
         }
@@ -523,6 +571,21 @@ fn first_error<T>(device: &wgpu::Device, f: impl FnOnce() -> T) -> (T, Option<wg
     (out, error)
 }
 
+/// Unwatched native callers need GPU errors to become `Unsupported` instead of reaching wgpu's
+/// default panic handler. Watched callers keep their fault callbacks, which stop work promptly
+/// and update the health flag shared with the canvas.
+fn scoped_work<T>(device: &wgpu::Device, watched: bool, f: impl FnOnce() -> Result<T, Unsupported>) -> Result<T, Unsupported> {
+    // WebGPU errors arrive asynchronously; its callers still use the health callbacks.
+    if watched || cfg!(target_arch = "wasm32") {
+        return f();
+    }
+    let (result, error) = first_error(device, f);
+    match error {
+        Some(error) => Err(Unsupported(format!("GPU work failed: {error}"))),
+        None => result,
+    }
+}
+
 impl Compositor {
     /// Create a compositor with the default accumulation format ([`ACC_FORMAT`]).
     pub fn new(device: &wgpu::Device) -> Self {
@@ -617,6 +680,7 @@ impl Compositor {
             frame: 0,
             stamp: 0,
             staged: 0,
+            recorded: 0,
             acc_format,
             effect_maps: map_error.is_none(),
             cmyk: 0,
@@ -804,6 +868,26 @@ impl Compositor {
         self.prefix.forget(doc);
     }
 
+    /// [`Self::forget_doc`] for every document `keep` rejects: what the compositor holds for
+    /// documents that were closed, however their canvas entry went (#4529).
+    pub fn retain_docs(&mut self, keep: impl Fn(DocId) -> bool) {
+        let mut gone: Vec<DocId> =
+            self.residents.values().map(|r| r.doc).chain(self.fx.values().map(|e| e.doc)).chain(self.prefix.doc()).filter(|d| !keep(*d)).collect();
+        gone.sort_by_key(|d| d.0);
+        gone.dedup();
+        for d in gone {
+            self.forget_doc(d);
+        }
+    }
+
+    /// Documents the compositor holds pages, effect maps or a lower-stack composite for.
+    pub fn held_docs(&self) -> Vec<DocId> {
+        let mut docs: Vec<DocId> = self.residents.values().map(|r| r.doc).chain(self.fx.values().map(|e| e.doc)).chain(self.prefix.doc()).collect();
+        docs.sort_by_key(|d| d.0);
+        docs.dedup();
+        docs
+    }
+
     /// GPU memory held by cached effect maps (bytes).
     pub fn fx_cache_bytes(&self) -> usize {
         self.fx.values().map(FxEntry::bytes).sum()
@@ -834,16 +918,16 @@ impl Compositor {
         region: Rect,
         mut sink: impl FnMut(&mut wgpu::CommandEncoder, ChunkOut<'_>),
     ) -> Result<Stats, Unsupported> {
-        let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("pc_compose") });
-        let stats = match self.encode_inner(device, queue, &mut encoder, doc, region, &mut sink, true) {
-            Ok(stats) => stats,
-            Err(error) => {
-                self.prefix.clear();
-                return Err(error);
-            }
-        };
-        queue.submit([encoder.finish()]);
-        Ok(stats)
+        let result = scoped_work(device, self.health.is_some(), || {
+            let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("pc_compose") });
+            let stats = self.encode_inner(device, queue, &mut encoder, doc, region, &mut sink, true)?;
+            queue.submit([encoder.finish()]);
+            Ok(stats)
+        });
+        if result.is_err() {
+            self.discard_failed_work();
+        }
+        result
     }
 
     /// Like [`Self::render`] but records into `encoder` without submitting.
@@ -856,7 +940,22 @@ impl Compositor {
         region: Rect,
         sink: &mut dyn FnMut(&mut wgpu::CommandEncoder, ChunkOut<'_>),
     ) -> Result<Stats, Unsupported> {
-        self.encode_inner(device, queue, encoder, doc, region, sink, false)
+        let result = scoped_work(device, self.health.is_some(), || self.encode_inner(device, queue, encoder, doc, region, sink, false));
+        if result.is_err() {
+            self.discard_failed_work();
+        }
+        result
+    }
+
+    fn discard_failed_work(&mut self) {
+        // Cache metadata advances while recording. A failed encoder may never execute its
+        // texture uploads or effect maps, so none of those cached pixels can be trusted.
+        self.prefix.clear();
+        self.residents.clear();
+        self.fx.clear();
+        self.patterns.clear();
+        self.temps.clear();
+        self.pool.clear();
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -899,6 +998,14 @@ impl Compositor {
         if region.is_empty() {
             return Ok(stats);
         }
+        let page = self.page;
+        let mut cells = grid_rects(region, page);
+        // Check every actual page cell before uploads, submissions or sink output. A later
+        // cell can need more chunk records than the first; a failure must leave the device healthy.
+        let buffer_limit = device.limits().max_buffer_size;
+        for part in &cells {
+            uniform_buffer_len(grid_rect_count(*part, self.chunk)?, plan.passes.len(), buffer_limit)?;
+        }
         if self.frame == 0 {
             // The first submission after device creation is dropped on some drivers (RADV),
             // which would render the first frame black; land it on an empty buffer instead.
@@ -907,6 +1014,7 @@ impl Compositor {
         self.frame += 1;
         self.stamp += 1;
         self.staged = 0;
+        self.recorded = 0;
 
         // Only render owns submission. A caller may discard encode's command buffer, so it
         // cannot establish (or consume) a checkpoint whose GPU copy might never execute.
@@ -925,8 +1033,6 @@ impl Compositor {
 
         // Page cells; every other frame in reverse, so a repeated full refresh of a document
         // larger than the budget starts with the pages still resident.
-        let page = self.page;
-        let mut cells = grid_rects(region, page);
         if self.frame.is_multiple_of(2) {
             cells.reverse();
         }
@@ -937,9 +1043,7 @@ impl Compositor {
         }
         let flush_bytes = FLUSH_BYTES.min(self.memory_budget() / 8).max(16 << 20);
         stats.cells = cells.len();
-        // The previous intermediate submit (waited for before the next is queued; the web has
-        // no blocking wait and relies on the browser's own scheduling).
-        #[cfg(not(target_arch = "wasm32"))]
+        // The previous intermediate submit (see `submit_batch`).
         let mut last_submit: Option<wgpu::SubmissionIndex> = None;
         // Work recorded and bytes evicted since the last submit.
         let (mut work, mut freed) = (0u64, 0u64);
@@ -958,29 +1062,19 @@ impl Compositor {
             let chunks = grid_rects(part, self.chunk);
             stats.chunks += chunks.len();
             work += part.width() as u64 * part.height() as u64 * plan.passes.len() as u64;
-            self.run_cell(device, queue, encoder, doc.id, &plan, &paged, cell, &fr, &chunks, checkpoint, &mut stats, sink);
+            let mut batch = flush.then_some(&mut last_submit);
+            self.run_cell(device, queue, encoder, doc.id, &plan, &paged, cell, &fr, &chunks, checkpoint, &mut stats, sink, &mut batch);
+            // The device was lost in a submit inside the cell: issue no more work.
+            if let Some(f) = self.fault() {
+                return Err(Unsupported(f.to_string()));
+            }
             let (evicted, bytes) = self.evict();
             stats.evicted += evicted;
             freed += bytes;
-            if flush && (self.staged >= flush_bytes || work >= FLUSH_WORK || freed >= flush_bytes) {
-                // Submit what's recorded, and wait for the previous submit, so at most two
-                // batches of uploads and evicted pages are in flight.
-                let done = std::mem::replace(encoder, device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("pc_compose") }));
-                let index = queue.submit([done.finish()]);
-                #[cfg(not(target_arch = "wasm32"))]
-                if let Some(prev) = last_submit.replace(index) {
-                    match &self.health {
-                        Some(h) => {
-                            h.wait(device, Some(prev));
-                        }
-                        None => {
-                            let _ = device.poll(wgpu::PollType::Wait { submission_index: Some(prev), timeout: None });
-                        }
-                    }
-                }
-                #[cfg(target_arch = "wasm32")]
-                let _ = index;
+            if flush && (self.staged >= flush_bytes || work >= FLUSH_WORK || freed >= flush_bytes || self.recorded >= FLUSH_OPS) {
+                submit_batch(device, queue, encoder, self.health.as_ref(), &mut last_submit);
                 self.staged = 0;
+                self.recorded = 0;
                 work = 0;
                 freed = 0;
                 stats.flushes += 1;
@@ -1135,6 +1229,8 @@ impl Compositor {
         checkpoint: Option<plan::Checkpoint>,
         stats: &mut Stats,
         sink: &mut dyn FnMut(&mut wgpu::CommandEncoder, ChunkOut<'_>),
+        // The previous intermediate submit, when this refresh may submit in between.
+        batch: &mut Option<&mut Option<wgpu::SubmissionIndex>>,
     ) {
         if chunks.is_empty() {
             return;
@@ -1161,7 +1257,8 @@ impl Compositor {
             self.pool.push((t, v));
         }
 
-        // Uniforms: chunk records, then one record per pass.
+        // Uniforms: chunk records, then one record per pass. encode_scoped preflight checked
+        // the length, device capacity and dynamic offsets before any GPU work for this frame.
         let op_base = chunks.len() as u64 * STRIDE;
         let mut data = vec![0u8; (op_base + plan.passes.len() as u64 * STRIDE) as usize];
         for (i, c) in chunks.iter().enumerate() {
@@ -1220,6 +1317,19 @@ impl Compositor {
                 if i < resume {
                     continue;
                 }
+                // Chunk textures, uniforms and bind groups outlive the submit, and the queue
+                // keeps the order, so a chunk may continue in the next command buffer.
+                if self.recorded >= FLUSH_OPS
+                    && let Some(last) = batch.as_deref_mut()
+                {
+                    submit_batch(device, queue, encoder, self.health.as_ref(), last);
+                    self.staged = 0;
+                    self.recorded = 0;
+                    stats.flushes += 1;
+                    if self.fault().is_some() {
+                        return;
+                    }
+                }
                 if resume == 0
                     && let Some(cp) = checkpoint.filter(|cp| cp.pass_end == i)
                     && let Some((src, _)) = self.pool.get(cp.slot as usize)
@@ -1257,10 +1367,12 @@ impl Compositor {
                             },
                             wgpu::Extent3d { width: scissor.width(), height: scissor.height(), depth_or_array_layers: 1 },
                         );
+                        self.recorded += 1;
                         continue;
                     }
                     _ => {}
                 }
+                self.recorded += 1;
                 let target = &self.pool[p.dst as usize].1;
                 let clear = p.kernel == Kernel::Clear;
                 let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@@ -1338,37 +1450,80 @@ impl Compositor {
             });
             let view = texture.create_view(&Default::default());
             let default_nonzero = default_pixel.iter().any(|v| *v != 0.0);
-            let mut r =
-                Resident { texture, view, region, kind, format, tiles: HashMap::new(), default_nonzero, default_bits, doc, last_used: 0, stamp: 0, cmyk };
+            let mut r = Resident {
+                texture,
+                view,
+                region,
+                kind,
+                format,
+                tiles: HashMap::new(),
+                default_nonzero,
+                default_bits: default_bits.clone(),
+                doc,
+                last_used: 0,
+                stamp: 0,
+                cmyk,
+                ordered: false,
+            };
             // Only the region moved (painting past a layer's tiles grows it): keep the texels the
             // old texture already holds instead of converting and uploading every tile again.
             let kept = self.residents.remove(&key).map_or(Rect::EMPTY, |old| keep_overlap(device, queue, &old, &mut r));
-            // A new texture starts zeroed: write the tiles that are present, and the default pixel
-            // where they are missing if it isn't zero. Coordinates sharing a tile (a solid fill,
-            // the default) take one upload and GPU copies (#1774). Kept tiles are brought up to
-            // date below, like those of a resident that didn't move.
-            let mut present = Vec::new();
-            let mut missing = Vec::new();
-            for c in region.tiles().filter(|c| !kept.contains_rect(&c.rect())) {
-                match surface.tile(c) {
-                    Some(t) => present.push((c, t.clone())),
-                    None if default_nonzero => missing.push(c),
-                    None => {}
+            // A new layer whose tiles another resident already holds (a duplicate shares its
+            // source's tiles) starts as a GPU copy of that texture. Duplicating a 20 MP photo
+            // converted and uploaded every tile again.
+            let shares =
+                |o: &Resident| region.tiles().filter(|c| surface.tile(*c).is_some_and(|t| o.tiles.get(c).is_some_and(|ot| Arc::ptr_eq(ot, t)))).count();
+            let donor = self
+                .residents
+                .iter()
+                .filter(|(k, o)| k.1 == key.1 && o.region == region && o.kind == kind && o.format == format && o.cmyk == cmyk && o.default_bits == default_bits)
+                .map(|(k, o)| (shares(o), *k))
+                .filter(|(n, _)| *n > 0)
+                .max_by_key(|(n, _)| *n);
+            if kept.is_empty()
+                && let Some((n, o)) = donor.and_then(|(n, k)| Some((n, self.residents.get_mut(&k)?)))
+            {
+                // Recorded in the frame's encoder, after the writes and copies that brought the
+                // donor up to date ([`keep_overlap`]'s own submission would run before those).
+                o.ordered = true;
+                encoder.copy_texture_to_texture(
+                    o.texture.as_image_copy(),
+                    r.texture.as_image_copy(),
+                    wgpu::Extent3d { width: region.width(), height: region.height(), depth_or_array_layers: 1 },
+                );
+                r.tiles = o.tiles.clone();
+                r.ordered = true;
+                stats.tiles_shared += n;
+            } else {
+                // A new texture starts zeroed: write the tiles that are present, and the default
+                // pixel where they are missing if it isn't zero. Coordinates sharing a tile (a
+                // solid fill, the default) take one upload and GPU copies (#1774). Kept tiles are
+                // brought up to date below, like those of a resident that didn't move.
+                let mut present = Vec::new();
+                let mut missing = Vec::new();
+                for c in region.tiles().filter(|c| !kept.contains_rect(&c.rect())) {
+                    match surface.tile(c) {
+                        Some(t) => present.push((c, t.clone())),
+                        None if default_nonzero => missing.push(c),
+                        None => {}
+                    }
                 }
-            }
-            if !missing.is_empty() {
-                let bytes = convert_tile(surface, None, kind, TileCoord::new(0, 0));
-                self.staged += put_tiles(device, queue, encoder, &r, &missing, &bytes);
-            }
-            let staged = &mut self.staged;
-            convert_tiles(surface, present, kind, |t, cs, bytes| {
-                *staged += put_tiles(device, queue, encoder, &r, cs, bytes);
-                for &c in cs {
-                    stats.tiles_uploaded += 1;
-                    stats.bytes_uploaded += bytes.len();
-                    r.tiles.insert(c, t.clone());
+                if !missing.is_empty() {
+                    let bytes = convert_tile(surface, None, kind, TileCoord::new(0, 0));
+                    self.staged += put_tiles(device, queue, encoder, &r, &missing, &bytes);
                 }
-            });
+                let staged = &mut self.staged;
+                convert_tiles(surface, present, kind, |t, cs, bytes| {
+                    *staged += put_tiles(device, queue, encoder, &r, cs, bytes);
+                    for &c in cs {
+                        stats.tiles_uploaded += 1;
+                        stats.bytes_uploaded += bytes.len();
+                        r.tiles.insert(c, t.clone());
+                    }
+                });
+            }
+            // Tiles the donor held that this surface doesn't, or holds differently, are fixed up
+            // by the pass over the region below.
             self.residents.insert(key, r);
         }
         // Present: inserted above when it was missing or stale.
@@ -1421,10 +1576,15 @@ impl Compositor {
         });
         let mode = self.pattern_mode;
         let key = format!("{}\u{0}{}\u{0}{mode:?}", pat.id, pat.name);
-        if let Some((f, t)) = self.patterns.get(&key)
-            && *f == fp
+        let format = pat.surface.format();
+        // Unstored tiles read the default pixel, interpreted in the source format.
+        let default_bits: Vec<u32> = pat.surface.default_pixel().iter().map(|v| v.to_bits()).collect();
+        if let Some(cached) = self.patterns.get(&key)
+            && cached.fingerprint == fp
+            && cached.format == format
+            && cached.default_bits == default_bits
         {
-            return t.view.clone();
+            return cached.texture.view.clone();
         }
         let (w, h) = (pat.width, pat.height);
         let px = photocraft_compose::pattern::pattern_rgba(pat, mode);
@@ -1437,7 +1597,7 @@ impl Compositor {
             wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
         );
         let v = t.view.clone();
-        self.patterns.insert(key, (fp, t));
+        self.patterns.insert(key, CachedPattern { fingerprint: fp, format, default_bits, texture: t });
         v
     }
 
@@ -1778,6 +1938,33 @@ fn write_tile(queue: &wgpu::Queue, r: &Resident, c: TileCoord, bytes: &[u8]) {
     );
 }
 
+/// Submit what `encoder` recorded and continue in a fresh one, then wait for the previous
+/// intermediate submit (`last`), so at most two batches of uploads and evicted pages are in
+/// flight. The web has no blocking wait and relies on the browser's own scheduling.
+fn submit_batch(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    encoder: &mut wgpu::CommandEncoder,
+    health: Option<&DeviceHealth>,
+    last: &mut Option<wgpu::SubmissionIndex>,
+) {
+    let done = std::mem::replace(encoder, device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("pc_compose") }));
+    let prev = last.replace(queue.submit([done.finish()]));
+    #[cfg(not(target_arch = "wasm32"))]
+    if let Some(prev) = prev {
+        match health {
+            Some(h) => {
+                h.wait(device, Some(prev));
+            }
+            None => {
+                let _ = device.poll(wgpu::PollType::Wait { submission_index: Some(prev), timeout: None });
+            }
+        }
+    }
+    #[cfg(target_arch = "wasm32")]
+    let _ = (prev, health);
+}
+
 /// Distinct tiles converted per parallel batch: bounds the converted bytes held at once (64 tiles
 /// of a 16-bit page are 32 MiB).
 const CONVERT_BATCH: usize = 64;
@@ -1787,7 +1974,9 @@ const CONVERT_BATCH: usize = 64;
 /// a scratch tile and GPU copies from it: writing each one from the CPU sent 387 MB per refresh
 /// of a filled 50 MP 16-bit page (#1774).
 fn put_tiles(device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, r: &Resident, cs: &[TileCoord], bytes: &[u8]) -> u64 {
-    if let [c] = cs {
+    if let [c] = cs
+        && !r.ordered
+    {
         write_tile(queue, r, *c, bytes);
         return bytes.len() as u64;
     }
@@ -2163,6 +2352,17 @@ pub fn render_to_vec_stats(
 mod tests {
     use super::*;
 
+    #[test]
+    fn uniform_buffer_sizes_are_checked_before_allocation() {
+        assert_eq!(uniform_buffer_len(1, 255, 65_536).unwrap(), 65_536);
+        assert!(uniform_buffer_len(1, 255, 65_535).is_err());
+        assert!(uniform_buffer_len(usize::MAX, 1, u64::MAX).is_err());
+        assert!(uniform_buffer_len(usize::MAX, 0, u64::MAX).is_err());
+        assert!(uniform_buffer_len(1, 16_777_216, u64::MAX).is_err(), "the last record offset cannot be represented by u32");
+        #[cfg(target_pointer_width = "64")]
+        assert_eq!(uniform_buffer_len(1, 16_777_215, u64::MAX).unwrap(), 4_294_967_296, "the last valid u32 dynamic offset is accepted");
+    }
+
     #[test]
     fn half_roundtrip() {
         for v in [0.0f32, 1.0, 0.5, 0.25, 1.0 / 255.0, 0.333, 65504.0, -2.5, 1e-6] {
diff --git a/crates/gpu/src/plan.rs b/crates/gpu/src/plan.rs
index a5218f826f..b8c083c7af 100644
--- a/crates/gpu/src/plan.rs
+++ b/crates/gpu/src/plan.rs
@@ -9,7 +9,8 @@
 //! effect maps (shadow / glow / satin / bevel coverage, stroke bands) are built once per layer
 //! state by [`crate::fx`] and sampled here; exterior effects paint into a copy of the backdrop,
 //! the layer at fill opacity takes the interior effects, and the two merge with the layer's mode
-//! and opacity. Effect passes are clipped to the layer's effect region and the result is copied
+//! (or the layer merges first and the effects paint over it: `effects::premerges_layer`) and
+//! opacity. Effect passes are clipped to the layer's effect region and the result is copied
 //! back into the backdrop in place, so a small text layer costs only its own pixels.
 
 use photocraft_color::BlendMode;
@@ -387,9 +388,30 @@ pub const F_HDR: u32 = 262144;
 pub const F_QUANT: u32 = 32768;
 /// `Lerp` as A + (B − C) premultiplied (layers clipped to pass-through groups).
 pub const F_ADD_DIFF: u32 = 16384;
+/// `Lerp`: B mixed back towards A (the backdrop) by the layer's Blend If weight
+/// (`compose::apply_blend_if`), from C ("This Layer", or B itself for an adjustment layer, `p4.y`)
+/// and A ("Underlying Layer"). The ranges are packed in `p0..p3` (`blend_if_params`); `p4.x` marks
+/// a one-channel document.
+pub const F_BLEND_IF: u32 = 524288;
 /// Blend / Atop / FxMerge of a type layer: coverage mixed at `psblend::TEXT_GAMMA`.
 pub const F_TEXT_GAMMA: u32 = 8192;
 
+/// A layer's Blend If ranges for `F_BLEND_IF`: Gray, then the colour channels, each as
+/// [this layer, underlying layer]; every range as two floats, `black low × 256 + black high` and
+/// `white low × 256 + white high` (exact in f32), so entry `e`, side `s` starts at float
+/// `(e × 2 + s) × 2`. Entries past the fourth never apply (RGB has four, one-channel modes two).
+fn blend_if_params(bi: &photocraft_doc::BlendIf) -> [[f32; 4]; 4] {
+    let mut f = [0.0f32; 16];
+    for e in 0..4 {
+        for (s, r) in bi.get(e).iter().enumerate() {
+            let i = (e * 2 + s) * 2;
+            f[i] = f32::from(r.black[0]) * 256.0 + f32::from(r.black[1]);
+            f[i + 1] = f32::from(r.white[0]) * 256.0 + f32::from(r.white[1]);
+        }
+    }
+    [[f[0], f[1], f[2], f[3]], [f[4], f[5], f[6], f[7]], [f[8], f[9], f[10], f[11]], [f[12], f[13], f[14], f[15]]]
+}
+
 /// `F_TEXT_GAMMA` for type layers while text gamma blending is on; the gamma goes in `p4.w`.
 fn gamma_flag(layer: &Layer) -> u32 {
     if photocraft_compose::text_gamma(layer) != 1.0 { F_TEXT_GAMMA } else { 0 }
@@ -514,12 +536,44 @@ impl<'a> Planner<'a> {
         })
     }
 
-    /// Blending Options › Blend If has no GPU pass yet: such documents use the CPU compositor.
-    fn check_blend_if(&self, layer: &Layer) -> Result<(), Unsupported> {
-        if photocraft_compose::blend_if_active(layer, self.cx.mode) {
-            return Err(Unsupported(format!("Blend If on `{}` (composited on the CPU)", layer.name)));
+    /// `compose::apply_blend_if`: `after` (the backdrop with `layer` drawn) mixed back towards
+    /// `before` (the backdrop without it) where the layer's Blend If ranges hide it. "This Layer"
+    /// is the layer's own content with its masks; an adjustment layer is judged by its result.
+    /// Consumes both slots.
+    fn blend_if(&mut self, layer: &'a Layer, before: Slot, after: Slot) -> Result<Slot, Unsupported> {
+        let own = match layer.content {
+            LayerContent::Adjustment(_) => None,
+            _ => Some(self.content(layer)?),
+        };
+        let mut p = Pass::new(Kernel::Lerp, 0);
+        p.a = Some(before);
+        p.b = Some(after);
+        p.c = own;
+        p.flags = F_BLEND_IF;
+        p.params = blend_if_params(&layer.blend_if);
+        let one_channel = self.cx.mode != photocraft_color::ColorMode::Rgb;
+        p.extra = [f32::from(u8::from(one_channel)), f32::from(u8::from(own.is_none())), 0.0, 0.0];
+        Ok(self.emit(p))
+    }
+
+    /// Channel restrictions and Blend If around `draw`, which composites `layer` onto `backdrop`
+    /// (`compose::composite_layer` / `composite_atop`: both are relative to the same backdrop).
+    fn restricted(&mut self, layer: &'a Layer, backdrop: Slot, draw: impl FnOnce(&mut Self, Slot) -> Result<Slot, Unsupported>) -> Result<Slot, Unsupported> {
+        let w = photocraft_compose::channel_weights(layer, self.cx.mode);
+        let blend_if = photocraft_compose::blend_if_active(layer, self.cx.mode);
+        if w.is_none() && !blend_if {
+            return draw(self, backdrop);
         }
-        Ok(())
+        let before = self.retain(backdrop);
+        let mut after = draw(self, backdrop)?;
+        if let Some(w) = w {
+            let b = if blend_if { self.retain(before) } else { before };
+            after = self.restore_channels(b, after, w);
+        }
+        if blend_if {
+            after = self.blend_if(layer, before, after)?;
+        }
+        Ok(after)
     }
 
     /// Blending Options › Advanced Blending (knockout, clipped layers blended individually, blend
@@ -535,16 +589,8 @@ impl<'a> Planner<'a> {
 
     /// composite_layer, honouring the layer's channel restrictions.
     fn layer(&mut self, layer: &'a Layer, clipped: &'a [Layer], backdrop: Slot) -> Result<Slot, Unsupported> {
-        self.check_blend_if(layer)?;
         self.check_advanced(layer, clipped)?;
-        match photocraft_compose::channel_weights(layer, self.cx.mode) {
-            Some(w) => {
-                let before = self.retain(backdrop);
-                let after = self.layer_any(layer, clipped, backdrop)?;
-                Ok(self.restore_channels(before, after, w))
-            }
-            None => self.layer_any(layer, clipped, backdrop),
-        }
+        self.restricted(layer, backdrop, |s, b| s.layer_any(layer, clipped, b))
     }
 
     /// `compose::restore_channels`: `after` with the channels a layer leaves out taken from
@@ -710,7 +756,6 @@ impl<'a> Planner<'a> {
         if clip.is_some_and(|c| c.is_empty()) {
             // Nothing to draw (an empty layer, or a group of them).
             for c in &visible_clipped {
-                self.check_blend_if(c)?;
                 self.check_advanced(c, &[])?;
             }
             return Ok(backdrop);
@@ -803,7 +848,7 @@ impl<'a> Planner<'a> {
                 // compose::render_fill: the pattern tiled from the layer's frame (transparent
                 // when missing), then the layer's masks.
                 let empty = self.clear();
-                let Some(pat) = photocraft_doc::pattern::find(self.cx.patterns, id, name).filter(|p| !p.is_empty()) else { return Ok(empty) };
+                let Some(pat) = photocraft_doc::pattern::find(self.cx.patterns, id, name).filter(|p| p.is_paintable()) else { return Ok(empty) };
                 let frame = photocraft_compose::fill_frame(layer, self.cx.canvas);
                 let anchor = if frame.is_empty() { (0.0, 0.0) } else { (f64::from(frame.x0), f64::from(frame.y0)) };
                 let paint = Paint::Pattern(pat, placement(anchor, *link, *phase, *scale, *angle));
@@ -893,16 +938,8 @@ impl<'a> Planner<'a> {
     /// composite_atop: `layer` onto `base`, restricted to the base's alpha, honouring the
     /// layer's channel restrictions.
     fn atop(&mut self, layer: &'a Layer, base: Slot) -> Result<Slot, Unsupported> {
-        self.check_blend_if(layer)?;
         self.check_advanced(layer, &[])?;
-        match photocraft_compose::channel_weights(layer, self.cx.mode) {
-            Some(w) => {
-                let before = self.retain(base);
-                let after = self.atop_any(layer, base)?;
-                Ok(self.restore_channels(before, after, w))
-            }
-            None => self.atop_any(layer, base),
-        }
+        self.restricted(layer, base, |s, b| s.atop_any(layer, b))
     }
 
     fn atop_any(&mut self, layer: &'a Layer, base: Slot) -> Result<Slot, Unsupported> {
@@ -934,7 +971,7 @@ impl<'a> Planner<'a> {
 
     /// adjust::apply_with on a slot (consumes it).
     fn adjust(&mut self, adj: &Adjustment, src: Slot) -> Result<Slot, Unsupported> {
-        if !adjustment_on_gpu(adj) {
+        if !adjustment_on_gpu(adj, self.cx.mode) {
             return Err(Unsupported(format!("{} on CMYK/Lab channels (evaluated on the CPU)", adj.label())));
         }
         if let Adjustment::GradientMap { stops, .. } = adj {
@@ -1095,9 +1132,22 @@ impl<'a> Planner<'a> {
         } else {
             init(self, lay_src, None, INIT_INSIDE, layer.fill_opacity)
         };
+        // Blend Interior Effects as Group off: the layer merges in its mode first and the
+        // interior effects paint over the result (`effects::premerges_layer`).
+        let premerge = photocraft_compose::effects::premerges_layer(layer);
+        if premerge {
+            let mut p = Pass::new(Kernel::Blend, 0);
+            p.a = Some(self.retain(w));
+            p.b = Some(l);
+            p.mode = layer.blend;
+            p.flags = gamma_flag(layer);
+            p.extra[3] = photocraft_compose::text_gamma(layer);
+            p.clip = Some(clip);
+            l = self.emit(p);
+        }
         for &(_, e) in &rev {
             if let Effect::PatternOverlay { common, name, id, scale, angle, link, phase } = e
-                && let Some(pat) = photocraft_doc::pattern::find(self.cx.patterns, id, name).filter(|p| !p.is_empty())
+                && let Some(pat) = photocraft_doc::pattern::find(self.cx.patterns, id, name).filter(|p| p.is_paintable())
             {
                 let paint = Paint::Pattern(pat, placement(anchor, *link, *phase, *scale, *angle));
                 l = self.paint(l, content, Cov::One, &paint, common.blend, common.opacity, F_GATE, clip, sb);
@@ -1257,7 +1307,7 @@ impl<'a> Planner<'a> {
             }
         }
 
-        let mode = if layer.blend == BlendMode::PassThrough { BlendMode::Normal } else { layer.blend };
+        let mode = if premerge || layer.blend == BlendMode::PassThrough { BlendMode::Normal } else { layer.blend };
         let late: Vec<(usize, &'a photocraft_doc::Bevel)> = rev
             .iter()
             .filter_map(|&(i, e)| if let Effect::BevelEmboss(b) = e { Some((i, b)) } else { None })
@@ -1312,7 +1362,7 @@ impl<'a> Planner<'a> {
         match p {
             FxPaint::Color(c) => Paint::Color(c.to_rgb()),
             FxPaint::Gradient(g) => Paint::Gradient(g),
-            FxPaint::Pattern { name, id, scale } => match photocraft_doc::pattern::find(self.cx.patterns, id, name).filter(|p| !p.is_empty()) {
+            FxPaint::Pattern { name, id, scale } => match photocraft_doc::pattern::find(self.cx.patterns, id, name).filter(|p| p.is_paintable()) {
                 Some(pat) => Paint::Pattern(pat, placement(anchor, true, (0.0, 0.0), *scale, 0.0)),
                 None => Paint::None,
             },
@@ -1512,10 +1562,20 @@ fn to_row(t: &[f32]) -> [f32; 4096] {
     row
 }
 
-/// Whether the adjustment kernel can evaluate `adj`: Levels and Curves on CMYK ink or Lab
-/// channels convert through ICC profiles per pixel, which only the CPU does.
-pub fn adjustment_on_gpu(adj: &Adjustment) -> bool {
-    !matches!(adj, Adjustment::Levels { space: ToneSpace::Cmyk | ToneSpace::Lab, .. } | Adjustment::Curves { space: ToneSpace::Cmyk | ToneSpace::Lab, .. })
+/// Whether the adjustment kernel can evaluate `adj` in a document of colour `mode`: Levels and
+/// Curves on CMYK ink or Lab channels convert through ICC profiles per pixel, and so do the
+/// adjustments a Lab document evaluates on L, a and b (`photocraft_compose::adjust::lab_channel_adjustment`)
+/// and a CMYK document on its inks (`cmyk_channel_adjustment`), which only the CPU does.
+pub fn adjustment_on_gpu(adj: &Adjustment, mode: photocraft_color::ColorMode) -> bool {
+    use photocraft_compose::adjust::{cmyk_channel_adjustment, lab_channel_adjustment};
+    let tone_in_space =
+        matches!(adj, Adjustment::Levels { space: ToneSpace::Cmyk | ToneSpace::Lab, .. } | Adjustment::Curves { space: ToneSpace::Cmyk | ToneSpace::Lab, .. });
+    let own_channels = match mode {
+        photocraft_color::ColorMode::Lab => lab_channel_adjustment(adj),
+        photocraft_color::ColorMode::Cmyk => cmyk_channel_adjustment(adj),
+        _ => false,
+    };
+    !tone_in_space && !own_channels
 }
 
 /// A tone transfer as the shader's `t_decode`/`t_encode` exponent (0: the sRGB curve).
@@ -1679,7 +1739,8 @@ fn gradient_rows(g: &Gradient) -> Vec<[f32; 4096]> {
 fn check_gradient_stops<T>(stops: &[(f32, T)]) -> Result<(), Unsupported> {
     let mut positions: Vec<f32> = stops.iter().map(|s| s.0).collect();
     positions.sort_by(f32::total_cmp);
-    if positions.windows(2).any(|w| w[0] == w[1]) {
+    // A 4096-entry LUT cannot keep two stops that fall in the same entry apart (#3053).
+    if positions.windows(2).any(|w| (w[1] - w[0]).abs() < 1.0 / 4095.0) {
         return Err(Unsupported("coincident gradient stops (composited on the CPU)".into()));
     }
     Ok(())
@@ -1731,6 +1792,34 @@ mod tests {
     use photocraft_color::{Color, ColorMode, SampleType};
     use photocraft_geom::Size;
 
+    #[test]
+    fn stops_closer_than_one_lut_step_stay_on_the_cpu() {
+        assert!(check_gradient_stops(&[(0.4999_f32, ()), (0.5, ())]).is_err());
+        assert!(check_gradient_stops(&[(0.0_f32, ()), (1.0, ())]).is_ok());
+    }
+
+    #[test]
+    fn lab_channel_adjustments_defer_to_the_cpu_in_lab_documents() {
+        let lab_rules = [
+            Adjustment::Invert,
+            Adjustment::Posterize { levels: 4 },
+            Adjustment::Threshold { level: 0.5 },
+            Adjustment::BrightnessContrast { brightness: 10.0, contrast: 5.0, legacy: false },
+            Adjustment::GradientMap { stops: vec![(0.0, [0.0; 3]), (1.0, [1.0; 3])], reverse: false, dither: false },
+        ];
+        for adj in &lab_rules {
+            assert!(!adjustment_on_gpu(adj, ColorMode::Lab), "{adj:?}");
+            for mode in [ColorMode::Rgb, ColorMode::Grayscale] {
+                assert!(adjustment_on_gpu(adj, mode), "{adj:?} in {mode:?}");
+            }
+            // CMYK documents invert, posterize and threshold their inks, on the CPU.
+            let inks = matches!(adj, Adjustment::Invert | Adjustment::Posterize { .. } | Adjustment::Threshold { .. });
+            assert_eq!(adjustment_on_gpu(adj, ColorMode::Cmyk), !inks, "{adj:?} in CMYK");
+        }
+        // Screen-colour adjustments stay on the GPU in Lab documents.
+        assert!(adjustment_on_gpu(&Adjustment::Exposure { exposure: 1.0, offset: 0.0, gamma: 1.0 }, ColorMode::Lab));
+    }
+
     #[test]
     fn native_cmyk_fills_fall_back_only_without_a_valid_cache() {
         use photocraft_doc::{FillCache, GradientStyle};
@@ -1927,17 +2016,32 @@ mod tests {
     }
 
     #[test]
-    fn blend_if_falls_back_to_the_cpu() {
+    fn blend_if_plans_on_the_gpu() {
         let mut d = Document::with_background("t", Size::new(8, 8), ColorMode::Rgb, SampleType::U8, Color::WHITE);
         let mut l = Layer::raster("bi", d.pixel_format());
+        l.surface_mut().unwrap().fill_rect(photocraft_geom::Rect::new(0, 0, 4, 4), &[1.0, 0.0, 0.0, 1.0]);
         l.blend_if.set(0, [photocraft_doc::BlendRange { black: [40, 40], white: [255, 255] }, photocraft_doc::BlendRange::FULL]);
         d.layers.push(l.clone());
-        assert!(plan(&d).unwrap_err().0.contains("Blend If"));
+        let blend_if = |d: &Document| plan(d).unwrap().passes.iter().filter(|p| p.flags & F_BLEND_IF != 0).count();
+        assert_eq!(blend_if(&d), 1);
         // Clipped layers too.
         l.clipped = true;
         d.layers[1].blend_if = Default::default();
         d.layers.push(l);
-        assert!(plan(&d).is_err());
+        assert_eq!(blend_if(&d), 1);
+        // Outside RGB, Grayscale and Duotone the setting round-trips without applying.
+        d.mode = ColorMode::Lab;
+        assert_eq!(blend_if(&d), 0);
+    }
+
+    #[test]
+    fn blend_if_params_pack_every_range_exactly() {
+        let mut bi = photocraft_doc::BlendIf::default();
+        bi.set(3, [photocraft_doc::BlendRange { black: [255, 255], white: [0, 1] }, photocraft_doc::BlendRange { black: [12, 200], white: [201, 254] }]);
+        let f: Vec<f32> = blend_if_params(&bi).iter().flatten().copied().collect();
+        // Entry 3 (B), this layer then underlying; unset entries are full ranges.
+        assert_eq!(&f[12..16], &[255.0 * 256.0 + 255.0, 1.0, 12.0 * 256.0 + 200.0, 201.0 * 256.0 + 254.0]);
+        assert_eq!(&f[0..2], &[0.0, 255.0 * 256.0 + 255.0]);
     }
 
     #[test]
diff --git a/crates/gpu/src/prefix.rs b/crates/gpu/src/prefix.rs
index fcd5c0a049..0312a25fa2 100644
--- a/crates/gpu/src/prefix.rs
+++ b/crates/gpu/src/prefix.rs
@@ -85,6 +85,11 @@ impl Prefix {
         }
     }
 
+    /// The document the cached composite belongs to, if any.
+    pub(crate) fn doc(&self) -> Option<photocraft_doc::DocId> {
+        self.context.as_ref().map(|d| d.id)
+    }
+
     pub(crate) fn prepare(&mut self, doc: &Document, plan: &Plan<'_>) -> Option<Checkpoint> {
         if self.budget == 0 {
             return None;
diff --git a/crates/gpu/tests/device_loss.rs b/crates/gpu/tests/device_loss.rs
index 5106c97a72..689a787280 100644
--- a/crates/gpu/tests/device_loss.rs
+++ b/crates/gpu/tests/device_loss.rs
@@ -81,3 +81,181 @@ fn health_wait_on_a_destroyed_device_is_safe() {
     assert!(!health.is_ok());
     assert!(!health.wait(&device, None));
 }
+
+fn assert_unwatched_destroyed_device(encode_only: bool) {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = device() else { return };
+    let mut comp = Compositor::try_new_with_format(&device, Compositor::preferred_acc_format(&adapter)).unwrap();
+    let d = Document::with_background("synthetic", Size::new(1, 1), ColorMode::Rgb, SampleType::U8, Color::rgba(0.9, 0.9, 0.9, 1.0));
+    assert!(render_to_vec(&mut comp, &device, &queue, &d, d.bounds()).is_ok());
+    let mut encoder = device.create_command_encoder(&Default::default());
+    device.destroy();
+    let mut changed = d.clone();
+    changed.layers[0].opacity = 0.4;
+    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if encode_only {
+            comp.encode(&device, &queue, &mut encoder, &changed, changed.bounds(), &mut |_, _| {})
+        } else {
+            comp.render(&device, &queue, &changed, changed.bounds(), |_, _| {})
+        }
+    }));
+    assert!(result.is_ok(), "an unwatched device failure must return Unsupported instead of panicking");
+    let error = result.unwrap().expect_err("a destroyed device must not report successful GPU work");
+    assert!(error.0.contains("GPU work failed"), "{error}");
+}
+
+#[test]
+fn an_unwatched_destroyed_device_returns_an_error_without_panicking() {
+    assert_unwatched_destroyed_device(false);
+}
+
+#[test]
+fn an_unwatched_encode_on_a_destroyed_device_returns_an_error_without_panicking() {
+    assert_unwatched_destroyed_device(true);
+}
+
+#[test]
+fn loss_during_an_unwatched_render_returns_an_error_without_panicking() {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = device() else { return };
+    let mut comp = Compositor::try_new_with_format(&device, Compositor::preferred_acc_format(&adapter)).unwrap();
+    comp.set_texture_limit(256);
+    let d = Document::with_background("synthetic", Size::new(512, 1), ColorMode::Rgb, SampleType::U8, Color::rgba(0.9, 0.9, 0.9, 1.0));
+    let mut chunks = 0;
+    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        comp.render(&device, &queue, &d, d.bounds(), |_, _| {
+            chunks += 1;
+            if chunks == 1 {
+                // A driver reset can arrive after the entry-point health check too.
+                device.destroy();
+            }
+        })
+    }));
+    assert!(chunks > 0, "the injection must occur after GPU work began");
+    assert!(result.is_ok(), "device loss mid-render must return Unsupported instead of panicking");
+    assert!(result.unwrap().is_err(), "a partially failed render must not report success");
+}
+
+#[test]
+fn a_captured_render_error_preserves_the_device_for_a_later_render() {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = device() else { return };
+    let mut comp = Compositor::try_new_with_format(&device, Compositor::preferred_acc_format(&adapter)).unwrap();
+    let d = Document::with_background("synthetic", Size::new(1, 1), ColorMode::Rgb, SampleType::U8, Color::rgba(0.9, 0.9, 0.9, 1.0));
+    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        comp.render(&device, &queue, &d, d.bounds(), |_, _| {
+            // Reject a buffer above the device's valid capability without actually allocating it.
+            let _ = device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("synthetic_invalid_buffer"),
+                size: device.limits().max_buffer_size + 1,
+                usage: wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            });
+        })
+    }));
+    assert!(result.is_ok(), "GPU validation errors must return Unsupported instead of panicking");
+    let error = result.unwrap().expect_err("an invalid allocation must fail this render");
+    assert!(error.0.contains("synthetic_invalid_buffer"), "{error}");
+    let out = render_to_vec(&mut comp, &device, &queue, &d, d.bounds()).expect("the next fitting render keeps working");
+    let expected = photocraft_compose::flatten(&d);
+    for (cpu, gpu) in expected.px[0].iter().zip(out[0]) {
+        assert!((cpu - gpu).abs() <= 1.0 / 255.0, "the healthy GPU control differs: {cpu} vs {gpu}");
+    }
+}
+
+fn assert_recovery_after_invalid_encoder(encode_only: bool) {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = device() else { return };
+    let mut comp = Compositor::try_new_with_format(&device, Compositor::preferred_acc_format(&adapter)).unwrap();
+    let mut d = doc();
+    d.layers[1].effects.items = vec![photocraft_doc::Effect::default_drop_shadow()];
+    // Pipeline creation errors are not proof of missing hardware capabilities: check the
+    // adapter and the features actually enabled on this device before allowing a skip.
+    let required = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
+    let features = device.features();
+    for format in [wgpu::TextureFormat::R32Float, wgpu::TextureFormat::R16Float] {
+        let adapter_usages = adapter.get_texture_format_features(format).allowed_usages;
+        let guaranteed_usages = format.guaranteed_format_features(features).allowed_usages;
+        if !adapter_usages.contains(required)
+            || (!features.contains(wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES) && !guaranteed_usages.contains(required))
+        {
+            eprintln!(
+                "skipping effect-map recovery test: {:?} {format:?} lacks {required:?}; adapter usages={adapter_usages:?}, guaranteed usages={guaranteed_usages:?}, device features={features:?}",
+                adapter.get_info().backend,
+            );
+            return;
+        }
+    }
+    comp.supports(&d).expect("a capable adapter must support the recovery fixture's effect-map pipelines");
+    let src = device.create_buffer(&wgpu::BufferDescriptor { label: None, size: 4, usage: wgpu::BufferUsages::COPY_SRC, mapped_at_creation: false });
+    let dst = device.create_buffer(&wgpu::BufferDescriptor { label: None, size: 4, usage: wgpu::BufferUsages::COPY_DST, mapped_at_creation: false });
+    let mut injected = false;
+    let mut sink = |encoder: &mut wgpu::CommandEncoder, _: photocraft_gpu::ChunkOut<'_>| {
+        injected = true;
+        // Misaligned copies invalidate the encoder, discarding all recorded effect-map work.
+        encoder.copy_buffer_to_buffer(&src, 0, &dst, 0, 1);
+        if encode_only {
+            // encode does not finish its caller-owned encoder; force an immediate error too.
+            let _ = device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("synthetic_invalid_buffer"),
+                size: device.limits().max_buffer_size + 1,
+                usage: wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            });
+        }
+    };
+    let result = if encode_only {
+        let mut encoder = device.create_command_encoder(&Default::default());
+        comp.encode(&device, &queue, &mut encoder, &d, d.bounds(), &mut sink)
+    } else {
+        comp.render(&device, &queue, &d, d.bounds(), sink)
+    };
+    assert!(injected, "the invalid encoder injection must reach the sink");
+    let error = result.expect_err("invalid encoder must fail");
+    assert!(error.0.contains("GPU work failed"), "the injected GPU error must be captured: {error}");
+    let recovered = render_to_vec(&mut comp, &device, &queue, &d, d.bounds()).unwrap();
+    let mut fresh = Compositor::try_new_with_format(&device, Compositor::preferred_acc_format(&adapter)).unwrap();
+    let expected = render_to_vec(&mut fresh, &device, &queue, &d, d.bounds()).unwrap();
+    for (a, b) in recovered.iter().zip(expected.iter()) {
+        for (a, b) in a.iter().zip(b.iter()) {
+            assert!((a - b).abs() <= 1.0 / 255.0, "recovered cached pixels differ: {a} vs {b}");
+        }
+    }
+}
+
+#[test]
+fn render_recovers_effect_maps_after_invalid_encoder() {
+    assert_recovery_after_invalid_encoder(false);
+}
+
+#[test]
+fn encode_recovers_effect_maps_after_invalid_encoder() {
+    assert_recovery_after_invalid_encoder(true);
+}
+
+#[test]
+fn loss_during_intermediate_unwatched_submissions_returns_an_error() {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = device() else { return };
+    let mut comp = Compositor::try_new_with_format(&device, Compositor::preferred_acc_format(&adapter)).unwrap();
+    comp.set_texture_limit(256);
+    let mut d = Document::with_background("synthetic", Size::new(2048, 1), ColorMode::Rgb, SampleType::U8, Color::rgba(0.9, 0.9, 0.9, 1.0));
+    for _ in 0..300 {
+        let mut layer = d.layers[0].clone();
+        layer.id = photocraft_doc::LayerId::fresh();
+        layer.opacity = 0.5;
+        d.layers.push(layer);
+    }
+    let mut chunks = 0;
+    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        comp.render(&device, &queue, &d, d.bounds(), |_, _| {
+            chunks += 1;
+            if chunks == 1 {
+                device.destroy();
+            }
+        })
+    }));
+    assert!(chunks > 0);
+    assert!(result.is_ok(), "intermediate submit polling must not escape as a panic");
+    assert!(result.unwrap().is_err());
+}
diff --git a/crates/gpu/tests/parity.rs b/crates/gpu/tests/parity.rs
index fca32a02c4..c61aee9b67 100644
--- a/crates/gpu/tests/parity.rs
+++ b/crates/gpu/tests/parity.rs
@@ -187,6 +187,27 @@ fn check(g: &mut Gpu, doc: &Document, what: &str) {
     diff_rect(g, doc, doc.bounds(), what).unwrap_or_else(|e| panic!("{e}"));
 }
 
+/// Closing a document frees what the compositor holds for it, however its canvas entry went
+/// (#4529): `retain_docs` drops the resident pages, effect maps and lower-stack composite of
+/// documents that aren't open, and keeps the open ones.
+#[test]
+fn retain_docs_frees_closed_documents() {
+    let Some(mut g) = gpu() else { return };
+    let a = base_doc(64, 48);
+    let mut b = base_doc(32, 32);
+    b.id = photocraft_doc::DocId(a.id.0 + 1);
+    for d in [&a, &b] {
+        render_to_vec(&mut g.comp, &g.device, &g.queue, d, d.bounds()).expect("render");
+    }
+    assert_eq!(g.comp.held_docs(), vec![a.id, b.id]);
+    g.comp.retain_docs(|d| d == b.id);
+    assert_eq!(g.comp.held_docs(), vec![b.id], "only the open document is left");
+    g.comp.retain_docs(|_| false);
+    assert!(g.comp.held_docs().is_empty());
+    assert_eq!(g.comp.composite_cache_bytes(), 0);
+    check(&mut g, &a, "renders again after being forgotten");
+}
+
 #[test]
 fn first_frame_renders() {
     // Regression: the first submission after device creation is dropped on some drivers
@@ -370,7 +391,7 @@ fn prefix_partial_damage_context_occlusion_and_budget_are_conservative() {
     check(&mut g, &doc, "bounded admission");
     assert!(g.comp.composite_cache_bytes() <= 1 << 20);
     assert!(diff_rect(&mut g, &doc, doc.bounds(), "bounded cache keeps its hits").unwrap().prefix_hits > 0);
-    doc.layers[0].blend_if.set(0, [photocraft_doc::BlendRange { black: [40, 40], white: [255, 255] }, photocraft_doc::BlendRange::FULL]);
+    doc.layers[0].advanced.knockout = photocraft_doc::Knockout::Deep;
     assert!(render_to_vec(&mut g.comp, &g.device, &g.queue, &doc, doc.bounds()).is_err());
     assert_eq!(g.comp.composite_cache_bytes(), 0);
 }
@@ -900,6 +921,42 @@ fn incremental_updates_follow_the_document() {
     check(&mut g, &d, "opacity");
 }
 
+/// A duplicate shares its source's tiles: its texture is a GPU copy of the source's, not an
+/// upload. Tiles written afterwards, to the copy or to the source in the same refresh, must not be
+/// lost to the copy or leak through it (queued writes land before the encoder's copy).
+#[test]
+fn duplicates_copy_their_source_texture() {
+    let Some(mut g) = gpu() else { return };
+    let mut d = base_doc(600, 300);
+    let mut src = noise_layer("src", PixelFormat::RGBA8, Rect::new(0, 0, 600, 300), 71, 0.0);
+    src.opacity = 0.7;
+    d.layers.push(src);
+    check(&mut g, &d, "source");
+    // A duplicate with no other change: nothing uploads.
+    let mut dup = d.layers[1].duplicate();
+    dup.blend = BlendMode::Difference;
+    d.layers.push(dup);
+    let stats = diff_rect(&mut g, &d, d.bounds(), "duplicate").unwrap_or_else(|e| panic!("{e}"));
+    assert_eq!(stats.tiles_uploaded, 0, "{stats:?}");
+    assert!(stats.tiles_shared > 0, "{stats:?}");
+    // Another duplicate, then one tile painted on it and one on its source, in the same refresh.
+    let mut dup2 = d.layers[1].duplicate();
+    dup2.blend = BlendMode::Screen;
+    dup2.surface_mut().unwrap().fill_rect(Rect::new(10, 10, 20, 20), &[1.0, 0.0, 0.0, 1.0]);
+    d.layers.push(dup2);
+    d.layers[1].surface_mut().unwrap().fill_rect(Rect::new(300, 100, 310, 110), &[0.0, 0.0, 1.0, 1.0]);
+    check(&mut g, &d, "duplicate and source painted");
+    // And a tile removed from a duplicate: it reads as transparent again.
+    let mut dup3 = d.layers[1].duplicate();
+    *dup3.surface_mut().unwrap() = {
+        let mut s = photocraft_raster::Surface::new(PixelFormat::RGBA8);
+        s.put_tiles(d.layers[1].surface().unwrap().tiles().skip(1).map(|(c, t)| (*c, t.clone())));
+        s
+    };
+    d.layers.push(dup3);
+    check(&mut g, &d, "duplicate missing a tile");
+}
+
 /// #2422: a mask whose default pixel changes without touching its tiles (Invert on a sparse mask)
 /// must re-upload the absent tiles between its stored ones, not keep the old default on the GPU.
 #[test]
@@ -1061,6 +1118,25 @@ fn small_layers_composite_over_their_bounds() {
     check(&mut g, &big, "small layers across chunks");
 }
 
+#[test]
+fn many_layers_submit_inside_one_chunk() {
+    // P12: a refresh recorded every pass of a page cell into one command buffer, and with a few
+    // hundred layers Metal ran out of command buffers (device lost, "pc_compose_uniforms is
+    // invalid"). 700 layers need well over 1000 passes in the document's only chunk.
+    let Some(mut g) = gpu() else { return };
+    let mut d = base_doc(64, 48);
+    let modes: Vec<BlendMode> = BlendMode::layer_modes().collect();
+    for (i, mode) in modes.iter().copied().cycle().take(700).enumerate() {
+        let mut l = noise_layer("l", PixelFormat::RGBA8, Rect::from_xywh(0, 0, 64, 48), 500 + i as u32, 0.0);
+        l.blend = mode;
+        l.opacity = 0.9;
+        d.layers.push(l);
+    }
+    let stats = diff_rect(&mut g, &d, d.bounds(), "700 layers").unwrap_or_else(|e| panic!("{e}"));
+    assert_eq!(stats.chunks, 1);
+    assert!(stats.flushes > 0, "{stats:?}");
+}
+
 fn blob(name: &str, fmt: PixelFormat, cx: f32, cy: f32, r: f32, color: [f32; 3]) -> Layer {
     let mut l = Layer::raster(name, fmt);
     let rect = Rect::new((cx - r - 12.0) as i32, (cy - r - 4.0) as i32, (cx + r + 14.0) as i32, (cy + r + 4.0) as i32);
@@ -1406,6 +1482,7 @@ fn layer_effects_opacity_fill_blend_and_off_canvas() {
         (0.6, 0.35, BlendMode::Multiply),
         (1.0, 0.5, BlendMode::Screen),
         (0.8, 1.0, BlendMode::Dissolve),
+        (1.0, 1.0, BlendMode::Color),
     ] {
         let mut d = fx_doc(96, 80, SampleType::U8);
         let mut l = blob("fx", d.pixel_format(), 46.0, 40.0, 22.0, [0.2, 0.6, 0.9]);
@@ -1643,6 +1720,78 @@ fn stroke_effects_on_filled_and_stroked_shapes() {
     }
 }
 
+/// Blend If on the GPU matches `compose::apply_blend_if` (#4395): this-layer and underlying
+/// ranges, hard and split points, per channel, on raster, masked, adjustment and clipped layers,
+/// with channel restrictions, and in grayscale. Hard points are compared on 8-bit documents only:
+/// 16/32-bit layers reach the GPU as RGBA16F, so a value within about a tenth of a level of a
+/// hard point can land on its other side (as with the GPU Threshold adjustment, also compared at
+/// 8 bits); split points are compared at every depth.
+#[test]
+fn blend_if() {
+    use photocraft_doc::BlendRange;
+    let Some(mut g) = gpu() else { return };
+    let r = |b0: u8, b1: u8, w0: u8, w1: u8| BlendRange { black: [b0, b1], white: [w0, w1] };
+    // (name, entry, [this layer, underlying], has a hard point)
+    let cases: [(&str, usize, [BlendRange; 2], bool); 7] = [
+        ("gray this hard", 0, [r(90, 90, 255, 255), BlendRange::FULL], true),
+        ("gray under split", 0, [BlendRange::FULL, r(30, 140, 150, 230)], false),
+        ("red both", 1, [r(0, 60, 200, 200), r(20, 20, 180, 250)], true),
+        ("red both split", 1, [r(0, 60, 190, 230), r(10, 50, 180, 250)], false),
+        ("green white split", 2, [r(0, 0, 100, 220), BlendRange::FULL], false),
+        ("blue under hard", 3, [BlendRange::FULL, r(128, 128, 255, 255)], true),
+        ("everything hidden", 0, [r(255, 255, 0, 0), BlendRange::FULL], true),
+    ];
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        let fmt = PixelFormat { sample: depth, ..PixelFormat::RGBA8 };
+        for (name, e, pair, hard) in cases {
+            if hard && depth != SampleType::U8 {
+                continue;
+            }
+            let mut d = Document::new("bi", Size::new(64, 48), ColorMode::Rgb, depth);
+            d.layers.push(noise_layer("bg", fmt, Rect::new(0, 0, 64, 48), 1, 0.3));
+            let mut l = noise_layer("top", fmt, Rect::new(4, 3, 60, 45), 2, 0.0);
+            l.blend = BlendMode::Multiply;
+            l.opacity = 0.8;
+            l.blend_if.set(e, pair);
+            d.layers.push(l.clone());
+            check(&mut g, &d, &format!("{depth:?} {name}"));
+            // Edits above it reuse the lower stack, Blend If included (prefix checkpoints).
+            let mut above = d.clone();
+            above.layers.push(noise_layer("above", fmt, Rect::new(20, 0, 40, 48), 4, 0.5));
+            check(&mut g, &above, &format!("{depth:?} {name} under another layer"));
+            above.layers[2].opacity = 0.4;
+            let hits = diff_rect(&mut g, &above, above.bounds(), &format!("{depth:?} {name} edit above")).unwrap_or_else(|e| panic!("{e}"));
+            assert!(hits.prefix_hits > 0, "{depth:?} {name}: the edit above reuses the lower stack");
+
+            // Masked, with channel restrictions.
+            let mut m = l.clone();
+            m.mask = Some(mask(Rect::new(0, 0, 64, 48), 5, 1.0));
+            m.excluded_channels = 0b010;
+            d.layers[1] = m;
+            check(&mut g, &d, &format!("{depth:?} {name} masked, channels"));
+
+            // An adjustment judged by its result, and a clipped layer.
+            let mut adj = Layer::new("inv", LayerContent::Adjustment(Adjustment::Invert));
+            adj.blend_if.set(e, pair);
+            d.layers[1] = l.clone();
+            d.layers[1].blend_if = Default::default();
+            d.layers.push(adj);
+            let mut c = noise_layer("clip", fmt, Rect::new(10, 10, 50, 40), 3, 0.2);
+            c.clipped = true;
+            c.blend_if.set(e, pair);
+            d.layers.push(c);
+            check(&mut g, &d, &format!("{depth:?} {name} adjustment, clipped"));
+        }
+    }
+    // Grayscale: the one channel's entries.
+    let mut d = Document::new("g", Size::new(32, 32), ColorMode::Grayscale, SampleType::U8);
+    d.layers.push(noise_layer("bg", PixelFormat::GRAYA8, Rect::new(0, 0, 32, 32), 9, 1.0));
+    let mut l = noise_layer("top", PixelFormat::GRAYA8, Rect::new(0, 0, 32, 32), 10, 1.0);
+    l.blend_if.set(1, [r(60, 120, 255, 255), r(0, 0, 140, 200)]);
+    d.layers.push(l);
+    check(&mut g, &d, "gray blend if");
+}
+
 #[test]
 fn channel_restrictions() {
     let Some(mut g) = gpu() else { return };
@@ -1960,6 +2109,76 @@ fn artboards() {
     }
 }
 
+/// Sparse patterns may have no stored tiles: their defaults still determine every pixel.
+#[test]
+fn pattern_cache_tracks_default_pixels() {
+    let Some(mut g) = gpu() else { return };
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        let fmt = PixelFormat::RGBA8.with_sample(depth);
+        let mut d = Document::new("pattern defaults", Size::new(8, 6), ColorMode::Rgb, depth);
+        let mut pat = Pattern::new("cache identity", photocraft_raster::Surface::with_default(fmt, &[1.0, 0.0, 0.0, 1.0]), 2, 2);
+        assert_eq!(pat.surface.tiles().count(), 0);
+        d.layers.push(Layer::new(
+            "pattern",
+            LayerContent::Fill(Fill::Pattern { name: pat.name.clone(), id: pat.id.clone(), scale: 1.0, angle: 0.0, link: true, phase: (0.0, 0.0) }),
+        ));
+        d.patterns.push(pat.clone());
+        check(&mut g, &d, &format!("red default {depth:?}"));
+        pat.surface = photocraft_raster::Surface::with_default(fmt, &[0.0, 0.0, 1.0, 1.0]);
+        assert_eq!(pat.surface.tiles().count(), 0);
+        d.patterns[0] = pat;
+        let cpu = photocraft_compose::flatten(&d);
+        let mut fresh = Compositor::new(&g.device);
+        let out = render_to_vec(&mut fresh, &g.device, &g.queue, &d, d.bounds()).unwrap();
+        assert!(worst_diff(&cpu.px, &out).0 <= TOL, "fresh compositor matches blue default");
+        check(&mut g, &d, &format!("blue default {depth:?}"));
+    }
+}
+
+#[test]
+fn pattern_cache_tracks_source_format_and_cow_tiles() {
+    let Some(mut g) = gpu() else { return };
+    let defaults = [0.5, 0.25, 0.75, 1.0];
+    let mut pat = Pattern::new("format identity", photocraft_raster::Surface::with_default(PixelFormat::RGBA32F, &defaults), 2, 2);
+    let mut d = Document::new("pattern formats", Size::new(8, 6), ColorMode::Rgb, SampleType::F32);
+    d.layers.push(Layer::new(
+        "pattern",
+        LayerContent::Fill(Fill::Pattern { name: pat.name.clone(), id: pat.id.clone(), scale: 1.0, angle: 0.0, link: true, phase: (0.0, 0.0) }),
+    ));
+    let mut previous = None;
+    for fmt in [PixelFormat::RGBA32F, PixelFormat::new(ColorMode::Lab, SampleType::F32, true), PixelFormat::RGBA16, PixelFormat::RGBA8] {
+        pat.surface = photocraft_raster::Surface::with_default(fmt, &defaults);
+        if fmt.sample == SampleType::F32 {
+            assert_eq!(pat.surface.default_pixel(), defaults);
+        }
+        d.patterns = vec![pat.clone()];
+        let cpu = photocraft_compose::flatten(&d);
+        if fmt.mode == ColorMode::Lab {
+            let old: Vec<[f32; 4]> = previous.take().unwrap();
+            assert!(worst_diff(&old, &cpu.px).0 > 0.1, "same default bits have different source-format colours");
+        }
+        previous = Some(cpu.px.clone());
+        let mut fresh = Compositor::new(&g.device);
+        let out = render_to_vec(&mut fresh, &g.device, &g.queue, &d, d.bounds()).unwrap();
+        assert!(worst_diff(&cpu.px, &out).0 <= TOL, "fresh compositor matches {fmt:?}");
+        check(&mut g, &d, &format!("source format {fmt:?}"));
+        check(&mut g, &d, &format!("unchanged source format {fmt:?}"));
+    }
+    pat.surface.fill_rect(pat.rect(), &[1.0, 0.0, 0.0, 1.0]);
+    d.patterns = vec![pat.clone()];
+    check(&mut g, &d, "stored red tile");
+    // Keep the old tile alive: this exercises COW invalidation, not allocator address reuse.
+    let old = pat.clone();
+    pat.surface.fill_rect(Rect::new(0, 0, 1, 1), &[0.0, 0.0, 1.0, 1.0]);
+    assert!(!std::sync::Arc::ptr_eq(old.surface.tiles().next().unwrap().1, pat.surface.tiles().next().unwrap().1));
+    d.patterns = vec![pat];
+    check(&mut g, &d, "COW blue tile edit");
+    let mut fresh = Compositor::new(&g.device);
+    let out = render_to_vec(&mut fresh, &g.device, &g.queue, &d, d.bounds()).unwrap();
+    assert!(worst_diff(&photocraft_compose::flatten(&d).px, &out).0 <= TOL, "fresh compositor matches COW edit");
+    assert_eq!(old.surface.tile_count(), 1);
+}
+
 #[test]
 fn pattern_fill_layers() {
     let Some(mut g) = gpu() else { return };
diff --git a/crates/gpu/tests/uniform_limits.rs b/crates/gpu/tests/uniform_limits.rs
new file mode 100644
index 0000000000..aea8fb6b12
--- /dev/null
+++ b/crates/gpu/tests/uniform_limits.rs
@@ -0,0 +1,146 @@
+//! A deep stack that cannot fit the device's uniform buffer must fall back without panicking.
+
+use photocraft_color::{Color, ColorMode, SampleType};
+use photocraft_doc::{Document, Fill, Layer, LayerContent};
+use photocraft_geom::Size;
+use photocraft_gpu::{Compositor, DeviceHealth, plan, render_to_vec};
+
+static GPU_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
+fn fills(count: usize) -> Document {
+    fills_size(count, Size::new(1, 1))
+}
+
+fn fills_size(count: usize, size: Size) -> Document {
+    let mut doc = Document::new("Small deep stack", size, ColorMode::Rgb, SampleType::U8);
+    for _ in 0..count {
+        doc.layers.push(Layer::new("Translucent fill", LayerContent::Fill(Fill::Solid(Color::rgba(0.25, 0.5, 0.75, 0.5)))));
+    }
+    doc
+}
+
+fn constrained_device() -> Option<(wgpu::Adapter, wgpu::Device, wgpu::Queue)> {
+    let instance = wgpu::Instance::default();
+    let adapter = match pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())) {
+        Ok(adapter) => adapter,
+        Err(error) => {
+            eprintln!("skipping uniform-limit test: no GPU adapter ({error})");
+            return None;
+        }
+    };
+    let limits =
+        wgpu::Limits { max_buffer_size: 65_536, max_storage_buffer_binding_size: 65_536, max_uniform_buffer_binding_size: 65_536, ..Default::default() };
+    let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor { required_limits: limits, ..Default::default() }))
+        .expect("the supported reduced device limits must create a device");
+    assert_eq!(device.limits().max_buffer_size, 65_536);
+    Some((adapter, device, queue))
+}
+
+fn compositor(adapter: &wgpu::Adapter, device: &wgpu::Device) -> Compositor {
+    let mut compositor =
+        Compositor::try_new_with_format(device, Compositor::preferred_acc_format(adapter)).expect("the reduced-limit device supports the compositor");
+    compositor.set_texture_limit(256);
+    compositor
+}
+
+fn healthy_control(compositor: &mut Compositor, device: &wgpu::Device, queue: &wgpu::Queue) {
+    let small = fills(2);
+    let expected = photocraft_compose::flatten(&small);
+    let actual = render_to_vec(compositor, device, queue, &small, small.bounds()).expect("a fitting stack renders on the same device");
+    assert_eq!(actual.len(), 1);
+    for (cpu, gpu) in expected.px[0].iter().zip(actual[0]) {
+        assert!((cpu - gpu).abs() <= 1.0 / 255.0, "the healthy small-stack CPU control differs: {cpu} vs {gpu}");
+    }
+}
+
+#[test]
+fn a_deep_stack_above_the_device_buffer_limit_returns_an_error_without_panicking() {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = constrained_device() else { return };
+    let mut compositor = compositor(&adapter, &device);
+    healthy_control(&mut compositor, &device, &queue);
+    let deep = fills(150);
+    eprintln!(
+        "uniform-limit reproduction: backend={:?}, buffer limit={}, page={}, passes={}",
+        adapter.get_info().backend,
+        device.limits().max_buffer_size,
+        compositor.page_size(),
+        plan(&deep).unwrap().passes.len()
+    );
+    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| render_to_vec(&mut compositor, &device, &queue, &deep, deep.bounds())));
+    assert!(result.is_ok(), "rendering an oversized uniform buffer must return Unsupported, not panic");
+    assert!(result.unwrap().is_err(), "a stack above the device's buffer limit must return Unsupported");
+}
+
+#[test]
+fn an_oversized_stack_falls_back_without_faulting_the_watched_device() {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = constrained_device() else { return };
+    let health = DeviceHealth::watch(&device);
+    let mut compositor = compositor(&adapter, &device);
+    compositor.set_health(health.clone());
+    healthy_control(&mut compositor, &device, &queue);
+    let deep = fills(150);
+    let fallback = match render_to_vec(&mut compositor, &device, &queue, &deep, deep.bounds()) {
+        Ok(_) => panic!("the oversized stack must return Unsupported for CPU fallback"),
+        Err(_) => photocraft_compose::flatten(&deep),
+    };
+    for (actual, expected) in fallback.px[0].iter().zip([0.25, 0.5, 0.75, 1.0]) {
+        assert!((actual - expected).abs() <= 1.0 / 255.0, "CPU fallback preserves the translucent-fill composite: {actual} vs {expected}");
+    }
+    let small = fills(2);
+    let next = render_to_vec(&mut compositor, &device, &queue, &small, small.bounds());
+    eprintln!("watched uniform-limit reproduction: errors={}, fault={:?}", health.errors(), health.fault());
+    eprintln!("next fitting stack after fallback: {next:?}");
+    assert!(health.is_ok(), "the unsupported stack must leave the device healthy: {:?}", health.fault());
+    assert_eq!(health.errors(), 0, "no invalid GPU operation is issued before falling back");
+    healthy_control(&mut compositor, &device, &queue);
+}
+
+#[test]
+fn the_exact_buffer_limit_still_renders_with_cpu_parity() {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = constrained_device() else { return };
+    let health = DeviceHealth::watch(&device);
+    let mut compositor = compositor(&adapter, &device);
+    compositor.set_health(health.clone());
+    let boundary = fills(127);
+    assert_eq!(plan(&boundary).unwrap().passes.len(), 255, "one chunk plus255passes uses exactly65536bytes");
+    let expected = photocraft_compose::flatten(&boundary);
+    let actual = render_to_vec(&mut compositor, &device, &queue, &boundary, boundary.bounds()).expect("the exact supported buffer boundary is accepted");
+    assert_eq!(actual.len(), 1);
+    for (cpu, gpu) in expected.px[0].iter().zip(actual[0]) {
+        assert!((cpu - gpu).abs() <= 1.0 / 255.0, "the boundary render differs from CPU: {cpu} vs {gpu}");
+    }
+    assert_eq!(health.errors(), 0);
+    assert!(health.is_ok());
+}
+
+#[test]
+fn later_oversized_page_cells_are_rejected_before_render_or_encode_calls_the_sink() {
+    let _lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some((adapter, device, queue)) = constrained_device() else { return };
+    let health = DeviceHealth::watch(&device);
+    let doc = fills_size(126, Size::new(4096, 2048));
+    let region = photocraft_geom::Rect::new(2047, 0, 4096, 2048);
+    assert_eq!(plan(&doc).unwrap().passes.len(), 253);
+    // Default pages are2048, chunks1024: the narrow first page has2chunks and fits;
+    // the later full page has4chunks and would exceed the same65536byte device limit.
+    for encode_only in [false, true] {
+        let mut compositor = Compositor::try_new_with_format(&device, Compositor::preferred_acc_format(&adapter)).unwrap();
+        compositor.set_health(health.clone());
+        assert_eq!(compositor.page_size(), 2048);
+        let mut calls = 0;
+        let mut sink = |_: &mut wgpu::CommandEncoder, _: photocraft_gpu::ChunkOut<'_>| calls += 1;
+        let result = if encode_only {
+            let mut encoder = device.create_command_encoder(&Default::default());
+            compositor.encode(&device, &queue, &mut encoder, &doc, region, &mut sink)
+        } else {
+            compositor.render(&device, &queue, &doc, region, &mut sink)
+        };
+        assert!(result.is_err(), "a later cell's uniform requirement must trigger CPU fallback");
+        assert_eq!(calls, 0, "preflight must reject the whole render before any partial sink output");
+        assert_eq!(health.errors(), 0);
+        assert!(health.is_ok());
+    }
+}
diff --git a/crates/heif/Cargo.toml b/crates/heif/Cargo.toml
index f8ddf6457a..18210b0c46 100644
--- a/crates/heif/Cargo.toml
+++ b/crates/heif/Cargo.toml
@@ -9,11 +9,11 @@ rust-version.workspace = true
 [dependencies]
 # Pure Rust, no unsafe. Pinned exactly: a young, single-owner crate that parses untrusted files;
 # moving the pin is a reviewed change (re-run the fuzz target and the heif corpus tests).
-heic-rs = { version = "=0.1.1", default-features = false, features = ["std"] }
+heic-rs = { version = "=0.1.4", default-features = false, features = ["std"] }
 
 # The tiles of a HEIC photo decode in parallel on native; wasm stays single-threaded.
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-heic-rs = { version = "=0.1.1", default-features = false, features = ["std", "parallel"] }
+heic-rs = { version = "=0.1.4", default-features = false, features = ["std", "parallel"] }
 
 [lints]
 workspace = true
diff --git a/crates/io/src/abr_map.rs b/crates/io/src/abr_map.rs
index 225869ea79..c21800f13d 100644
--- a/crates/io/src/abr_map.rs
+++ b/crates/io/src/abr_map.rs
@@ -86,7 +86,7 @@ pub fn map_file_with(f: &AbrFile, group: &str, ctl: &photocraft_raster::Interrup
                 }
             };
             let name = if b.name.trim().is_empty() { default_name } else { b.name.trim().to_string() };
-            out.presets.push(BrushPreset { name, brush, builtin: false, group: group.to_string(), folder: Vec::new() });
+            out.presets.push(BrushPreset { name, brush, builtin: false, group: group.to_string(), folder: Vec::new(), captures: Default::default() });
         }
     } else if f.presets.is_empty() {
         // Tips without a settings section (early v6 files): one preset per tip.
@@ -94,7 +94,14 @@ pub fn map_file_with(f: &AbrFile, group: &str, ctl: &photocraft_raster::Interrup
             step(i)?;
             let (tip, size) = m.tip(s);
             let brush = BrushSettings { pressure_size: false, spacing: 0.25, size, tip, ..Default::default() };
-            out.presets.push(BrushPreset { name: format!("Sampled Brush {}", i + 1), brush, builtin: false, group: group.to_string(), folder: Vec::new() });
+            out.presets.push(BrushPreset {
+                name: format!("Sampled Brush {}", i + 1),
+                brush,
+                builtin: false,
+                group: group.to_string(),
+                folder: Vec::new(),
+                captures: Default::default(),
+            });
         }
     } else {
         for (i, d) in f.presets.iter().enumerate() {
@@ -105,7 +112,7 @@ pub fn map_file_with(f: &AbrFile, group: &str, ctl: &photocraft_raster::Interrup
                 // named after the imported file.
                 Some(brush) => {
                     let folder = f.folders.get(i).cloned().unwrap_or_default();
-                    out.presets.push(BrushPreset { name, brush, builtin: false, group: group.to_string(), folder });
+                    out.presets.push(BrushPreset { name, brush, builtin: false, group: group.to_string(), folder, captures: Default::default() });
                 }
                 None => {
                     m.warnings.insert(format!("\"{name}\": its sampled tip is missing from the file; skipped"));
@@ -389,7 +396,9 @@ impl Mapper<'_> {
             t.invert = boolean(d, "InvT").unwrap_or(false);
             t.scale = pct(d, "textureScale").unwrap_or(1.0).clamp(0.01, 10.0);
             t.brightness = (num(d, "textureBrightness").unwrap_or(0.0) / 150.0).clamp(-1.0, 1.0) as f32;
-            t.contrast = (num(d, "textureContrast").unwrap_or(0.0) / 50.0).clamp(-1.0, 2.0) as f32;
+            // Photoshop's -50..100 onto the model's -1..1 (negative and positive scale apart).
+            let c = num(d, "textureContrast").unwrap_or(0.0);
+            t.contrast = (if c < 0.0 { c / 50.0 } else { c / 100.0 }).clamp(-1.0, 1.0) as f32;
             t.mode = mask_mode(enum_value(d, "textureBlendMode")).unwrap_or(MaskMode::Multiply);
             t.depth = pct(d, "textureDepth").unwrap_or(1.0).clamp(0.0, 1.0);
             let mut dj = self.dynamic(obj(d, "textureDepthDynamics"));
@@ -420,7 +429,12 @@ impl Mapper<'_> {
             }
             dual.mode = mask_mode(enum_value(db, "BlnM")).unwrap_or(MaskMode::Multiply);
             dual.flip = boolean(db, "Flip").unwrap_or(false);
-            if let Some(v) = pct(db, "Spcn") {
+            // The dual tip's own spacing (`Brsh › Spcn`) is what Photoshop's Dual Brush panel
+            // shows. The `Spcn` beside it on the `dualBrush` object reads 100 % in Photoshop CC
+            // presets whatever the panel says (#4809), so it only stands in for a tip without one.
+            if obj(db, "Brsh").and_then(|t| pct(t, "Spcn")).is_none()
+                && let Some(v) = pct(db, "Spcn")
+            {
                 dual.spacing = v.clamp(0.01, 10.0);
             }
             dual.scatter = self.dynamic(obj(db, "scatterDynamics")).jitter;
@@ -476,9 +490,8 @@ impl Mapper<'_> {
             }
             b.pressure_size = boolean(to, "usePressureOverridesSize").unwrap_or(false);
             b.pressure_opacity = boolean(to, "usePressureOverridesOpacity").unwrap_or(false);
-            if boolean(to, "smoothing").unwrap_or(true)
-                && let Some(v) = pct(to, "smoothingValue")
-            {
+            b.smoothing.enabled = boolean(to, "smoothing").unwrap_or(true);
+            if let Some(v) = pct(to, "smoothingValue") {
                 b.smoothing.amount = v.clamp(0.0, 1.0);
             }
             if let Some(v) = boolean(to, "smoothingRadiusMode") {
diff --git a/crates/io/src/abr_map/tests.rs b/crates/io/src/abr_map/tests.rs
index 9837f4ea4f..8bea763861 100644
--- a/crates/io/src/abr_map/tests.rs
+++ b/crates/io/src/abr_map/tests.rs
@@ -153,7 +153,7 @@ fn v6_settings_map_onto_brush_sections() {
         assert_eq!((sc.count, sc.scatter.jitter, sc.scatter.control, sc.scatter.fade_steps, sc.count_jitter.jitter), (3, 2.5, Control::Fade, 40, 0.5));
         let tx = &b.texture;
         assert!(tx.enabled && tx.each_tip && tx.invert);
-        assert_eq!((tx.scale, tx.brightness, tx.contrast, tx.mode, tx.depth), (1.5, -0.5, 0.5, MaskMode::ColorBurn, 0.6));
+        assert_eq!((tx.scale, tx.brightness, tx.contrast, tx.mode, tx.depth), (1.5, -0.5, 0.25, MaskMode::ColorBurn, 0.6));
         assert_eq!((tx.depth_jitter.jitter, tx.depth_jitter.minimum), (0.3, 0.2));
         let Pattern::Tile(pt) = &tx.pattern else { panic!("embedded pattern expected, got {:?}", tx.pattern) };
         assert_eq!((pt.width, pt.height, pt.data[3]), (4, 2, 65535));
@@ -188,6 +188,28 @@ fn missing_pattern_and_tip_are_reported() {
     assert!(imp.warnings.iter().any(|w| w.contains("Orphan")), "{:?}", imp.warnings);
 }
 
+#[test]
+fn disabled_smoothing_tool_options_keep_the_amount_and_mode() {
+    let preset = Descriptor::new("brushPreset")
+        .with("Nm  ", t("Smoothing off"))
+        .with("Brsh", Value::Descriptor(Descriptor::new("computedBrush").with("Dmtr", u(b"#Pxl", 19.0))))
+        .with(
+            "toolOptions",
+            Value::Descriptor(
+                Descriptor::new("currentToolOptions")
+                    .with("smoothing", Value::Boolean(false))
+                    .with("smoothingValue", Value::Integer(40))
+                    .with("smoothingRadiusMode", Value::Boolean(true)),
+            ),
+        );
+    for sub in [1, 2] {
+        let bytes = write_v6(sub, &[], &[], std::slice::from_ref(&preset), true).unwrap();
+        let imported = read_abr(&bytes, "Test").unwrap();
+        let smoothing = &imported.presets[0].brush.smoothing;
+        assert!(!smoothing.enabled && smoothing.amount == 0.4 && smoothing.pulled_string);
+    }
+}
+
 #[test]
 fn file_folders_nest_inside_the_import_group() {
     let named = |n: &str| Descriptor::new("brushPreset").with("Nm  ", t(n));
@@ -330,3 +352,79 @@ fn sampled_tip_paints_the_brush_colour_never_black() {
     assert!(painted > 0, "the imported tip painted nothing");
     assert!(painted < 64 * 64, "the tip covered everything - coverage was treated as solid colour");
 }
+
+/// #3340: Photoshop's texture Contrast runs -50..100; the model maps -50..0 and 0..100 onto
+/// -1..0 and 0..1 (as Brush Settings shows it), so +24 must not read back as +48.
+#[test]
+fn texture_contrast_maps_both_halves() {
+    for (c, want) in [(24, 0.24), (100, 1.0), (-30, -0.6), (-50, -1.0), (0, 0.0)] {
+        let preset = Descriptor::new("brushPreset")
+            .with("Nm  ", t("C"))
+            .with("Brsh", Value::Descriptor(Descriptor::new("computedBrush").with("Dmtr", u(b"#Pxl", 20.0))))
+            .with("useTexture", Value::Boolean(true))
+            .with("textureContrast", Value::Integer(c));
+        let bytes = write_v6(2, &[], &[], &[preset], false).unwrap();
+        let imp = read_abr(&bytes, "Test").unwrap();
+        let got = imp.presets[0].brush.texture.contrast;
+        assert!((got - want).abs() < 1e-6, "contrast {c}: {got}");
+    }
+}
+
+/// #3340: a Height-mode brush at a low depth with a darkened pattern (how Photoshop's own
+/// "Pen" presets in the reported file are set up) imported but painted nothing.
+#[test]
+fn low_depth_height_texture_brush_paints() {
+    use photocraft_color::PixelFormat;
+    use photocraft_paint::StrokePoint;
+    use photocraft_paint::render::render_stroke;
+    use photocraft_raster::Surface;
+
+    for mode in ["Hght", "linearHeight"] {
+        let preset = Descriptor::new("brushPreset")
+            .with("Nm  ", t("Pen"))
+            .with("Brsh", Value::Descriptor(Descriptor::new("computedBrush").with("Dmtr", u(b"#Pxl", 20.0)).with("Hrdn", prc(100.0)).with("Spcn", prc(5.0))))
+            .with("useTexture", Value::Boolean(true))
+            .with("textureBlendMode", en("BlnM", mode))
+            .with("textureDepth", prc(13.0))
+            .with("textureBrightness", Value::Integer(-87))
+            .with("textureContrast", Value::Integer(5))
+            .with("Txtr", Value::Descriptor(Descriptor::new("Ptrn").with("Nm  ", t("Grit")).with("Idnt", t("pat-uuid"))));
+        let bytes = write_v6(2, &[], &[grit_pattern()], &[preset], false).unwrap();
+        let imp = read_abr(&bytes, "Test").unwrap();
+        let b = imp.presets[0].brush.clone();
+        let mut s = Surface::new(PixelFormat::RGBA32F);
+        render_stroke(&mut s, &b, &[StrokePoint::new(10.0, 20.0, 1.0), StrokePoint::new(50.0, 20.0, 1.0)], None, false, 1.0);
+        let covered = (12..48).filter(|&x| s.rgba(x, 20)[3] > 0.5).count();
+        // 13 % depth reaches 1.55 pattern ranges: above the whole darkened Grit pattern.
+        assert_eq!(covered, 36, "{mode}: the stroke painted {covered} of 36 pixels");
+    }
+}
+
+/// #4809: Photoshop CC presets store the dual tip's spacing in `dualBrush › Brsh › Spcn` and a
+/// `Spcn` of 100 % on the `dualBrush` object beside it; the tip's value is the panel's. A tip
+/// without one still takes the outer value.
+#[test]
+fn dual_brush_spacing_comes_from_its_tip() {
+    let dual = |tip: Descriptor| {
+        Descriptor::new("brushPreset")
+            .with("Nm  ", t("SPACING 10%"))
+            .with("Brsh", Value::Descriptor(Descriptor::new("computedBrush").with("Dmtr", u(b"#Pxl", 30.0))))
+            .with(
+                "dualBrush",
+                Value::Descriptor(
+                    Descriptor::new("dualBrush")
+                        .with("useDualBrush", Value::Boolean(true))
+                        .with("Brsh", Value::Descriptor(tip))
+                        .with("BlnM", en("BlnM", "Ovrl"))
+                        .with("Spcn", prc(100.0)),
+                ),
+            )
+    };
+    let spacing = |preset: Descriptor| {
+        let bytes = write_v6(2, &[], &[], &[preset], false).unwrap();
+        read_abr(&bytes, "Test").unwrap().presets[0].brush.dual_brush.spacing
+    };
+    let tip = Descriptor::new("computedBrush").with("Dmtr", u(b"#Pxl", 40.0));
+    assert!((spacing(dual(tip.clone().with("Spcn", prc(10.0)))) - 0.10).abs() < 1e-6, "the tip's 10 %, not the outer 100 %");
+    assert!((spacing(dual(tip)) - 1.0).abs() < 1e-6, "no tip spacing: the outer value");
+}
diff --git a/crates/io/src/adjust_map.rs b/crates/io/src/adjust_map.rs
index 03f3180b0c..6e82478389 100644
--- a/crates/io/src/adjust_map.rs
+++ b/crates/io/src/adjust_map.rs
@@ -267,7 +267,10 @@ fn be32(d: &[u8], at: usize) -> Option<u32> {
 /// key), reverse, dither, [method], name, colour stops (location /4096, midpoint %, colour
 /// space + four u16 components, 2 bytes), transparency stops, then smoothness (/4096) among
 /// noise-gradient fields. Smoothness, midpoints and the method are baked into dense stops like
-/// gradient fills. Noise gradients (no colour stops) and non-RGB stops stay unsupported.
+/// gradient fills. Stops may be in any plain colour space Photoshop writes (RGB, HSB, CMYK, Lab,
+/// Grayscale: a CMYK or Lab document stores them in its own space); they are converted to RGB
+/// through the colour-managed conversions (the document's CMYK profile when one is in scope).
+/// Noise gradients (no colour stops) and stops in other spaces (book colours) stay unsupported.
 fn parse_gradient_map(d: &[u8]) -> Option<Adjustment> {
     let version = be16(d, 0)?;
     let reverse = *d.get(2)? != 0;
@@ -285,11 +288,9 @@ fn parse_gradient_map(d: &[u8]) -> Option<Adjustment> {
     for _ in 0..n {
         let loc = (be32(d, at)? as f32 / 4096.0).clamp(0.0, 1.0);
         let mid = be32(d, at + 4)? as f32 / 100.0;
-        if be16(d, at + 8)? != 0 {
-            return None;
-        }
-        let c = |k: usize| be16(d, at + 10 + 2 * k).map(|v| f32::from(v) / 65535.0);
-        stops.push((loc, photocraft_color::Color::rgb(c(0)?, c(1)?, c(2)?)));
+        let space = be16(d, at + 8)?;
+        let c = |k: usize| be16(d, at + 10 + 2 * k);
+        stops.push((loc, crate::channel_map::decode_known_color(space, [c(0)?, c(1)?, c(2)?, c(3)?])?));
         mids.push(mid);
         at += 20;
     }
@@ -309,6 +310,23 @@ fn parse_gradient_map(d: &[u8]) -> Option<Adjustment> {
     Some(Adjustment::GradientMap { stops, reverse, dither })
 }
 
+/// Points an imported `grdm` block at `target` when only Reverse and/or Dither differ (the
+/// stops parse unchanged): patches those two bytes and returns `true`, so the file's own stops
+/// (in whatever colour space it stored them), smoothness and method survive the save. `false`
+/// leaves `data` untouched.
+pub(crate) fn retarget_gradient_map(data: &mut [u8], target: &Adjustment, channels: Channels) -> bool {
+    let Adjustment::GradientMap { stops, reverse, dither } = target else { return false };
+    let same_stops = matches!(parse(b"grdm", data, None, channels), Adjustment::GradientMap { stops: s, .. } if s == *stops);
+    match (same_stops, data.get_mut(2..4)) {
+        (true, Some(flags)) => {
+            flags[0] = u8::from(*reverse);
+            flags[1] = u8::from(*dither);
+            true
+        }
+        _ => false,
+    }
+}
+
 /// `grdm` version 1 for [`Adjustment::GradientMap`] (Classic interpolation, Smoothness 0, so
 /// the stops are reproduced exactly).
 fn write_gradient_map(stops: &[(f32, [f32; 3])], reverse: bool, dither: bool) -> Vec<u8> {
@@ -488,8 +506,17 @@ fn parse_black_white(d: &[u8]) -> Option<Adjustment> {
 }
 
 /// `phfl` (Adobe spec, "Photo Filter"): version (2 or 3); version 2 has a colour structure
-/// (colour space + four u16), version 3 three i32 holding the Lab colour ×100 (as documented by
-/// ag-psd, MIT); then density (u32 percent) and preserve luminosity (1 byte).
+/// (colour space + four u16), version 3 "4 bytes each for XYZ color"; then density (u32 percent)
+/// and preserve luminosity (1 byte).
+///
+/// The spec gives no scale for the XYZ values. They are read as XYZ relative to the D50 white
+/// (X / 0.9642, Y, Z / 0.8249) with 1.0 = 32768, so white is stored as (32768, 32768, 32768).
+/// That is inferred, not documented: decoded this way, every version 3 colour in the Photoshop
+/// CS2 files of #3777 and #4940 is exactly a Photoshop preset (the Yellow filter holds
+/// (24191, 25002, 3827) and decodes to #F9E31C, Warming Filter (85) holds (15548, 12029, 0)
+/// and decodes to #EC8A00); reading them as absolute XYZ gives #FFE03A and #F18600.
+const PHFL_XYZ_ONE: f32 = 32768.0;
+
 fn parse_photo_filter(d: &[u8]) -> Option<Adjustment> {
     let (color, at) = match be16(d, 0)? {
         2 => {
@@ -501,11 +528,16 @@ fn parse_photo_filter(d: &[u8]) -> Option<Adjustment> {
             (crate::channel_map::decode_color(space, c).to_rgb(), 12)
         }
         3 => {
-            let lab = [be32(d, 2)? as i32, be32(d, 6)? as i32, be32(d, 10)? as i32].map(|v| v as f32 / 100.0);
-            if !(0.0..=100.0).contains(&lab[0]) || lab[1].abs() > 128.0 || lab[2].abs() > 128.0 {
+            let rel = [be32(d, 2)?, be32(d, 6)?, be32(d, 10)?].map(|v| v as f32 / PHFL_XYZ_ONE);
+            // Relative to the white, real colours stay below about 2.0 (Cooling Filter (82)
+            // reaches 1.99 on Z); anything past that is not an XYZ colour.
+            if rel.iter().any(|v| *v > 2.0) {
                 return None;
             }
-            (photocraft_color::convert::lab_to_srgb(lab), 14)
+            // Relative to the D50 white: bring it back to absolute D50 XYZ before converting.
+            let xyz = [rel[0] * photocraft_color::convert::D50[0], rel[1], rel[2] * photocraft_color::convert::D50[2]];
+            let lin = photocraft_color::convert::mat3_mul(&photocraft_color::convert::XYZ_D50_TO_SRGB, xyz);
+            (lin.map(|v| photocraft_color::convert::linear_to_srgb(v.clamp(0.0, 1.0))), 14)
         }
         _ => return None,
     };
@@ -824,6 +856,89 @@ mod tests {
         assert_eq!(write(&a)[0].1, block);
     }
 
+    /// A two-stop `grdm` (version 1) whose stops are the colour structures `a` and `b`.
+    fn grdm_with(a: (u16, [u16; 4]), b: (u16, [u16; 4])) -> Vec<u8> {
+        let mut v = write_gradient_map(&[(0.0, [0.0; 3]), (1.0, [1.0; 3])], false, false);
+        // Header 4 + name length 4 + "Custom\0" 14 + stop count 2; 20 bytes per stop.
+        for (i, (space, c)) in [a, b].into_iter().enumerate() {
+            let at = 24 + 20 * i + 8;
+            v[at..at + 2].copy_from_slice(&space.to_be_bytes());
+            for (k, x) in c.iter().enumerate() {
+                v[at + 2 + 2 * k..at + 4 + 2 * k].copy_from_slice(&x.to_be_bytes());
+            }
+        }
+        v
+    }
+
+    fn ends(a: &Adjustment) -> ([f32; 3], [f32; 3]) {
+        match a {
+            Adjustment::GradientMap { stops, .. } => (stops[0].1, stops[stops.len() - 1].1),
+            other => panic!("{other:?}"),
+        }
+    }
+
+    #[test]
+    fn gradient_map_stops_in_every_colour_space() {
+        use photocraft_color::{Color, ColorMode};
+        let white_rgb = (0, [65535, 65535, 65535, 0]);
+        // CMYK, stored inverted: 65535 = no ink. Full K only.
+        let k_only = grdm_with((2, [65535, 65535, 65535, 0]), white_rgb);
+        let expected = Color { mode: ColorMode::Cmyk, c: [0.0, 0.0, 0.0, 1.0], alpha: 1.0 }.to_rgb();
+        for channels in [Channels::Cmyk, Channels::Rgb, Channels::Lab] {
+            let a = parse(b"grdm", &k_only, None, channels);
+            let (first, last) = ends(&a);
+            assert!(first.iter().zip(expected).all(|(x, y)| (x - y).abs() < 1e-5), "{first:?} vs {expected:?}");
+            assert!(first[0] < 0.4 && (first[0] - first[2]).abs() < 0.05, "K-only black is a dark neutral: {first:?}");
+            assert_eq!(last, [1.0; 3]);
+        }
+        // Lab: L 50, a 0, b 0 is a neutral mid grey; L 100 white.
+        let lab = parse(b"grdm", &grdm_with((7, [5000, 0, 0, 0]), (7, [10000, 0, 0, 0])), None, Channels::Lab);
+        let (first, last) = ends(&lab);
+        assert!(first.iter().all(|v| (v - 0.466).abs() < 0.01), "{first:?}");
+        assert!(last.iter().all(|v| *v > 0.99), "{last:?}");
+        // Lab with chroma: a = +60 is reddish (a and b are signed hundredths).
+        let red = parse(b"grdm", &grdm_with((7, [5000, 6000, 0, 0]), white_rgb), None, Channels::Lab);
+        let (first, _) = ends(&red);
+        assert!(first[0] > first[1] + 0.2, "{first:?}");
+        // Grayscale: 0..10000 is ink coverage (10000 = black).
+        let gray = parse(b"grdm", &grdm_with((8, [10000, 0, 0, 0]), (8, [0, 0, 0, 0])), None, Channels::Gray);
+        assert_eq!(ends(&gray), ([0.0; 3], [1.0; 3]));
+        // HSB: hue 240 degrees (2/3 of 65535), full saturation and brightness = blue.
+        let hsb = parse(b"grdm", &grdm_with((1, [43690, 65535, 65535, 0]), white_rgb), None, Channels::Rgb);
+        let (first, _) = ends(&hsb);
+        assert!(first[0] < 1e-3 && first[1] < 1e-3 && (first[2] - 1.0).abs() < 1e-3, "{first:?}");
+        // Book colours and unknown ids are not guessed: the block stays raw.
+        for space in [3u16, 9, 0xFFFF] {
+            let d = grdm_with((space, [1, 2, 3, 4]), white_rgb);
+            assert!(matches!(parse(b"grdm", &d, None, Channels::Rgb), Adjustment::Unsupported { .. }), "space {space}");
+        }
+        // Truncated stops never panic.
+        for n in 0..k_only.len() {
+            let _ = parse(b"grdm", &k_only[..n], None, Channels::Cmyk);
+        }
+    }
+
+    #[test]
+    fn gradient_map_reverse_and_dither_keep_the_stops_block() {
+        let original = grdm_with((2, [65535, 65535, 65535, 0]), (7, [10000, 0, 0, 0]));
+        let Adjustment::GradientMap { stops, .. } = parse(b"grdm", &original, None, Channels::Cmyk) else { panic!() };
+        let mut data = original.clone();
+        let target = Adjustment::GradientMap { stops: stops.clone(), reverse: true, dither: true };
+        assert!(retarget_gradient_map(&mut data, &target, Channels::Cmyk));
+        assert_eq!(&data[2..4], &[1, 1]);
+        assert_eq!(data[4..], original[4..], "the stops keep their colour spaces");
+        assert_eq!(parse(b"grdm", &data, None, Channels::Cmyk), target);
+        // Edited stops are not patched in.
+        let mut edited = stops;
+        edited[0].1 = [0.5; 3];
+        let mut data2 = original.clone();
+        let target = Adjustment::GradientMap { stops: edited, reverse: false, dither: false };
+        assert!(!retarget_gradient_map(&mut data2, &target, Channels::Cmyk));
+        assert_eq!(data2, original);
+        assert!(!retarget_gradient_map(&mut [], &target, Channels::Cmyk));
+        assert!(!retarget_gradient_map(&mut data2, &Adjustment::Invert, Channels::Cmyk));
+    }
+
     fn rt(a: Adjustment) {
         let blocks = write(&a);
         assert!(!blocks.is_empty(), "{a:?}");
@@ -974,15 +1089,17 @@ mod tests {
         assert!(matches!(parse(b"mixr", &ours[0].1, None, Channels::Cmyk), Adjustment::ChannelMixer { .. }));
         assert!(matches!(parse(b"mixr", &ours[0].1, None, Channels::Other), Adjustment::ChannelMixer { .. }));
         assert!(matches!(parse(b"mixr", &[0, 1, 0, 0, 0, 100], None, Channels::Rgb), Adjustment::Unsupported { .. }));
-        // Photo Filter: unknown version, HSB colour space, out-of-range version-3 Lab, truncated.
+        // Photo Filter: unknown version, HSB colour space, out-of-range version-3 XYZ, truncated.
         assert!(matches!(parse(b"phfl", &[0, 4, 0, 0], None, Channels::Rgb), Adjustment::Unsupported { .. }));
         assert!(matches!(parse(b"phfl", &[0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 1], None, Channels::Rgb), Adjustment::Unsupported { .. }));
-        let mut lab = vec![0, 3];
-        for x in [20000i32, 0, 0] {
-            lab.extend(x.to_be_bytes());
+        for bad in [[200_000u32, 0, 0], [0, u32::MAX, 0]] {
+            let mut xyz = vec![0, 3];
+            for x in bad {
+                xyz.extend(x.to_be_bytes());
+            }
+            xyz.extend([0, 0, 0, 25, 1]);
+            assert!(matches!(parse(b"phfl", &xyz, None, Channels::Rgb), Adjustment::Unsupported { .. }));
         }
-        lab.extend([0, 0, 0, 25, 1]);
-        assert!(matches!(parse(b"phfl", &lab, None, Channels::Rgb), Adjustment::Unsupported { .. }));
         assert!(matches!(parse(b"phfl", &[0, 2, 0, 0, 0, 0], None, Channels::Rgb), Adjustment::Unsupported { .. }));
         // Arbitrary bytes never panic, whatever the key.
         for key in ADJUSTMENT_KEYS {
@@ -1055,25 +1172,56 @@ mod tests {
         let Adjustment::PhotoFilter { color, density, preserve_luminosity: false } = parse(b"phfl", &lab, None, Channels::Rgb) else { panic!() };
         assert!(color.iter().all(|c| (c - 0.466).abs() < 0.01), "{color:?}");
         assert_eq!(density, 0.25);
-        // Version 3: Lab ×100 as i32 (L 100, a 0, b 0 = white), density 100 %.
-        let mut v3 = vec![0, 3];
-        for x in [10000i32, 0, 0] {
-            v3.extend(x.to_be_bytes());
-        }
-        v3.extend(100u32.to_be_bytes());
-        v3.push(1);
+        // Version 3: XYZ relative to the D50 white, 1.0 = 32768. White is (32768, 32768, 32768).
+        let v3 = phfl_v3([32768, 32768, 32768], 100, true);
         let Adjustment::PhotoFilter { color, density, preserve_luminosity: true } = parse(b"phfl", &v3, None, Channels::Rgb) else { panic!() };
-        assert!(color.iter().all(|c| (c - 1.0).abs() < 0.01), "{color:?}");
+        assert!(color.iter().all(|c| (c - 1.0).abs() < 0.005), "{color:?}");
         assert_eq!(density, 1.0);
-        // A negative a* (green) in version 3.
-        let mut green = vec![0, 3];
-        for x in [5000i32, -6000, 0] {
-            green.extend(x.to_be_bytes());
+        // Photoshop's Warming Filter (85) preset, sRGB #EC8A00: the CS2 file of #4940 stores it
+        // relative to the D50 white as (15548, 12029, 0).
+        let Adjustment::PhotoFilter { color, density, preserve_luminosity: false } =
+            parse(b"phfl", &phfl_v3([15548, 12029, 0], 25, false), None, Channels::Rgb)
+        else {
+            panic!()
+        };
+        let expected = [0xecu8, 0x8a, 0x00].map(|v| f32::from(v) / 255.0);
+        assert!(color.iter().zip(expected).all(|(got, want)| (got - want).abs() < 1.5 / 255.0), "{color:?}");
+        assert_eq!(density, 0.25);
+        // The block from #3777 (Photoshop CS2): the Yellow filter preset, #F9E31C, density 63 %.
+        let issue = [0, 3, 0, 0, 0x5e, 0x7f, 0, 0, 0x61, 0xaa, 0, 0, 0x0e, 0xf3, 0, 0, 0, 0x3f, 1, 0];
+        let Adjustment::PhotoFilter { color, density, preserve_luminosity: true } = parse(b"phfl", &issue, None, Channels::Rgb) else { panic!() };
+        let expected = [0xf9u8, 0xe3, 0x1c].map(|v| f32::from(v) / 255.0);
+        assert!(color.iter().zip(expected).all(|(got, want)| (got - want).abs() < 1.5 / 255.0), "{color:?}");
+        assert_eq!(density, 0.63);
+        // Cooling Filter (82) from #4940: a deep blue outside sRGB; its Z stays under the 2.0
+        // garbage guard and the colour clamps to (0, 181, 255).
+        let Adjustment::PhotoFilter { color: cooling, density, preserve_luminosity: true } =
+            parse(b"phfl", &phfl_v3([5327, 9584, 65357], 72, true), None, Channels::Rgb)
+        else {
+            panic!("Cooling Filter (82) must parse")
+        };
+        let expected = [0u8, 181, 255].map(|v| f32::from(v) / 255.0);
+        assert!(cooling.iter().zip(expected).all(|(got, want)| (got - want).abs() < 1.5 / 255.0), "{cooling:?}");
+        assert_eq!(density, 0.72);
+        // The 19-byte form (no trailing pad) parses the same.
+        assert_eq!(parse(b"phfl", &issue[..19], None, Channels::Rgb), parse(b"phfl", &issue, None, Channels::Rgb));
+        // Version 3 is read, never written: an edited filter is saved as version 2 and keeps its colour.
+        let a = parse(b"phfl", &issue, None, Channels::Rgb);
+        let w = write(&a);
+        assert_eq!(&w[0].1[..2], &[0, 2]);
+        let Adjustment::PhotoFilter { color: back, .. } = parse(b"phfl", &w[0].1, None, Channels::Rgb) else { panic!() };
+        assert!(back.iter().zip(color).all(|(b, c)| (b - c).abs() <= 1.0 / 65535.0));
+    }
+
+    /// A version 3 Photo Filter block: version, three u32 XYZ components, density, flag, pad.
+    fn phfl_v3(xyz: [u32; 3], density: u32, preserve_luminosity: bool) -> Vec<u8> {
+        let mut d = vec![0, 3];
+        for x in xyz {
+            d.extend(x.to_be_bytes());
         }
-        green.extend(30u32.to_be_bytes());
-        green.push(0);
-        let Adjustment::PhotoFilter { color, .. } = parse(b"phfl", &green, None, Channels::Rgb) else { panic!() };
-        assert!(color[1] > color[0] && color[1] > color[2], "{color:?}");
+        d.extend(density.to_be_bytes());
+        d.extend([u8::from(preserve_luminosity), 0]);
+        d
     }
 
     #[test]
diff --git a/crates/io/src/affinity.rs b/crates/io/src/affinity.rs
index f829326e21..efba868be0 100644
--- a/crates/io/src/affinity.rs
+++ b/crates/io/src/affinity.rs
@@ -151,6 +151,7 @@ impl Builder {
             bg.prune();
             let mut l = Layer::new("Background", LayerContent::Raster(bg));
             l.locks.transparency = true;
+            l.locks.position = true;
             layers.insert(0, l);
         }
         self.doc.layers = layers;
diff --git a/crates/io/src/annotations_map.rs b/crates/io/src/annotations_map.rs
index 28ab181c83..27b6c04477 100644
--- a/crates/io/src/annotations_map.rs
+++ b/crates/io/src/annotations_map.rs
@@ -133,6 +133,11 @@ fn parse_entries(data: &[u8]) -> Option<Vec<Entry>> {
     for _ in 0..count {
         let start = r.p;
         let len = r.u32()? as usize;
+        // The length counts itself and the type: anything shorter would put the cursor back on
+        // this entry, and a hostile count would then loop until memory runs out.
+        if len < 8 {
+            return None;
+        }
         let end = start.checked_add(len)?;
         let raw = data.get(start..end)?;
         let kind = r.take(4)?;
@@ -422,6 +427,22 @@ mod tests {
         assert!(!anno_unreadable(&d));
     }
 
+    /// An entry length below 8 (its own `u32` plus the type) put the cursor back on the same
+    /// entry, so a count of 0xFFFFFFFF looped ~4.3e9 times and ran out of memory.
+    #[test]
+    fn short_entry_length_is_unreadable_not_a_loop() {
+        for len in [0u8, 4, 7] {
+            for kind in [b"sndA", b"txtA"] {
+                let mut b = vec![0, 2, 0, 1, 0, 0, 0, 3, 0, 0, 0, len];
+                b.extend_from_slice(kind);
+                b.extend_from_slice(&[0; 64]);
+                assert!(parse_entries(&b).is_none(), "len {len} {kind:?}");
+            }
+        }
+        let hostile = [0, 2, 0, 1, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0, b's', b'n', b'd', b'A'];
+        assert!(parse_anno(&hostile).is_none());
+    }
+
     #[test]
     fn scale_resource_roundtrip_and_keep_rules() {
         let s = MeasurementScale { pixel_length: 150.0, logical_length: 2.0, units: "mm".into() };
diff --git a/crates/io/src/blocks.rs b/crates/io/src/blocks.rs
index 329ee35fb8..87fda102fe 100644
--- a/crates/io/src/blocks.rs
+++ b/crates/io/src/blocks.rs
@@ -527,15 +527,25 @@ pub(crate) fn with_pattern_placement(mut d: Descriptor, angle: f32, link: bool,
 
 /// The warp of a placed layer (`SoLd`/`SoLE` `warp` descriptor): style, bend, distortions,
 /// axis, bounds and, for `warpCustom`, the 4 × 4 `customEnvelopeWarp` mesh. Read-only: the raw
-/// block is what gets written back. `None` when absent or `warpNone` with no mesh.
+/// block is what gets written back. `None` when absent or `warpNone` with no mesh. A `PlLd`
+/// record keeps its warp elsewhere: see [`parse_plld_warp`].
 pub fn parse_placed_warp(key: &[u8; 4], data: &[u8]) -> Option<photocraft_geom::warp::Warp> {
-    use photocraft_geom::warp::{BezierMesh, Warp, WarpStyle};
     if key != b"SoLd" && key != b"SoLE" {
         return None;
     }
     let d = data.get(8..).and_then(parse_prefix_versioned)?;
-    let w = get_desc(&d, "warp")?;
+    warp_of(get_desc(&d, "warp")?).flatten()
+}
+
+/// A `warp` descriptor (the `SoLd` key, or the whole descriptor after a `PlLd` record's corners)
+/// as a warp: `Some(None)` for no warp (`warpNone`, or a warp that moves nothing), `None` when it
+/// can't be read (an unknown style, missing bounds, a mesh that isn't 4 × 4).
+fn warp_of(w: &Descriptor) -> Option<Option<photocraft_geom::warp::Warp>> {
+    use photocraft_geom::warp::{BezierMesh, Warp, WarpStyle};
     let style = enum_of(w, "warpStyle").and_then(|v| WarpStyle::parse(&String::from_utf8_lossy(v)))?;
+    if style == WarpStyle::None {
+        return Some(None);
+    }
     let b = get_desc(w, "bounds")?;
     let g = |k: &str| num(b.get(k));
     let bounds = [g("Left")?, g("Top ")?, g("Rght")?, g("Btom")?];
@@ -558,7 +568,7 @@ pub fn parse_placed_warp(key: &[u8; 4], data: &[u8]) -> Option<photocraft_geom::
         warp.mesh = mesh.is_valid().then_some(mesh);
         warp.mesh.as_ref()?;
     }
-    (!warp.is_identity()).then_some(warp)
+    Some((!warp.is_identity()).then_some(warp))
 }
 
 /// Text content and transform from a `TySh` block (best effort).
@@ -582,7 +592,24 @@ pub(crate) fn parse_prefix_versioned(data: &[u8]) -> Option<Descriptor> {
     VersionedDescriptor::parse_prefix(data).ok().map(|(v, _)| v.descriptor)
 }
 
-/// Smart object identifier and transform from `SoLd`/`PlLd` (best effort).
+/// The source-space box Photoshop maps onto a placed layer's `Trnf` quad: the bounding box of a
+/// single-patch custom warp's 16 control points, which may spill past the source, else the source
+/// rect `0..w × 0..h`. Mapping the source rect instead counts the overhang twice and stretches the
+/// placement. A degenerate or non-finite box falls back to the source rect.
+pub(crate) fn placed_frame(warp: Option<&photocraft_geom::warp::Warp>, w: f64, h: f64) -> [f64; 4] {
+    let rect = [0.0, 0.0, w, h];
+    let Some(m) = warp.filter(|wp| wp.style == photocraft_geom::warp::WarpStyle::Custom).and_then(|wp| wp.mesh.as_ref()).filter(|m| m.points.len() == 16)
+    else {
+        return rect;
+    };
+    let inf = f64::INFINITY;
+    let b = m.points.iter().fold([inf, inf, -inf, -inf], |b, [x, y]| [b[0].min(*x), b[1].min(*y), b[2].max(*x), b[3].max(*y)]);
+    let ok = b.iter().all(|v| v.is_finite()) && b[2] - b[0] > 1e-9 && b[3] - b[1] > 1e-9;
+    if ok { b } else { rect }
+}
+
+/// Smart object identifier and transform from `SoLd`/`SoLE` (best effort). A `PlLd` block
+/// stores no source size, so its transform needs the embedded file: see [`parse_plld`].
 pub fn parse_smart(key: &[u8; 4], data: &[u8]) -> (String, Affine) {
     // SoLd: 'soLD' + version(4) + versioned descriptor.
     let desc = if key == b"SoLd" || key == b"SoLE" { data.get(8..).and_then(parse_prefix_versioned) } else { None };
@@ -595,13 +622,97 @@ pub fn parse_smart(key: &[u8; 4], data: &[u8]) -> (String, Affine) {
     if let (Some(Value::List(pts)), Some(sz)) = (d.get("Trnf"), get_desc(&d, "Sz  ")) {
         let p: Vec<f64> = pts.iter().filter_map(|v| num(Some(v))).collect();
         let (w, h) = (num(sz.get("Wdth")).unwrap_or(0.0), num(sz.get("Hght")).unwrap_or(0.0));
-        if p.len() == 8 && w > 0.0 && h > 0.0 {
-            affine = Affine { m: [(p[2] - p[0]) / w, (p[3] - p[1]) / w, (p[6] - p[0]) / h, (p[7] - p[1]) / h, p[0], p[1]] };
+        if let (Ok(p), true) = (<[f64; 8]>::try_from(p), w > 0.0 && h > 0.0) {
+            affine = corners_affine(&p, placed_frame(parse_placed_warp(key, data).as_ref(), w, h)).unwrap_or(Affine::IDENTITY);
         }
     }
     (id, affine)
 }
 
+/// The affine that takes the source-space box `frame` (left, top, right, bottom; see
+/// [`placed_frame`]) onto placed corners `p` (top-left, top-right, bottom-right, bottom-left as
+/// x, y pairs). `None` for an empty or non-finite frame, or non-finite corners.
+pub fn corners_affine(p: &[f64; 8], frame: [f64; 4]) -> Option<Affine> {
+    let [x0, y0, x1, y1] = frame;
+    let (bw, bh) = (x1 - x0, y1 - y0);
+    if !(frame.iter().chain(p).all(|v| v.is_finite()) && bw > 0.0 && bh > 0.0) {
+        return None;
+    }
+    let (a, b, c, d) = ((p[2] - p[0]) / bw, (p[3] - p[1]) / bw, (p[6] - p[0]) / bh, (p[7] - p[1]) / bh);
+    let m = [a, b, c, d, p[0] - a * x0 - c * y0, p[1] - b * x0 - d * y0];
+    m.iter().all(|v| v.is_finite()).then_some(Affine { m })
+}
+
+/// The transform and (Distort/Perspective) projective placement of a `PlLd` record's corners `p`
+/// for a source of `size` warped by `warp`: the inverse of [`crate::smart_map::plld_bytes`]'s
+/// quad. As for `SoLd`'s `Trnf` (#3677), affine corners frame a single-patch custom warp's
+/// control-point box (which may spill past the source), else the source rect; projective corners
+/// frame the source rect, as `parse_smart_perspective` reads them. `PlLd` stores no source size:
+/// without the source file (`None`) the layer is taken as placed at 100 %, the edge lengths being
+/// its size (a custom warp's box needs no size); position and rotation stay right, only Replace
+/// Contents and re-renders depend on the scale. Import and export (which keeps an unedited record
+/// verbatim) both place a `PlLd` layer with this.
+pub fn plld_transform(p: &[f64; 8], size: Option<(f64, f64)>, warp: Option<&photocraft_geom::warp::Warp>) -> (Affine, Option<[f64; 9]>) {
+    let (w, h) = size.unwrap_or_else(|| ((p[2] - p[0]).hypot(p[3] - p[1]), (p[6] - p[0]).hypot(p[7] - p[1])));
+    let perspective = corners_perspective([[p[0], p[1]], [p[2], p[3]], [p[4], p[5]], [p[6], p[7]]], (w, h));
+    let frame = if perspective.is_some() { [0.0, 0.0, w, h] } else { placed_frame(warp, w, h) };
+    (corners_affine(p, frame).unwrap_or(Affine::IDENTITY), perspective)
+}
+
+/// The source identifier and placed corners of a `PlLd` block, the placed-layer record Photoshop
+/// CS2 and older write with no `SoLd` next to it (#2465). Adobe PSD spec, "Placed Layer": `plcL`,
+/// version, Pascal unique id (unpadded), page, total pages, anti-alias policy, layer type, then
+/// 8 doubles: the x, y of each corner (top-left, top-right, bottom-right, bottom-left). The warp
+/// that follows is read by [`parse_plld_warp`]. `None` for anything else or a truncated record.
+pub fn parse_plld(data: &[u8]) -> Option<(String, [f64; 8])> {
+    plld_record(data).map(|(id, corners, _)| (id, corners))
+}
+
+/// [`parse_plld`] and the offset just past the corners, where the warp starts.
+fn plld_record(data: &[u8]) -> Option<(String, [f64; 8], usize)> {
+    if data.get(..4)? != b"plcL" {
+        return None;
+    }
+    let n = usize::from(*data.get(8)?);
+    let id = String::from_utf8_lossy(data.get(9..9 + n)?).into_owned();
+    // Page number, total pages, anti-alias policy and layer type (4 × u32).
+    let at = 9 + n + 16;
+    let mut corners = [0.0; 8];
+    for (i, c) in corners.iter_mut().enumerate() {
+        let b = data.get(at + i * 8..at + i * 8 + 8)?;
+        *c = f64::from_be_bytes(b.try_into().ok()?);
+    }
+    corners.iter().all(|v| v.is_finite()).then_some((id, corners, at + 64))
+}
+
+/// The warp of a placed layer's `PlLd` record (Photoshop CS2 can warp a smart object).
+#[derive(Debug, Clone, PartialEq)]
+pub enum PlldWarp {
+    /// No warp: `warpNone`, a warp that moves nothing, or a record that ends at its corners.
+    None,
+    /// The warp, in source pixels like the `SoLd` one.
+    Warp(photocraft_geom::warp::Warp),
+    /// A warp is stored but can't be read (or the record itself can't be): re-rendering the
+    /// layer from its source would drop it.
+    Unreadable,
+}
+
+/// The warp after a `PlLd` record's corners: a u32 warp version, then a versioned `warp`
+/// descriptor (Adobe PSD spec, "Placed Layer"; the layout [`crate::smart_map::plld_bytes`]
+/// writes).
+pub fn parse_plld_warp(data: &[u8]) -> PlldWarp {
+    let Some(rest) = plld_record(data).and_then(|(_, _, end)| data.get(end..)) else { return PlldWarp::Unreadable };
+    // Only padding after the corners: no warp stored.
+    if rest.iter().all(|b| *b == 0) {
+        return PlldWarp::None;
+    }
+    match rest.get(4..).and_then(parse_prefix_versioned).as_ref().and_then(warp_of) {
+        Some(Some(w)) => PlldWarp::Warp(w),
+        Some(None) => PlldWarp::None,
+        None => PlldWarp::Unreadable,
+    }
+}
+
 /// The projective placement of a `SoLd` / `SoLE` block whose corners aren't a parallelogram
 /// (Distort, Perspective): source pixels → document pixels, row-major 3×3. Read from
 /// `nonAffineTransform` (the placed corners), else `Trnf`. `None` for affine placements, which
@@ -619,6 +730,12 @@ pub fn parse_smart_perspective(key: &[u8; 4], data: &[u8]) -> Option<[f64; 9]> {
         (p.len() == 8 && p.iter().all(|v| v.is_finite())).then(|| [[p[0], p[1]], [p[2], p[3]], [p[4], p[5]], [p[6], p[7]]])
     };
     let q = quad("nonAffineTransform").or_else(|| quad("Trnf"))?;
+    corners_perspective(q, (w, h))
+}
+
+/// The projective placement of a `w` × `h` source onto corners `q` that aren't a parallelogram;
+/// `None` for affine corners (see [`corners_affine`]) or an empty size.
+pub fn corners_perspective(q: [[f64; 2]; 4], (w, h): (f64, f64)) -> Option<[f64; 9]> {
     // A parallelogram (top-left + bottom-right = top-right + bottom-left) is affine.
     let tol = 1e-6 * (1.0 + q.iter().flatten().fold(0.0f64, |m, v| m.max(v.abs())));
     if (0..2).all(|i| (q[0][i] + q[2][i] - q[1][i] - q[3][i]).abs() <= tol) || w <= 0.0 || h <= 0.0 {
@@ -897,6 +1014,229 @@ mod more_tests {
         assert_eq!(id, "uuid-1");
         assert_eq!(a.m, [2.0, 0.0, 0.0, 2.0, 10.0, 20.0]);
         assert_eq!(parse_smart(b"PlLd", &data).0, "");
+        assert_eq!(parse_plld(&data), None, "soLD data is not a plcL record");
+    }
+
+    /// A `PlLd` record (as Photoshop CS2 writes it, with no `SoLd`, #2465) gives its source id and
+    /// placed corners; with the source size those are the same transform `SoLd` gives.
+    #[test]
+    fn plld_id_and_corners() {
+        use crate::smart_map::{PlacedSpec, plld_bytes};
+        let t = Affine { m: [1.5, 0.25, -0.5, 2.0, 10.0, 20.0] };
+        let spec = PlacedSpec { idnt: "uuid-cs2", placed: "", transform: t, perspective: None, size: (40.0, 30.0), dpi: 72.0, warp: None, filter_fx: None };
+        let data = plld_bytes(&spec, &mut Vec::new());
+        let (id, p) = parse_plld(&data).expect("a plcL record");
+        assert_eq!(id, "uuid-cs2");
+        assert_eq!(p, [10.0, 20.0, 70.0, 30.0, 55.0, 90.0, -5.0, 80.0]);
+        let back = corners_affine(&p, [0.0, 0.0, 40.0, 30.0]).unwrap();
+        for (a, b) in back.m.iter().zip(t.m) {
+            assert!((a - b).abs() < 1e-12, "{back:?} vs {t:?}");
+        }
+        assert_eq!(corners_perspective([[p[0], p[1]], [p[2], p[3]], [p[4], p[5]], [p[6], p[7]]], (40.0, 30.0)), None, "affine corners");
+        assert_eq!(corners_affine(&p, [0.0, 0.0, 0.0, 30.0]), None);
+        assert_eq!(corners_affine(&p, [0.0, 0.0, f64::NAN, 30.0]), None);
+        assert_eq!(corners_affine(&p, [5.0, 0.0, 5.0, 30.0]), None, "an empty frame");
+        let mut nan = p;
+        nan[3] = f64::INFINITY;
+        assert_eq!(corners_affine(&nan, [0.0, 0.0, 40.0, 30.0]), None);
+        // The placed-layer record is the one block that can be the principal one: PlLd-only
+        // layers have no smart transform from `parse_smart`.
+        assert_eq!(parse_smart(b"PlLd", &data), (String::new(), Affine::IDENTITY));
+    }
+
+    /// A `PlLd` record's corners frame the same box as `SoLd`'s `Trnf` (#3677): with a custom
+    /// warp whose control points spill past the source, the control-point box, not the source
+    /// rect. The CS2 record then places the layer exactly as the equivalent `SoLd` does, with or
+    /// without the source size (the box needs none).
+    #[test]
+    fn plld_corners_frame_a_spilled_custom_warp_like_sold() {
+        use crate::smart_map::{PlacedSpec, parse_sold, plld_bytes, sold_bytes};
+        use photocraft_geom::warp::{BezierMesh, Warp};
+        let bounds = [0.0, 0.0, 50.0, 25.0];
+        let mut mesh = BezierMesh::identity(bounds, 1, 1);
+        mesh.points[0] = [-10.0, -5.0];
+        mesh.points[15] = [60.0, 25.0];
+        let warp = Warp::custom(mesh, bounds);
+        let t = Affine { m: [2.0, 0.5, -0.25, 2.0, 120.0, 210.0] };
+        let spec = PlacedSpec { idnt: "cs2", placed: "p", transform: t, perspective: None, size: (50.0, 25.0), dpi: 72.0, warp: Some(&warp), filter_fx: None };
+        let plld = plld_bytes(&spec, &mut Vec::new());
+        let sold = sold_bytes(None, &spec, &mut Vec::new());
+        let (_, p) = parse_plld(&plld).expect("a plcL record");
+        assert_eq!(parse_plld_warp(&plld), PlldWarp::Warp(warp.clone()));
+        let from_sold = parse_smart(b"SoLd", &sold).1;
+        assert_eq!(parse_sold(&sold).map(|s| s.transform), Some(from_sold));
+        let close = |a: Affine, b: Affine| a.m.iter().zip(b.m).all(|(x, y)| (x - y).abs() < 1e-9);
+        assert!(close(from_sold, t), "{from_sold:?} vs {t:?}");
+        for size in [Some((50.0, 25.0)), None] {
+            let (got, perspective) = plld_transform(&p, size, Some(&warp));
+            assert!(close(got, from_sold), "size {size:?}: {got:?} vs SoLd {from_sold:?}");
+            assert_eq!(perspective, None);
+        }
+        // Framing the source rect instead would stretch it (the bug #3677 fixed for SoLd).
+        let rect = corners_affine(&p, [0.0, 0.0, 50.0, 25.0]).unwrap();
+        assert!(!close(rect, t), "the test needs a mesh that spills: {rect:?}");
+        // With no warp, or a preset one, the frame is the source rect, as before.
+        let plain = PlacedSpec { warp: None, ..spec };
+        let (_, q) = parse_plld(&plld_bytes(&plain, &mut Vec::new())).unwrap();
+        assert!(close(plld_transform(&q, Some((50.0, 25.0)), None).0, t));
+    }
+
+    /// Malformed `PlLd` data (wrong magic, truncated anywhere, a Pascal length past the end,
+    /// non-finite corners) reads as `None`, never a panic.
+    #[test]
+    fn plld_malformed_is_none() {
+        use crate::smart_map::{PlacedSpec, plld_bytes};
+        let spec =
+            PlacedSpec { idnt: "id", placed: "", transform: Affine::IDENTITY, perspective: None, size: (4.0, 4.0), dpi: 72.0, warp: None, filter_fx: None };
+        let data = plld_bytes(&spec, &mut Vec::new());
+        // Magic + version + Pascal "id" + 4 × u32 + 8 × f64: everything after is the warp.
+        let end = 4 + 4 + 1 + 2 + 16 + 64;
+        assert!(parse_plld(&data[..end]).is_some());
+        for n in 0..end {
+            assert_eq!(parse_plld(&data[..n]), None, "truncated to {n} bytes");
+        }
+        let mut bad = data.clone();
+        bad[..4].copy_from_slice(b"soLD");
+        assert_eq!(parse_plld(&bad), None);
+        let mut long = data.clone();
+        long[8] = 255; // a Pascal id longer than the record
+        assert_eq!(parse_plld(&long[..200.min(long.len())]), None);
+        let mut nan = data.clone();
+        nan[end - 8..end].copy_from_slice(&f64::NAN.to_be_bytes());
+        assert_eq!(parse_plld(&nan), None);
+        assert_eq!(parse_plld(&[]), None);
+    }
+
+    /// Photoshop CS2 can warp a smart object; `PlLd` keeps that warp after the corners (a u32
+    /// warp version, then the versioned `warp` descriptor). It reads back as written, and
+    /// `warpNone`, an identity warp or a record that stops at its corners mean no warp.
+    #[test]
+    fn plld_warps_round_trip() {
+        use crate::smart_map::{PlacedSpec, plld_bytes};
+        use photocraft_geom::warp::{BezierMesh, Warp, WarpStyle};
+        let bounds = [0.0, 0.0, 60.0, 30.0];
+        let mut arc = Warp::preset(WarpStyle::Arc, 40.0, bounds);
+        arc.vertical = true;
+        arc.h_distort = 10.0;
+        let mut mesh = BezierMesh::identity(bounds, 1, 1);
+        mesh.points[15] = [67.0, 30.0];
+        let custom = Warp::custom(mesh, bounds);
+        let flat = Warp::preset(WarpStyle::Flag, 0.0, bounds);
+        for (w, back) in
+            [(Some(&arc), PlldWarp::Warp(arc.clone())), (Some(&custom), PlldWarp::Warp(custom.clone())), (Some(&flat), PlldWarp::None), (None, PlldWarp::None)]
+        {
+            let t = Affine { m: [0.5, 0.0, 0.0, 0.5, 3.0, 4.0] };
+            let spec = PlacedSpec { idnt: "w", placed: "", transform: t, perspective: None, size: (60.0, 30.0), dpi: 72.0, warp: w, filter_fx: None };
+            let data = plld_bytes(&spec, &mut Vec::new());
+            assert_eq!(parse_plld_warp(&data), back, "{w:?}");
+            // The corners are unchanged by the warp that follows them.
+            assert_eq!(parse_plld(&data).map(|(_, p)| p[..2].to_vec()), Some(vec![3.0, 4.0]));
+        }
+        let spec =
+            PlacedSpec { idnt: "id", placed: "", transform: Affine::IDENTITY, perspective: None, size: (4.0, 4.0), dpi: 72.0, warp: None, filter_fx: None };
+        let end = 4 + 4 + 1 + 2 + 16 + 64;
+        let data = plld_bytes(&spec, &mut Vec::new());
+        assert_eq!(parse_plld_warp(&data[..end]), PlldWarp::None, "no warp stored");
+        assert_eq!(parse_plld_warp(&[data[..end].to_vec(), vec![0; 3]].concat()), PlldWarp::None, "padding");
+    }
+
+    /// A `PlLd` warp that is stored but can't be read (truncated, an unknown style, a missing
+    /// bounds rectangle or mesh) is `Unreadable`, so the import keeps the warped pixels.
+    #[test]
+    fn plld_unreadable_warps() {
+        use crate::smart_map::{PlacedSpec, plld_bytes};
+        use photocraft_geom::warp::{Warp, WarpStyle};
+        let arc = Warp::preset(WarpStyle::Arc, 40.0, [0.0, 0.0, 4.0, 4.0]);
+        let spec = PlacedSpec {
+            idnt: "id",
+            placed: "",
+            transform: Affine::IDENTITY,
+            perspective: None,
+            size: (4.0, 4.0),
+            dpi: 72.0,
+            warp: Some(&arc),
+            filter_fx: None,
+        };
+        let data = plld_bytes(&spec, &mut Vec::new());
+        let end = 4 + 4 + 1 + 2 + 16 + 64;
+        assert!(matches!(parse_plld_warp(&data), PlldWarp::Warp(_)));
+        for n in end + 1..data.len() - 4 {
+            if data[end..n].iter().any(|b| *b != 0) {
+                assert_eq!(parse_plld_warp(&data[..n]), PlldWarp::Unreadable, "truncated to {n} bytes");
+            }
+        }
+        let with = |d: Descriptor| [data[..end].to_vec(), vec![0; 4], VersionedDescriptor::new(d).to_bytes()].concat();
+        let style = |s: &str| Value::Enumerated { type_id: Id::new("warpStyle"), value: Id::new(s) };
+        assert_eq!(parse_plld_warp(&with(Descriptor::new("warp").with("warpStyle", style("warpSomethingNew")))), PlldWarp::Unreadable);
+        assert_eq!(parse_plld_warp(&with(Descriptor::new("warp").with("warpStyle", style("warpArc")))), PlldWarp::Unreadable, "no bounds");
+        assert_eq!(parse_plld_warp(&with(Descriptor::new("warp").with("warpStyle", style("warpNone")))), PlldWarp::None);
+        let bounds = Descriptor::new("classFloatRect")
+            .with("Top ", Value::Double(0.0))
+            .with("Left", Value::Double(0.0))
+            .with("Btom", Value::Double(4.0))
+            .with("Rght", Value::Double(4.0));
+        let custom = Descriptor::new("warp").with("warpStyle", style("warpCustom")).with("bounds", Value::Descriptor(bounds));
+        assert_eq!(parse_plld_warp(&with(custom)), PlldWarp::Unreadable, "custom with no mesh");
+        assert_eq!(parse_plld_warp(&[data[..end].to_vec(), vec![0, 0, 0, 0, 0, 0, 0, 16, 1, 2]].concat()), PlldWarp::Unreadable);
+        assert_eq!(parse_plld_warp(&data[..end - 1]), PlldWarp::Unreadable, "the record itself");
+        assert_eq!(parse_plld_warp(&[]), PlldWarp::Unreadable);
+    }
+
+    /// `SoLd` data with a 50 × 25 source, the quad `trnf` and, when given, a custom warp whose
+    /// 16 control points are `pts`.
+    fn sold_with_warp(trnf: [f64; 8], pts: Option<&[[f64; 2]]>) -> Vec<u8> {
+        use photocraft_psd::descriptor::ObjectArray;
+        let e = |t: &str, v: &str| Value::Enumerated { type_id: Id::new(t), value: Id::new(v) };
+        let mut d = Descriptor::new("null")
+            .with("Idnt", Value::Text(UnicodeString::new_nul("uuid-1")))
+            .with("Trnf", Value::List(trnf.map(Value::Double).to_vec()))
+            .with("Sz  ", Value::Descriptor(Descriptor::new("Pnt ").with("Wdth", Value::Double(50.0)).with("Hght", Value::Double(25.0))));
+        if let Some(pts) = pts {
+            let bounds = Descriptor::new("Rctn")
+                .with("Top ", Value::Double(0.0))
+                .with("Left", Value::Double(0.0))
+                .with("Btom", Value::Double(25.0))
+                .with("Rght", Value::Double(50.0));
+            let mesh = Descriptor::new("null")
+                .with("Hrzn", Value::UnitFloats { unit: *b"#Pxl", values: pts.iter().map(|p| p[0]).collect() })
+                .with("Vrtc", Value::UnitFloats { unit: *b"#Pxl", values: pts.iter().map(|p| p[1]).collect() });
+            let warp = Descriptor::new("warp").with("warpStyle", e("warpStyle", "warpCustom")).with("bounds", Value::Descriptor(bounds)).with(
+                "customEnvelopeWarp",
+                Value::Descriptor(Descriptor::new("customEnvelopeWarp").with("meshPoints", Value::ObjectArray(ObjectArray { prefix: 16, body: mesh }))),
+            );
+            d = d.with("warp", Value::Descriptor(warp));
+        }
+        let mut data = b"soLD".to_vec();
+        data.extend_from_slice(&4u32.to_be_bytes());
+        data.extend(VersionedDescriptor::new(d).to_bytes());
+        data
+    }
+
+    /// Photoshop's `Trnf` is the image of the custom warp's control-point bounding box, not of the
+    /// source rect: a mesh spilling to x = -10, y = -5 and x = 60 frames a 70 × 30 box.
+    #[test]
+    fn smart_transform_maps_the_warp_control_box_onto_the_quad() {
+        let mut pts = photocraft_geom::warp::BezierMesh::identity([0.0, 0.0, 50.0, 25.0], 1, 1).points;
+        pts[0] = [-10.0, -5.0];
+        pts[15] = [60.0, 25.0];
+        let quad = [100.0, 200.0, 240.0, 200.0, 240.0, 260.0, 100.0, 260.0];
+        let (_, a) = parse_smart(b"SoLd", &sold_with_warp(quad, Some(&pts)));
+        assert_eq!(a.m, [2.0, 0.0, 0.0, 2.0, 120.0, 210.0]);
+        // Without a warp the source rect is the frame, as before.
+        assert_eq!(parse_smart(b"SoLd", &sold_with_warp(quad, None)).1.m, [2.8, 0.0, 0.0, 2.4, 100.0, 200.0]);
+    }
+
+    /// A custom mesh with no area (every control point on one spot) can't frame the quad: the
+    /// source rect does, with no division by zero.
+    #[test]
+    fn smart_transform_with_a_degenerate_warp_box_uses_the_source_rect() {
+        let quad = [100.0, 200.0, 240.0, 200.0, 240.0, 260.0, 100.0, 260.0];
+        let (_, a) = parse_smart(b"SoLd", &sold_with_warp(quad, Some(&[[7.0, 7.0]; 16])));
+        assert_eq!(a.m, [2.8, 0.0, 0.0, 2.4, 100.0, 200.0]);
+        let mut warp = photocraft_geom::warp::Warp::preset(photocraft_geom::warp::WarpStyle::Custom, 0.0, [0.0, 0.0, 50.0, 25.0]);
+        warp.mesh = Some(photocraft_geom::warp::BezierMesh { us: vec![0.0, 1.0], vs: vec![0.0, 1.0], points: vec![[f64::NAN, 1.0]; 16] });
+        assert_eq!(placed_frame(Some(&warp), 50.0, 25.0), [0.0, 0.0, 50.0, 25.0]);
+        assert_eq!(placed_frame(None, 50.0, 25.0), [0.0, 0.0, 50.0, 25.0]);
     }
 
     #[test]
diff --git a/crates/io/src/camera_raw_xmp.rs b/crates/io/src/camera_raw_xmp.rs
new file mode 100644
index 0000000000..159e298a06
--- /dev/null
+++ b/crates/io/src/camera_raw_xmp.rs
@@ -0,0 +1,423 @@
+//! Camera Raw Filter › Save Settings… / Load Settings… (#4274): Adobe Camera Raw settings files
+//! (`.xmp`), the `crs:` namespace (`http://ns.adobe.com/camera-raw-settings/1.0/`) on an
+//! `x:xmpmeta/rdf:RDF/rdf:Description`, as attributes or as child elements.
+//!
+//! Loading applies only the settings the file holds, over the current ones, as Camera Raw's
+//! Load Settings does; settings PhotoCraft has no control for (lens corrections, calibration,
+//! geometry, defringe, …) are ignored and named in the report. Saving writes every supported
+//! control, so loading the file in Photoshop reproduces the dialog.
+//!
+//! White balance: a Camera Raw Filter on a rendered image uses the relative
+//! `IncrementalTemperature` / `IncrementalTint` (−100..=100), which are PhotoCraft's Temperature
+//! and Tint. The absolute `Temperature` (kelvin) / `Tint` of raw-file settings have no
+//! counterpart and are ignored.
+
+use photocraft_algo::camera_raw::{CameraRaw, validate_curve};
+
+/// The Camera Raw settings namespace.
+pub const CRS_NS: &str = "http://ns.adobe.com/camera-raw-settings/1.0/";
+const RDF_NS: &str = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+/// Largest settings file read; real ones are a few kilobytes.
+pub const MAX_XMP_BYTES: usize = 4 * 1024 * 1024;
+
+type Field = fn(&mut CameraRaw) -> &mut f32;
+
+/// `crs:` scalar name, PhotoCraft field, and the slider range values are clamped to.
+const SCALARS: &[(&str, Field, f32, f32)] = &[
+    ("IncrementalTemperature", |p| &mut p.temperature, -100.0, 100.0),
+    ("IncrementalTint", |p| &mut p.tint, -100.0, 100.0),
+    ("Exposure2012", |p| &mut p.exposure, -5.0, 5.0),
+    ("Contrast2012", |p| &mut p.contrast, -100.0, 100.0),
+    ("Highlights2012", |p| &mut p.highlights, -100.0, 100.0),
+    ("Shadows2012", |p| &mut p.shadows, -100.0, 100.0),
+    ("Whites2012", |p| &mut p.whites, -100.0, 100.0),
+    ("Blacks2012", |p| &mut p.blacks, -100.0, 100.0),
+    ("Texture", |p| &mut p.texture, -100.0, 100.0),
+    ("Clarity2012", |p| &mut p.clarity, -100.0, 100.0),
+    ("Dehaze", |p| &mut p.dehaze, -100.0, 100.0),
+    ("Vibrance", |p| &mut p.vibrance, -100.0, 100.0),
+    ("Saturation", |p| &mut p.saturation, -100.0, 100.0),
+    ("ParametricShadows", |p| &mut p.curve_shadows, -100.0, 100.0),
+    ("ParametricDarks", |p| &mut p.curve_darks, -100.0, 100.0),
+    ("ParametricLights", |p| &mut p.curve_lights, -100.0, 100.0),
+    ("ParametricHighlights", |p| &mut p.curve_highlights, -100.0, 100.0),
+    ("ParametricShadowSplit", |p| &mut p.curve_splits[0], 0.0, 100.0),
+    ("ParametricMidtoneSplit", |p| &mut p.curve_splits[1], 0.0, 100.0),
+    ("ParametricHighlightSplit", |p| &mut p.curve_splits[2], 0.0, 100.0),
+    ("HueAdjustmentRed", |p| &mut p.hsl_hue[0], -100.0, 100.0),
+    ("HueAdjustmentOrange", |p| &mut p.hsl_hue[1], -100.0, 100.0),
+    ("HueAdjustmentYellow", |p| &mut p.hsl_hue[2], -100.0, 100.0),
+    ("HueAdjustmentGreen", |p| &mut p.hsl_hue[3], -100.0, 100.0),
+    ("HueAdjustmentAqua", |p| &mut p.hsl_hue[4], -100.0, 100.0),
+    ("HueAdjustmentBlue", |p| &mut p.hsl_hue[5], -100.0, 100.0),
+    ("HueAdjustmentPurple", |p| &mut p.hsl_hue[6], -100.0, 100.0),
+    ("HueAdjustmentMagenta", |p| &mut p.hsl_hue[7], -100.0, 100.0),
+    ("SaturationAdjustmentRed", |p| &mut p.hsl_sat[0], -100.0, 100.0),
+    ("SaturationAdjustmentOrange", |p| &mut p.hsl_sat[1], -100.0, 100.0),
+    ("SaturationAdjustmentYellow", |p| &mut p.hsl_sat[2], -100.0, 100.0),
+    ("SaturationAdjustmentGreen", |p| &mut p.hsl_sat[3], -100.0, 100.0),
+    ("SaturationAdjustmentAqua", |p| &mut p.hsl_sat[4], -100.0, 100.0),
+    ("SaturationAdjustmentBlue", |p| &mut p.hsl_sat[5], -100.0, 100.0),
+    ("SaturationAdjustmentPurple", |p| &mut p.hsl_sat[6], -100.0, 100.0),
+    ("SaturationAdjustmentMagenta", |p| &mut p.hsl_sat[7], -100.0, 100.0),
+    ("LuminanceAdjustmentRed", |p| &mut p.hsl_lum[0], -100.0, 100.0),
+    ("LuminanceAdjustmentOrange", |p| &mut p.hsl_lum[1], -100.0, 100.0),
+    ("LuminanceAdjustmentYellow", |p| &mut p.hsl_lum[2], -100.0, 100.0),
+    ("LuminanceAdjustmentGreen", |p| &mut p.hsl_lum[3], -100.0, 100.0),
+    ("LuminanceAdjustmentAqua", |p| &mut p.hsl_lum[4], -100.0, 100.0),
+    ("LuminanceAdjustmentBlue", |p| &mut p.hsl_lum[5], -100.0, 100.0),
+    ("LuminanceAdjustmentPurple", |p| &mut p.hsl_lum[6], -100.0, 100.0),
+    ("LuminanceAdjustmentMagenta", |p| &mut p.hsl_lum[7], -100.0, 100.0),
+    // Color Grading keeps the split-toning names for the shadow and highlight wheels' hue and
+    // saturation, and the balance.
+    ("SplitToningShadowHue", |p| &mut p.grade_shadows.hue, 0.0, 360.0),
+    ("SplitToningShadowSaturation", |p| &mut p.grade_shadows.sat, 0.0, 100.0),
+    ("ColorGradeShadowLum", |p| &mut p.grade_shadows.lum, -100.0, 100.0),
+    ("ColorGradeMidtoneHue", |p| &mut p.grade_midtones.hue, 0.0, 360.0),
+    ("ColorGradeMidtoneSat", |p| &mut p.grade_midtones.sat, 0.0, 100.0),
+    ("ColorGradeMidtoneLum", |p| &mut p.grade_midtones.lum, -100.0, 100.0),
+    ("SplitToningHighlightHue", |p| &mut p.grade_highlights.hue, 0.0, 360.0),
+    ("SplitToningHighlightSaturation", |p| &mut p.grade_highlights.sat, 0.0, 100.0),
+    ("ColorGradeHighlightLum", |p| &mut p.grade_highlights.lum, -100.0, 100.0),
+    ("ColorGradeGlobalHue", |p| &mut p.grade_global.hue, 0.0, 360.0),
+    ("ColorGradeGlobalSat", |p| &mut p.grade_global.sat, 0.0, 100.0),
+    ("ColorGradeGlobalLum", |p| &mut p.grade_global.lum, -100.0, 100.0),
+    ("ColorGradeBlending", |p| &mut p.grade_blending, 0.0, 100.0),
+    ("SplitToningBalance", |p| &mut p.grade_balance, -100.0, 100.0),
+    ("Sharpness", |p| &mut p.sharpen_amount, 0.0, 150.0),
+    ("SharpenRadius", |p| &mut p.sharpen_radius, 0.5, 3.0),
+    ("SharpenDetail", |p| &mut p.sharpen_detail, 0.0, 100.0),
+    ("SharpenEdgeMasking", |p| &mut p.sharpen_masking, 0.0, 100.0),
+    ("LuminanceSmoothing", |p| &mut p.noise_luminance, 0.0, 100.0),
+    ("LuminanceNoiseReductionDetail", |p| &mut p.noise_luminance_detail, 0.0, 100.0),
+    ("ColorNoiseReduction", |p| &mut p.noise_color, 0.0, 100.0),
+    ("ColorNoiseReductionDetail", |p| &mut p.noise_color_detail, 0.0, 100.0),
+    ("GrainAmount", |p| &mut p.grain_amount, 0.0, 100.0),
+    ("GrainSize", |p| &mut p.grain_size, 0.0, 100.0),
+    ("GrainFrequency", |p| &mut p.grain_roughness, 0.0, 100.0),
+    ("PostCropVignetteAmount", |p| &mut p.vignette_amount, -100.0, 100.0),
+    ("PostCropVignetteMidpoint", |p| &mut p.vignette_midpoint, 0.0, 100.0),
+    ("PostCropVignetteRoundness", |p| &mut p.vignette_roundness, -100.0, 100.0),
+    ("PostCropVignetteFeather", |p| &mut p.vignette_feather, 0.0, 100.0),
+    ("PostCropVignetteHighlightContrast", |p| &mut p.vignette_highlights, 0.0, 100.0),
+];
+
+type Curve = fn(&mut CameraRaw) -> &mut Vec<[f32; 2]>;
+const CURVES: &[(&str, Curve)] = &[
+    ("ToneCurvePV2012", |p| &mut p.point_curve),
+    ("ToneCurvePV2012Red", |p| &mut p.point_curve_red),
+    ("ToneCurvePV2012Green", |p| &mut p.point_curve_green),
+    ("ToneCurvePV2012Blue", |p| &mut p.point_curve_blue),
+];
+
+const STYLES: &[(&str, &str)] = &[("1", "highlightPriority"), ("2", "colorPriority"), ("3", "paintOverlay")];
+
+/// Bookkeeping fields Camera Raw writes that carry no setting.
+const METADATA: &[&str] = &[
+    "Version",
+    "ProcessVersion",
+    "HasSettings",
+    "HasCrop",
+    "WhiteBalance",
+    "ToneCurveName2012",
+    "CameraProfile",
+    "PresetType",
+    "UUID",
+    "SupportsAmount",
+    "SupportsColor",
+    "SupportsMonochrome",
+    "SupportsHighDynamicRange",
+    "SupportsNormalDynamicRange",
+    "SupportsSceneReferred",
+    "SupportsOutputReferred",
+    "CameraModelRestriction",
+    "Copyright",
+    "ContactInfo",
+    "Name",
+    "ShortName",
+    "SortName",
+    "Group",
+    "Description",
+];
+
+/// What [`load`] applied.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct LoadReport {
+    /// How many settings were applied.
+    pub applied: usize,
+    /// `crs:` settings without a PhotoCraft control (set to something other than their neutral
+    /// value), or with an unusable value, in file order.
+    pub ignored: Vec<String>,
+}
+
+fn number(s: &str) -> Option<f32> {
+    let s = s.trim();
+    let v: f32 = s.strip_prefix('+').unwrap_or(s).parse().ok()?;
+    v.is_finite().then_some(v)
+}
+
+/// `"0, 0"` items of an `rdf:Seq` → curve points.
+fn curve(node: roxmltree::Node<'_, '_>) -> Option<Vec<[f32; 2]>> {
+    let seq = node.children().find(|c| c.is_element() && c.tag_name().namespace() == Some(RDF_NS) && c.tag_name().name() == "Seq")?;
+    let mut points = Vec::new();
+    for li in seq.children().filter(|c| c.is_element() && c.tag_name().name() == "li") {
+        let text = li.text().unwrap_or("");
+        let (x, y) = text.split_once(',')?;
+        points.push([number(x)?, number(y)?]);
+    }
+    validate_curve(&points).ok()?;
+    // Camera Raw's linear curve is the identity's two end points; PhotoCraft's is empty.
+    if points == [[0.0, 0.0], [255.0, 255.0]] {
+        points.clear();
+    }
+    Some(points)
+}
+
+/// An unsupported setting at its neutral value changes nothing, so it isn't reported: zero,
+/// `False`, and the few neutral values that aren't zero.
+fn neutral(name: &str, value: &str) -> bool {
+    let v = value.trim();
+    if v.eq_ignore_ascii_case("false") || number(v) == Some(0.0) {
+        return true;
+    }
+    match name {
+        "GrainSeed" => true,
+        "VignetteMidpoint" => number(v) == Some(50.0),
+        "PerspectiveScale" => number(v) == Some(100.0),
+        _ => name.starts_with("Defringe") && name.contains("Hue"),
+    }
+}
+
+fn apply(params: &mut CameraRaw, report: &mut LoadReport, name: &str, value: &str) {
+    if let Some((_, field, lo, hi)) = SCALARS.iter().find(|(n, ..)| *n == name) {
+        match number(value) {
+            Some(v) => {
+                *field(params) = v.clamp(*lo, *hi);
+                report.applied += 1;
+            }
+            None => report.ignored.push(name.to_string()),
+        }
+    } else if name == "PostCropVignetteStyle" {
+        match STYLES.iter().find(|(n, _)| *n == value.trim()) {
+            Some((_, style)) => {
+                params.vignette_style = (*style).into();
+                report.applied += 1;
+            }
+            None => report.ignored.push(name.to_string()),
+        }
+    } else if !METADATA.contains(&name) && !neutral(name, value) {
+        report.ignored.push(name.to_string());
+    }
+}
+
+/// Apply a Camera Raw settings file over `params`. Fails on input that isn't XMP or holds no
+/// Camera Raw settings; never panics on malformed input.
+pub fn load(params: &mut CameraRaw, bytes: &[u8]) -> Result<LoadReport, String> {
+    if bytes.len() > MAX_XMP_BYTES {
+        return Err("the settings file is too large".into());
+    }
+    let text = std::str::from_utf8(bytes).map_err(|_| "not a Camera Raw settings file (not UTF-8 text)".to_string())?;
+    // Some writers put a byte order mark or an `<?xpacket?>` wrapper first; roxmltree takes both.
+    let text = text.trim_start_matches('\u{feff}');
+    let doc = roxmltree::Document::parse(text).map_err(|e| format!("not a Camera Raw settings file ({e})"))?;
+    let mut next = params.clone();
+    let mut report = LoadReport::default();
+    let mut found = false;
+    for desc in doc.descendants().filter(|n| n.is_element() && n.tag_name().namespace() == Some(RDF_NS) && n.tag_name().name() == "Description") {
+        for a in desc.attributes().filter(|a| a.namespace() == Some(CRS_NS)) {
+            found = true;
+            apply(&mut next, &mut report, a.name(), a.value());
+        }
+        for c in desc.children().filter(|c| c.is_element() && c.tag_name().namespace() == Some(CRS_NS)) {
+            found = true;
+            let name = c.tag_name().name();
+            if let Some((_, field)) = CURVES.iter().find(|(n, _)| *n == name) {
+                match curve(c) {
+                    Some(points) => {
+                        *field(&mut next) = points;
+                        report.applied += 1;
+                    }
+                    None => report.ignored.push(name.to_string()),
+                }
+            } else if c.children().any(|g| g.is_element()) {
+                // Structured settings (masks, looks, lens profiles…) have no counterpart.
+                if !METADATA.contains(&name) {
+                    report.ignored.push(name.to_string());
+                }
+            } else {
+                apply(&mut next, &mut report, name, c.text().unwrap_or(""));
+            }
+        }
+    }
+    if !found {
+        return Err("no Camera Raw settings in the file".into());
+    }
+    *params = next;
+    Ok(report)
+}
+
+fn signed(v: f32, decimals: usize) -> String {
+    let s = format!("{v:.decimals$}");
+    if v > 0.0 && !s.starts_with('+') { format!("+{s}") } else { s }
+}
+
+fn escape(s: &str) -> String {
+    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")
+}
+
+/// Write `params` as a Camera Raw settings file Photoshop's Load Settings… reads.
+pub fn save(params: &CameraRaw) -> String {
+    let mut p = params.clone();
+    let wb = if p.temperature != 0.0 || p.tint != 0.0 { "Custom" } else { "As Shot" };
+    let mut out = String::from(
+        "<x:xmpmeta xmlns:x=\"adobe:ns:meta/\" x:xmptk=\"PhotoCraft\">\n <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n  <rdf:Description rdf:about=\"\"\n    xmlns:crs=\"http://ns.adobe.com/camera-raw-settings/1.0/\"\n",
+    );
+    out.push_str("   crs:Version=\"18.4\"\n   crs:ProcessVersion=\"15.4\"\n");
+    out.push_str(&format!("   crs:WhiteBalance=\"{wb}\"\n"));
+    for (name, field, lo, _) in SCALARS {
+        let v = *field(&mut p);
+        // Exposure has two decimals in Camera Raw, the sharpening radius one; the rest are levels.
+        let text = match *name {
+            "Exposure2012" => signed(v, 2),
+            "SharpenRadius" => signed(v, 1),
+            _ if *lo < 0.0 => signed(v.round(), 0),
+            _ => format!("{:.0}", v.round()),
+        };
+        out.push_str(&format!("   crs:{name}=\"{text}\"\n"));
+    }
+    let style = STYLES.iter().find(|(_, s)| *s == p.vignette_style).map_or("1", |(n, _)| n);
+    out.push_str(&format!("   crs:PostCropVignetteStyle=\"{}\"\n", escape(style)));
+    out.push_str("   crs:ToneCurveName2012=\"Custom\"\n   crs:HasSettings=\"True\">\n");
+    for (name, field) in CURVES {
+        let points = field(&mut p);
+        let points = if points.is_empty() { vec![[0.0, 0.0], [255.0, 255.0]] } else { points.clone() };
+        out.push_str(&format!("   <crs:{name}>\n    <rdf:Seq>\n"));
+        for [x, y] in points {
+            out.push_str(&format!("     <rdf:li>{}, {}</rdf:li>\n", x.round(), y.round()));
+        }
+        out.push_str(&format!("    </rdf:Seq>\n   </crs:{name}>\n"));
+    }
+    out.push_str("  </rdf:Description>\n </rdf:RDF>\n</x:xmpmeta>\n");
+    out
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+    use super::*;
+
+    /// A hand-written settings file laid out as Photoshop 26's Camera Raw Filter saves one (the
+    /// field set and order follow Camera Raw 18; the values are synthetic), plus element-form
+    /// settings, which XMP allows and some writers use.
+    const FIXTURE: &[u8] = br#"<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 7.0-c000 1.000000, 0000/00/00-00:00:00        ">
+ <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+  <rdf:Description rdf:about=""
+    xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/"
+   crs:Version="18.1.1" crs:ProcessVersion="15.4" crs:WhiteBalance="Custom"
+   crs:IncrementalTemperature="0" crs:IncrementalTint="+10" crs:Exposure2012="+0.05"
+   crs:Contrast2012="-5" crs:Highlights2012="-20" crs:Shadows2012="+10" crs:Whites2012="+35"
+   crs:Blacks2012="0" crs:Texture="+30" crs:Clarity2012="+5" crs:Vibrance="+20" crs:Saturation="-5"
+   crs:ParametricShadowSplit="25" crs:ParametricMidtoneSplit="50" crs:ParametricHighlightSplit="75"
+   crs:Sharpness="15" crs:SharpenRadius="+1.0" crs:LuminanceSmoothing="5"
+   crs:LuminanceNoiseReductionContrast="0" crs:HueAdjustmentGreen="+25" crs:SaturationAdjustmentGreen="+20"
+   crs:ColorGradeBlending="50" crs:LensProfileEnable="0" crs:VignetteAmount="-20"
+   crs:PerspectiveScale="100" crs:GrainAmount="10" crs:RedHue="-5" crs:GrainSeed="2834497962"
+   crs:ToneCurveName2012="Linear" crs:CameraProfile="Default Color" crs:HasSettings="True" crs:HasCrop="False">
+   <crs:Dehaze>+12</crs:Dehaze>
+   <crs:ToneCurvePV2012>
+    <rdf:Seq>
+     <rdf:li>0, 0</rdf:li>
+     <rdf:li>255, 255</rdf:li>
+    </rdf:Seq>
+   </crs:ToneCurvePV2012>
+   <crs:ToneCurvePV2012Red>
+    <rdf:Seq>
+     <rdf:li>0, 0</rdf:li>
+     <rdf:li>128, 140</rdf:li>
+     <rdf:li>255, 255</rdf:li>
+    </rdf:Seq>
+   </crs:ToneCurvePV2012Red>
+  </rdf:Description>
+ </rdf:RDF>
+</x:xmpmeta>"#;
+
+    #[test]
+    fn reads_a_photoshop_preset() {
+        let mut p = CameraRaw::default();
+        let r = load(&mut p, FIXTURE).unwrap();
+        assert_eq!(p.tint, 10.0);
+        assert_eq!(p.exposure, 0.05);
+        assert_eq!((p.contrast, p.highlights, p.shadows, p.whites), (-5.0, -20.0, 10.0, 35.0));
+        assert_eq!((p.texture, p.clarity, p.vibrance, p.saturation), (30.0, 5.0, 20.0, -5.0));
+        assert_eq!((p.hsl_hue[3], p.hsl_sat[3]), (25.0, 20.0));
+        assert_eq!((p.sharpen_amount, p.noise_luminance, p.grain_amount), (15.0, 5.0, 10.0));
+        assert_eq!(p.grade_blending, 50.0);
+        // The linear tone curve is PhotoCraft's empty one; an element-form setting is read too.
+        assert!(p.point_curve.is_empty());
+        assert_eq!(p.point_curve_red, vec![[0.0, 0.0], [128.0, 140.0], [255.0, 255.0]]);
+        assert_eq!(p.dehaze, 12.0);
+        // Lens vignetting, calibration and geometry have no counterpart.
+        assert_eq!(r.ignored, vec!["VignetteAmount".to_string(), "RedHue".to_string()]);
+    }
+
+    #[test]
+    fn save_then_load_round_trips() {
+        let mut p = CameraRaw {
+            temperature: -12.0,
+            exposure: 1.25,
+            contrast: 30.0,
+            sharpen_radius: 1.4,
+            vignette_amount: -40.0,
+            vignette_style: "paintOverlay".into(),
+            curve_splits: [20.0, 45.0, 80.0],
+            point_curve: vec![[0.0, 10.0], [128.0, 150.0], [255.0, 240.0]],
+            ..CameraRaw::default()
+        };
+        p.hsl_lum[5] = -33.0;
+        p.grade_shadows.hue = 210.0;
+        p.grade_shadows.sat = 40.0;
+        p.grade_global.lum = 7.0;
+        let text = save(&p);
+        assert!(text.contains("crs:Exposure2012=\"+1.25\""));
+        assert!(text.contains("crs:WhiteBalance=\"Custom\""));
+        let mut back = CameraRaw::default();
+        let r = load(&mut back, text.as_bytes()).unwrap();
+        assert!(r.ignored.is_empty(), "{:?}", r.ignored);
+        assert_eq!(back, p);
+    }
+
+    #[test]
+    fn load_applies_only_the_settings_in_the_file() {
+        let mut p = CameraRaw { contrast: 40.0, ..CameraRaw::default() };
+        let xmp = br#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+            <rdf:Description xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/"><crs:Exposure2012>-9</crs:Exposure2012>
+            <crs:Clarity2012>abc</crs:Clarity2012></rdf:Description></rdf:RDF></x:xmpmeta>"#;
+        let r = load(&mut p, xmp).unwrap();
+        assert_eq!((p.exposure, p.contrast, p.clarity), (-5.0, 40.0, 0.0));
+        assert_eq!(r, LoadReport { applied: 1, ignored: vec!["Clarity2012".into()] });
+    }
+
+    #[test]
+    fn malformed_input_is_an_error_and_leaves_settings_alone() {
+        let before = CameraRaw { exposure: 0.5, ..CameraRaw::default() };
+        for bad in [
+            &b""[..],
+            b"\xff\xfe\x00garbage",
+            b"<x:xmpmeta><unclosed",
+            b"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"/>",
+            b"<?xml version=\"1.0\"?><!DOCTYPE a [<!ENTITY e \"x\">]><a>&e;</a>",
+        ] {
+            let mut p = before.clone();
+            assert!(load(&mut p, bad).is_err());
+            assert_eq!(p, before);
+        }
+        // A broken curve or NaN is skipped, not fatal.
+        let xmp = br#"<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><rdf:Description
+            xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:Contrast2012="NaN"><crs:ToneCurvePV2012><rdf:Seq>
+            <rdf:li>10</rdf:li></rdf:Seq></crs:ToneCurvePV2012></rdf:Description></rdf:RDF>"#;
+        let mut p = before.clone();
+        let r = load(&mut p, xmp).unwrap();
+        assert_eq!(p, before);
+        assert_eq!(r.ignored, vec!["Contrast2012".to_string(), "ToneCurvePV2012".to_string()]);
+    }
+}
diff --git a/crates/io/src/channel_map.rs b/crates/io/src/channel_map.rs
index f8dada8b0b..bafde26f30 100644
--- a/crates/io/src/channel_map.rs
+++ b/crates/io/src/channel_map.rs
@@ -1,10 +1,10 @@
 //! Alpha / spot channel options <-> PSD `DisplayInfo` image resources (1077, and the older 1007).
 //!
 //! Layout (Adobe PSD spec, "DisplayInfo"): resource 1077 starts with a 4-byte version (1), then
-//! one 14-byte record per extra channel: colour space (u16), four u16 colour components, opacity
-//! (u16, 0..100), kind (u8: 0 = colour indicates selected areas, 1 = masked ("protected") areas,
-//! 2 = spot channel) and one padding byte. Resource 1007 has the same records without the
-//! version and without the spot kind.
+//! one 13-byte record per extra channel: colour space (u16), four u16 colour components, opacity
+//! (u16, 0..100) and kind (u8: 0 = colour indicates selected areas, 1 = masked ("protected")
+//! areas, 2 = spot channel). Resource 1007 has the same records without the version and the spot
+//! kind, each followed by a padding byte (14 bytes).
 
 use photocraft_color::{Color, ColorMode};
 use photocraft_doc::{AlphaChannel, ColorIndicates};
@@ -15,13 +15,21 @@ pub(crate) const DISPLAY_INFO_OLD: u16 = 1007;
 pub(crate) const QUICK_MASK_INFO: u16 = 1022;
 
 const SPACE_RGB: u16 = 0;
+const SPACE_HSB: u16 = 1;
 const SPACE_CMYK: u16 = 2;
 const SPACE_LAB: u16 = 7;
 const SPACE_GRAY: u16 = 8;
 
-/// Resource 1077 for `channels` (in file order).
-pub(crate) fn display_info(channels: &[&AlphaChannel]) -> Vec<u8> {
+/// Resource 1077 for `channels` (in file order): a version, then 13 bytes per channel (colour
+/// space, four components, opacity, kind). Every corpus file, Photoshop's included, uses 13;
+/// 14-byte records (the older 1007 layout) shift every channel after the first.
+/// `transparency`: the merged image's transparency channel comes first and gets a record too.
+pub(crate) fn display_info(channels: &[&AlphaChannel], transparency: bool) -> Vec<u8> {
     let mut out = 1u32.to_be_bytes().to_vec();
+    if transparency {
+        // As Photoshop writes it: red, 100 %, masked areas.
+        out.extend_from_slice(&[0, 0, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 100, 1]);
+    }
     for c in channels {
         let (color, opacity, kind) = match c.spot {
             Some((ink, solidity)) => (ink, solidity, 2u8),
@@ -34,15 +42,16 @@ pub(crate) fn display_info(channels: &[&AlphaChannel]) -> Vec<u8> {
         }
         out.extend_from_slice(&((opacity.clamp(0.0, 1.0) * 100.0).round() as u16).to_be_bytes());
         out.push(kind);
-        out.push(0);
     }
     out
 }
 
-/// Applies a DisplayInfo resource (`versioned` = 1077) to the imported channels in order.
-pub(crate) fn apply_display_info(data: &[u8], versioned: bool, channels: &mut [AlphaChannel]) {
-    let body = if versioned { data.get(4..).unwrap_or(&[]) } else { data };
-    for (c, rec) in channels.iter_mut().zip(body.as_chunks::<14>().0) {
+/// Applies a DisplayInfo resource (`versioned` = 1077: 13-byte records after a version; else the
+/// older 1007 with 14-byte records) to the imported channels in order, after skipping `skip`
+/// records (the merged transparency channel's).
+pub(crate) fn apply_display_info(data: &[u8], versioned: bool, skip: usize, channels: &mut [AlphaChannel]) {
+    let (body, size) = if versioned { (data.get(4..).unwrap_or(&[]), 13) } else { (data, 14) };
+    for (c, rec) in channels.iter_mut().zip(body.chunks_exact(size).skip(skip)) {
         let u = |i: usize| u16::from_be_bytes([rec[i], rec[i + 1]]);
         let comps = [u(2), u(4), u(6), u(8)];
         let color = decode_color(u(0), comps);
@@ -50,6 +59,8 @@ pub(crate) fn apply_display_info(data: &[u8], versioned: bool, channels: &mut [A
         match rec[12] {
             2 => c.spot = Some((color, opacity)),
             k => {
+                // An alpha channel, not an ink (a Multichannel import starts every channel as one).
+                c.spot = None;
                 c.color = color;
                 c.opacity = opacity;
                 c.indicates = if k == 0 { ColorIndicates::SelectedAreas } else { ColorIndicates::MaskedAreas };
@@ -58,9 +69,25 @@ pub(crate) fn apply_display_info(data: &[u8], versioned: bool, channels: &mut [A
     }
 }
 
+/// A PSD colour structure (space id + four u16 components) as an RGB [`Color`]; unknown spaces
+/// (book colours…) read the first three components as RGB. See [`decode_known_color`].
 pub(crate) fn decode_color(space: u16, c: [u16; 4]) -> Color {
     let n = |v: u16| f32::from(v) / 65535.0;
-    match space {
+    decode_known_color(space, c).unwrap_or_else(|| Color::rgb(n(c[0]), n(c[1]), n(c[2])))
+}
+
+/// A PSD colour structure in one of the spaces Photoshop writes for plain colours (0 RGB,
+/// 1 HSB, 2 CMYK, 7 Lab, 8 Grayscale) as an RGB [`Color`], or `None` for any other space id.
+/// CMYK goes through the colour-managed conversion (the active document CMYK profile, see
+/// `photocraft_color::convert::with_cmyk_space`), Lab through the D50 Lab → sRGB conversion.
+pub(crate) fn decode_known_color(space: u16, c: [u16; 4]) -> Option<Color> {
+    let n = |v: u16| f32::from(v) / 65535.0;
+    Some(match space {
+        SPACE_RGB => Color::rgb(n(c[0]), n(c[1]), n(c[2])),
+        SPACE_HSB => {
+            let rgb = hsb_to_rgb(n(c[0]) * 360.0, n(c[1]), n(c[2]));
+            Color::rgb(rgb[0], rgb[1], rgb[2])
+        }
         // Photoshop colour structures store CMYK inverted (65535 = no ink).
         SPACE_CMYK => {
             let cmyk = Color { mode: ColorMode::Cmyk, c: [1.0 - n(c[0]), 1.0 - n(c[1]), 1.0 - n(c[2]), 1.0 - n(c[3])], alpha: 1.0 };
@@ -79,7 +106,23 @@ pub(crate) fn decode_color(space: u16, c: [u16; 4]) -> Color {
             let v = 1.0 - f32::from(c[0].min(10000)) / 10000.0;
             Color::rgb(v, v, v)
         }
-        _ => Color::rgb(n(c[0]), n(c[1]), n(c[2])),
+        _ => return None,
+    })
+}
+
+/// HSB (hue in degrees, saturation and brightness 0..1) → RGB.
+fn hsb_to_rgb(h: f32, s: f32, v: f32) -> [f32; 3] {
+    let h = if h.is_finite() { h.rem_euclid(360.0) / 60.0 } else { 0.0 };
+    let (s, v) = (s.clamp(0.0, 1.0), v.clamp(0.0, 1.0));
+    let f = h - h.floor();
+    let (p, q, t) = (v * (1.0 - s), v * (1.0 - s * f), v * (1.0 - s * (1.0 - f)));
+    match h.floor() as u8 {
+        0 => [v, t, p],
+        1 => [q, v, p],
+        2 => [p, v, t],
+        3 => [p, q, v],
+        4 => [t, p, v],
+        _ => [v, p, q],
     }
 }
 
@@ -97,17 +140,25 @@ mod tests {
         a.indicates = ColorIndicates::SelectedAreas;
         let mut s = AlphaChannel::new("S", Surface::new(PixelFormat::GRAY8));
         s.spot = Some((Color::rgb(1.0, 0.0, 1.0), 0.8));
-        let bytes = display_info(&[&a, &s]);
-        assert_eq!(bytes.len(), 4 + 28);
+        let bytes = display_info(&[&a, &s], false);
+        // 13 bytes per channel, as every corpus file (Photoshop's included) lays out 1077.
+        assert_eq!(bytes.len(), 4 + 2 * 13);
         let mut back = vec![AlphaChannel::new("A", Surface::new(PixelFormat::GRAY8)), AlphaChannel::new("S", Surface::new(PixelFormat::GRAY8))];
-        apply_display_info(&bytes, true, &mut back);
+        apply_display_info(&bytes, true, 0, &mut back);
         assert_eq!(back[0].color, a.color);
         assert!((back[0].opacity - 0.3).abs() < 1e-6);
         assert_eq!(back[0].indicates, ColorIndicates::SelectedAreas);
         assert_eq!(back[1].spot, s.spot);
+        // With the merged transparency's record first, the channels still get their own.
+        let with_t = display_info(&[&a, &s], true);
+        assert_eq!(with_t.len(), 4 + 3 * 13);
+        let mut back = vec![AlphaChannel::new("A", Surface::new(PixelFormat::GRAY8)), AlphaChannel::new("S", Surface::new(PixelFormat::GRAY8))];
+        apply_display_info(&with_t, true, 1, &mut back);
+        assert_eq!(back[0].indicates, ColorIndicates::SelectedAreas);
+        assert_eq!(back[1].spot, s.spot);
         // Truncated data is ignored rather than misread.
         let mut c = vec![AlphaChannel::new("x", Surface::new(PixelFormat::GRAY8))];
-        apply_display_info(&bytes[..10], true, &mut c);
+        apply_display_info(&bytes[..10], true, 0, &mut c);
         assert_eq!(c[0].opacity, 0.5);
     }
 
@@ -117,5 +168,13 @@ mod tests {
         assert_eq!(g.to_rgb(), [0.0; 3]);
         let lab = decode_color(SPACE_LAB, [10000, 0, 0, 0]).to_rgb();
         assert!(lab.iter().all(|v| *v > 0.95), "{lab:?}");
+        // HSB: hue 120 degrees (65535 / 3), full saturation and brightness is pure green.
+        let g = decode_color(SPACE_HSB, [21845, 65535, 65535, 0]).to_rgb();
+        assert!((g[0]).abs() < 1e-3 && (g[1] - 1.0).abs() < 1e-3 && g[2].abs() < 1e-3, "{g:?}");
+        let half = decode_color(SPACE_HSB, [0, 0, 32768, 0]).to_rgb();
+        assert!(half.iter().all(|v| (v - 0.5).abs() < 1e-3), "{half:?}");
+        // Unknown spaces (book colours) are not guessed.
+        assert_eq!(decode_known_color(3, [1, 2, 3, 4]), None);
+        assert_eq!(decode_known_color(SPACE_RGB, [65535, 0, 0, 0]), Some(Color::rgb(1.0, 0.0, 0.0)));
     }
 }
diff --git a/crates/io/src/comps_map.rs b/crates/io/src/comps_map.rs
index 5b0759da37..8d0c78f3b0 100644
--- a/crates/io/src/comps_map.rs
+++ b/crates/io/src/comps_map.rs
@@ -376,6 +376,9 @@ mod tests {
         });
         d.last_applied_comp = Some(7);
         let res = write_comps_resource(&d).unwrap();
+        // `list` is a length-4 string id, as Photoshop writes it, never a code.
+        assert!(res.windows(8).any(|w| w == b"\0\0\0\x04list"));
+        assert!(!res.windows(8).any(|w| w == b"\0\0\0\0list"));
         let cm = write_cmls(&d.layer_comps, None, d.layer(lid).unwrap(), 3).unwrap();
         // Attach as Photoshop would: shmd with cmls plus another item.
         let mut raw = vec![(*b"shmd", write_shmd(&[MetadataItem::new(*b"cust", vec![1, 2])]))];
diff --git a/crates/io/src/displace_map.rs b/crates/io/src/displace_map.rs
new file mode 100644
index 0000000000..8993663cc0
--- /dev/null
+++ b/crates/io/src/displace_map.rs
@@ -0,0 +1,343 @@
+//! Displace smart filters (`Fltr` class `Dspl`) as observed in Photoshop-authored mockup PSDs.
+//!
+//! The filter descriptor holds the scales (`HrzS`, `VrtS`, percent), the fit (`DspM`: `StrF`
+//! stretch or `Tile`), the undefined areas (`UndA`: `RptE` repeat edge pixels or `WrpA` wrap),
+//! an alias to the map file on the author's disk (`DspF`, usually unavailable), `EmbF` (true) and
+//! the map itself, embedded as raw data (`DspD`, type `tdta`):
+//!
+//! ```text
+//! u32 LE height, u32 LE width, u16 LE mode (3 observed), then two 8-bit planes of
+//! width * height bytes (horizontal map, vertical map), then padding
+//! ```
+//!
+//! The whole `filterFX` item (with the map) is kept verbatim in the params as a template
+//! ([`TEMPLATE_KEY`]), so the filter re-renders, survives `.pcraft` and is written back to PSD
+//! with only the editable settings replaced. Anything else (another mode, a missing or truncated
+//! map, unknown enum values) stays an opaque [`super::UNSUPPORTED_FILTER`].
+
+use std::sync::Arc;
+
+use photocraft_algo::Image;
+use photocraft_doc::SmartFilter;
+use photocraft_geom::Rect;
+use photocraft_psd::descriptor::{Descriptor, Id, Value};
+use serde_json::{Value as J, json};
+
+use super::{blend_options, from_hex, get_desc, int, set, to_hex};
+use crate::blocks::{enum_of, num};
+
+pub(super) const CLASS: &str = "Dspl";
+pub(super) const COMMAND: &str = "filter.distort.displace";
+const FILTER_ID: i32 = super::code(b"Dspl");
+pub(super) const TEMPLATE_KEY: &str = "__displacePsd";
+/// The embedded map (raw data).
+const MAP_KEY: &str = "DspD";
+/// `tdta` header: height, width (u32 LE) and mode (u16 LE).
+const HEADER: usize = 10;
+/// The only map layout seen in Photoshop files: two 8-bit planes.
+const MODE_TWO_PLANES: u16 = 3;
+/// 8K × 8K: far beyond the observed document-sized maps, and bounds the f32 map we build.
+const MAX_MAP_PIXELS: usize = 1 << 26;
+/// The template is the item plus the map; a little room for the rest of the descriptor.
+const MAX_TEMPLATE_BYTES: usize = 2 * MAX_MAP_PIXELS + (1 << 20);
+
+const FITS: [(&[u8], &str); 2] = [(b"StrF", "stretch"), (b"Tile", "tile")];
+const UNDEFINED: [(&[u8], &str); 2] = [(b"RptE", "repeat"), (b"WrpA", "wrap")];
+
+/// A parsed embedded map: size and the two 8-bit planes (borrowed from the blob).
+#[derive(Debug, PartialEq)]
+pub(super) struct EmbeddedMap<'a> {
+    pub width: usize,
+    pub height: usize,
+    pub horizontal: &'a [u8],
+    pub vertical: &'a [u8],
+}
+
+/// Parses an embedded displacement map; `None` for any other mode, a zero or oversized map, or a
+/// blob shorter than the header plus both planes.
+pub(super) fn parse_map(data: &[u8]) -> Option<EmbeddedMap<'_>> {
+    let u32_at = |i: usize| Some(u32::from_le_bytes(data.get(i..i + 4)?.try_into().ok()?));
+    let height = usize::try_from(u32_at(0)?).ok()?;
+    let width = usize::try_from(u32_at(4)?).ok()?;
+    let mode = u16::from_le_bytes(data.get(8..HEADER)?.try_into().ok()?);
+    let n = width.checked_mul(height)?;
+    if mode != MODE_TWO_PLANES || n == 0 || n > MAX_MAP_PIXELS {
+        return None;
+    }
+    let horizontal = data.get(HEADER..HEADER.checked_add(n)?)?;
+    let vertical = data.get(HEADER + n..HEADER.checked_add(n.checked_mul(2)?)?)?;
+    Some(EmbeddedMap { width, height, horizontal, vertical })
+}
+
+fn fltr_map(item: &Descriptor) -> Option<EmbeddedMap<'_>> {
+    match get_desc(item, "Fltr")?.get(MAP_KEY)? {
+        Value::RawData(b) => parse_map(b),
+        _ => None,
+    }
+}
+
+fn lookup<'a>(table: &[(&[u8], &'a str)], v: &[u8]) -> Option<&'a str> {
+    table.iter().find(|(k, _)| *k == v).map(|(_, s)| *s)
+}
+
+/// Editable settings of a `Dspl` descriptor, `None` when one is missing or unknown.
+fn settings(f: &Descriptor) -> Option<J> {
+    let scale = |k| num(f.get(k)).filter(|v| v.is_finite() && (-999.0..=999.0).contains(v));
+    Some(json!({
+        "horizontal": scale("HrzS")?,
+        "vertical": scale("VrtS")?,
+        "fit": lookup(&FITS, enum_of(f, "DspM")?)?,
+        "undefinedAreas": lookup(&UNDEFINED, enum_of(f, "UndA")?)?,
+    }))
+}
+
+/// `filter.distort.displace` params for a Displace item with an embedded map.
+pub(super) fn import_params(item: &Descriptor) -> Option<J> {
+    let f = get_desc(item, "Fltr")?;
+    if !f.class_id.is(CLASS) {
+        return None;
+    }
+    let mut params = settings(f)?;
+    fltr_map(item)?;
+    // Neutral blending in the template: the model's own fields replace it on export.
+    let mut template = item.clone();
+    let neutral = SmartFilter { command: String::new(), params: J::Null, blend: photocraft_color::BlendMode::Normal, opacity: 1.0, visible: true };
+    set(&mut template, "blendOptions", blend_options(&neutral));
+    set(&mut template, "enab", Value::Boolean(true));
+    params.as_object_mut()?.insert(TEMPLATE_KEY.into(), json!(to_hex(&template.to_bytes())));
+    Some(params)
+}
+
+/// The template item of `params`, checked to be a Displace filter with a readable map.
+fn template(params: &J) -> Result<Descriptor, String> {
+    let raw = params.get(TEMPLATE_KEY).ok_or("a Displace map from a file or document is not written to PSD")?;
+    let raw = raw.as_str().ok_or("the Displace PSD data must be hex text")?;
+    if raw.len() > MAX_TEMPLATE_BYTES * 2 {
+        return Err("the Displace PSD data is too large".into());
+    }
+    let bytes = from_hex(raw).ok_or("the Displace PSD data is not valid hex")?;
+    let item = Descriptor::from_bytes(&bytes).map_err(|e| format!("the Displace PSD data is unreadable ({e})"))?;
+    if !item.class_id.is("filterFX") || int(&item, "filterID") != Some(FILTER_ID) || fltr_map(&item).is_none() {
+        return Err("the Displace PSD data is not a Displace filter with an embedded map".into());
+    }
+    Ok(item)
+}
+
+/// The `filterFXList` item: the template with the current scales, fit and undefined areas.
+pub(super) fn export_item(params: &J) -> Result<Descriptor, String> {
+    let object = params.as_object().ok_or("Displace parameters must be an object")?;
+    if let Some(k) = object.keys().find(|k| !super::is_meta(k) && !["horizontal", "vertical", "fit", "undefinedAreas"].contains(&k.as_str())) {
+        return Err(format!("Displace setting `{k}` has no PSD equivalent next to its embedded map"));
+    }
+    let mut item = template(params)?;
+    let mut f = get_desc(&item, "Fltr").ok_or("the Displace PSD data has no filter")?.clone();
+    let scale = |k: &str, d: f64| -> Result<Value, String> {
+        let v = params.get(k).map_or(Some(d), J::as_f64).filter(|v| v.is_finite()).ok_or(format!("Displace `{k}` must be a number"))?;
+        Ok(Value::Integer(v.round().clamp(-999.0, 999.0) as i32))
+    };
+    let choice = |k: &str, table: &[(&[u8], &str)], d: &str| -> Result<Id, String> {
+        let v = params.get(k).map_or(Some(d), J::as_str).ok_or(format!("Displace `{k}` must be text"))?;
+        let code = table.iter().find(|(_, s)| *s == v).map(|(c, _)| *c).ok_or(format!("Displace `{k}` is not one of the PSD values"))?;
+        Ok(Id::new(std::str::from_utf8(code).map_err(|e| e.to_string())?))
+    };
+    // Keep the template's enum types; only the values change.
+    let set_enum = |f: &mut Descriptor, key: &str, value: Id| {
+        let type_id = match f.get(key) {
+            Some(Value::Enumerated { type_id, .. }) => type_id.clone(),
+            _ => Id::new(key),
+        };
+        set(f, key, Value::Enumerated { type_id, value });
+    };
+    set(&mut f, "HrzS", scale("horizontal", 10.0)?);
+    set(&mut f, "VrtS", scale("vertical", 10.0)?);
+    set_enum(&mut f, "DspM", choice("fit", &FITS, "stretch")?);
+    set_enum(&mut f, "UndA", choice("undefinedAreas", &UNDEFINED, "repeat")?);
+    set(&mut item, "Fltr", Value::Descriptor(f));
+    Ok(item)
+}
+
+/// The displacement map embedded in Displace params imported from PSD (`None` when there is
+/// none or it is unreadable). The two planes become the first two channels; identical planes
+/// (every file seen so far) become one channel, which Displace reads for both directions.
+pub fn embedded_map(params: &J) -> Option<Arc<Image>> {
+    let item = template(params).ok()?;
+    let m = fltr_map(&item)?;
+    let rect = Rect::new(0, 0, i32::try_from(m.width).ok()?, i32::try_from(m.height).ok()?);
+    let v = |b: u8| f32::from(b) / 255.0;
+    let (ch, data) = if m.horizontal == m.vertical {
+        (1, m.horizontal.iter().map(|&b| v(b)).collect())
+    } else {
+        (3, m.horizontal.iter().zip(m.vertical).flat_map(|(&h, &w)| [v(h), v(w), 0.5]).collect())
+    };
+    Some(Arc::new(Image { rect, ch, data }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::smart_map::{UNSUPPORTED_FILTER, filter_from_item, item_for_filter};
+
+    /// A `tdta` blob: `w`×`h`, horizontal plane `h_of(i)`, vertical `v_of(i)`, then `pad` zeros.
+    fn tdta(w: u32, h: u32, h_of: impl Fn(usize) -> u8, v_of: impl Fn(usize) -> u8, pad: usize) -> Vec<u8> {
+        let n = (w * h) as usize;
+        let mut b = Vec::new();
+        b.extend(h.to_le_bytes());
+        b.extend(w.to_le_bytes());
+        b.extend(MODE_TWO_PLANES.to_le_bytes());
+        b.extend((0..n).map(h_of));
+        b.extend((0..n).map(v_of));
+        b.extend(std::iter::repeat_n(0, pad));
+        b
+    }
+
+    /// A `filterFXList` item as Photoshop writes a Displace smart filter.
+    fn item(map: Vec<u8>) -> Descriptor {
+        let e = |t: &str, v: &str| Value::Enumerated { type_id: Id::new(t), value: Id::new(v) };
+        Descriptor::new("filterFX")
+            .with("Nm  ", Value::Text(photocraft_psd::descriptor::UnicodeString::new_nul("Displace...")))
+            .with(
+                "blendOptions",
+                blend_options(&SmartFilter {
+                    command: String::new(),
+                    params: J::Null,
+                    blend: photocraft_color::BlendMode::Normal,
+                    opacity: 1.0,
+                    visible: true,
+                }),
+            )
+            .with("enab", Value::Boolean(true))
+            .with("hasoptions", Value::Boolean(true))
+            .with(
+                "Fltr",
+                Value::Descriptor(
+                    Descriptor::new(CLASS)
+                        .with("HrzS", Value::Integer(10))
+                        .with("VrtS", Value::Integer(10))
+                        .with("DspM", e("DspM", "StrF"))
+                        .with("UndA", e("UndA", "RptE"))
+                        .with("DspF", Value::Alias(b"Macintosh HD:maps:displace.psd".to_vec()))
+                        .with("EmbF", Value::Boolean(true))
+                        .with(MAP_KEY, Value::RawData(map)),
+                ),
+            )
+            .with("filterID", Value::Integer(FILTER_ID))
+    }
+
+    #[test]
+    fn filter_id_is_dspl() {
+        assert_eq!(FILTER_ID, 1148416108);
+    }
+
+    #[test]
+    fn parses_the_observed_layout() {
+        let b = tdta(3, 2, |i| i as u8, |i| 100 + i as u8, 3);
+        let m = parse_map(&b).unwrap();
+        assert_eq!((m.width, m.height), (3, 2));
+        assert_eq!(m.horizontal, &[0, 1, 2, 3, 4, 5]);
+        assert_eq!(m.vertical, &[100, 101, 102, 103, 104, 105]);
+    }
+
+    #[test]
+    fn hostile_maps_are_rejected_without_panicking() {
+        let good = tdta(4, 4, |i| i as u8, |i| i as u8, 0);
+        for len in 0..good.len() {
+            assert!(parse_map(&good[..len]).is_none(), "truncated to {len}");
+        }
+        let header = |h: u32, w: u32, mode: u16| [h.to_le_bytes().as_slice(), &w.to_le_bytes(), &mode.to_le_bytes(), &[0; 64]].concat();
+        assert!(parse_map(&header(u32::MAX, u32::MAX, 3)).is_none());
+        assert!(parse_map(&header(1 << 16, 1 << 16, 3)).is_none());
+        assert!(parse_map(&header(0, 4, 3)).is_none());
+        assert!(parse_map(&header(2, 2, 2)).is_none());
+        assert!(parse_map(&header(2, 2, 4)).is_none());
+        assert!(parse_map(&header(2, 2, 3)).is_some());
+        // Every possible short blob, and a few corrupted bytes of a good one.
+        for seed in 0..512u32 {
+            let mut b = good.clone();
+            let i = (seed as usize * 7) % b.len();
+            b[i] = b[i].wrapping_add(seed as u8 | 1);
+            let _ = parse_map(&b);
+            let _ = embedded_map(&json!({TEMPLATE_KEY: to_hex(&item(b).to_bytes())}));
+        }
+    }
+
+    #[test]
+    fn displace_items_map_to_the_command_and_round_trip() {
+        let src = item(tdta(4, 3, |i| (i * 20) as u8, |i| (i * 20) as u8, 4));
+        let f = filter_from_item(&src);
+        assert_eq!(f.command, COMMAND);
+        assert_eq!(
+            (f.params["horizontal"].as_f64(), f.params["fit"].as_str(), f.params["undefinedAreas"].as_str()),
+            (Some(10.0), Some("stretch"), Some("repeat"))
+        );
+        assert_eq!(item_for_filter(&f).unwrap(), src, "unchanged settings write the original item back");
+        let map = embedded_map(&f.params).unwrap();
+        assert_eq!((map.rect, map.ch), (Rect::new(0, 0, 4, 3), 1));
+        assert_eq!(map.data[1], 20.0 / 255.0);
+
+        let mut edited = f.clone();
+        edited.params["horizontal"] = json!(-25.4);
+        edited.params["fit"] = json!("tile");
+        edited.params["undefinedAreas"] = json!("wrap");
+        edited.opacity = 0.5;
+        let back = filter_from_item(&item_for_filter(&edited).unwrap());
+        assert_eq!(back.command, COMMAND);
+        assert_eq!(
+            (back.params["horizontal"].as_f64(), back.params["fit"].as_str(), back.params["undefinedAreas"].as_str()),
+            (Some(-25.0), Some("tile"), Some("wrap"))
+        );
+        assert_eq!(back.opacity, 0.5);
+        assert!(embedded_map(&back.params).is_some(), "the map survives");
+    }
+
+    #[test]
+    fn different_planes_drive_each_direction() {
+        let f = filter_from_item(&item(tdta(2, 1, |_| 255, |_| 0, 0)));
+        let map = embedded_map(&f.params).unwrap();
+        assert_eq!(map.ch, 3);
+        assert_eq!(&map.data[..3], &[1.0, 0.0, 0.5]);
+    }
+
+    #[test]
+    fn unreadable_displace_filters_stay_opaque() {
+        let only_alias = {
+            let mut i = item(Vec::new());
+            let mut f = get_desc(&i, "Fltr").unwrap().clone();
+            f.items.retain(|(k, _)| !k.is(MAP_KEY));
+            set(&mut i, "Fltr", Value::Descriptor(f));
+            i
+        };
+        let mut bad_enum = item(tdta(2, 2, |_| 0, |_| 0, 0));
+        let mut f = get_desc(&bad_enum, "Fltr").unwrap().clone();
+        set(&mut f, "DspM", Value::Enumerated { type_id: Id::new("DspM"), value: Id::new("Huh?") });
+        set(&mut bad_enum, "Fltr", Value::Descriptor(f));
+        let wrong_mode = item([tdta(2, 2, |_| 0, |_| 0, 0)[..8].to_vec(), 1u16.to_le_bytes().to_vec(), vec![0; 8]].concat());
+        for src in [only_alias, bad_enum, wrong_mode, item(vec![1, 2, 3])] {
+            let f = filter_from_item(&src);
+            assert_eq!(f.command, UNSUPPORTED_FILTER);
+            assert_eq!(item_for_filter(&f).unwrap(), src);
+        }
+    }
+
+    #[test]
+    fn bad_exports_report_errors() {
+        let ok = filter_from_item(&item(tdta(2, 2, |_| 0, |_| 0, 0))).params;
+        let with = |k: &str, v: J| {
+            let mut p = ok.clone();
+            p[k] = v;
+            p
+        };
+        for p in [
+            J::Null,
+            json!({"horizontal": 10}),
+            json!({TEMPLATE_KEY: "zz"}),
+            json!({TEMPLATE_KEY: 12}),
+            json!({TEMPLATE_KEY: to_hex(&Descriptor::new("filterFX").with("filterID", Value::Integer(FILTER_ID)).to_bytes())}),
+            with("horizontal", json!("big")),
+            with("fit", json!("squash")),
+            with("mapPath", json!("/tmp/map.psd")),
+        ] {
+            assert!(export_item(&p).is_err(), "{p}");
+        }
+        assert!(embedded_map(&json!({TEMPLATE_KEY: "0".repeat(MAX_TEMPLATE_BYTES * 2 + 2)})).is_none());
+    }
+}
diff --git a/crates/io/src/exr_parts.rs b/crates/io/src/exr_parts.rs
index 93b8e85f36..5474d00310 100644
--- a/crates/io/src/exr_parts.rs
+++ b/crates/io/src/exr_parts.rs
@@ -98,6 +98,12 @@ fn channel_base_split(name: &str) -> Option<(&str, &str)> {
     (!prefix.is_empty()).then_some((prefix, base))
 }
 
+/// The name a part is listed, selected and imported as: its `name` attribute, or
+/// `part <index>` when it has none (a single-part render usually carries no name).
+fn part_display_name(part: &codecs::ExrPartInfo) -> String {
+    part.name.clone().unwrap_or_else(|| format!("part {}", part.index))
+}
+
 /// Lists the entries of a multi-part or channel-grouped EXR for a chooser: flat parts in
 /// file order, then the channel groups, then the Cryptomatte layers as information. A file
 /// whose parts are all deep is refused (the deep decoder composites those).
@@ -113,7 +119,7 @@ pub fn entries(bytes: &[u8]) -> Result<Vec<Entry>, IoError> {
         }
         out.push(Entry {
             kind: EntryKind::Part,
-            name: part.name.clone().unwrap_or_else(|| format!("part {}", part.index)),
+            name: part_display_name(part),
             view: part.view.clone(),
             width: part.width,
             height: part.height,
@@ -186,8 +192,14 @@ pub fn import(name: &str, bytes: &[u8], sel: &Selection) -> Result<ImportResult,
     }
     let all_groups = groups(bytes)?;
     let view_passes = |view: &Option<String>| view.as_ref().is_none_or(|v| sel.view.eq_ignore_ascii_case("both") || v.eq_ignore_ascii_case(&sel.view));
-    let part_by_name =
-        |want: &str| info.iter().find(|p| !p.deep && p.name.as_deref() == Some(want)).ok_or_else(|| IoError::Unsupported(format!("no flat part named {want}")));
+    // A named part wins over an unnamed one listed under the same fallback name ("part 0").
+    let part_by_name = |want: &str| {
+        let flat = || info.iter().filter(|p| !p.deep);
+        flat()
+            .find(|p| p.name.as_deref() == Some(want))
+            .or_else(|| flat().find(|p| p.name.is_none() && part_display_name(p) == want))
+            .ok_or_else(|| IoError::Unsupported(format!("no flat part named {want}")))
+    };
     let mut chosen_parts: Vec<&codecs::ExrPartInfo> = Vec::new();
     for want in &sel.parts {
         let p = part_by_name(want)?;
@@ -235,7 +247,7 @@ pub fn import(name: &str, bytes: &[u8], sel: &Selection) -> Result<ImportResult,
         }
         let (surface, mode) = layer_surface(&img, &mut max)?;
         gray_only &= mode == ColorMode::Grayscale;
-        layers.push(Layer::new(part.name.clone().unwrap_or_else(|| format!("part {}", part.index)), LayerContent::Raster(surface)));
+        layers.push(Layer::new(part_display_name(part), LayerContent::Raster(surface)));
     }
     for group in &chosen_groups {
         let mut names = group.channels.clone();
diff --git a/crates/io/src/flat.rs b/crates/io/src/flat.rs
index 3659666f8e..5512a55c01 100644
--- a/crates/io/src/flat.rs
+++ b/crates/io/src/flat.rs
@@ -20,7 +20,21 @@ pub fn import_flat(name: &str, bytes: &[u8]) -> Result<ImportResult, IoError> {
         return import_tiff_page(name, bytes, None);
     }
     let img = codecs::decode(bytes)?;
+    // A palette BMP or PNG opens in Indexed Color mode with its colour table, as in Photoshop
+    // (#3802, #4804).
+    let palette = match codecs::detect(bytes) {
+        Some(Format::Bmp) => codecs::bmp_palette(bytes).ok().flatten().map(|c| (c, None)),
+        Some(Format::Png) => codecs::png_palette(bytes).ok().flatten().map(|p| (p.colors, p.transparent)),
+        _ => None,
+    };
     let mut r = image_to_document(name, &img)?;
+    if let Some((colors, transparent)) = palette.filter(|(c, _)| !c.is_empty())
+        && r.document.mode == ColorMode::Rgb
+    {
+        r.document.mode = ColorMode::Indexed;
+        r.document.color_table = Some(photocraft_doc::ColorTable { colors, transparent });
+    }
+    r.document.file_encoding = file_encoding(bytes);
     if codecs::detect(bytes) == Some(Format::Tga) && img.layout() == ChannelLayout::Rgba {
         tga_alpha_to_channel(&mut r.document)?;
     }
@@ -50,6 +64,45 @@ pub fn import_gif_frames(name: &str, bytes: &[u8], each: &mut dyn FnMut(Document
     Ok(n)
 }
 
+/// The lossy settings `bytes` were encoded with, for File › Save to keep: a JPEG's quality
+/// (estimated from its quantisation tables) and a WebP's lossless or lossy encoding with its
+/// quality. A lossy WebP whose quality can't be read gets [`DEFAULT_LOSSY_WEBP_QUALITY`].
+pub fn file_encoding(bytes: &[u8]) -> photocraft_doc::FileEncoding {
+    let mut e = photocraft_doc::FileEncoding::default();
+    match codecs::detect(bytes) {
+        Some(Format::Jpeg) => e.jpeg_quality = codecs::jpeg_quality(bytes),
+        Some(Format::WebP) => match codecs::webp_encoding(bytes) {
+            Some(codecs::WebpEncoding::Lossless) => e.webp_lossless = Some(true),
+            Some(codecs::WebpEncoding::Lossy { quality }) => {
+                e.webp_lossless = Some(false);
+                e.webp_quality = Some(quality.unwrap_or(DEFAULT_LOSSY_WEBP_QUALITY));
+            }
+            None => {}
+        },
+        _ => {}
+    }
+    e
+}
+
+/// The quality a lossy WebP is saved at when its own can't be read.
+pub const DEFAULT_LOSSY_WEBP_QUALITY: u8 = 75;
+
+/// Applies the settings `doc`'s file was encoded with (see [`file_encoding`]) to `opts`: what a
+/// save that chose no quality writes, so a JPEG keeps its quality and a WebP stays lossy or
+/// lossless.
+pub fn apply_file_encoding(doc: &Document, opts: &mut codecs::EncodeOptions) {
+    let e = &doc.file_encoding;
+    if let Some(q) = e.jpeg_quality {
+        opts.jpeg_quality = q.clamp(1, 100);
+    }
+    if let Some(lossless) = e.webp_lossless {
+        opts.webp_lossless = lossless;
+    }
+    if let Some(q) = e.webp_quality {
+        opts.webp_quality = q.min(100);
+    }
+}
+
 /// Photoshop opens a 32-bit Targa as an opaque Background plus an "Alpha 1" channel holding the
 /// fourth byte, even when the header declares no alpha bits, and keeps the stored colours (#2225;
 /// measured on Photoshop 27.11). Layer transparency would hide those colours and lose the channel
@@ -256,12 +309,18 @@ pub(crate) fn csample(s: SampleType) -> CSample {
 
 /// Renders the document to a flat codec image (native pixels when possible).
 pub fn document_to_image(doc: &Document, warnings: &mut Vec<String>) -> Result<Image, IoError> {
+    document_to_image_for(doc, warnings, true)
+}
+
+fn document_to_image_for(doc: &Document, warnings: &mut Vec<String>, cmyk_target: bool) -> Result<Image, IoError> {
     let (w, h) = (doc.size.width, doc.size.height);
     let canvas = doc.bounds();
     let fmt = doc.pixel_format();
     let n = (w as usize) * (h as usize);
-    // Lab has no flat-format layout here: Lab documents always go through the composite.
-    let native = single_layer(doc).filter(|_| fmt.mode != ColorMode::Lab);
+    // Lab has no flat-format layout here: Lab documents always go through the composite, which
+    // flattens nothing when there is a single plain layer.
+    let single = single_layer(doc);
+    let native = single.filter(|_| fmt.mode != ColorMode::Lab);
     let mut icc = doc.icc_profile.as_ref().map(|i| i.to_vec());
     let img = if let Some(s) = native {
         // Native path: keep model and depth. The surface's encoded samples are the codec's raw
@@ -288,18 +347,46 @@ pub fn document_to_image(doc: &Document, warnings: &mut Vec<String>) -> Result<I
         }
         Image::from_raw(w, h, layout, csample(fmt.sample), data)?
     } else {
-        let count = doc.layer_count();
-        warnings.push(format!("{count} layer(s) flattened; layers, masks and blend modes are not kept"));
-        // The compositor works in RGB; write RGB/gray.
+        if single.is_none() {
+            let count = doc.layer_count();
+            warnings.push(format!("{count} layer(s) flattened; layers, masks and blend modes are not kept"));
+        }
+        let cmyk = fmt.mode == ColorMode::Cmyk && cmyk_target;
+        // Only a CMYK target needs the document's profile; RGB-only targets keep the compositor's
+        // own handling (built-in coated CMYK when the embedded profile is unusable).
+        let space = if cmyk {
+            use photocraft_cms::{Builtin, ColorSpace, Intent, Profile, Transform};
+            let profile = match doc.icc_profile.as_ref() {
+                Some(bytes) => Profile::parse(bytes).map_err(|e| IoError::Unsupported(format!("invalid CMYK composite profile: {e}")))?,
+                None => Builtin::CoatedCmyk.profile().clone(),
+            };
+            if profile.color_space != ColorSpace::Cmyk {
+                return Err(IoError::Unsupported("CMYK composite requires a CMYK ICC profile".into()));
+            }
+            let srgb = Builtin::Srgb.profile();
+            Transform::new(&profile, srgb, Intent::RelativeColorimetric, true).map_err(|e| IoError::Unsupported(e.to_string()))?;
+            Transform::new(srgb, &profile, Intent::RelativeColorimetric, true).map_err(|e| IoError::Unsupported(e.to_string()))?;
+            if icc.is_none() {
+                icc = Some(profile.to_bytes().to_vec());
+            }
+            photocraft_compose::cmyk_space(doc)
+        } else {
+            None
+        };
         let gray = fmt.mode == ColorMode::Grayscale;
-        if fmt.mode == ColorMode::Cmyk || fmt.mode == ColorMode::Lab {
-            // The compositor renders CMYK/Lab documents in sRGB (CMYK through the built-in
-            // profile), so the file is tagged sRGB.
+        if (fmt.mode == ColorMode::Cmyk && !cmyk) || fmt.mode == ColorMode::Lab {
+            // RGB-only targets use the sRGB composite directly, without reseparating CMYK.
             warnings.push(format!("{:?} composite written as sRGB RGB (colour-managed conversion)", fmt.mode));
             icc = Some(photocraft_cms::Builtin::Srgb.profile().to_bytes().to_vec());
         }
         let cs = csample(fmt.sample);
-        let colors = if gray { 1 } else { 3 };
+        let colors = if cmyk {
+            4
+        } else if gray {
+            1
+        } else {
+            3
+        };
         // Rendered and quantised in bands (no full-size float composite), with alpha; the alpha
         // is dropped afterwards, in place, when every pixel turned out opaque.
         let mut data = try_buffer(n, (colors + 1) * cs.bytes())?;
@@ -307,26 +394,35 @@ pub fn document_to_image(doc: &Document, warnings: &mut Vec<String>) -> Result<I
         let _ = photocraft_compose::render_bands(doc, canvas, 0, |band| -> Result<(), ()> {
             opaque &= band.px.iter().all(|p| p[3] >= 1.0);
             let parts = crate::pixels::par_map(crate::pixels::bands(band.px.len()), |range| {
-                let mut out = Vec::with_capacity(range.len() * (colors + 1) * cs.bytes());
-                let mut put = |v: f32| {
-                    let v = if v.is_nan() { 0.0 } else { v };
-                    match cs {
-                        CSample::U8 => out.push((v.clamp(0.0, 1.0) * 255.0).round() as u8),
-                        CSample::U16 => out.extend_from_slice(&((v.clamp(0.0, 1.0) * 65535.0).round() as u16).to_ne_bytes()),
-                        CSample::F16 | CSample::F32 => out.extend_from_slice(&v.to_ne_bytes()),
+                photocraft_color::convert::with_cmyk_space(space.as_ref(), || {
+                    let mut out = Vec::with_capacity(range.len() * (colors + 1) * cs.bytes());
+                    let mut put = |v: f32| {
+                        let v = if v.is_nan() { 0.0 } else { v };
+                        match cs {
+                            CSample::U8 => out.push((v.clamp(0.0, 1.0) * 255.0).round() as u8),
+                            CSample::U16 => out.extend_from_slice(&((v.clamp(0.0, 1.0) * 65535.0).round() as u16).to_ne_bytes()),
+                            CSample::F16 | CSample::F32 => out.extend_from_slice(&v.to_ne_bytes()),
+                        }
+                    };
+                    let mut converted = [0.0; 5];
+                    for p in &band.px[range] {
+                        if cmyk {
+                            let channels = photocraft_raster::from_rgba_into(&fmt, *p, &mut converted);
+                            for value in converted.iter().take(channels) {
+                                put(*value);
+                            }
+                            continue;
+                        } else if gray {
+                            put(photocraft_color::convert::rgb_to_gray([p[0], p[1], p[2]]));
+                        } else {
+                            put(p[0]);
+                            put(p[1]);
+                            put(p[2]);
+                        }
+                        put(p[3]);
                     }
-                };
-                for p in &band.px[range] {
-                    if gray {
-                        put(photocraft_color::convert::rgb_to_gray([p[0], p[1], p[2]]));
-                    } else {
-                        put(p[0]);
-                        put(p[1]);
-                        put(p[2]);
-                    }
-                    put(p[3]);
-                }
-                out
+                    out
+                })
             });
             for part in parts {
                 data.extend_from_slice(&part);
@@ -336,7 +432,16 @@ pub fn document_to_image(doc: &Document, warnings: &mut Vec<String>) -> Result<I
         if opaque {
             drop_alpha(&mut data, colors * cs.bytes(), cs.bytes());
         }
-        let layout = layout_for(if gray { ColorMode::Grayscale } else { ColorMode::Rgb }, !opaque);
+        let layout = layout_for(
+            if cmyk {
+                ColorMode::Cmyk
+            } else if gray {
+                ColorMode::Grayscale
+            } else {
+                ColorMode::Rgb
+            },
+            !opaque,
+        );
         Image::from_raw(w, h, layout, cs, data)?
     };
     let meta = codecs::Metadata {
@@ -413,7 +518,8 @@ pub(crate) fn export_flat_with(doc: &Document, format: Format, opts: &ExportOpti
         return Ok(r);
     }
     let mut warnings = Vec::new();
-    let mut img = document_to_image(doc, &mut warnings)?;
+    let cmyk_target = format.caps().layouts.iter().any(|layout| layout.is_cmyk());
+    let mut img = document_to_image_for(doc, &mut warnings, cmyk_target)?;
     ctl.check().map_err(|_| IoError::Cancelled)?;
     ctl.progress(composite_share(format));
     if opts.xmp == XmpEmbed::None {
@@ -441,11 +547,14 @@ pub(crate) fn export_flat_with(doc: &Document, format: Format, opts: &ExportOpti
             img = linear;
         }
     } else if !format.caps().icc {
-        // Untagged files read back as sRGB: convert to it (as Quick Export does) rather than
+        // Untagged files read back as sRGB/sGray: convert to it (as Quick Export does) rather than
         // write values that only mean something under the dropped profile.
         if let Some(srgb) = convert_rgb(&img, Builtin::Srgb.profile(), Intent::Perceptual, true, img.sample_type())? {
             img = srgb;
             warnings.push(format!("colours converted to sRGB; {format:?} can't embed the document's colour profile"));
+        } else if let Some(gray) = convert_gray(&img, Builtin::SGray.profile(), img.sample_type())? {
+            img = gray;
+            warnings.push(format!("colours converted to sGray; {format:?} can't embed the document's colour profile"));
         }
     }
     if format == Format::Tga {
diff --git a/crates/io/src/gradient_bake.rs b/crates/io/src/gradient_bake.rs
index c9265a9102..e452ae9e1f 100644
--- a/crates/io/src/gradient_bake.rs
+++ b/crates/io/src/gradient_bake.rs
@@ -14,8 +14,9 @@
 
 use photocraft_color::{Color, ColorMode};
 
+/// Photoshop's gradient interpolation methods.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) enum Method {
+pub enum Method {
     Classic,
     Perceptual,
     Linear,
@@ -23,6 +24,16 @@ pub(crate) enum Method {
 }
 
 impl Method {
+    /// The method a command names (`classic`, `perceptual`, `linear`, `smooth`); `None` otherwise.
+    pub fn from_name(name: &str) -> Option<Method> {
+        match name.to_ascii_lowercase().as_str() {
+            "classic" => Some(Method::Classic),
+            "perceptual" => Some(Method::Perceptual),
+            "linear" => Some(Method::Linear),
+            "smooth" => Some(Method::Smooth),
+            _ => None,
+        }
+    }
     pub(crate) fn from_code(code: Option<&[u8]>) -> Method {
         match code {
             Some(b"Perc") => Method::Perceptual,
@@ -140,7 +151,7 @@ fn eval(stops: &[(f32, [f32; 3])], mids: &[f32], smooth: f32, t: f32, m: Method)
 
 /// Dense linear stops reproducing Photoshop's interpolation. Returns the input unchanged when it
 /// already interpolates linearly in sRGB.
-pub(crate) fn bake(stops: Vec<(f32, Color)>, midpoints: &[f32], smoothness: f32, method: Method) -> Vec<(f32, Color)> {
+pub fn bake(stops: Vec<(f32, Color)>, midpoints: &[f32], smoothness: f32, method: Method) -> Vec<(f32, Color)> {
     let plain_mids = midpoints.iter().all(|m| (m - 0.5).abs() < 1e-3);
     // Classic interpolates in the stops' own model: Lab stops (Lab documents) blend in L*a*b*, which the
     // compositors' sRGB interpolation can't reproduce (psd-tools 4x4_16bit_lab).
diff --git a/crates/io/src/kra.rs b/crates/io/src/kra.rs
new file mode 100644
index 0000000000..64e4facf61
--- /dev/null
+++ b/crates/io/src/kra.rs
@@ -0,0 +1,342 @@
+//! Krita (`.kra`, `.krz`) import. Layout observed from files Krita writes (no Krita code used):
+//! a ZIP whose first, stored entry is `mimetype` = `application/x-krita`, a `maindoc.xml` node
+//! tree, one tiled pixel file per paint layer and mask under `<image name>/layers/`, the
+//! image's ICC profile in `<image name>/annotations/icc`, and Krita's rendering in
+//! `mergedimage.png`.
+//!
+//! Tiled pixel files are a short text header (`VERSION 2`, `TILEWIDTH`, `TILEHEIGHT`,
+//! `PIXELSIZE`, `DATA <tiles>`) followed by, per tile, a `x,y,LZF,<bytes>` line and that many
+//! bytes: a flag (1 = LZF-compressed, 0 = raw) and the tile's pixels stored as byte planes
+//! (every pixel's first byte, then every pixel's second byte, ...). RGB pixels are in
+//! Krita's BGRA order, 16-bit samples little-endian.
+//!
+//! Imported: paint layers (8 and 16-bit RGBA and gray), groups (isolated and pass-through),
+//! names, visibility, opacity, blend modes, locks, layer offsets and transparency masks.
+//! Every other node kind (vector, filter, fill, file and clone layers, filter, transform and
+//! colorize masks) is left out with a warning; Krita's merged image still shows their look.
+//! Documents in a colour space we don't read open as Krita's merged image, flagged as a preview.
+
+#[cfg(test)]
+mod tests;
+mod tiles;
+
+use photocraft_color::{BlendMode, PixelFormat};
+use photocraft_doc::{Document, Layer, LayerContent, LayerMask};
+use photocraft_format::zip::ZipReader;
+use photocraft_geom::Size;
+use photocraft_raster::{Interrupt, Surface};
+
+use crate::ora::{MAX_NODES, MAX_PIXEL_BYTES, MAX_SIDE, Warnings, krita_blend};
+use crate::{ImportResult, IoError};
+use tiles::{Space, TileFile};
+
+type Result<T> = std::result::Result<T, IoError>;
+
+/// The `mimetype` entry of a Krita archive.
+pub(crate) const MIMETYPE: &[u8] = b"application/x-krita";
+pub(crate) const EXTENSIONS: [&str; 2] = ["kra", "krz"];
+const MAX_MAINDOC: usize = 32 << 20;
+const MAX_LAYER_FILE: usize = 1 << 30;
+
+fn invalid(message: impl Into<String>) -> IoError {
+    IoError::Kra(message.into())
+}
+
+/// `true` for a Krita archive (by its `mimetype` entry).
+pub(crate) fn is_kra(bytes: &[u8]) -> bool {
+    crate::ora::zip_mimetype(bytes).is_some_and(|mime| mime.trim_ascii() == MIMETYPE)
+}
+
+fn attr<'a>(node: roxmltree::Node<'a, '_>, name: &str) -> Option<&'a str> {
+    node.attribute(name).map(str::trim)
+}
+
+fn number(node: roxmltree::Node<'_, '_>, name: &str, default: f64) -> Result<f64> {
+    match attr(node, name) {
+        None | Some("") => Ok(default),
+        Some(v) => v.parse::<f64>().ok().filter(|v| v.is_finite()).ok_or_else(|| invalid(format!("invalid {name} attribute `{v}`"))),
+    }
+}
+
+fn offset(node: roxmltree::Node<'_, '_>, name: &str) -> Result<i32> {
+    let v = number(node, name, 0.0)?.round();
+    if v.abs() > f64::from(MAX_SIDE) * 4.0 {
+        return Err(invalid(format!("{name} offset {v} is out of range")));
+    }
+    Ok(v as i32)
+}
+
+fn truthy(node: roxmltree::Node<'_, '_>, name: &str) -> bool {
+    matches!(attr(node, name), Some("1" | "true"))
+}
+
+/// Child elements named `tag` inside the node's `<container>` element (`layers` or `masks`).
+fn children<'a, 'i>(node: roxmltree::Node<'a, 'i>, container: &str, tag: &'static str) -> impl Iterator<Item = roxmltree::Node<'a, 'i>> {
+    node.children().filter(move |c| c.has_tag_name(container)).flat_map(move |c| c.children().filter(move |n| n.has_tag_name(tag)))
+}
+
+struct Reader<'a, 'c> {
+    zip: ZipReader<'a>,
+    ctl: &'c Interrupt<'c>,
+    /// `<image name>/layers/`.
+    dir: String,
+    /// The document's pixel format (layers in another supported space are converted to it).
+    fmt: PixelFormat,
+    nodes: usize,
+    budget: usize,
+    warnings: Warnings,
+}
+
+impl Reader<'_, '_> {
+    fn file(&self, name: &str) -> Result<Option<Vec<u8>>> {
+        let path = format!("{}{name}", self.dir);
+        match self.zip.find(&path) {
+            None => Ok(None),
+            Some(e) => self.zip.read(e, MAX_LAYER_FILE).map(Some).map_err(|err| invalid(format!("{path}: {err}"))),
+        }
+    }
+
+    /// The default pixel Krita stores next to a tiled file, decoded to `space` samples.
+    fn default_pixel(&self, name: &str, space: Space) -> Result<Option<Vec<f32>>> {
+        let Some(bytes) = self.file(&format!("{name}.defaultpixel"))? else { return Ok(None) };
+        if bytes.len() != space.pixel_size() {
+            return Err(invalid(format!("{name}.defaultpixel has {} bytes, expected {}", bytes.len(), space.pixel_size())));
+        }
+        Ok(Some(space.normalised(&bytes)))
+    }
+
+    /// A tiled pixel file in `space` as a surface in `fmt`, offset by (`dx`, `dy`).
+    fn surface(&mut self, name: &str, space: Space, fmt: PixelFormat, dx: i32, dy: i32) -> Result<Option<Surface>> {
+        let Some(bytes) = self.file(name)? else { return Ok(None) };
+        let file = TileFile::parse(&bytes)?;
+        if file.pixel_size != space.pixel_size() {
+            return Err(invalid(format!("{name}: pixel size {} does not match its colour space", file.pixel_size)));
+        }
+        let cost = file.decoded_bytes(fmt.bytes_per_pixel())?;
+        self.budget = self.budget.checked_sub(cost).ok_or_else(|| invalid("decoded layers exceed the 1 GiB limit"))?;
+        let mut surface = match self.default_pixel(name, space)? {
+            Some(px) if px.iter().any(|v| *v != 0.0) => Surface::with_default(fmt, &space.to_format(&px, fmt)),
+            _ => Surface::new(fmt),
+        };
+        file.decode_into(&mut surface, space, dx, dy, self.ctl)?;
+        surface.prune();
+        Ok(Some(surface))
+    }
+
+    fn props(&mut self, node: roxmltree::Node<'_, '_>, layer: &mut Layer) -> Result<()> {
+        layer.name = attr(node, "name").filter(|n| !n.is_empty()).map_or_else(|| format!("Layer {}", self.nodes), str::to_string);
+        layer.visible = attr(node, "visible") != Some("0");
+        layer.opacity = (number(node, "opacity", 255.0)? / 255.0).clamp(0.0, 1.0) as f32;
+        if truthy(node, "locked") {
+            layer.locks.all = true;
+        }
+        let op = attr(node, "compositeop").unwrap_or("normal");
+        layer.blend = match krita_blend(op) {
+            Some((mode, approx)) => {
+                if approx {
+                    self.warnings.note(&format!("Krita's {op} blend mode is approximated by {}", mode.label()));
+                }
+                mode
+            }
+            None => {
+                self.warnings.layer(&layer.name, &format!("Krita's {op} blend mode is not supported; it opens as Normal"));
+                BlendMode::Normal
+            }
+        };
+        if attr(node, "channelflags").is_some_and(|f| f.contains('0')) {
+            self.warnings.layer(&layer.name, "channel locks (Krita's per-channel blending) are ignored");
+        }
+        if truthy(node, "inheritalpha") {
+            self.warnings.layer(&layer.name, "Inherit Alpha is not supported; these layers blend normally");
+        }
+        if attr(node, "keyframes").is_some_and(|k| !k.is_empty()) {
+            self.warnings.layer(&layer.name, "animated layers open with the frame Krita saved in the layer");
+        }
+        Ok(())
+    }
+
+    /// The node's transparency masks, combined into one layer mask.
+    fn masks(&mut self, node: roxmltree::Node<'_, '_>, layer: &mut Layer, dx: i32, dy: i32) -> Result<()> {
+        for mask in children(node, "masks", "mask") {
+            self.ctl.check().map_err(|_| IoError::Cancelled)?;
+            let kind = attr(mask, "nodetype").unwrap_or("");
+            match kind {
+                "transparencymask" => {}
+                // A layer's local selection: not part of its look.
+                "selectionmask" => continue,
+                other => {
+                    let what = match other {
+                        "filtermask" => "filter masks",
+                        "transformmask" => "transform masks",
+                        "colorizemask" => "colorize masks",
+                        _ => "unknown masks",
+                    };
+                    self.warnings.layer(&layer.name, &format!("{what} are not supported and were left out"));
+                    continue;
+                }
+            }
+            if layer.mask.is_some() {
+                self.warnings.layer(&layer.name, "only the first transparency mask of a layer is kept");
+                continue;
+            }
+            let Some(file) = attr(mask, "filename") else { continue };
+            let (mx, my) = (dx.saturating_add(offset(mask, "x")?), dy.saturating_add(offset(mask, "y")?));
+            match self.surface(&format!("{file}.pixelselection"), Space::Alpha8, PixelFormat::GRAY8, mx, my)? {
+                Some(surface) => {
+                    layer.mask = Some(LayerMask { surface, enabled: attr(mask, "visible") != Some("0"), ..LayerMask::reveal_all() });
+                }
+                None => self.warnings.layer(&layer.name, "a transparency mask's pixels are missing from the file"),
+            }
+        }
+        Ok(())
+    }
+
+    /// The `<layers>` of `node`, bottom-to-top (maindoc.xml lists the topmost first).
+    fn layers(&mut self, node: roxmltree::Node<'_, '_>, depth: usize, dx: i32, dy: i32) -> Result<Vec<Layer>> {
+        if depth > photocraft_doc::MAX_GROUP_DEPTH {
+            return Err(IoError::Unsupported(format!("layer groups nested deeper than {}", photocraft_doc::MAX_GROUP_DEPTH)));
+        }
+        let mut out = Vec::new();
+        for child in children(node, "layers", "layer") {
+            self.ctl.check().map_err(|_| IoError::Cancelled)?;
+            self.nodes += 1;
+            if self.nodes > MAX_NODES {
+                return Err(invalid(format!("more than {MAX_NODES} layers")));
+            }
+            let (x, y) = (dx.saturating_add(offset(child, "x")?), dy.saturating_add(offset(child, "y")?));
+            let kind = attr(child, "nodetype").unwrap_or("");
+            let mut layer = match kind {
+                "paintlayer" => {
+                    let mut layer = Layer::raster("", self.fmt);
+                    self.props(child, &mut layer)?;
+                    let space = attr(child, "colorspacename").and_then(Space::from_name);
+                    match (space, attr(child, "filename")) {
+                        (Some(space), Some(file)) => match self.surface(file, space, self.fmt, x, y)? {
+                            Some(s) => layer.content = LayerContent::Raster(s),
+                            None => self.warnings.layer(&layer.name, "the layer's pixels are missing from the file; it opens empty"),
+                        },
+                        (None, _) => {
+                            let cs = attr(child, "colorspacename").unwrap_or("?");
+                            self.warnings.layer(&layer.name, &format!("layers in Krita's {cs} colour space are not supported and were left out"));
+                            continue;
+                        }
+                        (_, None) => self.warnings.layer(&layer.name, "the layer names no pixel file; it opens empty"),
+                    }
+                    layer
+                }
+                "grouplayer" => {
+                    let mut layer = Layer::group("", Vec::new());
+                    self.props(child, &mut layer)?;
+                    if truthy(child, "passthrough") {
+                        if layer.blend != BlendMode::Normal {
+                            self.warnings.layer(&layer.name, "a pass-through group's blend mode is ignored, as in Krita");
+                        }
+                        layer.blend = BlendMode::PassThrough;
+                    }
+                    // A group's own x/y is not applied to its children: Krita moves a group by
+                    // moving their pixels, and its merged image ignores the group offset.
+                    let kids = self.layers(child, depth + 1, dx, dy)?;
+                    if let LayerContent::Group(g) = &mut layer.content {
+                        g.children = kids;
+                        g.expanded = !truthy(child, "collapsed");
+                    }
+                    layer
+                }
+                other => {
+                    let name = attr(child, "name").unwrap_or(other).to_string();
+                    let what = match other {
+                        "shapelayer" => "vector layers",
+                        "adjustmentlayer" => "filter layers",
+                        "generatorlayer" => "fill layers",
+                        "filelayer" => "file layers",
+                        "clonelayer" => "clone layers",
+                        _ => "unknown layer kinds",
+                    };
+                    self.warnings.layer(&name, &format!("Krita {what} are not supported yet and were left out"));
+                    continue;
+                }
+            };
+            self.masks(child, &mut layer, x, y)?;
+            out.push(layer);
+        }
+        out.reverse();
+        Ok(out)
+    }
+}
+
+/// Krita's merged image as a one-layer stand-in, for documents we can't read layer by layer.
+fn preview(name: &str, zip: &ZipReader<'_>, why: String) -> Result<ImportResult> {
+    let png = zip.read_by_name("mergedimage.png", MAX_LAYER_FILE).map_err(|e| invalid(format!("{why}, and the merged image can't be read: {e}")))?;
+    let mut r = crate::flat::import_flat(name, &png)?;
+    r.document.name = name.to_string();
+    r.warnings.insert(0, format!("{why}; the file opens as Krita's merged image, without its layers"));
+    r.source_read_only = true;
+    r.preview_only = true;
+    Ok(r)
+}
+
+pub(crate) fn import(name: &str, bytes: &[u8], ctl: &Interrupt<'_>) -> Result<ImportResult> {
+    let zip = ZipReader::new(bytes).map_err(|e| invalid(e.to_string()))?;
+    let mime = zip.read_by_name("mimetype", 256).map_err(|e| invalid(e.to_string()))?;
+    if mime.trim_ascii() != MIMETYPE {
+        return Err(invalid("the archive's mimetype is not application/x-krita"));
+    }
+    let xml = zip.read_by_name("maindoc.xml", MAX_MAINDOC).map_err(|e| invalid(e.to_string()))?;
+    let xml = std::str::from_utf8(&xml).map_err(|_| invalid("maindoc.xml is not UTF-8"))?;
+    // maindoc.xml declares Krita's DTD by public id; roxmltree only reads internal subsets and
+    // guards entity expansion.
+    let opts = roxmltree::ParsingOptions { allow_dtd: true, ..Default::default() };
+    let tree = roxmltree::Document::parse_with_options(xml, opts).map_err(|e| invalid(format!("maindoc.xml: {e}")))?;
+    let image = tree.root_element().children().find(|n| n.has_tag_name("IMAGE")).ok_or_else(|| invalid("maindoc.xml has no IMAGE"))?;
+    let side = |a: &str| -> Result<u32> {
+        let v = number(image, a, 0.0)?;
+        if !(1.0..=f64::from(MAX_SIDE)).contains(&v) || v.fract() != 0.0 {
+            return Err(invalid(format!("image {a} {v} must be a whole number of pixels from 1 to {MAX_SIDE}")));
+        }
+        Ok(v as u32)
+    };
+    let (w, h) = (side("width")?, side("height")?);
+    if (w as usize).saturating_mul(h as usize).saturating_mul(8) > MAX_PIXEL_BYTES {
+        return Err(invalid("the canvas exceeds the 1 GiB pixel limit"));
+    }
+    let cs = attr(image, "colorspacename").unwrap_or("");
+    let Some(space) = Space::from_name(cs) else {
+        return preview(name, &zip, format!("Krita's {cs} colour space is not supported yet"));
+    };
+    let (mode, depth) = space.model();
+    let image_name = attr(image, "name").unwrap_or("");
+    let mut reader = Reader {
+        zip,
+        ctl,
+        dir: format!("{image_name}/layers/"),
+        fmt: PixelFormat::new(mode, depth, true),
+        nodes: 0,
+        budget: MAX_PIXEL_BYTES,
+        warnings: Warnings::default(),
+    };
+    let layers = reader.layers(image, 1, 0, 0)?;
+    ctl.progress(0.9);
+    let mut document = Document::new(name, Size::new(w, h), mode, depth);
+    document.layers = layers;
+    let icc = format!("{image_name}/annotations/icc");
+    if let Some(e) = reader.zip.find(&icc) {
+        let profile = reader.zip.read(e, 16 << 20).map_err(|err| invalid(format!("{icc}: {err}")))?;
+        if !profile.is_empty() {
+            document.icc_profile = Some(std::sync::Arc::new(profile));
+        }
+    }
+    let (xres, yres) = (number(image, "x-res", 72.0)?, number(image, "y-res", 72.0)?);
+    if xres > 0.0 && xres < 1.0e6 {
+        document.resolution_dpi = xres as f32;
+        if let Some(w) = crate::unequal_resolution_warning(xres, yres) {
+            reader.warnings.note(&w);
+        }
+    }
+    if document.layers.is_empty() {
+        reader.warnings.note("no layers of the Krita document could be imported");
+    }
+    if image.children().any(|n| n.has_tag_name("assistants") || n.has_tag_name("ReferenceImages")) {
+        reader.warnings.note("drawing assistants and reference images were left out");
+    }
+    Ok(ImportResult { document, warnings: reader.warnings.finish(), source_read_only: true, preview_only: false })
+}
diff --git a/crates/io/src/kra/tests.rs b/crates/io/src/kra/tests.rs
new file mode 100644
index 0000000000..4316a74c10
--- /dev/null
+++ b/crates/io/src/kra/tests.rs
@@ -0,0 +1,287 @@
+use super::tiles::{Space, lzf_decompress};
+use super::*;
+use photocraft_codecs::{ChannelLayout, Format, Image, SampleType as CSample};
+use photocraft_color::{ColorMode, SampleType};
+use photocraft_format::zip::ZipWriter;
+use photocraft_geom::Rect;
+
+const T: usize = 4; // small tiles keep the fixtures short
+
+/// LZF with literal runs only (valid liblzf output).
+fn lzf_literal(data: &[u8]) -> Vec<u8> {
+    let mut out = Vec::new();
+    for run in data.chunks(32) {
+        out.push((run.len() - 1) as u8);
+        out.extend_from_slice(run);
+    }
+    out
+}
+
+/// A tiled pixel file from (x, y, interleaved Krita pixels) tiles; odd tiles LZF, even raw.
+fn tile_file(pixel_size: usize, tiles: &[(i32, i32, Vec<u8>)]) -> Vec<u8> {
+    let mut out = format!("VERSION 2\nTILEWIDTH {T}\nTILEHEIGHT {T}\nPIXELSIZE {pixel_size}\nDATA {}\n", tiles.len()).into_bytes();
+    for (i, (x, y, px)) in tiles.iter().enumerate() {
+        let n = T * T;
+        let mut planar = vec![0; n * pixel_size];
+        for p in 0..n {
+            for k in 0..pixel_size {
+                planar[k * n + p] = px[p * pixel_size + k];
+            }
+        }
+        let body: Vec<u8> = if i % 2 == 1 { [vec![1], lzf_literal(&planar)].concat() } else { [vec![0], planar].concat() };
+        out.extend(format!("{x},{y},LZF,{}\n", body.len()).into_bytes());
+        out.extend(body);
+    }
+    out
+}
+
+fn archive(maindoc: &str, files: &[(&str, Vec<u8>)]) -> Vec<u8> {
+    let mut z = ZipWriter::new();
+    z.add("mimetype", MIMETYPE).unwrap();
+    z.add("maindoc.xml", maindoc.as_bytes()).unwrap();
+    for (name, data) in files {
+        z.add(name, data).unwrap();
+    }
+    z.finish().unwrap()
+}
+
+fn maindoc(cs: &str, layers: &str) -> String {
+    format!(
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE DOC PUBLIC '-//KDE//DTD krita 2.0//EN' 'http://www.calligra.org/DTD/krita-2.0.dtd'>\n\
+         <DOC xmlns=\"http://www.calligra.org/DTD/krita\" syntaxVersion=\"2.0\"><IMAGE name=\"img\" width=\"12\" height=\"8\" colorspacename=\"{cs}\" x-res=\"300\" y-res=\"300\"><layers>{layers}</layers></IMAGE></DOC>"
+    )
+}
+
+/// One tile of BGRA8 pixels: pixel p = (b, g, r, a) from `f(p)`.
+fn bgra(f: impl Fn(usize) -> [u8; 4]) -> Vec<u8> {
+    (0..T * T).flat_map(f).collect()
+}
+
+fn layer<'a>(d: &'a Document, name: &str) -> &'a Layer {
+    fn find<'a>(ls: &'a [Layer], name: &str) -> Option<&'a Layer> {
+        ls.iter().find_map(|l| if l.name == name { Some(l) } else { l.children().and_then(|c| find(c, name)) })
+    }
+    find(&d.layers, name).unwrap_or_else(|| panic!("no layer {name}"))
+}
+
+#[test]
+fn reads_layers_groups_masks_and_properties() {
+    let doc = maindoc(
+        "RGBA",
+        r#"<layer nodetype="grouplayer" name="Through" passthrough="1" compositeop="multiply" visible="1" opacity="255" filename="layer1" x="2" y="1" collapsed="1">
+             <layers><layer nodetype="paintlayer" name="Inner" colorspacename="RGBA" filename="layer2" compositeop="screen" opacity="128" x="1" y="0" locked="1"/></layers>
+           </layer>
+           <layer nodetype="paintlayer" name="Masked" colorspacename="RGBA" filename="layer3" compositeop="diff" visible="0" x="0" y="0">
+             <masks><mask nodetype="transparencymask" name="m" filename="mask4" x="0" y="0"/><mask nodetype="selectionmask" filename="sel"/></masks>
+           </layer>
+           <layer nodetype="shapelayer" name="Vector" filename="layer5"/>
+           <layer nodetype="paintlayer" name="Lab layer" colorspacename="LABA" filename="layer6"/>"#,
+    );
+    let red = bgra(|p| [0, 0, 255, (p * 16) as u8]);
+    let files = [
+        ("img/layers/layer2", tile_file(4, &[(0, 0, red.clone()), (4, 0, bgra(|_| [10, 20, 30, 255]))])),
+        ("img/layers/layer2.defaultpixel", vec![0; 4]),
+        ("img/layers/layer3", tile_file(4, &[(-4, 4, bgra(|_| [1, 2, 3, 200]))])),
+        ("img/layers/mask4.pixelselection", tile_file(1, &[(-4, 4, (0..T * T).map(|p| (p * 10) as u8).collect())])),
+        ("img/layers/mask4.pixelselection.defaultpixel", vec![0]),
+        ("img/annotations/icc", b"not really a profile".to_vec()),
+    ];
+    let r = crate::import("art.kra", &archive(&doc, &files)).unwrap();
+    let d = &r.document;
+    assert!(r.source_read_only && !r.preview_only);
+    assert_eq!((d.size.width, d.size.height, d.mode, d.depth), (12, 8, ColorMode::Rgb, SampleType::U8));
+    assert_eq!(d.resolution_dpi, 300.0);
+    assert!(d.icc_profile.is_some());
+    // Bottom-to-top: the unsupported nodes are left out.
+    let names: Vec<&str> = d.layers.iter().map(|l| l.name.as_str()).collect();
+    assert_eq!(names, ["Masked", "Through"]);
+    let through = layer(d, "Through");
+    assert_eq!(through.blend, BlendMode::PassThrough);
+    assert!(matches!(&through.content, LayerContent::Group(g) if !g.expanded));
+    let inner = layer(d, "Inner");
+    assert_eq!((inner.blend, inner.locks.all), (BlendMode::Screen, true));
+    assert!((inner.opacity - 128.0 / 255.0).abs() < 1e-6);
+    // The layer's offset (1, 0) moves its tiles; the group's (2, 1) does not, as in Krita.
+    let s = inner.surface().unwrap();
+    assert_eq!(s.content_bounds(), Rect::from_xywh(1, 0, 8, 4));
+    let px = s.to_interleaved(Rect::from_xywh(1, 0, 2, 1));
+    assert_eq!(px, [255, 0, 0, 0, 255, 0, 0, 16]);
+    assert_eq!(s.to_interleaved(Rect::from_xywh(5, 0, 1, 1)), [30, 20, 10, 255]);
+    let masked = layer(d, "Masked");
+    assert!(!masked.visible);
+    assert_eq!(masked.blend, BlendMode::Difference);
+    let mask = masked.mask.as_ref().unwrap();
+    assert_eq!(mask.surface.to_interleaved(Rect::from_xywh(-4, 4, 2, 1)), [0, 10]);
+    assert_eq!(mask.surface.to_interleaved(Rect::from_xywh(5, 5, 1, 1)), [0], "outside the tiles the default (hide) applies");
+    let all = r.warnings.join("\n");
+    for needle in ["vector layers", "LABA", "pass-through group's blend mode"] {
+        assert!(all.contains(needle), "{needle} not in {all}");
+    }
+}
+
+#[test]
+fn sixteen_bit_and_gray_spaces_convert_exactly() {
+    let px16: Vec<u8> = (0..T * T).flat_map(|p| [1000u16 + p as u16, 2000, 3000, 65535].iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<_>>()).collect();
+    let doc = maindoc(
+        "RGBA16",
+        r#"<layer nodetype="paintlayer" name="L" colorspacename="RGBA16" filename="l"/><layer nodetype="paintlayer" name="G" colorspacename="GRAYA" filename="g"/>"#,
+    );
+    let gray: Vec<u8> = (0..T * T).flat_map(|p| [p as u8 * 10, 255]).collect();
+    let r =
+        crate::import("a.kra", &archive(&doc, &[("img/layers/l", tile_file(8, &[(0, 0, px16)])), ("img/layers/g", tile_file(2, &[(0, 0, gray)]))])).unwrap();
+    let d = &r.document;
+    assert_eq!(d.depth, SampleType::U16);
+    let s = layer(d, "L").surface().unwrap();
+    assert_eq!(s.format(), PixelFormat::RGBA16);
+    let got: Vec<u16> = s.to_interleaved(Rect::from_xywh(1, 0, 1, 1)).as_chunks::<2>().0.iter().map(|b| u16::from_ne_bytes(*b)).collect();
+    // Krita's B, G, R, A becomes R, G, B, A.
+    assert_eq!(got, [3000, 2000, 1001, 65535]);
+    // A gray layer in an RGB document is converted.
+    let g = layer(d, "G").surface().unwrap();
+    assert_eq!(g.format(), PixelFormat::RGBA16);
+    let v: Vec<u16> = g.to_interleaved(Rect::from_xywh(2, 0, 1, 1)).as_chunks::<2>().0.iter().map(|b| u16::from_ne_bytes(*b)).collect();
+    assert_eq!(v, [20 * 257, 20 * 257, 20 * 257, 65535]);
+
+    let doc = maindoc("GRAYAU16", r#"<layer nodetype="paintlayer" name="G16" colorspacename="GRAYAU16" filename="g"/>"#);
+    let g16: Vec<u8> = (0..T * T).flat_map(|p| [(p as u16 * 4000).to_le_bytes(), 40000u16.to_le_bytes()].concat()).collect();
+    let r = crate::import("g.kra", &archive(&doc, &[("img/layers/g", tile_file(4, &[(0, 0, g16)]))])).unwrap();
+    assert_eq!((r.document.mode, r.document.depth), (ColorMode::Grayscale, SampleType::U16));
+    let s = layer(&r.document, "G16").surface().unwrap();
+    let v: Vec<u16> = s.to_interleaved(Rect::from_xywh(3, 0, 1, 1)).as_chunks::<2>().0.iter().map(|b| u16::from_ne_bytes(*b)).collect();
+    assert_eq!(v, [12000, 40000]);
+}
+
+#[test]
+fn a_nonzero_default_pixel_fills_untouched_areas() {
+    let doc = maindoc("RGBA", r#"<layer nodetype="paintlayer" name="L" colorspacename="RGBA" filename="l"/>"#);
+    let files = [("img/layers/l", tile_file(4, &[])), ("img/layers/l.defaultpixel", vec![255, 0, 0, 255])];
+    let r = crate::import("a.kra", &archive(&doc, &files)).unwrap();
+    let s = layer(&r.document, "L").surface().unwrap();
+    assert_eq!(s.to_interleaved(Rect::from_xywh(100, 100, 1, 1)), [0, 0, 255, 255]);
+}
+
+fn merged_png() -> Vec<u8> {
+    let img = Image::from_raw(12, 8, ChannelLayout::Rgba, CSample::U8, vec![90; 12 * 8 * 4]).unwrap();
+    photocraft_codecs::encode(&img, Format::Png, &Default::default()).unwrap()
+}
+
+#[test]
+fn unsupported_colour_spaces_open_as_the_merged_image() {
+    let doc = maindoc("CMYKA", "");
+    let r = crate::import("c.kra", &archive(&doc, &[("mergedimage.png", merged_png())])).unwrap();
+    assert!(r.preview_only && r.source_read_only);
+    assert_eq!(r.document.layers.len(), 1);
+    assert!(r.warnings.first().is_some_and(|w| w.contains("CMYKA") && w.contains("merged image")), "{:?}", r.warnings);
+    assert!(crate::import("c.kra", &archive(&doc, &[])).is_err(), "no merged image to fall back to");
+}
+
+#[test]
+fn export_is_refused() {
+    let d = Document::new("x", Size::new(2, 2), ColorMode::Rgb, SampleType::U8);
+    for name in ["x.kra", "x.KRZ"] {
+        assert!(matches!(crate::export(&d, name, &Default::default()), Err(IoError::Unsupported(_))), "{name}");
+    }
+}
+
+#[test]
+fn lzf_decodes_literals_and_overlapping_references() {
+    // "abc" then a 6-byte back-reference 3 back: abcabcabc.
+    assert_eq!(lzf_decompress(&[2, b'a', b'b', b'c', 0x80, 2], 9).unwrap(), b"abcabcabc");
+    // A long back-reference (len 7 + extra) over a single byte: run-length.
+    assert_eq!(lzf_decompress(&[0, b'x', 0xe0, 3, 0], 13).unwrap(), vec![b'x'; 13]);
+    for bad in [&[0x20, 5][..], &[5, 1, 2], &[0xe0], &[2, 1, 2, 3, 0x20]] {
+        assert!(lzf_decompress(bad, 64).is_err(), "{bad:?}");
+    }
+    assert!(lzf_decompress(&[2, 1, 2, 3], 2).is_err(), "overrun");
+    assert!(lzf_decompress(&[2, 1, 2, 3], 4).is_err(), "short");
+}
+
+#[test]
+fn malformed_files_fail_cleanly() {
+    let one = |cs: &str, data: Vec<u8>| {
+        archive(&maindoc(cs, r#"<layer nodetype="paintlayer" name="L" colorspacename="RGBA" filename="l"/>"#), &[("img/layers/l", data)])
+    };
+    let cases: Vec<(&str, Vec<u8>)> = vec![
+        ("not a zip", b"nope".to_vec()),
+        ("no maindoc", {
+            let mut z = ZipWriter::new();
+            z.add("mimetype", MIMETYPE).unwrap();
+            z.finish().unwrap()
+        }),
+        ("bad xml", archive("<DOC><IMAGE", &[])),
+        ("no image", archive("<DOC/>", &[])),
+        ("zero size", archive(&maindoc("RGBA", "").replace("width=\"12\"", "width=\"0\""), &[])),
+        ("huge", archive(&maindoc("RGBA", "").replace("width=\"12\"", "width=\"300000\"").replace("height=\"8\"", "height=\"300000\""), &[])),
+        ("version 1", one("RGBA", b"VERSION 1\n".to_vec())),
+        ("no header", one("RGBA", b"garbage".to_vec())),
+        ("big tiles", one("RGBA", b"VERSION 2\nTILEWIDTH 99999\nTILEHEIGHT 64\nPIXELSIZE 4\nDATA 0\n".to_vec())),
+        ("pixel size", one("RGBA", tile_file(2, &[]))),
+        ("too many tiles", one("RGBA", format!("VERSION 2\nTILEWIDTH {T}\nTILEHEIGHT {T}\nPIXELSIZE 4\nDATA 999999\n").into_bytes())),
+        ("bad tile line", one("RGBA", format!("VERSION 2\nTILEWIDTH {T}\nTILEHEIGHT {T}\nPIXELSIZE 4\nDATA 1\n0,0,ZIP,4\n").into_bytes())),
+        ("truncated tile", one("RGBA", format!("VERSION 2\nTILEWIDTH {T}\nTILEHEIGHT {T}\nPIXELSIZE 4\nDATA 1\n0,0,LZF,400\n\0").into_bytes())),
+        ("raw size", one("RGBA", format!("VERSION 2\nTILEWIDTH {T}\nTILEHEIGHT {T}\nPIXELSIZE 4\nDATA 1\n0,0,LZF,3\n\0ab").into_bytes())),
+        ("flag", one("RGBA", format!("VERSION 2\nTILEWIDTH {T}\nTILEHEIGHT {T}\nPIXELSIZE 4\nDATA 1\n0,0,LZF,1\n\x07").into_bytes())),
+        ("far tile", one("RGBA", format!("VERSION 2\nTILEWIDTH {T}\nTILEHEIGHT {T}\nPIXELSIZE 4\nDATA 1\n2000000000,0,LZF,1\n\x01").into_bytes())),
+        ("bad opacity", archive(&maindoc("RGBA", r#"<layer nodetype="paintlayer" name="L" colorspacename="RGBA" opacity="x"/>"#), &[])),
+    ];
+    for (what, bytes) in cases {
+        assert!(crate::import("x.kra", &bytes).is_err(), "{what}");
+    }
+    let deep = maindoc("RGBA", &format!("{}{}", r#"<layer nodetype="grouplayer"><layers>"#.repeat(150), "</layers></layer>".repeat(150)));
+    assert!(matches!(crate::import("x.kra", &archive(&deep, &[])), Err(IoError::Unsupported(_))));
+}
+
+#[test]
+fn truncated_and_corrupted_files_never_panic() {
+    let doc = maindoc(
+        "RGBA",
+        r#"<layer nodetype="paintlayer" name="L" colorspacename="RGBA" filename="l"><masks><mask nodetype="transparencymask" filename="m"/></masks></layer>"#,
+    );
+    let bytes = archive(
+        &doc,
+        &[
+            ("img/layers/l", tile_file(4, &[(0, 0, bgra(|p| [p as u8; 4])), (4, 4, bgra(|_| [9; 4]))])),
+            ("img/layers/m.pixelselection", tile_file(1, &[(0, 0, vec![7; T * T])])),
+            ("mergedimage.png", merged_png()),
+        ],
+    );
+    assert!(crate::import("ok.kra", &bytes).is_ok());
+    for cut in (0..bytes.len()).step_by((bytes.len() / 300).max(1)) {
+        let _ = crate::import("x.kra", bytes.get(..cut).unwrap_or_default());
+    }
+    let mut state = 0x1234_5678_u32;
+    for _ in 0..400 {
+        let mut b = bytes.clone();
+        for _ in 0..3 {
+            state ^= state << 13;
+            state ^= state >> 17;
+            state ^= state << 5;
+            let i = state as usize % b.len();
+            b[i] ^= (state >> 24) as u8 | 1;
+        }
+        let _ = crate::import("x.kra", &b);
+    }
+}
+
+#[test]
+fn space_names() {
+    assert_eq!(Space::from_name("RGBA"), Some(Space::Rgba8));
+    assert_eq!(Space::from_name("RGBAF32"), None);
+    assert!(is_kra(&archive("<DOC/>", &[])));
+}
+
+#[test]
+fn a_png_with_a_misleading_kra_extension_remains_a_png() {
+    for name in ["renamed.kra", "renamed.krz"] {
+        let r = crate::import(name, &merged_png()).unwrap();
+        assert_eq!(r.document.size.width, 12);
+        assert!(!r.source_read_only, "a real PNG must not be treated as a Krita source");
+    }
+}
+
+#[test]
+fn the_mimetype_wins_over_the_extension() {
+    let bytes = archive(&maindoc("RGBA", ""), &[]);
+    assert!(is_kra(&bytes));
+    assert!(crate::import("download", &bytes).is_ok_and(|r| r.source_read_only));
+}
diff --git a/crates/io/src/kra/tiles.rs b/crates/io/src/kra/tiles.rs
new file mode 100644
index 0000000000..b369341b99
--- /dev/null
+++ b/crates/io/src/kra/tiles.rs
@@ -0,0 +1,259 @@
+//! Krita's tiled pixel files and the LZF compression inside them.
+
+use photocraft_color::{ColorMode, PixelFormat, SampleType};
+use photocraft_geom::Rect;
+use photocraft_raster::{Interrupt, Surface};
+
+use super::{Result, invalid};
+use crate::IoError;
+
+/// The pixel layouts we read, by Krita colour-space id. Samples are straight (unpremultiplied).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Space {
+    /// `RGBA`: B, G, R, A bytes.
+    Rgba8,
+    /// `RGBA16`: B, G, R, A as little-endian u16.
+    Rgba16,
+    /// `GRAYA`: gray, alpha bytes.
+    Gray8,
+    /// `GRAYAU16`: gray, alpha as little-endian u16.
+    Gray16,
+    /// Masks and selections: one byte.
+    Alpha8,
+}
+
+impl Space {
+    pub(crate) fn from_name(name: &str) -> Option<Space> {
+        Some(match name {
+            "RGBA" => Space::Rgba8,
+            "RGBA16" => Space::Rgba16,
+            "GRAYA" => Space::Gray8,
+            "GRAYAU16" => Space::Gray16,
+            _ => return None,
+        })
+    }
+    pub(crate) fn pixel_size(self) -> usize {
+        match self {
+            Space::Rgba8 => 4,
+            Space::Rgba16 => 8,
+            Space::Gray8 => 2,
+            Space::Gray16 => 4,
+            Space::Alpha8 => 1,
+        }
+    }
+    /// The document colour mode and depth for an image in this space.
+    pub(crate) fn model(self) -> (ColorMode, SampleType) {
+        match self {
+            Space::Rgba8 => (ColorMode::Rgb, SampleType::U8),
+            Space::Rgba16 => (ColorMode::Rgb, SampleType::U16),
+            Space::Gray8 | Space::Alpha8 => (ColorMode::Grayscale, SampleType::U8),
+            Space::Gray16 => (ColorMode::Grayscale, SampleType::U16),
+        }
+    }
+    /// The surface format whose bytes [`Self::convert`] writes directly.
+    fn native(self) -> PixelFormat {
+        match self {
+            Space::Alpha8 => PixelFormat::GRAY8,
+            s => {
+                let (mode, depth) = s.model();
+                PixelFormat::new(mode, depth, true)
+            }
+        }
+    }
+    /// One interleaved Krita pixel as straight RGBA (0..1).
+    fn rgba(self, px: &[u8]) -> [f32; 4] {
+        let b = |i: usize| f32::from(px.get(i).copied().unwrap_or(0)) / 255.0;
+        let w = |i: usize| f32::from(u16::from_le_bytes([px.get(i).copied().unwrap_or(0), px.get(i + 1).copied().unwrap_or(0)])) / 65535.0;
+        match self {
+            Space::Rgba8 => [b(2), b(1), b(0), b(3)],
+            Space::Rgba16 => [w(4), w(2), w(0), w(6)],
+            Space::Gray8 => [b(0), b(0), b(0), b(1)],
+            Space::Gray16 => [w(0), w(0), w(0), w(2)],
+            Space::Alpha8 => [b(0), b(0), b(0), 1.0],
+        }
+    }
+    /// A default pixel's samples (Krita order, 0..1), for [`Self::to_format`].
+    pub(crate) fn normalised(self, px: &[u8]) -> Vec<f32> {
+        self.rgba(px).to_vec()
+    }
+    /// RGBA samples from [`Self::normalised`] as `fmt`'s channels.
+    pub(crate) fn to_format(self, rgba: &[f32], fmt: PixelFormat) -> Vec<f32> {
+        let p = [0, 1, 2, 3].map(|i| rgba.get(i).copied().unwrap_or(0.0));
+        photocraft_raster::from_rgba(&fmt, p)
+    }
+    /// Interleaved Krita pixels as encoded `fmt` bytes.
+    fn convert(self, src: &[u8], fmt: PixelFormat, out: &mut Vec<u8>) {
+        out.clear();
+        let ps = self.pixel_size();
+        if fmt == self.native() {
+            for px in src.chunks_exact(ps) {
+                match self {
+                    Space::Rgba8 => out.extend([2, 1, 0, 3].map(|i| px.get(i).copied().unwrap_or(0))),
+                    Space::Rgba16 => {
+                        for i in [4, 2, 0, 6] {
+                            let v = u16::from_le_bytes([px.get(i).copied().unwrap_or(0), px.get(i + 1).copied().unwrap_or(0)]);
+                            out.extend(v.to_ne_bytes());
+                        }
+                    }
+                    Space::Gray16 => {
+                        for i in [0, 2] {
+                            let v = u16::from_le_bytes([px.get(i).copied().unwrap_or(0), px.get(i + 1).copied().unwrap_or(0)]);
+                            out.extend(v.to_ne_bytes());
+                        }
+                    }
+                    Space::Gray8 | Space::Alpha8 => out.extend_from_slice(px),
+                }
+            }
+            return;
+        }
+        let mut enc = vec![0; fmt.bytes_per_pixel()];
+        for px in src.chunks_exact(ps) {
+            let v = photocraft_raster::from_rgba(&fmt, self.rgba(px));
+            photocraft_raster::encode_pixel(&fmt, &v, &mut enc);
+            out.extend_from_slice(&enc);
+        }
+    }
+}
+
+/// LZF decompression (the liblzf format) into exactly `expected` bytes.
+pub(crate) fn lzf_decompress(src: &[u8], expected: usize) -> Result<Vec<u8>> {
+    let bad = || invalid("corrupt LZF tile data");
+    let mut out = Vec::with_capacity(expected);
+    let mut ip = 0;
+    while ip < src.len() {
+        let ctrl = usize::from(*src.get(ip).ok_or_else(bad)?);
+        ip += 1;
+        if ctrl < 32 {
+            let len = ctrl + 1;
+            let lit = src.get(ip..ip + len).ok_or_else(bad)?;
+            if out.len() + len > expected {
+                return Err(bad());
+            }
+            out.extend_from_slice(lit);
+            ip += len;
+        } else {
+            let mut len = ctrl >> 5;
+            if len == 7 {
+                len += usize::from(*src.get(ip).ok_or_else(bad)?);
+                ip += 1;
+            }
+            len += 2;
+            let back = ((ctrl & 0x1f) << 8) + usize::from(*src.get(ip).ok_or_else(bad)?) + 1;
+            ip += 1;
+            let start = out.len().checked_sub(back).ok_or_else(bad)?;
+            if out.len() + len > expected {
+                return Err(bad());
+            }
+            // Back-references may overlap the bytes they produce, so copy one at a time.
+            for i in start..start + len {
+                let b = *out.get(i).ok_or_else(bad)?;
+                out.push(b);
+            }
+        }
+    }
+    if out.len() != expected {
+        return Err(invalid(format!("LZF tile data decodes to {} bytes, expected {expected}", out.len())));
+    }
+    Ok(out)
+}
+
+/// A parsed tiled pixel file (`VERSION 2`), borrowing the tile payloads.
+pub(crate) struct TileFile<'a> {
+    pub(crate) width: usize,
+    pub(crate) height: usize,
+    pub(crate) pixel_size: usize,
+    tiles: Vec<(i32, i32, &'a [u8])>,
+}
+
+fn line<'a>(bytes: &'a [u8], pos: &mut usize) -> Result<&'a str> {
+    let rest = bytes.get(*pos..).ok_or_else(|| invalid("truncated tile file"))?;
+    let end = rest.iter().take(256).position(|b| *b == b'\n').ok_or_else(|| invalid("truncated or malformed tile file header"))?;
+    *pos += end + 1;
+    std::str::from_utf8(rest.get(..end).unwrap_or_default()).map_err(|_| invalid("tile file header is not text"))
+}
+
+fn header_value(bytes: &[u8], pos: &mut usize, key: &str, max: usize) -> Result<usize> {
+    let l = line(bytes, pos)?;
+    let v = l.strip_prefix(key).map(str::trim).ok_or_else(|| invalid(format!("tile file: expected {key}, found `{l}`")))?;
+    v.parse::<usize>().ok().filter(|v| (1..=max).contains(v)).ok_or_else(|| invalid(format!("tile file: invalid {key} `{v}`")))
+}
+
+impl<'a> TileFile<'a> {
+    pub(crate) fn parse(bytes: &'a [u8]) -> Result<TileFile<'a>> {
+        let mut pos = 0;
+        let version = line(bytes, &mut pos)?;
+        if version.trim() != "VERSION 2" {
+            return Err(IoError::Unsupported(format!("Krita tile file `{}` (only VERSION 2, Krita 2.0 and later)", version.trim())));
+        }
+        let width = header_value(bytes, &mut pos, "TILEWIDTH", 1024)?;
+        let height = header_value(bytes, &mut pos, "TILEHEIGHT", 1024)?;
+        let pixel_size = header_value(bytes, &mut pos, "PIXELSIZE", 64)?;
+        let l = line(bytes, &mut pos)?;
+        let count = l
+            .strip_prefix("DATA")
+            .map(str::trim)
+            .and_then(|v| v.parse::<usize>().ok())
+            .ok_or_else(|| invalid(format!("tile file: invalid DATA line `{l}`")))?;
+        // Every tile needs at least a header line and a flag byte.
+        if count > bytes.len() / 8 + 1 {
+            return Err(invalid("tile count exceeds the file size"));
+        }
+        let mut tiles = Vec::with_capacity(count);
+        for _ in 0..count {
+            let l = line(bytes, &mut pos)?;
+            let mut f = l.split(',');
+            let (x, y, method, len) = (f.next(), f.next(), f.next(), f.next());
+            let coord = |v: Option<&str>| v.and_then(|v| v.trim().parse::<i32>().ok()).filter(|v| v.unsigned_abs() <= super::MAX_SIDE * 4);
+            let (Some(x), Some(y), Some("LZF"), Some(len), None) =
+                (coord(x), coord(y), method.map(str::trim), len.and_then(|v| v.trim().parse::<usize>().ok()), f.next())
+            else {
+                return Err(invalid(format!("tile file: malformed tile header `{l}`")));
+            };
+            let data = bytes.get(pos..pos.checked_add(len).ok_or_else(|| invalid("tile size overflow"))?).ok_or_else(|| invalid("truncated tile data"))?;
+            pos += len;
+            tiles.push((x, y, data));
+        }
+        Ok(TileFile { width, height, pixel_size, tiles })
+    }
+
+    /// Bytes the decoded tiles take at `bpp` bytes per pixel.
+    pub(crate) fn decoded_bytes(&self, bpp: usize) -> Result<usize> {
+        self.tiles.len().checked_mul(self.width * self.height).and_then(|n| n.checked_mul(bpp)).ok_or_else(|| invalid("tile size overflow"))
+    }
+
+    /// Writes every tile into `surface` (format `surface.format()`), offset by (`dx`, `dy`).
+    pub(crate) fn decode_into(&self, surface: &mut Surface, space: Space, dx: i32, dy: i32, ctl: &Interrupt<'_>) -> Result<()> {
+        let fmt = surface.format();
+        let n = self.width * self.height;
+        let expected = n * self.pixel_size;
+        let mut interleaved = vec![0u8; expected];
+        let mut out = Vec::new();
+        for &(x, y, data) in &self.tiles {
+            ctl.check().map_err(|_| IoError::Cancelled)?;
+            let (flag, payload) = data.split_first().ok_or_else(|| invalid("empty tile"))?;
+            let planar = match flag {
+                1 => lzf_decompress(payload, expected)?,
+                0 if payload.len() == expected => payload.to_vec(),
+                0 => return Err(invalid("raw tile has the wrong size")),
+                f => return Err(invalid(format!("unknown tile compression flag {f}"))),
+            };
+            // Byte planes: byte k of pixel i is at k * n + i.
+            for (k, plane) in planar.chunks_exact(n).enumerate() {
+                for (i, b) in plane.iter().enumerate() {
+                    if let Some(slot) = interleaved.get_mut(i * self.pixel_size + k) {
+                        *slot = *b;
+                    }
+                }
+            }
+            space.convert(&interleaved, fmt, &mut out);
+            let (x0, y0) =
+                (x.checked_add(dx).ok_or_else(|| invalid("tile offset overflow"))?, y.checked_add(dy).ok_or_else(|| invalid("tile offset overflow"))?);
+            let rect = Rect::from_xywh(x0, y0, self.width as u32, self.height as u32);
+            if rect.width() as usize != self.width || rect.height() as usize != self.height || out.len() != n * fmt.bytes_per_pixel() {
+                return Err(invalid("tile does not fit its position"));
+            }
+            surface.write_interleaved(rect, &out);
+        }
+        Ok(())
+    }
+}
diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rs
index 4a395e1630..49e4bb60e2 100644
--- a/crates/io/src/lib.rs
+++ b/crates/io/src/lib.rs
@@ -18,6 +18,8 @@
 //! * Paint.NET PDN3 documents open as editable bitmap layers (import only).
 //! * OpenRaster (`.ora`) documents open and save with their layers, groups, blend modes,
 //!   opacity and visibility; see `ora`.
+//! * Krita (`.kra`, `.krz`) documents open with their paint layers, groups and transparency
+//!   masks (import only); see `kra`.
 //! * Affinity documents (`.af`, `.afdesign`, `.afphoto`, `.afpub`) open natively
 //!   with no source save path, what isn't imported listed in the warnings; a file
 //!   whose native data can't be read opens as its embedded preview; see `affinity`.
@@ -35,15 +37,19 @@ mod adjust_map;
 pub mod affinity;
 pub mod annotations_map;
 pub mod blocks;
+pub mod camera_raw_xmp;
 mod channel_map;
 pub mod comps_map;
 pub mod effects_map;
 pub mod exr_parts;
 mod flat;
 mod gradient_bake;
+pub use gradient_bake::{Method as GradientMethod, bake as bake_gradient};
+mod kra;
 pub mod linked;
 mod multichannel_map;
 mod ora;
+pub use ora::losses as ora_losses;
 pub mod pattern_map;
 mod pdn;
 pub mod pixels;
@@ -59,12 +65,16 @@ pub mod text_styles_map;
 pub mod tiff_layers;
 pub mod vector_map;
 
+pub use photocraft_codecs::DpxBits;
 use photocraft_codecs::{CodecError, EncodeOptions};
 use photocraft_doc::Document;
 use photocraft_psd::{PsdError, PsdFile};
 
 pub use adjust_map::ADJUSTMENT_KEYS;
-pub use flat::{document_to_image, import_gif_frames, import_tiff_page, tga_alpha_channel_to_transparency, tga_default_bits};
+pub use flat::{
+    DEFAULT_LOSSY_WEBP_QUALITY, apply_file_encoding, document_to_image, file_encoding, import_gif_frames, import_tiff_page, tga_alpha_channel_to_transparency,
+    tga_default_bits,
+};
 pub use psd_export::{PsdExportOptions, document_to_psd, document_to_psd_with};
 pub use psd_import::{psd_to_document, psd_to_document_with};
 
@@ -74,6 +84,9 @@ pub enum IoError {
     /// Paint.NET document decode failure.
     #[error("PDN: {0}")]
     Pdn(String),
+    /// Krita document read failure.
+    #[error("Krita: {0}")]
+    Kra(String),
     /// OpenRaster read failure.
     #[error("OpenRaster: {0}")]
     Ora(String),
@@ -169,11 +182,23 @@ pub struct ExportOptions {
     /// PSD/PSB: embed the thumbnail image resource (1036), Preferences › File Handling › Image
     /// Previews. On by default, as Photoshop's Always Save.
     pub image_previews: bool,
+    /// PSD/PSB: write the real merged image, Preferences › File Handling › Maximize PSD and PSB
+    /// File Compatibility (see [`PsdExportOptions::maximize_compatibility`]). On by default, as
+    /// Photoshop's Always.
+    pub psd_maximize_compatibility: bool,
 }
 
 impl Default for ExportOptions {
     fn default() -> Self {
-        ExportOptions { encode: EncodeOptions::default(), force_psb: false, tiff_layers: false, xmp: XmpEmbed::All, tga_bits: None, image_previews: true }
+        ExportOptions {
+            encode: EncodeOptions::default(),
+            force_psb: false,
+            tiff_layers: false,
+            xmp: XmpEmbed::All,
+            tga_bits: None,
+            image_previews: true,
+            psd_maximize_compatibility: true,
+        }
     }
 }
 
@@ -265,6 +290,11 @@ fn import_stages(name: &str, bytes: &[u8], ctl: &photocraft_raster::Interrupt, m
     if ora::is_ora(bytes) || has_extension(name, "ora") {
         return ora::import(name, bytes, ctl);
     }
+    // Krita files are ZIP containers. A recognized raster signature still wins over a
+    // misleading .kra suffix (as with SVG imports).
+    if kra::is_kra(bytes) || (kra::EXTENSIONS.iter().any(|e| has_extension(name, e)) && photocraft_codecs::detect(bytes).is_none()) {
+        return kra::import(name, bytes, ctl);
+    }
     if has_extension(name, "pdn") || bytes.starts_with(b"PDN3") {
         return pdn::import(name, bytes, ctl);
     }
@@ -297,6 +327,22 @@ fn has_extension(name: &str, expected: &str) -> bool {
     name.rsplit(['/', '\\']).next().and_then(|name| name.rsplit_once('.')).is_some_and(|(base, ext)| !base.is_empty() && ext.eq_ignore_ascii_case(expected))
 }
 
+/// The document as it is written to `name` (a file name, path or bare extension): a copy whose
+/// name is that file's own, so a `.pcraft` manifest reports the file it lives in — the name the
+/// session adopts on the save that wrote it, and the name every other format gives the document
+/// when it is opened (#3312). A bare extension ("pcraft") names no file and changes nothing.
+pub fn named_for_file<'a>(doc: &'a Document, name: &str) -> std::borrow::Cow<'a, Document> {
+    let file = name.contains(['/', '\\', '.']).then(|| name.rsplit(['/', '\\']).next().unwrap_or(name));
+    match file {
+        Some(file) if !file.is_empty() && doc.name != file => {
+            let mut owned = (*doc).clone();
+            owned.name = file.to_string();
+            std::borrow::Cow::Owned(owned)
+        }
+        _ => std::borrow::Cow::Borrowed(doc),
+    }
+}
+
 /// Exports `doc` to the format named by `name_or_ext` (a file name, path or
 /// bare extension).
 pub fn export(doc: &Document, name_or_ext: &str, opts: &ExportOptions) -> Result<ExportResult, IoError> {
@@ -338,21 +384,25 @@ fn export_stages(doc: &Document, name_or_ext: &str, opts: &ExportOptions, ctl: &
     if affinity::EXTENSIONS.contains(&ext.as_str()) {
         return Err(IoError::Unsupported("Affinity export is not implemented; save a new PSD, PNG or .pcraft copy".into()));
     }
+    if kra::EXTENSIONS.contains(&ext.as_str()) {
+        return Err(IoError::Unsupported("Krita files are import-only; save as .ora to open the layers in Krita, or .pcraft to keep everything".into()));
+    }
     if ext == "ora" {
         return ora::export(doc);
     }
     if ext == photocraft_format::EXTENSION {
-        let thumbnail = Some(photocraft_compose::thumbnail(doc, 256));
+        let doc = named_for_file(doc, name_or_ext);
+        let thumbnail = Some(photocraft_compose::thumbnail(doc.as_ref(), 256));
         ctl.check().map_err(|_| IoError::Cancelled)?;
         ctl.progress(PCRAFT_THUMBNAIL_DONE);
-        let composite = Some(photocraft_compose::thumbnail(doc, 1024));
+        let composite = Some(photocraft_compose::thumbnail(doc.as_ref(), 1024));
         ctl.check().map_err(|_| IoError::Cancelled)?;
         ctl.progress(PCRAFT_PREVIEWS_DONE);
         let previews = photocraft_format::SaveOptions { thumbnail, composite };
-        return Ok(ExportResult { bytes: photocraft_format::save_to_bytes(doc, &previews)?, warnings: Vec::new() });
+        return Ok(ExportResult { bytes: photocraft_format::save_to_bytes(doc.as_ref(), &previews)?, warnings: Vec::new() });
     }
     if ext == "psd" || ext == "psb" {
-        let o = PsdExportOptions { force_psb: opts.force_psb || ext == "psb", ..Default::default() };
+        let o = PsdExportOptions { force_psb: opts.force_psb || ext == "psb", maximize_compatibility: opts.psd_maximize_compatibility, ..Default::default() };
         let (mut file, mut warnings) = with_span(ctl, 0.0, PSD_MODEL_DONE, |ctl| psd_export::document_to_psd_interruptible(doc, &o, ctl));
         // A cancelled conversion stops early with an incomplete model: never write it.
         ctl.check().map_err(|_| IoError::Cancelled)?;
@@ -458,7 +508,10 @@ pub fn merged_composite(file: &PsdFile) -> Result<Vec<[f32; 4]>, IoError> {
     }
     let l = doc.layers.first().ok_or_else(|| IoError::Unsupported("no merged image".into()))?;
     let s = l.surface().ok_or_else(|| IoError::Unsupported("no merged image".into()))?;
-    Ok(photocraft_compose::surface_to_buffer(s, doc.bounds()).px)
+    // CMYK reads through the file's own profile, as the compositor reads its layers, so a tagged
+    // file's merged image and its composite are compared in the same colours.
+    let cmyk = photocraft_compose::cmyk_space(&doc);
+    Ok(photocraft_color::convert::with_cmyk_space(cmyk.as_ref(), || photocraft_compose::surface_to_buffer(s, doc.bounds()).px))
 }
 
 #[cfg(test)]
diff --git a/crates/io/src/linked.rs b/crates/io/src/linked.rs
index b1b7286d25..6634735ef0 100644
--- a/crates/io/src/linked.rs
+++ b/crates/io/src/linked.rs
@@ -50,6 +50,14 @@ impl<'a> Rd<'a> {
 
 /// Parses one item; `None` for malformed data or non-`liFD` items.
 fn parse_item(item: &[u8]) -> Option<LinkedFile> {
+    let (uuid, file_name, start, len) = item_header(item)?;
+    let bytes = item.get(start..start.checked_add(len)?)?.to_vec();
+    Some(LinkedFile { uuid, file_name, bytes })
+}
+
+/// The uuid and file name of an embedded (`liFD`) item, and where its file bytes start and how
+/// many there are; `None` for malformed data or other items.
+fn item_header(item: &[u8]) -> Option<(String, String, usize, usize)> {
     let mut r = Rd { d: item, p: 0 };
     let kind = r.take(4)?;
     let _version = r.u32()?;
@@ -65,8 +73,26 @@ fn parse_item(item: &[u8]) -> Option<LinkedFile> {
     if kind != b"liFD" {
         return None;
     }
-    let bytes = r.take(len)?.to_vec();
-    Some(LinkedFile { uuid, file_name, bytes })
+    Some((uuid, file_name, r.p, len))
+}
+
+/// The file name of the embedded file for smart-object `uuid` among the document's preserved PSD
+/// global blocks, without copying its bytes: whether a placed layer's source is embedded.
+pub fn embedded_file_name(meta: &Metadata, uuid: &str) -> Option<String> {
+    if uuid.is_empty() {
+        return None;
+    }
+    meta.psd_global_blocks.iter().filter(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD")).find_map(|(_, _, d)| {
+        let mut r = Rd { d, p: 0 };
+        while let Some(len) = r.u64() {
+            let item = r.take(usize::try_from(len).ok()?)?;
+            if let Some((_, name, ..)) = item_header(item).filter(|h| h.0 == uuid) {
+                return Some(name);
+            }
+            r.p = r.p.next_multiple_of(4);
+        }
+        None
+    })
 }
 
 /// Every embedded (`liFD`) file in one linked-layer block's data.
@@ -84,14 +110,101 @@ pub fn parse_linked_files(data: &[u8]) -> Vec<LinkedFile> {
 
 /// The embedded file for smart-object `uuid` among the document's preserved PSD global blocks.
 pub fn find_linked_file(meta: &Metadata, uuid: &str) -> Option<LinkedFile> {
+    find_in_blocks(meta.psd_global_blocks.iter().map(|(_, k, d)| (k, d.as_slice())), uuid)
+}
+
+/// The embedded file for smart-object `uuid` among PSD global blocks given as (key, data).
+pub fn find_in_blocks<'a>(blocks: impl IntoIterator<Item = (&'a [u8; 4], &'a [u8])>, uuid: &str) -> Option<LinkedFile> {
     if uuid.is_empty() {
         return None;
     }
-    meta.psd_global_blocks
-        .iter()
-        .filter(|(_, k, _)| matches!(k, b"lnk2" | b"lnk3" | b"lnkD"))
-        .flat_map(|(_, _, d)| parse_linked_files(d))
-        .find(|f| f.uuid == uuid)
+    blocks.into_iter().filter(|(k, _)| matches!(*k, b"lnk2" | b"lnk3" | b"lnkD")).flat_map(|(_, d)| parse_linked_files(d)).find(|f| f.uuid == uuid)
+}
+
+/// The size of embedded file `uuid` among PSD global blocks given as (key, data), when it is there
+/// and readable with a non-empty size (the source size a `PlLd` record leaves out).
+pub(crate) fn source_size_in_blocks<'a>(
+    blocks: impl IntoIterator<Item = (&'a [u8; 4], &'a [u8])>,
+    uuid: &str,
+    ctl: &photocraft_raster::Interrupt,
+) -> Option<(f64, f64)> {
+    let f = find_in_blocks(blocks, uuid)?;
+    if ctl.cancelled() {
+        return None;
+    }
+    source_size_probe(&f.bytes).filter(|(w, h)| *w > 0.0 && *h > 0.0)
+}
+
+/// Pixel size of an embedded source file from its header: PSD/PSB, TIFF (the default page's
+/// directory), PNG (`IHDR`) and JPEG (the frame header); any other image is decoded flat by
+/// `photocraft-codecs`. It never imports a document: a layered TIFF can carry PSD layer data
+/// whose `lnkD` holds another file, so a full import here would nest without bound (#2465).
+pub(crate) fn source_size_probe(bytes: &[u8]) -> Option<(f64, f64)> {
+    let be32 = |at: usize| bytes.get(at..at + 4).map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]));
+    let size = |w: u32, h: u32| (f64::from(w), f64::from(h));
+    match bytes {
+        _ if crate::is_psd(bytes) => be32(18).zip(be32(14)).map(|(w, h)| size(w, h)),
+        [b'I', b'I', 42, 0, ..] | [b'M', b'M', 0, 42, ..] | [b'I', b'I', 43, 0, ..] | [b'M', b'M', 0, 43, ..] => {
+            let info = photocraft_codecs::tiff_info(bytes).ok()?;
+            let page = info.pages.get(info.default_page()?)?;
+            Some(size(page.width, page.height))
+        }
+        [0x89, b'P', b'N', b'G', 0x0D, 0x0A, 0x1A, 0x0A, ..] => be32(16).zip(be32(20)).map(|(w, h)| size(w, h)),
+        [0xFF, 0xD8, ..] => jpeg_size(bytes),
+        _ => photocraft_codecs::decode(bytes).ok().map(|img| {
+            let (w, h) = img.dimensions();
+            size(w, h)
+        }),
+    }
+}
+
+/// A JPEG's size from its first start-of-frame marker (ITU-T T.81 B.2.2), walking the marker
+/// segments without decoding. Each step moves forward, so a malformed file ends the walk.
+fn jpeg_size(bytes: &[u8]) -> Option<(f64, f64)> {
+    let mut at = 2usize;
+    loop {
+        // Markers are 0xFF then a code; extra 0xFF fill bytes may come first.
+        while bytes.get(at) == Some(&0xFF) && bytes.get(at + 1) == Some(&0xFF) {
+            at += 1;
+        }
+        if *bytes.get(at)? != 0xFF {
+            return None;
+        }
+        let code = *bytes.get(at + 1)?;
+        match code {
+            // SOF0..SOF15, except DHT (C4), JPG (C8) and DAC (CC).
+            0xC0..=0xCF if !matches!(code, 0xC4 | 0xC8 | 0xCC) => {
+                let h = bytes.get(at + 5..at + 7)?;
+                let w = bytes.get(at + 7..at + 9)?;
+                return Some((f64::from(u16::from_be_bytes([w[0], w[1]])), f64::from(u16::from_be_bytes([h[0], h[1]]))));
+            }
+            // Standalone markers have no length.
+            0x01 | 0xD0..=0xD7 => at = at.checked_add(2)?,
+            // Start of scan or end of image before any frame header.
+            0xDA | 0xD9 => return None,
+            _ => {
+                let len = bytes.get(at + 2..at + 4).map(|b| usize::from(u16::from_be_bytes([b[0], b[1]])))?;
+                if len < 2 {
+                    return None;
+                }
+                at = at.checked_add(2 + len)?;
+            }
+        }
+    }
+}
+
+/// Size and resolution of a smart-object source file (PSD/PSB header, `.pcraft`, or any image).
+/// Other formats are decoded in full, which `ctl` can cancel (its progress is left alone: this is
+/// a step of a larger operation).
+pub(crate) fn source_geometry(name: &str, bytes: &[u8], ctl: &photocraft_raster::Interrupt) -> Result<((f64, f64), f64), String> {
+    if crate::is_psd(bytes) {
+        let rd = |at: usize| bytes.get(at..at + 4).map(|b| f64::from(u32::from_be_bytes([b[0], b[1], b[2], b[3]])));
+        let (h, w) = rd(14).zip(rd(18)).ok_or("truncated PSD header")?;
+        return Ok(((w, h), 72.0));
+    }
+    let cancel = || ctl.cancelled();
+    let doc = crate::import_with(name, bytes, &photocraft_raster::Interrupt::cancel_only(&cancel)).map_err(|e| e.to_string())?.document;
+    Ok(((f64::from(doc.size.width), f64::from(doc.size.height)), f64::from(doc.resolution_dpi)))
 }
 
 /// The four-character file type Photoshop records for an embedded file, from its contents.
@@ -188,6 +301,85 @@ pub fn block_uuids(data: &[u8]) -> Vec<String> {
     split_items(data).into_iter().filter_map(|(u, _)| u).collect()
 }
 
+/// Copies only records accepted by `keep` (UUID and complete raw record including padding).
+/// Unlike [`rebuild_block`], unidentified records and malformed tails are discarded: clipboard
+/// copies must not carry unrelated embedded files. Empty UUIDs cannot identify source bytes.
+/// Selected identity must be provable without lossy UTF-8 decoding; an ambiguous or truncated
+/// selected ID is an error instead. No payload decoding or filesystem access is performed.
+/// `None` means the block already contains only selected complete records and can be shared.
+pub fn select_items(data: &[u8], keep: &dyn Fn(&str, &[u8]) -> bool) -> Result<Option<Vec<u8>>, crate::IoError> {
+    let error = || crate::IoError::Unsupported("can't copy a truncated selected PSD linked-layer record".into());
+    let mut selected = None;
+    let mut at = 0usize;
+    while let Some(rest) = data.get(at..).filter(|r| !r.is_empty()) {
+        let Some((item, raw)) = framed_item(rest) else {
+            if let Some(item) = rest.get(8..)
+                && selection_uuid(item, rest, keep)?.is_some_and(|uuid| keep(uuid, rest))
+            {
+                return Err(error());
+            }
+            if selected.is_none() {
+                let mut prefix = Vec::new();
+                append_selected(&mut prefix, data.get(..at).ok_or_else(error)?)?;
+                selected = Some(prefix);
+            }
+            break;
+        };
+        if selection_uuid(item, raw, keep)?.is_some_and(|uuid| keep(uuid, raw)) {
+            if let Some(out) = &mut selected {
+                append_selected(out, raw)?;
+            }
+        } else if selected.is_none() {
+            let mut prefix = Vec::new();
+            append_selected(&mut prefix, data.get(..at).ok_or_else(error)?)?;
+            selected = Some(prefix);
+        }
+        at = at.checked_add(raw.len()).ok_or_else(error)?;
+    }
+    Ok(selected)
+}
+
+// Legacy PSD readers retain lossy IDs for file fidelity. Selection needs exact identity;
+// a lossy label is used only to refuse an ambiguous transfer, never to retain a record.
+fn selection_uuid<'a>(item: &'a [u8], raw: &[u8], keep: &dyn Fn(&str, &[u8]) -> bool) -> Result<Option<&'a str>, crate::IoError> {
+    let Some(n) = item.get(8).map(|n| usize::from(*n)) else { return Ok(None) };
+    let Some(bytes) = 9usize.checked_add(n).and_then(|end| item.get(9..end)).filter(|bytes| !bytes.is_empty()) else { return Ok(None) };
+    match std::str::from_utf8(bytes) {
+        Ok(uuid) => Ok(Some(uuid)),
+        Err(_) if keep(&String::from_utf8_lossy(bytes), raw) => {
+            Err(crate::IoError::Unsupported("can't verify a PSD linked-layer source ID with invalid UTF-8".into()))
+        }
+        Err(_) => Ok(None),
+    }
+}
+
+/// Whether a complete raw record already occurs in a block, without decoding its file bytes.
+pub fn contains_item(data: &[u8], record: &[u8]) -> bool {
+    let mut remaining = data;
+    while let Some((_, raw)) = framed_item(remaining) {
+        if raw == record {
+            return true;
+        }
+        let Some(next) = remaining.get(raw.len()..) else { return false };
+        remaining = next;
+    }
+    false
+}
+
+fn framed_item(data: &[u8]) -> Option<(&[u8], &[u8])> {
+    let len = usize::try_from(u64::from_be_bytes(data.get(..8)?.try_into().ok()?)).ok()?;
+    let end = len.checked_add(8)?;
+    let item = data.get(8..end)?;
+    let padded = end.checked_add(3).map(|n| n & !3)?.min(data.len());
+    Some((item, data.get(..padded)?))
+}
+
+fn append_selected(out: &mut Vec<u8>, bytes: &[u8]) -> Result<(), crate::IoError> {
+    out.try_reserve(bytes.len()).map_err(|_| crate::IoError::Unsupported("not enough memory to copy PSD linked-layer records".into()))?;
+    out.extend_from_slice(bytes);
+    Ok(())
+}
+
 /// Copies one linked item under a new UUID, preserving its embedded, external or alias payload.
 pub(crate) fn copy_item(data: &[u8], uuid: &str, new_uuid: &str) -> Option<Vec<u8>> {
     let (_, raw) = split_items(data).into_iter().find(|(u, _)| u.as_deref() == Some(uuid))?;
@@ -210,6 +402,45 @@ mod tests {
     use super::*;
     use std::sync::Arc;
 
+    /// #2465: a placed source's size comes from its header, for every format a CS2 file embeds,
+    /// and never by importing it as a document.
+    #[test]
+    fn source_size_probe_reads_headers() {
+        use photocraft_codecs::{ChannelLayout, EncodeOptions, Format, Image, SampleType};
+        let img = Image::new(7, 5, ChannelLayout::Rgb, SampleType::U8).unwrap();
+        for format in [Format::Png, Format::Jpeg, Format::Tiff, Format::Bmp] {
+            let bytes = photocraft_codecs::encode(&img, format, &EncodeOptions::default()).unwrap();
+            assert_eq!(source_size_probe(&bytes), Some((7.0, 5.0)), "{format:?}");
+        }
+        let mut psd = b"8BPS\0\x01".to_vec();
+        psd.extend([0; 6]);
+        psd.extend(3u16.to_be_bytes());
+        psd.extend(40u32.to_be_bytes()); // height
+        psd.extend(30u32.to_be_bytes()); // width
+        assert_eq!(source_size_probe(&psd), Some((30.0, 40.0)));
+        assert_eq!(source_size_probe(b"not an image"), None);
+        assert_eq!(source_size_probe(&[]), None);
+    }
+
+    /// Malformed JPEG marker walks end without a size and without panicking or looping.
+    #[test]
+    fn jpeg_size_rejects_malformed_marker_walks() {
+        let sof = [0xFF, 0xC0, 0, 17, 8, 0, 5, 0, 7];
+        let ok: Vec<u8> = [&[0xFF, 0xD8][..], &[0xFF, 0xE0, 0, 4, 1, 2], &[0xFF, 0xFF, 0xD0], &sof].concat();
+        assert_eq!(jpeg_size(&ok), Some((7.0, 5.0)), "APP0, a fill byte and a standalone marker are skipped");
+        for bad in [
+            vec![0xFF, 0xD8],
+            vec![0xFF, 0xD8, 0xFF, 0xE0, 0, 1],       // length below 2
+            vec![0xFF, 0xD8, 0xFF, 0xE0, 0xFF, 0xFF], // length past the end
+            vec![0xFF, 0xD8, 0x00, 0x00],             // not a marker
+            vec![0xFF, 0xD8, 0xFF, 0xDA, 0, 2],       // scan before any frame header
+            vec![0xFF, 0xD8, 0xFF, 0xC0, 0, 17, 8],   // truncated frame header
+            [&[0xFF, 0xD8][..], &[0xFF; 64]].concat(),
+        ] {
+            assert_eq!(jpeg_size(&bad), None, "{bad:?}");
+        }
+    }
+
     #[test]
     fn round_trips_and_finds_by_uuid() {
         let a = LinkedFile { uuid: "abc-1".into(), file_name: "a.png".into(), bytes: vec![1, 2, 3] };
@@ -266,4 +497,79 @@ mod tests {
         assert_eq!(&copy[17 + "independent-copy".len()..8 + copied_len], &raw[20..8 + original_len]);
         assert!(copy_item(&raw, "missing", "new").is_none());
     }
+    #[test]
+    fn selected_records_exclude_other_files_and_unidentified_pieces() {
+        let a = encode_linked_file(&LinkedFile { uuid: "a".into(), file_name: "a.psb".into(), bytes: vec![1; 3] });
+        let b = encode_linked_file(&LinkedFile { uuid: "b".into(), file_name: "b.psb".into(), bytes: vec![2; 4] });
+        assert!(select_items(&a, &|uuid, _| uuid == "a").unwrap().is_none(), "an exclusive block can keep its original Arc");
+        let mut data = a.clone();
+        data.extend(&b);
+        data.extend([0, 0, 0, 0, 0, 0, 1, 0, 9]);
+        assert_eq!(select_items(&data, &|uuid, _| uuid == "a").unwrap(), Some(a.clone()));
+        assert_eq!(select_items(&data, &|uuid, _| uuid == "b").unwrap(), Some(b));
+        assert_eq!(select_items(&data, &|_, _| false).unwrap(), Some(Vec::new()));
+        // A complete but unidentified item can be skipped without losing a later selected item.
+        let mut unreadable = 1u64.to_be_bytes().to_vec();
+        unreadable.extend([7, 0, 0, 0]);
+        unreadable.extend(&a);
+        assert_eq!(select_items(&unreadable, &|uuid, _| uuid == "a").unwrap(), Some(a));
+    }
+
+    #[test]
+    fn selected_external_and_alias_records_keep_unknown_payloads_verbatim() {
+        for kind in [*b"liFE", *b"liFA", *b"next"] {
+            let mut raw = encode_linked_file(&LinkedFile { uuid: "selected".into(), file_name: "missing.psb".into(), bytes: vec![7; 5] });
+            raw[8..12].copy_from_slice(&kind);
+            raw[12..16].copy_from_slice(&42u32.to_be_bytes()); // an unknown future version
+            let mut data = encode_linked_file(&LinkedFile { uuid: "unselected".into(), file_name: "other.psb".into(), bytes: vec![9; 3] });
+            data.extend(&raw);
+            assert_eq!(select_items(&data, &|uuid, _| uuid == "selected").unwrap(), Some(raw));
+        }
+    }
+
+    #[test]
+    fn truncated_selected_records_fail_instead_of_becoming_unavailable() {
+        let mut raw = encode_linked_file(&LinkedFile { uuid: "selected".into(), file_name: "missing.psb".into(), bytes: vec![7; 5] });
+        raw[..8].copy_from_slice(&u64::MAX.to_be_bytes());
+        assert!(select_items(&raw, &|uuid, _| uuid == "selected").unwrap_err().to_string().contains("truncated selected"));
+        assert_eq!(select_items(&raw, &|uuid, _| uuid == "other").unwrap(), Some(Vec::new()));
+    }
+    #[test]
+    fn existing_records_are_matched_individually_without_matching_other_payloads() {
+        let a = encode_linked_file(&LinkedFile { uuid: "a".into(), file_name: "a.psb".into(), bytes: vec![1; 3] });
+        let b = encode_linked_file(&LinkedFile { uuid: "b".into(), file_name: "b.psb".into(), bytes: vec![2; 4] });
+        let different = encode_linked_file(&LinkedFile { uuid: "a".into(), file_name: "a.psb".into(), bytes: vec![9; 3] });
+        let mut combined = a.clone();
+        combined.extend(&b);
+        assert!(contains_item(&combined, &a));
+        assert!(contains_item(&combined, &b));
+        assert!(!contains_item(&combined, &different));
+        assert_eq!(select_items(&a, &|_, raw| !contains_item(&combined, raw)).unwrap(), Some(Vec::new()));
+        assert!(select_items(&different, &|_, raw| !contains_item(&combined, raw)).unwrap().is_none());
+    }
+    #[test]
+    fn empty_uuids_are_unidentified_even_when_requested() {
+        let raw = encode_linked_file(&LinkedFile { uuid: String::new(), file_name: "unidentified.psb".into(), bytes: vec![7; 5] });
+        assert_eq!(select_items(&raw, &|_, _| true).unwrap(), Some(Vec::new()));
+        let mut truncated = raw;
+        truncated[..8].copy_from_slice(&u64::MAX.to_be_bytes());
+        assert_eq!(select_items(&truncated, &|_, _| true).unwrap(), Some(Vec::new()));
+    }
+    #[test]
+    fn selection_never_uses_lossy_uuid_aliases_as_record_identity() {
+        let mut a = encode_linked_file(&LinkedFile { uuid: "x".into(), file_name: "a.psb".into(), bytes: vec![1; 3] });
+        let mut b = encode_linked_file(&LinkedFile { uuid: "x".into(), file_name: "b.psb".into(), bytes: vec![2; 4] });
+        a[17] = 0xff;
+        b[17] = 0xfe;
+        let mut data = a;
+        data.extend(b);
+        assert_eq!(block_uuids(&data), vec!["\u{fffd}", "\u{fffd}"], "legacy lossy parsing remains unchanged");
+        assert!(select_items(&data, &|uuid, _| uuid == "\u{fffd}").unwrap_err().to_string().contains("invalid UTF-8"));
+        let valid = encode_linked_file(&LinkedFile { uuid: "valid".into(), file_name: "valid.psb".into(), bytes: vec![3; 5] });
+        data.extend(&valid);
+        assert_eq!(select_items(&data, &|uuid, _| uuid == "valid").unwrap(), Some(valid));
+        // A literal replacement character can itself be a valid UTF-8 identity.
+        let valid_unicode = encode_linked_file(&LinkedFile { uuid: "\u{fffd}".into(), file_name: "unicode.psb".into(), bytes: vec![4; 2] });
+        assert!(select_items(&valid_unicode, &|uuid, _| uuid == "\u{fffd}").unwrap().is_none());
+    }
 }
diff --git a/crates/io/src/multichannel_map.rs b/crates/io/src/multichannel_map.rs
index 40b6884bec..db31e743ef 100644
--- a/crates/io/src/multichannel_map.rs
+++ b/crates/io/src/multichannel_map.rs
@@ -9,13 +9,21 @@
 use photocraft_color::{Color, ColorMode, PixelFormat, SampleType};
 use photocraft_doc::{AlphaChannel, Document};
 use photocraft_geom::Rect;
-use photocraft_psd::file::LayerInfoPlacement;
+use photocraft_psd::file::{GlobalLayerMask, LayerInfoPlacement};
 use photocraft_psd::resources::{ImageResource, ResolutionInfo, ids, version_info_resource};
-use photocraft_psd::{ColorMode as PsdMode, Compression, Header, ImageData, PsdFile};
+use photocraft_psd::{ColorMode as PsdMode, Compression, Header, ImageData, PsdFile, TaggedBlock};
 use photocraft_raster::Surface;
 
 use crate::pixels::{encode_be, psd_depth};
 
+/// Grid and guides.
+const GRID_AND_GUIDES: u16 = 1032;
+/// Alpha identifiers: one u32 per extra channel.
+const ALPHA_IDENTIFIERS: u16 = 1053;
+/// Resources that only describe layers: target layer (1024), layer groups (1026), layer
+/// selection ids (1069) and layer groups enabled (1072). A Multichannel document has no layers.
+const LAYER_ONLY_RESOURCES: [u16; 4] = [ids::LAYER_STATE, ids::LAYER_GROUP_INFO, 1069, 1072];
+
 /// Value of sample `i` of a big-endian plane.
 fn decode(plane: &[u8], i: usize, s: SampleType) -> f32 {
     match s {
@@ -44,13 +52,14 @@ pub(crate) fn import(file: &PsdFile, all: &[u8], doc: &mut Document, names: &[St
         s.write_region(canvas, &vals);
         s.prune();
         let name = names.get(k).cloned().filter(|s| !s.is_empty()).unwrap_or_else(|| format!("Channel {}", k + 1));
-        // Without DisplayInfo the channels print in black, as Photoshop shows them.
+        // Without DisplayInfo the channels print in black, as Photoshop shows them. DisplayInfo
+        // turns alpha-type channels (selected / masked areas) back into alpha channels.
         doc.channels.push(AlphaChannel { spot: Some((Color::BLACK, 0.0)), ..AlphaChannel::new(name, s) });
     }
     if let Some(r) = file.resource(crate::channel_map::DISPLAY_INFO) {
-        crate::channel_map::apply_display_info(&r.data, true, &mut doc.channels);
+        crate::channel_map::apply_display_info(&r.data, true, 0, &mut doc.channels);
     } else if let Some(r) = file.resource(crate::channel_map::DISPLAY_INFO_OLD) {
-        crate::channel_map::apply_display_info(&r.data, false, &mut doc.channels);
+        crate::channel_map::apply_display_info(&r.data, false, 0, &mut doc.channels);
     }
 }
 
@@ -97,17 +106,54 @@ pub(crate) fn document_to_psd(doc: &Document, force_psb: bool) -> (PsdFile, Vec<
     let image_data = ImageData::encode(Compression::Rle, &planes, &header)
         .or_else(|_| ImageData::encode(Compression::Raw, &planes, &header))
         .unwrap_or(ImageData { compression: Compression::Raw, data: planes });
-    let mut resources = vec![ImageResource::new(ids::RESOLUTION_INFO, ResolutionInfo::from_dpi(f64::from(doc.resolution_dpi)).to_bytes())];
+    let mut resources = vec![
+        ImageResource::new(ids::RESOLUTION_INFO, ResolutionInfo::from_dpi(f64::from(doc.resolution_dpi)).to_bytes()),
+        ImageResource::new(ids::GLOBAL_ANGLE, (doc.global_light.angle.round() as i32).to_be_bytes().to_vec()),
+        ImageResource::new(ids::GLOBAL_ALTITUDE, (doc.global_light.altitude.round() as i32).to_be_bytes().to_vec()),
+    ];
+    // Grid and guides: Photoshop writes it in every file, guides or not.
+    resources.push(ImageResource::new(GRID_AND_GUIDES, crate::psd_export::guides_resource(doc)));
     if !channels.is_empty() {
         let names: Vec<&str> = channels.iter().map(|c| c.name.as_str()).collect();
         resources.push(ImageResource::new(1006, crate::psd_export::pascal_names_resource(&names)));
         resources.push(ImageResource::new(1045, crate::psd_export::unicode_names_resource(&names)));
-        resources.push(ImageResource::new(crate::channel_map::DISPLAY_INFO, crate::channel_map::display_info(&channels)));
+        resources.push(ImageResource::new(crate::channel_map::DISPLAY_INFO, crate::channel_map::display_info(&channels, false)));
     }
+    resources.extend(crate::psd_export::path_resources(doc, &mut warnings));
+    // The XMP and EXIF resolution follow the ResolutionInfo resource, so no copy contradicts it.
+    let ppi = Some((doc.resolution_dpi, doc.resolution_dpi)).filter(|d| d.0 > 0.0);
     if let Some(x) = &doc.metadata.xmp {
-        resources.push(ImageResource::new(ids::XMP, x.as_bytes().to_vec()));
+        resources.push(ImageResource::new(ids::XMP, photocraft_codecs::export_xmp(x, ppi).as_bytes().to_vec()));
+    }
+    if let Some(e) = &doc.metadata.exif {
+        resources.push(ImageResource::new(ids::EXIF, photocraft_codecs::export_exif(e, ppi).into_owned()));
+    }
+    // Every other imported resource (print settings, IPTC, the layer-id seed, ...), except the
+    // ones that only describe layers and any already written above.
+    let written: Vec<u16> = resources.iter().map(|r| r.id).collect();
+    for (id, name, data) in &doc.metadata.psd_resources {
+        if LAYER_ONLY_RESOURCES.contains(id) || written.contains(id) || !crate::psd_export::keep_imported_resource(doc, *id, data) {
+            continue;
+        }
+        // Alpha identifiers: one u32 per channel, only while they still match the channels.
+        if *id == ALPHA_IDENTIFIERS && data.len() != channels.len().saturating_mul(4) {
+            continue;
+        }
+        let mut r = ImageResource::new(*id, data.to_vec());
+        r.name = crate::psd_export::legacy_name(name);
+        resources.push(r);
+    }
+    if let Some(data) = crate::annotations_map::fresh_scale_resource(doc) {
+        resources.push(ImageResource::new(crate::annotations_map::MEASUREMENT_SCALE, data));
     }
     resources.push(version_info_resource(true));
+    // Document-level tagged blocks (patterns, notes, ...) are valid without a layer section; a
+    // kept layer block would describe layers the document doesn't have.
+    let global_blocks: Vec<TaggedBlock> = crate::annotations_map::export_blocks(doc, crate::pattern_map::export_global_blocks(doc))
+        .into_iter()
+        .filter(|(_, key, _)| !matches!(key, b"Layr" | b"Lr16" | b"Lr32"))
+        .map(|(sig, key, data)| crate::psd_export::global_block(sig, key, &data))
+        .collect();
     let color_mode_data = photocraft_psd::hdr::color_mode_data_for_depth(header.depth);
     let file = PsdFile {
         header,
@@ -115,8 +161,8 @@ pub(crate) fn document_to_psd(doc: &Document, force_psb: bool) -> (PsdFile, Vec<
         resources,
         layer_info: None,
         layer_info_placement: LayerInfoPlacement::Section,
-        global_layer_mask: None,
-        global_blocks: Vec::new(),
+        global_layer_mask: (!global_blocks.is_empty()).then(GlobalLayerMask::default),
+        global_blocks,
         layer_mask_trailing: Vec::new(),
         image_data,
     };
diff --git a/crates/io/src/ora.rs b/crates/io/src/ora.rs
index dba3c96197..42b2ab7a33 100644
--- a/crates/io/src/ora.rs
+++ b/crates/io/src/ora.rs
@@ -476,6 +476,8 @@ struct Writer<'a> {
     next: usize,
     sample: CSample,
     warnings: Warnings,
+    /// Only collect the warnings ([`losses`]): no pixels are rendered or encoded.
+    dry: bool,
 }
 
 /// Straight RGBA floats as interleaved PNG samples at `sample` depth.
@@ -559,6 +561,20 @@ impl Writer<'_> {
         attrs
     }
 
+    /// What saving a non-group layer's pixels loses: a type, shape, fill or smart object layer
+    /// becomes pixels, and its pixel mask is applied to them.
+    fn content_warnings(&mut self, layer: &Layer) {
+        if !matches!(layer.content, LayerContent::Raster(_)) {
+            self.warnings.layer(&layer.name, &format!("{} layers are saved to OpenRaster as pixels", layer.content.kind_name().to_lowercase()));
+        }
+        if let Some(mask) = layer.mask.as_ref().filter(|m| m.enabled) {
+            if mask.feather > 0.0 {
+                self.warnings.layer(&layer.name, "layer mask feathering is not applied in OpenRaster");
+            }
+            self.warnings.layer(&layer.name, "layer masks were applied to the layer pixels");
+        }
+    }
+
     /// The layer's own pixels (straight RGBA floats) and their bounds; its pixel mask applied.
     fn pixels(&mut self, layer: &Layer) -> (Rect, Vec<[f32; 4]>) {
         let canvas = self.doc.bounds();
@@ -578,15 +594,10 @@ impl Writer<'_> {
                 solo.mask = None;
                 solo.effects = Default::default();
                 let r = photocraft_compose::composite_bounds(&solo, canvas).unwrap_or(canvas).intersect(&canvas);
-                self.warnings.layer(&layer.name, &format!("{} layers are saved to OpenRaster as pixels", layer.content.kind_name().to_lowercase()));
                 (r, photocraft_compose::render_layer(&solo, r).px)
             }
         };
         if let Some(mask) = layer.mask.as_ref().filter(|m| m.enabled) {
-            if mask.feather > 0.0 {
-                self.warnings.layer(&layer.name, "layer mask feathering is not applied in OpenRaster");
-            }
-            self.warnings.layer(&layer.name, "layer masks were applied to the layer pixels");
             let mut values = Vec::new();
             mask.values_into(rect, &mut values);
             for (p, m) in buf.iter_mut().zip(values) {
@@ -623,6 +634,10 @@ impl Writer<'_> {
                 }
                 _ => {
                     let attrs = self.common(layer);
+                    self.content_warnings(layer);
+                    if self.dry {
+                        continue;
+                    }
                     let (rect, px) = self.pixels(layer);
                     let (rect, px) = if rect.is_empty() { (Rect::from_xywh(0, 0, 1, 1), vec![[0.0; 4]]) } else { (rect, px) };
                     let src = format!("data/layer{}.png", self.next);
@@ -648,10 +663,8 @@ pub(crate) fn export(doc: &Document) -> Result<ExportResult> {
     let mut zip = ZipWriter::new();
     // The mimetype must be the first entry, stored, so the type is readable at a fixed offset.
     zip.add("mimetype", MIMETYPE)?;
-    let mut w = Writer { doc, zip, xml: String::new(), next: 0, sample, warnings: Warnings::default() };
-    if doc.depth == SampleType::F32 {
-        w.warnings.note("32-bit float layers are saved as 16-bit PNGs");
-    }
+    let mut w = Writer { doc, zip, xml: String::new(), next: 0, sample, warnings: Warnings::default(), dry: false };
+    document_warnings(doc, &mut w.warnings);
     w.xml.push_str(&format!(
         "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<image version=\"0.0.6\" w=\"{}\" h=\"{}\" xres=\"{}\" yres=\"{}\"><stack>",
         doc.size.width,
@@ -661,24 +674,48 @@ pub(crate) fn export(doc: &Document) -> Result<ExportResult> {
     ));
     w.layers(&doc.layers, 1)?;
     w.xml.push_str("</stack></image>\n");
-    let Writer { mut zip, xml, mut warnings, .. } = w;
+    let Writer { mut zip, xml, warnings, .. } = w;
     zip.add("stack.xml", xml.as_bytes())?;
     let merged = photocraft_compose::flatten(doc);
     zip.add("mergedimage.png", &png(doc.size.width, doc.size.height, &merged.px, sample)?)?;
     let thumb = photocraft_compose::thumbnail(doc, THUMBNAIL_SIDE);
     let thumb = Image::from_raw(thumb.width, thumb.height, ChannelLayout::Rgba, CSample::U8, thumb.pixels)?;
     zip.add("Thumbnails/thumbnail.png", &codecs::encode(&thumb, Format::Png, &codecs::EncodeOptions::default())?)?;
+    Ok(ExportResult { bytes: zip.finish()?, warnings: warnings.finish() })
+}
+
+/// What saving `doc` to OpenRaster loses that isn't in a layer.
+fn document_warnings(doc: &Document, warnings: &mut Warnings) {
+    if doc.depth == SampleType::F32 {
+        warnings.note("32-bit float layers are saved as 16-bit PNGs");
+    }
     if !doc.channels.is_empty() {
         warnings.note("alpha channels are not saved to OpenRaster");
     }
     if !doc.metadata.text.is_empty() || doc.metadata.xmp.is_some() || doc.metadata.exif.is_some() {
         warnings.note("metadata (XMP, EXIF, text) is not saved to OpenRaster");
     }
-    if doc.icc_profile.is_some() {
+    // Readers assume sRGB, so an sRGB document loses nothing by the missing tag.
+    let srgb = |bytes: &[u8]| photocraft_cms::Profile::parse(bytes).is_ok_and(|p| p.same_colors(photocraft_cms::Builtin::Srgb.profile()));
+    if doc.icc_profile.as_deref().is_some_and(|b| !srgb(b)) {
         warnings.note("the colour profile is not saved to OpenRaster; readers assume sRGB");
     }
     if doc.mode == ColorMode::Grayscale {
         warnings.note("grayscale layers are saved as RGB");
     }
-    Ok(ExportResult { bytes: zip.finish()?, warnings: warnings.finish() })
+}
+
+/// Everything saving `doc` to OpenRaster would lose (the warnings [`export`] gives), without
+/// rendering or encoding anything. Empty when an OpenRaster file holds the whole document, so it
+/// can be the document's own file; otherwise a save to OpenRaster is a copy (#3806).
+pub fn losses(doc: &Document) -> Vec<String> {
+    if !matches!(doc.mode, ColorMode::Rgb | ColorMode::Grayscale) {
+        return vec!["OpenRaster holds RGB layers; convert the document to RGB or Grayscale first".into()];
+    }
+    let mut w = Writer { doc, zip: ZipWriter::new(), xml: String::new(), next: 0, sample: CSample::U8, warnings: Warnings::default(), dry: true };
+    document_warnings(doc, &mut w.warnings);
+    if let Err(e) = w.layers(&doc.layers, 1) {
+        w.warnings.note(&e.to_string());
+    }
+    w.warnings.finish()
 }
diff --git a/crates/io/src/ora/tests.rs b/crates/io/src/ora/tests.rs
index 625630d08c..319414a94d 100644
--- a/crates/io/src/ora/tests.rs
+++ b/crates/io/src/ora/tests.rs
@@ -397,3 +397,53 @@ fn group_opacity_and_fill_are_combined_without_affecting_raster_opacity() {
     assert!((back.layers[0].opacity - 0.25).abs() < 1e-6);
     assert_eq!(back.layers[0].children().unwrap()[0].opacity, 1.0);
 }
+
+/// One document per thing OpenRaster can't hold, each also checked against the exporter.
+fn lossy_documents() -> Vec<(&'static str, Document)> {
+    let fmt = PixelFormat::new(ColorMode::Rgb, SampleType::U8, true);
+    let with = |f: &dyn Fn(&mut Document)| {
+        let mut d = doc(SampleType::U8);
+        f(&mut d);
+        d
+    };
+    vec![
+        ("adjustment", with(&|d| d.layers.push(Layer::new("Curves", LayerContent::Adjustment(Adjustment::Invert))))),
+        ("fill", with(&|d| d.layers.push(Layer::new("Fill", LayerContent::Fill(Fill::Solid(Color::rgba(1.0, 0.0, 0.0, 1.0))))))),
+        ("mask", {
+            let mut l = block("Masked", fmt, 0, 0, 20, 20, 9);
+            l.mask = Some(LayerMask::reveal_all());
+            with(&move |d| d.layers.push(l.clone()))
+        }),
+        ("clipped", with(&|d| d.layers[1].clipped = true)),
+        ("fill opacity", with(&|d| d.layers[0].fill_opacity = 0.5)),
+        ("float", doc(SampleType::F32)),
+        ("profile", with(&|d| d.icc_profile = Some(photocraft_cms::Builtin::DisplayP3.profile().to_bytes()))),
+        ("metadata", with(&|d| d.metadata.xmp = Some("<x/>".into()))),
+    ]
+}
+
+/// The exporter's warnings and [`losses`] are one list, so they can't drift apart.
+#[test]
+fn losses_are_exactly_what_the_exporter_warns_about() {
+    for (what, d) in lossy_documents() {
+        let losses = losses(&d);
+        assert!(!losses.is_empty(), "{what}: OpenRaster can't hold it");
+        assert_eq!(losses, export(&d).unwrap().warnings, "{what}");
+    }
+}
+
+/// A document of plain pixel layers and groups loses nothing, so its OpenRaster file can stay its
+/// own; an sRGB profile isn't a loss, as readers assume sRGB.
+#[test]
+fn plain_documents_lose_nothing() {
+    for depth in [SampleType::U8, SampleType::U16] {
+        let mut d = doc(depth);
+        assert_eq!(losses(&d), Vec::<String>::new(), "{depth:?}");
+        d.icc_profile = Some(photocraft_cms::Builtin::Srgb.profile().to_bytes());
+        assert_eq!(losses(&d), Vec::<String>::new(), "{depth:?} tagged sRGB");
+        assert_eq!(export(&d).unwrap().warnings, Vec::<String>::new());
+    }
+    let mut cmyk = doc(SampleType::U8);
+    cmyk.mode = ColorMode::Cmyk;
+    assert_eq!(losses(&cmyk).len(), 1, "a document OpenRaster can't hold at all");
+}
diff --git a/crates/io/src/psd_export.rs b/crates/io/src/psd_export.rs
index 771ebcb780..9db3d4799f 100644
--- a/crates/io/src/psd_export.rs
+++ b/crates/io/src/psd_export.rs
@@ -15,6 +15,11 @@ use crate::blocks;
 use crate::pixels::{deinterleave, encode_be, psd_depth};
 use crate::psd_import::REGENERATED;
 
+/// Blocks that define a layer's content as something other than pixels: fill (`SoCo`, `GdFl`,
+/// `PtFl`), placed / smart object (`SoLd`, `PlLd`, `SoLE`), type (`TySh`) and shape fill (`vscg`).
+/// A raster layer never writes them, nor adjustment blocks.
+const RASTER_STALE_KEYS: [&[u8; 4]; 8] = [b"SoCo", b"GdFl", b"PtFl", b"SoLd", b"PlLd", b"SoLE", b"TySh", b"vscg"];
+
 const PSD_MAX_FILE_SIZE: u64 = 2 * 1024 * 1024 * 1024;
 const PSD_ESTIMATE_FIXED_OVERHEAD: u64 = 1024 * 1024;
 const PSD_ESTIMATE_LAYER_OVERHEAD: u64 = 64 * 1024;
@@ -30,11 +35,17 @@ pub struct PsdExportOptions {
     pub merged_matte: bool,
     /// Compression of the merged image (32-bit float documents are always written raw).
     pub merged_compression: Compression,
+    /// Write the real merged image (Preferences › File Handling › Maximize PSD and PSB File
+    /// Compatibility). `false` writes Photoshop's white placeholder instead and records
+    /// `has_real_merged_data = false` in resource 1057: a smaller file and a faster save, but
+    /// readers that only show the merged image see white. A document without layer records always
+    /// gets the real image, since its pixels live nowhere else.
+    pub maximize_compatibility: bool,
 }
 
 impl Default for PsdExportOptions {
     fn default() -> Self {
-        PsdExportOptions { force_psb: false, merged_matte: true, merged_compression: Compression::Rle }
+        PsdExportOptions { force_psb: false, merged_matte: true, merged_compression: Compression::Rle, maximize_compatibility: true }
     }
 }
 
@@ -49,6 +60,8 @@ struct Ex {
     cmyk: bool,
     version: Version,
     next_id: u32,
+    /// Reserved imported layer and generated divider IDs.
+    used_ids: std::collections::HashSet<u32>,
     /// PSD ids assigned to document layers (kept from `psd_id` when unique).
     layer_ids: std::collections::HashMap<photocraft_doc::LayerId, u32>,
     /// The generated `Txt2` object number of each type layer (a preserved `TySh` keeps its own
@@ -66,6 +79,32 @@ struct Ex {
     smart: SmartOut,
     /// The document's patterns, which Pattern Fill layers are rendered from.
     patterns: Vec<photocraft_doc::Pattern>,
+    /// The layer written as Photoshop's Background (see [`psd_background`]).
+    background: Option<photocraft_doc::LayerId>,
+}
+
+/// The layer Photoshop should open as its Background: the bottom top-level layer when it is a
+/// locked (transparency and position), unclipped, unmasked raster that is opaque over the whole
+/// canvas at full opacity and Normal, as a Background always is. Photoshop recognises a
+/// Background by the bottom layer having no transparency channel (measured on Photoshop 27.11:
+/// with the `-1` channel written, 317 of 427 re-exported corpus files reopened with the
+/// Background as an ordinary layer).
+fn psd_background(doc: &Document) -> Option<photocraft_doc::LayerId> {
+    let l = doc.layers.first()?;
+    let LayerContent::Raster(s) = &l.content else { return None };
+    let locked = l.locks.transparency && l.locks.position;
+    let plain = !l.clipped && l.mask.is_none() && l.vector_mask.is_none() && l.opacity >= 1.0 && l.fill_opacity >= 1.0;
+    let normal = l.blend == photocraft_doc::BlendMode::Normal;
+    if !(locked && plain && normal) {
+        return None;
+    }
+    let canvas = doc.bounds();
+    if canvas.is_empty() || s.content_bounds() != canvas {
+        return None;
+    }
+    let n = s.channels();
+    let opaque = s.read_region(canvas).chunks_exact(n).all(|p| p.last().is_some_and(|a| *a >= 1.0));
+    opaque.then_some(l.id)
 }
 
 /// How deep embedded documents are exported inside each other before a smart object is written
@@ -233,17 +272,6 @@ impl SmartOut {
     }
 }
 
-/// Size and resolution of a smart-object source file (PSD/PSB header, `.pcraft`, or any image).
-fn source_geometry(name: &str, bytes: &[u8]) -> Result<((f64, f64), f64), String> {
-    if crate::is_psd(bytes) {
-        let rd = |at: usize| bytes.get(at..at + 4).map(|b| f64::from(u32::from_be_bytes([b[0], b[1], b[2], b[3]])));
-        let (h, w) = rd(14).zip(rd(18)).ok_or("truncated PSD header")?;
-        return Ok(((w, h), 72.0));
-    }
-    let doc = crate::import(name, bytes).map_err(|e| e.to_string())?.document;
-    Ok(((f64::from(doc.size.width), f64::from(doc.size.height)), f64::from(doc.resolution_dpi)))
-}
-
 /// The source size of a smart object whose file we can't decode: its rendered bounds taken back
 /// through the inverse transform (the source's top-left is the origin).
 fn size_from_layer(sm: &photocraft_doc::SmartObject) -> (f64, f64) {
@@ -270,6 +298,10 @@ fn upsert(raw: &mut Vec<([u8; 4], Vec<u8>)>, key: &[u8; 4], data: Vec<u8>, befor
     }
 }
 
+fn h_of(r: photocraft_geom::Rect) -> usize {
+    r.height() as usize
+}
+
 fn psd_mode(m: ColorMode) -> PsdMode {
     match m {
         ColorMode::Grayscale => PsdMode::Grayscale,
@@ -307,18 +339,28 @@ impl Ex {
         (-1..self.cc as i16).map(|id| self.encode(id, &[], 0, 0)).collect()
     }
 
-    fn pixel_channels(&mut self, s: &Surface, name: &str) -> (PsdRect, Vec<ChannelData>) {
+    fn pixel_channels(&self, s: &Surface, name: &str) -> (PsdRect, Vec<ChannelData>, Vec<String>) {
+        let mut warnings = Vec::new();
         let s = if s.format() != self.fmt {
-            self.warnings.push(format!("layer \"{name}\": pixels converted from {:?} to {:?}", s.format(), self.fmt));
+            warnings.push(format!("layer \"{name}\": pixels converted from {:?} to {:?}", s.format(), self.fmt));
             s.convert(self.fmt)
         } else {
             s.clone()
         };
         let r = s.content_bounds();
         if r.is_empty() {
-            return (PsdRect::default(), self.empty_channels());
+            return (PsdRect::default(), self.empty_channels(), warnings);
+        }
+        // The interleaved gather is the sequential pass for full-canvas layers, so it runs
+        // in row bands on all cores and the band results concatenate in order.
+        let row_len = r.width() as usize;
+        let bands = crate::pixels::bands(h_of(r));
+        let parts =
+            crate::pixels::par_map(bands, |rows| s.to_interleaved(photocraft_geom::Rect::new(r.x0, r.y0 + rows.start as i32, r.x1, r.y0 + rows.end as i32)));
+        let mut bytes = Vec::with_capacity(row_len * h_of(r) * s.format().bytes_per_pixel());
+        for part in parts {
+            bytes.extend_from_slice(&part);
         }
-        let mut bytes = s.to_interleaved(r);
         if self.fmt.mode == ColorMode::Lab && self.fmt.sample == SampleType::U16 {
             crate::pixels::lab16_chroma(&mut bytes, self.cc + 1, false);
         }
@@ -331,7 +373,7 @@ impl Ex {
         let order: Vec<(i16, &Vec<u8>)> =
             std::iter::once((-1, &planes[self.cc])).chain(planes.iter().take(self.cc).enumerate().map(|(c, p)| (c as i16, p))).collect();
         let ch = crate::pixels::par_map(order, |(id, plane)| self.encode(id, plane, w, h));
-        (to_psd_rect(r), ch)
+        (to_psd_rect(r), ch, warnings)
     }
 
     fn mask(&self, m: &LayerMask, vector: Option<(f32, f32)>) -> (MaskData, Option<ChannelData>) {
@@ -363,10 +405,14 @@ impl Ex {
         (MaskData::Mask(pm), Some(self.encode(-2, &plane, w, h)))
     }
 
-    /// Ids for section dividers: above every layer id.
+    /// Prefer numbers above imported layer IDs, wrapping safely at u32::MAX.
     fn fresh_id(&mut self) -> u32 {
-        self.next_id += 1;
-        self.next_id
+        loop {
+            self.next_id = self.next_id.wrapping_add(1).max(1);
+            if self.used_ids.insert(self.next_id) {
+                return self.next_id;
+            }
+        }
     }
 
     fn layer_id(&mut self, l: &Layer) -> u32 {
@@ -378,10 +424,11 @@ impl Ex {
 
     fn record(&mut self, l: &Layer, extra: Vec<TaggedBlock>, pixels: Option<&Surface>) -> LayerRecord {
         let id = self.layer_id(l);
-        let (rect, mut channels) = match pixels {
+        let (rect, mut channels, warnings) = match pixels {
             Some(s) => self.pixel_channels(s, &l.name),
-            None => (PsdRect::default(), self.empty_channels()),
+            None => (PsdRect::default(), self.empty_channels(), Vec::new()),
         };
+        self.warnings.extend(warnings);
         let mut mask = MaskData::None;
         // Vector mask density/feather live in the mask parameters, with or without a user mask.
         let vector = l.vector_mask.as_ref().map(|vm| (vm.density, vm.feather));
@@ -401,7 +448,16 @@ impl Ex {
                 real_first: true,
             });
         }
-        let mut flags = LayerFlags(0);
+        // A Background carries no transparency channel: that is how Photoshop tells it apart.
+        if self.background == Some(l.id) {
+            channels.retain(|c| c.id != -1);
+        }
+        // As Photoshop writes them: bit 4 is meaningful, and set for layers whose pixels don't
+        // show (adjustment layers).
+        let mut flags = LayerFlags(LayerFlags::BIT4_USEFUL);
+        if matches!(l.content, LayerContent::Adjustment(_)) {
+            flags.0 |= LayerFlags::PIXEL_DATA_IRRELEVANT;
+        }
         flags.set_hidden(!l.visible);
         flags.set_transparency_protected(l.locks.transparency);
         let mut blocks = vec![TaggedBlock::unicode_name(&l.name), TaggedBlock::layer_id(id)];
@@ -529,6 +585,12 @@ impl Ex {
                     let legacy_phfl = k == b"phfl" && d.starts_with(&[0, 2]) && d.len() % 4 != 0;
                     !legacy_phfl && adjust_map::ADJUSTMENT_KEYS.contains(&k) && adjust_map::parse(k, d, cged.as_deref(), channels) == *a
                 });
+                // A Gradient Map whose stops are unchanged keeps the file's own block (stops in
+                // the document's CMYK/Lab/Gray space, smoothness, method) with Reverse and Dither
+                // updated in place.
+                let keep = keep
+                    || (matches!(a, photocraft_doc::Adjustment::GradientMap { .. })
+                        && raw.iter_mut().any(|(k, d)| k == b"grdm" && adjust_map::retarget_gradient_map(d, a, channels)));
                 if !keep {
                     raw.retain(|(k, _)| !adjust_map::ADJUSTMENT_KEYS.contains(&k) && k != b"CgEd");
                     let w = adjust_map::write(a);
@@ -576,15 +638,27 @@ impl Ex {
             }
             LayerContent::Smart(sm) => {
                 let parsed = sm.psd_raw.as_deref().and_then(|d| crate::smart_map::parse_sold(d));
-                if sm.psd_raw.is_some() && parsed.is_none() {
-                    // Placed-layer data we don't parse (`PlLd` only): kept verbatim.
+                if sm.psd_raw.is_some() && parsed.is_none() && !self.plld_edited(sm) {
+                    // Placed-layer data that isn't `SoLd` (a CS2 `PlLd` record, or one we can't
+                    // read) and still says what the layer is: kept verbatim.
                     self.smart.prune_ok = false;
                     set_principal(&mut raw, smart_keys(sm.psd_raw.as_deref().map(Vec::as_slice)), sm.psd_raw.as_ref());
                 } else {
+                    // An edited CS2 `PlLd`-only layer is written like any other smart object
+                    // (`SoLd` and a regenerated `PlLd`), with its current placement (#2465).
                     self.smart_blocks(l, sm, parsed, &mut raw);
                 }
             }
-            LayerContent::Raster(_) | LayerContent::Group(_) => {}
+            // A pixel layer carries no content-defining blocks: a fill, placed (smart), type or
+            // shape-fill block left over from before Rasterize would make a reader (ours or
+            // Photoshop's) reopen the layer as that kind and discard the pixels. A shape stroke
+            // (`vstk`) beside a vector mask makes a shape too; without one, Photoshop keeps it on
+            // pixel layers, so it stays. A vector mask (`vmsk`/`vsms`, `vogk`) stays.
+            LayerContent::Raster(_) => {
+                let masked = l.vector_mask.is_some();
+                raw.retain(|(k, _)| !(RASTER_STALE_KEYS.contains(&k) || adjust_map::ADJUSTMENT_KEYS.contains(&k) || k == b"CgEd" || (k == b"vstk" && masked)));
+            }
+            LayerContent::Group(_) => {}
         }
         // Effects reference point: written from the field (in place, keeping block order).
         match l.effects.reference {
@@ -741,6 +815,36 @@ impl Ex {
         self.warnings.extend(warnings.into_iter().map(|w| if w.starts_with("layer ") { w } else { format!("layer \"{}\": {w}", l.name) }));
     }
 
+    /// Whether a CS2 placed layer (`PlLd` with no `SoLd`, #2465) no longer matches its record:
+    /// moved, transformed, warped, filtered or given other contents. `false` for a record that
+    /// can't be read (or whose warp can't), or whose file isn't embedded: its contents were never
+    /// available, so it is kept.
+    fn plld_edited(&self, sm: &photocraft_doc::SmartObject) -> bool {
+        let Some(data) = sm.psd_raw.as_deref() else { return false };
+        let Some((id, corners)) = blocks::parse_plld(data) else { return false };
+        // Without its embedded file the contents were never available: keep the record as it
+        // is, rather than resolve the id (bytes from the file) as a path on disk.
+        if !self.smart.known.contains(&id) {
+            return false;
+        }
+        let warp = match blocks::parse_plld_warp(data) {
+            blocks::PlldWarp::Unreadable => return false,
+            blocks::PlldWarp::None => None,
+            blocks::PlldWarp::Warp(w) => Some(w),
+        };
+        if sm.source != (photocraft_doc::SmartSource::Linked { path: id.clone() })
+            || sm.warp != warp
+            || !sm.smart_filters.is_empty()
+            || sm.filter_mask.is_some()
+        {
+            return true;
+        }
+        // Placed as the importer places it (the same source size, from the same file, and the
+        // same frame: a custom warp's control-point box, #3677).
+        let size = crate::linked::source_size_in_blocks(self.smart.globals.iter().map(|(_, k, d)| (k, d.as_slice())), &id, &photocraft_raster::Interrupt::NONE);
+        blocks::plld_transform(&corners, size, warp.as_ref()) != (sm.transform, sm.perspective)
+    }
+
     /// Whether an imported placed layer still says what the smart object is: transform, warp,
     /// filter stack and filter mask as stored.
     fn placed_unchanged(&self, t: &crate::smart_map::Placed, data: &[u8], sm: &photocraft_doc::SmartObject, stack: &crate::smart_map::FilterStack) -> bool {
@@ -772,7 +876,7 @@ impl Ex {
                 let geometry = stored.map(|size| (size, f64::from(self.dpi))).or_else(|| {
                     let meta = photocraft_doc::Metadata { psd_global_blocks: self.smart.globals.clone(), ..Default::default() };
                     let f = crate::linked::find_linked_file(&meta, path)?;
-                    source_geometry(&f.file_name, &f.bytes).ok()
+                    crate::linked::source_geometry(&f.file_name, &f.bytes, &photocraft_raster::Interrupt::NONE).ok()
                 });
                 let (size, dpi) = geometry.unwrap_or((size_from_layer(sm), f64::from(self.dpi)));
                 let original = self.smart.linked_contents.entry(path.clone()).or_insert(sm.contents_id);
@@ -882,7 +986,8 @@ impl Ex {
             (format!("{stem}.psb"), data, size, f64::from(doc.resolution_dpi), Some(doc))
         } else {
             // Formats we can't decode (vector PDF/AI…) are still embedded; their size comes from the layer.
-            let (size, dpi) = source_geometry(file_name, bytes).unwrap_or(((0.0, 0.0), f64::from(self.dpi)));
+            let (size, dpi) =
+                crate::linked::source_geometry(file_name, bytes, &photocraft_raster::Interrupt::NONE).unwrap_or(((0.0, 0.0), f64::from(self.dpi)));
             (file_name.to_string(), bytes.to_vec(), size, dpi, None)
         };
         let uuid = contents_uuid(contents_id, &data);
@@ -1033,7 +1138,7 @@ fn effects_unchanged(l: &Layer) -> Option<bool> {
     Some(m == l.effects.enabled && items == l.effects.items)
 }
 
-fn legacy_name(s: &str) -> Vec<u8> {
+pub(crate) fn legacy_name(s: &str) -> Vec<u8> {
     s.chars().map(|c| if c.is_ascii() && !c.is_ascii_control() { c as u8 } else { b'?' }).take(255).collect()
 }
 
@@ -1059,7 +1164,7 @@ pub(crate) fn pascal_names_resource(names: &[&str]) -> Vec<u8> {
     v
 }
 
-fn guides_resource(doc: &Document) -> Vec<u8> {
+pub(crate) fn guides_resource(doc: &Document) -> Vec<u8> {
     let mut v = Vec::new();
     v.extend_from_slice(&1u32.to_be_bytes());
     v.extend_from_slice(&576u32.to_be_bytes());
@@ -1075,6 +1180,72 @@ fn guides_resource(doc: &Document) -> Vec<u8> {
     v
 }
 
+/// Path resources: saved paths (2000+), the work path (1025) and the clipping path name (2999),
+/// the last only when the imported one doesn't already name the document's clipping path.
+pub(crate) fn path_resources(doc: &Document, warnings: &mut Vec<String>) -> Vec<ImageResource> {
+    use crate::vector_map::{CLIPPING_PATH, WORK_PATH, path_from_resource, path_to_records};
+    let mut out = Vec::new();
+    let (w, h) = (doc.size.width, doc.size.height);
+    let max = (*crate::vector_map::SAVED_PATHS.end() - *crate::vector_map::SAVED_PATHS.start() + 1) as usize;
+    if doc.paths.len() > max {
+        warnings.push(format!("only {max} saved paths fit in PSD; the rest were dropped"));
+    }
+    for (i, p) in doc.paths.iter().take(max).enumerate() {
+        let data = match &p.psd_raw {
+            Some(r) if path_from_resource(r, w, h).as_ref() == Some(&p.path) => r.to_vec(),
+            _ => path_to_records(&p.path, w, h).to_bytes(),
+        };
+        let mut r = ImageResource::new(crate::vector_map::SAVED_PATHS.start() + i as u16, data);
+        r.name = legacy_name(&p.name);
+        out.push(r);
+    }
+    if let Some(wp) = &doc.work_path {
+        out.push(ImageResource::new(WORK_PATH, path_to_records(wp, w, h).to_bytes()));
+    }
+    let raw_clip = doc.metadata.psd_resources.iter().find(|(id, _, _)| *id == CLIPPING_PATH);
+    let raw_name = raw_clip.map(|(_, _, d)| {
+        let n = usize::from(d.first().copied().unwrap_or(0));
+        d.get(1..1 + n).map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default()
+    });
+    if let Some(c) = &doc.clipping_path
+        && raw_name.as_deref() != Some(c.name.as_str())
+    {
+        // Pascal name, then flatness as 16.16 fixed (best effort; see vector_map docs).
+        let mut data = vec![0u8];
+        let name = legacy_name(&c.name);
+        data[0] = name.len() as u8;
+        data.extend_from_slice(&name);
+        data.extend_from_slice(&((c.flatness.max(0.0) * 65536.0) as u32).to_be_bytes());
+        out.push(ImageResource::new(CLIPPING_PATH, data));
+    }
+    out
+}
+
+/// Whether an imported (unmodelled) resource still describes the document and is written back.
+pub(crate) fn keep_imported_resource(doc: &Document, id: u16, data: &[u8]) -> bool {
+    // Measurement scale / count resources: only while they still describe the document.
+    if !crate::annotations_map::keep_resource(doc, id) {
+        return false;
+    }
+    // A preserved clipping-path resource is only valid while it names the current one.
+    if id == crate::vector_map::CLIPPING_PATH {
+        let n = usize::from(data.first().copied().unwrap_or(0));
+        let raw_name = data.get(1..1 + n).map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default();
+        return doc.clipping_path.as_ref().is_some_and(|c| c.name == raw_name);
+    }
+    true
+}
+
+/// A document-level (global) tagged block. Photoshop pads these to a multiple of 4, and readers
+/// such as psd-tools step to the next block that way: an even pad after `CAI ` (77 bytes)
+/// misaligned every block after it (#200).
+pub(crate) fn global_block(signature: [u8; 4], key: [u8; 4], data: &[u8]) -> TaggedBlock {
+    let mut tb = TaggedBlock::new(key, data.to_vec());
+    tb.signature = signature;
+    tb.padding = Some(vec![0; (4 - data.len() % 4) % 4]);
+    tb
+}
+
 fn cmyk_of(fmt: &PixelFormat) -> bool {
     fmt.mode == ColorMode::Cmyk
 }
@@ -1141,6 +1312,28 @@ fn merged_planes(doc: &Document, fmt: &PixelFormat, cmyk: bool, matte: bool, ctl
     (planes, has_alpha, translucent)
 }
 
+/// The merged image of a file saved without Maximize Compatibility: Photoshop's white placeholder
+/// in the document's colour channels, with no alpha. Encoded like [`merged_planes`], so CMYK white
+/// is no ink and Lab white is L 100 with neutral a*/b*.
+fn placeholder_planes(doc: &Document, fmt: &PixelFormat) -> Vec<u8> {
+    let cc = fmt.mode.color_channels();
+    let cmyk = cmyk_of(fmt);
+    let lab16 = fmt.mode == ColorMode::Lab && fmt.sample == SampleType::U16;
+    let space = photocraft_compose::cmyk_space(doc);
+    let white = photocraft_color::convert::with_cmyk_space(space.as_ref(), || photocraft_raster::from_rgba(fmt, [1.0, 1.0, 1.0, 1.0]));
+    let n = doc.size.area() as usize;
+    let mut planes = Vec::with_capacity(n * fmt.sample.bytes() * cc);
+    for c in 0..cc {
+        let v = white.get(c).copied().unwrap_or(1.0);
+        let x = if cmyk { 1.0 - v } else { v };
+        let x = if lab16 && (c == 1 || c == 2) { x * (crate::pixels::LAB16_CHROMA_MAX / 65535.0) } else { x };
+        let mut sample = Vec::with_capacity(4);
+        encode_be(x, fmt.sample, &mut sample);
+        planes.extend(sample.iter().copied().cycle().take(n * sample.len()));
+    }
+    planes
+}
+
 /// Converts a document to a PSD file model (see [`document_to_psd_with`]).
 pub fn document_to_psd(doc: &Document) -> PsdFile {
     document_to_psd_with(doc, &PsdExportOptions::default()).0
@@ -1270,6 +1463,13 @@ pub(crate) fn estimate_psd_size(doc: &Document) -> Option<u64> {
     estimate_encoded_size(raw_bytes, rows, structural_bytes)
 }
 
+/// The signature a kept tagged block is written with. `8B64` exists only in PSB files: a PSD
+/// with an `8B64` block (kept from a PSB source, e.g. its global `FMsk` or `cinf`) is refused by
+/// Photoshop as "not compatible with this version" (measured in Photoshop 27.11).
+fn block_signature(sig: [u8; 4], version: Version) -> [u8; 4] {
+    if version == Version::Psd && sig == *b"8B64" { *b"8BIM" } else { sig }
+}
+
 pub(crate) fn psd_version(doc: &Document, force_psb: bool, size_exceeds_limit: bool) -> Version {
     let exceeds_dimensions = doc.size.width > 30_000 || doc.size.height > 30_000;
     if force_psb || exceeds_dimensions || size_exceeds_limit { Version::Psb } else { Version::Psd }
@@ -1300,6 +1500,7 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
         cmyk: fmt.mode == ColorMode::Cmyk,
         version,
         next_id: 0,
+        used_ids: Default::default(),
         layer_ids: Default::default(),
         canvas: doc.bounds(),
         records: Vec::new(),
@@ -1308,6 +1509,7 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
         comps: (!crate::comps_map::comps_unchanged(doc)).then(|| (doc.layer_comps.clone(), doc.last_document_state.clone())),
         smart: SmartOut::new(doc, depth),
         patterns: doc.patterns.clone(),
+        background: psd_background(doc),
     };
     if big && !opts.force_psb {
         ex.warnings.push("document exceeds 30000 px; written as PSB".into());
@@ -1340,6 +1542,7 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
             }
         }
         ex.next_id = used.iter().copied().max().unwrap_or(0);
+        ex.used_ids = used;
         // Text objects' number in the generated `Txt2` (#1348): a preserved `TySh` keeps the
         // number it already names — its `Txt2` object must sit at that slot for `apply_txt2` —
         // and new layers get the next free number.
@@ -1377,15 +1580,24 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
     let space = photocraft_compose::cmyk_space(doc);
     photocraft_color::convert::with_cmyk_space(space.as_ref(), || ex.emit(&doc.layers, &mut tick));
 
-    // Merged composite, rendered and encoded in bands (no full-size float composite). Matting
-    // against white only changes pixels with alpha < 1; if some are slightly translucent but all
-    // round to opaque (so no alpha channel is written), encode once more without the matte.
-    let merged_end = layers_share + (1.0 - layers_share) * MERGED_RENDERED;
-    let (mut planes, has_alpha, translucent) =
-        crate::with_span(ctl, layers_share, merged_end, |ctl| merged_planes(doc, &fmt, cmyk_of(&fmt), opts.merged_matte, ctl));
-    if !has_alpha && translucent && opts.merged_matte {
-        planes = merged_planes(doc, &fmt, cmyk_of(&fmt), false, &Interrupt::cancel_only(&|| ctl.cancelled())).0;
-    }
+    // Without Maximize Compatibility the merged image is a white placeholder and the composite
+    // isn't rendered at all. A document without layer records keeps the real image: its pixels
+    // live nowhere else.
+    let real_merged = opts.maximize_compatibility || ex.records.is_empty();
+    let (mut planes, has_alpha) = if real_merged {
+        // Merged composite, rendered and encoded in bands (no full-size float composite). Matting
+        // against white only changes pixels with alpha < 1; if some are slightly translucent but
+        // all round to opaque (so no alpha channel is written), encode once more without the matte.
+        let merged_end = layers_share + (1.0 - layers_share) * MERGED_RENDERED;
+        let (mut planes, has_alpha, translucent) =
+            crate::with_span(ctl, layers_share, merged_end, |ctl| merged_planes(doc, &fmt, cmyk_of(&fmt), opts.merged_matte, ctl));
+        if !has_alpha && translucent && opts.merged_matte {
+            planes = merged_planes(doc, &fmt, cmyk_of(&fmt), false, &Interrupt::cancel_only(&|| ctl.cancelled())).0;
+        }
+        (planes, has_alpha)
+    } else {
+        (placeholder_planes(doc, &fmt), false)
+    };
     let n = doc.size.area() as usize;
     if !has_alpha {
         planes.truncate(cc * n * sample.bytes());
@@ -1435,53 +1647,19 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
         resources.push(ImageResource::new(1032, guides_resource(doc)));
     }
     if !extra.is_empty() {
-        let names: Vec<&str> = extra.iter().map(|a| a.name.as_str()).collect();
+        // One entry per extra channel, the merged transparency included (as in every file
+        // Photoshop opens; one short, Photoshop refuses the file with "unexpected end-of-file").
+        let names: Vec<&str> = has_alpha.then_some("Transparency").into_iter().chain(extra.iter().map(|a| a.name.as_str())).collect();
         resources.push(ImageResource::new(1006, pascal_names_resource(&names)));
         resources.push(ImageResource::new(1045, unicode_names_resource(&names)));
-        resources.push(ImageResource::new(crate::channel_map::DISPLAY_INFO, crate::channel_map::display_info(&extra)));
+        resources.push(ImageResource::new(crate::channel_map::DISPLAY_INFO, crate::channel_map::display_info(&extra, has_alpha)));
     }
     if let Some(id) = quick_mask_id {
         let mut data = id.to_be_bytes().to_vec();
         data.push(0);
         resources.push(ImageResource::new(crate::channel_map::QUICK_MASK_INFO, data));
     }
-    // Paths: saved paths (2000+), the work path (1025), the clipping path name (2999).
-    {
-        use crate::vector_map::{CLIPPING_PATH, WORK_PATH, path_from_resource, path_to_records};
-        let (w, h) = (doc.size.width, doc.size.height);
-        let max = (*crate::vector_map::SAVED_PATHS.end() - *crate::vector_map::SAVED_PATHS.start() + 1) as usize;
-        if doc.paths.len() > max {
-            ex.warnings.push(format!("only {max} saved paths fit in PSD; the rest were dropped"));
-        }
-        for (i, p) in doc.paths.iter().take(max).enumerate() {
-            let data = match &p.psd_raw {
-                Some(r) if path_from_resource(r, w, h).as_ref() == Some(&p.path) => r.to_vec(),
-                _ => path_to_records(&p.path, w, h).to_bytes(),
-            };
-            let mut r = ImageResource::new(crate::vector_map::SAVED_PATHS.start() + i as u16, data);
-            r.name = legacy_name(&p.name);
-            resources.push(r);
-        }
-        if let Some(wp) = &doc.work_path {
-            resources.push(ImageResource::new(WORK_PATH, path_to_records(wp, w, h).to_bytes()));
-        }
-        let raw_clip = doc.metadata.psd_resources.iter().find(|(id, _, _)| *id == CLIPPING_PATH);
-        let raw_name = raw_clip.map(|(_, _, d)| {
-            let n = usize::from(d.first().copied().unwrap_or(0));
-            d.get(1..1 + n).map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default()
-        });
-        if let Some(c) = &doc.clipping_path
-            && raw_name.as_deref() != Some(c.name.as_str())
-        {
-            // Pascal name, then flatness as 16.16 fixed (best effort; see vector_map docs).
-            let mut data = vec![0u8];
-            let name = legacy_name(&c.name);
-            data[0] = name.len() as u8;
-            data.extend_from_slice(&name);
-            data.extend_from_slice(&((c.flatness.max(0.0) * 65536.0) as u32).to_be_bytes());
-            resources.push(ImageResource::new(CLIPPING_PATH, data));
-        }
-    }
+    resources.extend(path_resources(doc, &mut ex.warnings));
     if let Some(groups) = link_group_resource(&doc.layers) {
         resources.push(ImageResource::new(ids::LAYER_GROUP_INFO, groups));
     }
@@ -1526,13 +1704,7 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
         if !ex.records.is_empty() && matches!(&key, b"Lr16" | b"Lr32" | b"Layr") {
             continue;
         }
-        let mut tb = TaggedBlock::new(key, data.to_vec());
-        tb.signature = sig;
-        // Photoshop pads document-level (global) blocks to a multiple of 4, and readers such as
-        // psd-tools step to the next block that way: an even pad after `CAI ` (77 bytes)
-        // misaligned every block after it (#200).
-        tb.padding = Some(vec![0; (4 - data.len() % 4) % 4]);
-        global_blocks.push(tb);
+        global_blocks.push(global_block(block_signature(sig, version), key, &data));
     }
     if let Some(txt2) = txt2 {
         let mut tb = TaggedBlock::new(*b"Txt2", txt2.clone());
@@ -1554,18 +1726,9 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
         if *id == crate::slices_map::SLICES && slices_resource.is_some() {
             continue;
         }
-        // Measurement scale / count resources: only while they still describe the document.
-        if !crate::annotations_map::keep_resource(doc, *id) {
+        if !keep_imported_resource(doc, *id, data) {
             continue;
         }
-        // A preserved clipping-path resource is only valid while it names the current one.
-        if *id == crate::vector_map::CLIPPING_PATH {
-            let n = usize::from(data.first().copied().unwrap_or(0));
-            let raw_name = data.get(1..1 + n).map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default();
-            if doc.clipping_path.as_ref().is_none_or(|c| c.name != raw_name) {
-                continue;
-            }
-        }
         let mut r = ImageResource::new(*id, data.to_vec());
         r.name = legacy_name(name);
         resources.push(r);
@@ -1579,7 +1742,7 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
     if let Some(Some(data)) = slices_resource {
         resources.push(ImageResource::new(crate::slices_map::SLICES, data));
     }
-    resources.push(version_info_resource(true));
+    resources.push(version_info_resource(real_merged));
 
     let has_layers = !ex.records.is_empty();
     let placement = match (has_layers, sample) {
@@ -1592,7 +1755,11 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
     if let Some(info) = &mut layer_info {
         // Photoshop pads the layer info to 4 bytes (an even pad misaligns readers after a global
         // `Lr16`/`Lr32` block, #200). A length that cannot be computed keeps the even default.
-        if info.pad_to(version, 4).is_err() {
+        // A global block's length is the exact data length and its padding to 4 follows the block:
+        // readers that check that length exactly (Unity's PSD Importer) reject it otherwise (#4654).
+        if matches!(placement, LayerInfoPlacement::GlobalBlock { .. }) {
+            info.padding = Some(Vec::new());
+        } else if info.pad_to(version, 4).is_err() {
             info.padding = None;
         }
     }
@@ -1635,6 +1802,68 @@ mod tests {
         Document::new("size estimate", photocraft_geom::Size::new(width, height), ColorMode::Rgb, SampleType::U8)
     }
 
+    /// Photoshop opens a PSD's bottom layer as its Background only when that layer has no
+    /// transparency channel (measured on Photoshop 27.11: with the channel written, re-exported
+    /// files reopened with the Background as an ordinary layer).
+    #[test]
+    fn a_background_is_written_without_a_transparency_channel() {
+        use photocraft_color::Color;
+        let size = photocraft_geom::Size::new(8, 6);
+        let mut doc = Document::with_background("bg", size, ColorMode::Rgb, SampleType::U8, Color::rgb(0.2, 0.4, 0.6));
+        doc.layers.push(Layer::raster("Layer 1", doc.pixel_format()));
+        let file = document_to_psd(&doc);
+        let layers = &file.layer_info.as_ref().unwrap().layers;
+        let ids = |i: usize| layers[i].channels.iter().map(|c| c.id).collect::<Vec<_>>();
+        assert_eq!(ids(0), vec![0, 1, 2], "the Background has no -1 channel");
+        assert_eq!(layers[0].flags.0, LayerFlags::BIT4_USEFUL | LayerFlags::TRANSPARENCY_PROTECTED, "as Photoshop writes it");
+        assert!(ids(1).contains(&-1), "other layers keep their transparency");
+        // It comes back as the same locked, opaque Background.
+        let back = crate::import("bg.psd", &file.to_bytes().unwrap()).unwrap().document;
+        let bg = &back.layers[0];
+        assert!(bg.locks.transparency && bg.locks.position, "{:?}", bg.locks);
+        assert_eq!(bg.surface().unwrap().read_region(back.bounds()), doc.layers[0].surface().unwrap().read_region(doc.bounds()));
+        // A bottom layer with transparency (or unlocked) is not a Background.
+        let mut holey = doc.clone();
+        holey.layers[0].surface_mut().unwrap().write_pixel(2, 2, &[0.0, 0.0, 0.0, 0.0]);
+        assert!(document_to_psd(&holey).layer_info.unwrap().layers[0].channels.iter().any(|c| c.id == -1));
+        let mut unlocked = doc.clone();
+        unlocked.layers[0].locks.position = false;
+        assert!(document_to_psd(&unlocked).layer_info.unwrap().layers[0].channels.iter().any(|c| c.id == -1));
+    }
+
+    /// A flat 1-bit Bitmap file (no layers) opens in Photoshop as its Background; so does it in
+    /// PhotoCraft, and it is written back as one (no transparency channel).
+    #[test]
+    fn a_flat_bitmap_file_opens_and_saves_as_a_background() {
+        let file = photocraft_psd::testgen::merged_only(Version::Psd, PsdMode::Bitmap, 1, Compression::Raw, 8, 4);
+        let doc = crate::import("flat.psd", &file.to_bytes().unwrap()).unwrap().document;
+        let bg = &doc.layers[0];
+        assert!(bg.name == "Background" && bg.locks.transparency && bg.locks.position, "{:?}", bg.locks);
+        let out = document_to_psd(&doc);
+        assert!(out.layer_info.unwrap().layers[0].channels.iter().all(|c| c.id >= 0));
+    }
+
+    #[test]
+    fn group_divider_id_wraps_without_colliding_with_imported_layer_ids() {
+        let mut doc = document(8, 8);
+        let mut group = Layer::group("Imported group", vec![Layer::raster("Child", doc.pixel_format())]);
+        group.psd_id = Some(u32::MAX);
+        doc.layers.push(group);
+
+        let file = document_to_psd(&doc);
+        let ids: Vec<u32> = file.layers().iter().filter_map(|layer| layer.layer_id()).collect();
+        let unique: std::collections::HashSet<u32> = ids.iter().copied().collect();
+        assert_eq!(ids.len(), 3, "group, child and closing divider");
+        assert_eq!(unique.len(), ids.len(), "no generated ID may collide");
+        assert!(unique.contains(&u32::MAX), "preserve the imported group ID");
+        assert!(unique.contains(&1), "reuse the first unused positive ID on wrap");
+
+        let encoded = file.to_bytes().unwrap();
+        let parsed = PsdFile::from_bytes(&encoded).unwrap();
+        let reloaded_ids: std::collections::HashSet<u32> = parsed.layers().iter().filter_map(|layer| layer.layer_id()).collect();
+        assert_eq!(unique, reloaded_ids);
+    }
+
     #[test]
     fn unreadable_lr16_warns_on_import_and_is_not_saved_twice() {
         // #2700: a 16-bit file whose Lr16 block claims five layers but holds none.
@@ -1690,6 +1919,36 @@ mod tests {
         assert_phfl(&PsdFile::from_bytes(&repaired_bytes).unwrap());
     }
 
+    #[test]
+    fn photo_filter_version_3_is_kept_until_edited() {
+        // The #3777 block (Photoshop CS2, XYZ colour): saved back byte-exact while unchanged.
+        let v3 = vec![0, 3, 0, 0, 0x5e, 0x7f, 0, 0, 0x61, 0xaa, 0, 0, 0x0e, 0xf3, 0, 0, 0, 0x3f, 1, 0];
+        let adjustment = crate::adjust_map::parse(b"phfl", &v3, None, crate::adjust_map::Channels::Rgb);
+        let photocraft_doc::Adjustment::PhotoFilter { color, .. } = adjustment else { panic!("{adjustment:?}") };
+        let mut doc =
+            Document::with_background("Photo Filter v3", photocraft_geom::Size::new(8, 8), ColorMode::Rgb, SampleType::U8, photocraft_doc::Color::WHITE);
+        let mut layer = Layer::new("Photo Filter 1", LayerContent::Adjustment(adjustment.clone()));
+        layer.psd_blocks = vec![(*b"phfl", std::sync::Arc::new(v3.clone()))];
+        doc.layers.push(layer);
+        let phfl = |doc: &Document| {
+            let file = PsdFile::from_bytes(&document_to_psd(doc).to_bytes().unwrap()).unwrap();
+            let records = &file.layer_info.as_ref().unwrap().layers;
+            records.iter().flat_map(|r| r.blocks.iter()).find(|b| b.key == *b"phfl").map(|b| b.data.clone()).expect("Photo Filter adjustment data")
+        };
+        assert_eq!(phfl(&doc), v3);
+        // Once edited it is written as version 2 (RGB), and the colour survives.
+        let edited = photocraft_doc::Adjustment::PhotoFilter { color, density: 0.5, preserve_luminosity: true };
+        if let Some(l) = doc.layers.last_mut() {
+            l.content = LayerContent::Adjustment(edited.clone());
+        }
+        let saved = phfl(&doc);
+        assert_eq!(&saved[..2], &[0, 2]);
+        let reread = crate::adjust_map::parse(b"phfl", &saved, None, crate::adjust_map::Channels::Rgb);
+        let photocraft_doc::Adjustment::PhotoFilter { color: back, density, .. } = reread else { panic!("{reread:?}") };
+        assert!(back.iter().zip(color).all(|(b, c)| (b - c).abs() <= 1.0 / 65535.0), "{back:?} vs {color:?}");
+        assert_eq!(density, 0.5);
+    }
+
     #[test]
     fn size_limit_boundary_keeps_limit_and_switches_above_it() {
         assert!(!exceeds_psd_size_limit(Some(PSD_MAX_FILE_SIZE)));
@@ -1717,4 +1976,53 @@ mod tests {
         assert_eq!(psd_version(&small, false, small_size_exceeds_limit), Version::Psd);
         assert_eq!(psd_version(&small, true, small_size_exceeds_limit), Version::Psb);
     }
+    #[test]
+    fn kept_psb_blocks_are_written_as_8bim_in_a_psd() {
+        // Photoshop 27.11 refuses a PSD holding `8B64` blocks ("not compatible with this
+        // version"); they came from re-saving a PSB as PSD with its global FMsk and cinf kept.
+        let mut doc = document(4, 4);
+        doc.metadata.psd_global_blocks = vec![
+            (*b"8B64", *b"FMsk", std::sync::Arc::new(vec![0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50])),
+            (*b"8BIM", *b"Patt", std::sync::Arc::new(Vec::new())),
+        ];
+        let signatures = |force_psb| {
+            let opts = PsdExportOptions { force_psb, ..PsdExportOptions::default() };
+            let bytes = document_to_psd_with(&doc, &opts).0.to_bytes().unwrap();
+            let file = PsdFile::from_bytes(&bytes).unwrap();
+            file.global_blocks.iter().map(|b| (b.signature, b.key)).collect::<Vec<_>>()
+        };
+        assert_eq!(signatures(false), vec![(*b"8BIM", *b"FMsk"), (*b"8BIM", *b"Patt")]);
+        assert_eq!(signatures(true), vec![(*b"8B64", *b"FMsk"), (*b"8BIM", *b"Patt")], "a PSB keeps 8B64");
+    }
+
+    /// A layered document with transparency in the merged image and an alpha channel: the name
+    /// and DisplayInfo resources hold one entry per extra channel, the merged transparency first,
+    /// as in every file Photoshop opens (one short, Photoshop 27.11 refused the file with "Could
+    /// not import the clipboard because an unexpected end-of-file was encountered"). The alpha
+    /// channel keeps its own name and options on the way back.
+    #[test]
+    fn alpha_names_count_the_merged_transparency() {
+        let mut doc = document(8, 6);
+        let mut layer = Layer::raster("Layer 1", doc.pixel_format());
+        layer.surface_mut().unwrap().write_pixel(1, 1, &[1.0, 0.0, 0.0, 1.0]);
+        doc.layers.push(layer);
+        let mut a = photocraft_doc::AlphaChannel::new("Alpha 1", photocraft_raster::Surface::new(PixelFormat::GRAY8));
+        a.opacity = 0.5;
+        doc.channels.push(a);
+        let file = document_to_psd(&doc);
+        let header_extra = usize::from(file.header.channels) - 3;
+        let names = |id| file.resources.iter().find(|r| r.id == id).map(|r| r.data.clone()).unwrap();
+        let pascal = names(1006);
+        let (mut count, mut i) = (0, 0);
+        while i < pascal.len() {
+            count += 1;
+            i += 1 + usize::from(pascal[i]);
+        }
+        assert_eq!((header_extra, count), (2, 2), "transparency + Alpha 1");
+        assert_eq!(names(crate::channel_map::DISPLAY_INFO).len(), 4 + 2 * 13);
+        let back = crate::import("a.psd", &file.to_bytes().unwrap()).unwrap().document;
+        assert_eq!(back.channels.len(), 1);
+        assert_eq!(back.channels[0].name, "Alpha 1");
+        assert!((back.channels[0].opacity - 0.5).abs() < 1e-6);
+    }
 }
diff --git a/crates/io/src/psd_import.rs b/crates/io/src/psd_import.rs
index da483c04d3..444c2d6e5b 100644
--- a/crates/io/src/psd_import.rs
+++ b/crates/io/src/psd_import.rs
@@ -59,6 +59,8 @@ pub(crate) struct Ctx<'a> {
     pub filter_effects: Vec<photocraft_psd::filter_effects::FilterEffectsItem>,
     /// Placed layers naming the same source share editable contents, not their placement.
     pub smart_contents: std::collections::HashMap<String, SmartContentsId>,
+    /// Source sizes of `PlLd`-only placed layers, by source id (read once per embedded file).
+    pub plld_sizes: std::collections::HashMap<String, Option<(f64, f64)>>,
     /// Cancellation and progress for background opens (checked per layer record).
     pub ctl: photocraft_raster::Interrupt<'a>,
     /// Layer records decoded so far, out of `total` (progress).
@@ -105,11 +107,51 @@ fn soft_shape_fill(rec: &LayerRecord, has_vector: bool, fill_key: Option<&[u8; 4
     (soft || pattern).then_some((fill, soft))
 }
 
+/// Where a placed layer's source goes: read from `SoLd`/`SoLE`, or from a CS2 `PlLd` record.
+/// An empty `id` leaves the contents unavailable (the stored pixels stay the rendering).
+#[derive(Default)]
+struct Placement {
+    id: String,
+    transform: photocraft_geom::Affine,
+    perspective: Option<[f64; 9]>,
+    warp: Option<photocraft_geom::warp::Warp>,
+}
+
 impl Ctx<'_> {
     fn warn(&mut self, s: impl Into<String>) {
         self.warnings.push(s.into());
     }
 
+    /// Source id, transform, (Distort/Perspective) projective placement and warp of a placed
+    /// layer that has only a `PlLd` block, as Photoshop CS2 and older write it (#2465). `PlLd`
+    /// stores the placed corners but not the source size, which comes from the embedded file.
+    fn plld_placement(&mut self, data: &[u8], name: &str) -> Placement {
+        let Some((id, p)) = blocks::parse_plld(data) else {
+            self.warn(format!("layer \"{name}\": its placed-layer data (PlLd) could not be read; the smart object's contents are unavailable"));
+            return Placement::default();
+        };
+        let warp = match blocks::parse_plld_warp(data) {
+            blocks::PlldWarp::None => None,
+            blocks::PlldWarp::Warp(w) => Some(w),
+            blocks::PlldWarp::Unreadable => {
+                // Re-rendering from the source would unwarp the layer: keep it as saved (its
+                // warped pixels), as before PlLd was read.
+                self.warn(format!(
+                    "layer \"{name}\": its smart object warp (PlLd) could not be read; the layer keeps its warped pixels but its contents are unavailable"
+                ));
+                return Placement::default();
+            }
+        };
+        let (file, ctl) = (self.file, self.ctl);
+        let size = *self
+            .plld_sizes
+            .entry(id.clone())
+            .or_insert_with(|| crate::linked::source_size_in_blocks(file.global_blocks.iter().map(|b| (&b.key, b.data.as_slice())), &id, &ctl));
+        // Without the source (missing or unreadable), it is taken as placed at 100 %.
+        let (transform, perspective) = blocks::plld_transform(&p, size, warp.as_ref());
+        Placement { id, transform, perspective, warp }
+    }
+
     fn channel_plane(&mut self, rec: &LayerRecord, id: i16, name: &str) -> Option<Vec<u8>> {
         rec.channel(id)?;
         match rec.decode_channel(id, self.file.header.depth, self.file.header.version) {
@@ -121,6 +163,13 @@ impl Ctx<'_> {
         }
     }
 
+    /// [`Self::channel_plane`] without the warnings sink, so a layer's channels decode
+    /// concurrently (their RLE rows are the bulk of the open time on full-canvas layers).
+    fn channel_plane_decoded(&self, rec: &LayerRecord, id: i16) -> Option<Vec<u8>> {
+        rec.channel(id)?;
+        rec.decode_channel(id, self.file.header.depth, self.file.header.version).ok()
+    }
+
     fn record_surface(&mut self, rec: &LayerRecord, name: &str) -> Surface {
         let r = rec.rect;
         if r.is_empty() || r.size().is_err() {
@@ -128,15 +177,28 @@ impl Ctx<'_> {
         }
         let (w, h) = r.size().unwrap_or((0, 0));
         let s = self.fmt.sample;
-        let mut planes = Vec::with_capacity(self.cc + 1);
-        for c in 0..self.cc {
-            planes.push(self.channel_plane(rec, c as i16, name));
-        }
-        planes.push(self.channel_plane(rec, CHANNEL_TRANSPARENCY, name));
+        let ids: Vec<i16> = (0..self.cc as i16).chain([CHANNEL_TRANSPARENCY]).collect();
+        let planes: Vec<Option<Vec<u8>>> = if cfg!(target_arch = "wasm32") {
+            ids.iter().map(|&id| self.channel_plane(rec, id, name)).collect()
+        } else {
+            // The channels decode independently; their RLE rows are the bulk of the open
+            // time for full-canvas layers, so they run side by side and the warnings land
+            // in the same order afterwards.
+            // par_map reuses the crate's worker pool (one OS thread per channel per layer
+            // would spawn thousands on a file with many layers).
+            let decoded: Vec<Option<Vec<u8>>> = crate::pixels::par_map(ids.to_vec(), |id| self.channel_plane_decoded(rec, id));
+            let mut planes: Vec<Option<Vec<u8>>> = Vec::with_capacity(decoded.len());
+            for (&id, p) in ids.iter().zip(decoded) {
+                if p.is_none() && rec.channel(id).is_some() {
+                    self.warn(format!("layer \"{name}\": channel {id} could not be decoded; treated as empty"));
+                }
+                planes.push(p);
+            }
+            planes
+        };
         // A channel that is in the file but could not be decoded leaves the layer empty, as the
         // warning says. Filling in for it would paint an opaque black layer over the document.
-        let ids = (0..self.cc as i16).chain([CHANNEL_TRANSPARENCY]);
-        if ids.zip(&planes).any(|(id, p)| p.is_none() && rec.channel(id).is_some()) {
+        if ids.iter().zip(planes.iter()).any(|(&id, p)| p.is_none() && rec.channel(id).is_some()) {
             return Surface::new(self.fmt);
         }
         // Only decoded channel data justifies a buffer: the decoders bound their output by the
@@ -267,7 +329,8 @@ impl Ctx<'_> {
         let fill_key = [b"SoCo", b"GdFl", b"PtFl"].into_iter().find(|k| rec.block(k).is_some());
         let vector_key = [b"vsms", b"vmsk"].into_iter().find(|k| rec.block(k).is_some());
         let adj_key = ADJUSTMENT_KEYS.into_iter().find(|k| rec.block(k).is_some());
-        let smart_key = [b"SoLd", b"PlLd", b"SoLE"].into_iter().find(|k| rec.block(k).is_some());
+        // `SoLE` (a linked smart object) before `PlLd`: a `PlLd` alone is Photoshop CS2's record.
+        let smart_key = [b"SoLd", b"SoLE", b"PlLd"].into_iter().find(|k| rec.block(k).is_some());
         let blocks = preserved_blocks(rec);
         // `psd_raw` shares the Arc of the matching `psd_blocks` entry.
         let principal = |k: &[u8; 4]| blocks.iter().find(|(bk, _)| bk == k).map(|(_, d)| d.clone());
@@ -307,6 +370,7 @@ impl Ctx<'_> {
             });
             if let Some(txt2) = &self.txt2 {
                 photocraft_text::psd::apply_txt2(&mut t, &data, txt2);
+                photocraft_text::psd::apply_txt2_frame(&mut t, &data, txt2);
             }
             // Photoshop's pixels are the cache only when the file has some: ag-psd, GIMP and
             // other writers leave type layers without image data (Photoshop re-renders them on
@@ -320,7 +384,16 @@ impl Ctx<'_> {
             t.psd_raw = principal(b"TySh");
             LayerContent::Text(t)
         } else if let Some(k) = smart_key {
-            let (id, transform) = rec.block(k).map(|b| blocks::parse_smart(k, &b.data)).unwrap_or_default();
+            let Placement { id, transform, perspective, warp } = match rec.block(k) {
+                Some(b) if k == b"PlLd" => self.plld_placement(&b.data, &name),
+                Some(b) => {
+                    let (id, transform) = blocks::parse_smart(k, &b.data);
+                    // Distort / Perspective: the fourth corner (the affine `transform` drops it).
+                    let perspective = blocks::parse_smart_perspective(k, &b.data);
+                    Placement { id, transform, perspective, warp: blocks::parse_placed_warp(k, &b.data) }
+                }
+                None => Placement::default(),
+            };
             let contents_id =
                 if id.is_empty() { SmartContentsId::fresh() } else { *self.smart_contents.entry(id.clone()).or_insert_with(SmartContentsId::fresh) };
             // Smart filters (`filterFX` in the placed-layer data) and their mask (`FEid`).
@@ -339,10 +412,9 @@ impl Ctx<'_> {
                 psd_raw: principal(k),
                 filters_enabled: stack.enabled,
                 filter_mask,
-                warp: rec.block(k).and_then(|b| blocks::parse_placed_warp(k, &b.data)),
+                warp,
                 stack_mode: None,
-                // Distort / Perspective: the fourth corner (the affine `transform` drops it).
-                perspective: rec.block(k).and_then(|b| blocks::parse_smart_perspective(k, &b.data)),
+                perspective,
             })
         } else if let Some((f, soft)) = soft_shape_fill(rec, vector_key.is_some(), fill_key) {
             // A shape whose vector mask has a density or feather is a fill layer seen through a
@@ -547,6 +619,35 @@ fn parse_guides(data: &[u8], doc: &mut Document) {
 }
 
 /// Converts a parsed PSD into a document. Never fails: problems become warnings.
+/// A flattened file's merged image as its layer: like Photoshop, an opaque one is the locked
+/// Background (Photoshop 27.11 opens psd-tools' flat Bitmap and Indexed files that way), so it is
+/// written back as one.
+fn flat_background(s: Surface) -> Layer {
+    let opaque = {
+        let r = s.content_bounds();
+        let n = s.channels();
+        !r.is_empty() && s.read_region(r).chunks_exact(n).all(|p| p.last().is_some_and(|a| *a >= 1.0))
+    };
+    let mut l = Layer::new("Background", LayerContent::Raster(s));
+    l.locks.transparency = opaque;
+    l.locks.position = opaque;
+    l
+}
+
+/// Photoshop opens a file's bottom layer as its Background when that layer's record has no
+/// transparency (`-1`) channel, whatever its name and lock flags say: it is then locked and shown
+/// as "Background" (measured on Photoshop 27.11 with files from psd-tools and ag-psd whose bottom
+/// layer is called "Фон", "bg" or "Layer 1" and carries no locks).
+fn mark_background(file: &PsdFile, layers: &mut [Layer]) {
+    let Some(rec) = file.layers().first() else { return };
+    let Some(bottom) = layers.first_mut() else { return };
+    let opaque_record = !rec.channels.is_empty() && rec.channels.iter().all(|c| c.id >= 0);
+    if opaque_record && matches!(bottom.content, LayerContent::Raster(_)) && !bottom.clipped {
+        bottom.locks.transparency = true;
+        bottom.locks.position = true;
+    }
+}
+
 pub fn psd_to_document(file: &PsdFile) -> (Document, Vec<String>) {
     // Never cancelled, so always `Some`; the fallback is unreachable.
     psd_to_document_with(file, &photocraft_raster::Interrupt::NONE)
@@ -649,6 +750,7 @@ pub fn psd_to_document_with(file: &PsdFile, ctl: &photocraft_raster::Interrupt)
         txt2: file.global_blocks.iter().find(|b| &b.key == b"Txt2").and_then(|b| photocraft_text::psd::parse_txt2(&b.data)),
         filter_effects: Vec::new(),
         smart_contents: Default::default(),
+        plld_sizes: Default::default(),
         ctl: *ctl,
         done: 0,
         total: file.layers().len(),
@@ -702,7 +804,14 @@ pub fn psd_to_document_with(file: &PsdFile, ctl: &photocraft_raster::Interrupt)
         // Capped like `build` (#2940): a group past the document's nesting cap keeps no children,
         // so no file can make this tree, or anything walking or dropping it, recurse deeper.
         let tree = file.layer_tree_max_depth(photocraft_doc::MAX_GROUP_DEPTH);
-        doc.layers = cx.build(&tree, 0);
+        // Colours stored in the document's CMYK space (Gradient Map stops…) convert through
+        // its own profile, as the compositor and the PSD writer read them.
+        let space = photocraft_compose::cmyk_space(&doc);
+        doc.layers = photocraft_color::convert::with_cmyk_space(space.as_ref(), || cx.build(&tree, 0));
+        // Photoshop's Background: the bottom record stored without a transparency channel (-1),
+        // locked whatever its (localized) name and whether or not the file carries an `lspf`
+        // block. Its name is kept.
+        mark_background(file, &mut doc.layers);
         // Layer › Link Layers: resource 1026 holds one group id per layer record (0 = unlinked).
         if let Some(Ok(photocraft_psd::resources::ResourceData::LayerGroupInfo(groups))) =
             file.resources.iter().find(|r| r.id == ids::LAYER_GROUP_INFO).and_then(photocraft_psd::resources::ImageResource::parsed)
@@ -799,7 +908,7 @@ pub fn psd_to_document_with(file: &PsdFile, ctl: &photocraft_raster::Interrupt)
                 .collect();
             s.write_region(canvas, &vals);
             s.prune();
-            doc.layers.push(Layer::new("Background", LayerContent::Raster(s)));
+            doc.layers.push(flat_background(s));
         }
     }
 
@@ -808,6 +917,9 @@ pub fn psd_to_document_with(file: &PsdFile, ctl: &photocraft_raster::Interrupt)
         let first = cc + usize::from(file.merged_has_alpha());
         let plane = h.row_bytes() * hh;
         let names = file.resource(1045).map(|r| unicode_names(&r.data)).unwrap_or_default();
+        // Photoshop lists every extra channel, the merged transparency first when there is one.
+        let skip = usize::from(file.merged_has_alpha() && names.len() == usize::from(h.channels).saturating_sub(cc));
+        let names = names.get(skip..).unwrap_or_default();
         for (k, idx) in (first..usize::from(h.channels)).enumerate() {
             let Some(p) = all.get(idx * plane..(idx + 1) * plane) else { break };
             let mut s = Surface::new(cx.mask_fmt);
@@ -818,9 +930,9 @@ pub fn psd_to_document_with(file: &PsdFile, ctl: &photocraft_raster::Interrupt)
         }
         // Channel options (overlay colour, opacity, colour indicates) and spot inks.
         if let Some(r) = file.resource(crate::channel_map::DISPLAY_INFO) {
-            crate::channel_map::apply_display_info(&r.data, true, &mut doc.channels);
+            crate::channel_map::apply_display_info(&r.data, true, skip, &mut doc.channels);
         } else if let Some(r) = file.resource(crate::channel_map::DISPLAY_INFO_OLD) {
-            crate::channel_map::apply_display_info(&r.data, false, &mut doc.channels);
+            crate::channel_map::apply_display_info(&r.data, false, skip, &mut doc.channels);
         }
         // Saved in Quick Mask mode: that channel becomes the document's Quick Mask again.
         if let Some(r) = file.resource(crate::channel_map::QUICK_MASK_INFO)
diff --git a/crates/io/src/raw.rs b/crates/io/src/raw.rs
index 6ff2f59042..008173839b 100644
--- a/crates/io/src/raw.rs
+++ b/crates/io/src/raw.rs
@@ -14,7 +14,8 @@ use std::sync::Arc;
 
 use photocraft_cms::{Builtin, Intent, Profile, Transform};
 use photocraft_codecs::{self as codecs, ChannelLayout, Format, Image, SampleType};
-use photocraft_raw::{CameraLook, DevelopOptions, Limits, RawError, Reference, Sensor, WhiteBalance};
+use photocraft_raw::{CameraLook, DevelopOptions, Limits, PreviewColorSpace, RawError, Reference, Sensor, WhiteBalance};
+pub use photocraft_raw::{Tone, retone};
 
 use crate::flat::image_to_document;
 use crate::{ImportResult, IoError};
@@ -37,12 +38,13 @@ fn limits() -> Limits {
 fn upright_preview(raw: &[u8], jpeg: &[u8]) -> Result<Image, IoError> {
     let img = codecs::decode_as_with(Format::Jpeg, jpeg, &codecs::DecodeOptions { keep_orientation: true, ..Default::default() })?;
     let own = img.meta.exif.as_deref().map_or(1, codecs::exif_orientation);
-    let o = if own != 1 { own } else { codecs::exif_orientation(raw) };
+    let o = if own != 1 { own } else { photocraft_raw::orientation(raw).unwrap_or_else(|| codecs::exif_orientation(raw)) };
     Ok(img.oriented(o)?)
 }
 
-/// Camera Raw's Temperature, Tint and Exposure, applied while developing the sensor data
-/// (the open-time Camera Raw dialog) instead of to the developed RGB pixels.
+/// Camera Raw's Temperature, Tint, Exposure, Shadows, Highlights, Clarity, Texture and Dehaze,
+/// applied while developing the sensor data (the open-time Camera Raw dialog) instead of to the
+/// developed RGB pixels.
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct RawTuning {
     /// −100…100, as `photocraft_algo::camera_raw::CameraRaw::temperature`.
@@ -51,11 +53,23 @@ pub struct RawTuning {
     pub tint: f32,
     /// EV, as `CameraRaw::exposure`.
     pub exposure: f32,
+    /// −100…100, as `CameraRaw::shadows`: in linear light before the tone curve, as Camera Raw
+    /// does for raw files ([`photocraft_raw::Tone`]).
+    pub shadows: f32,
+    /// −100…100, as `CameraRaw::highlights`.
+    pub highlights: f32,
+    /// −100…100, as `CameraRaw::clarity`.
+    pub clarity: f32,
+    /// −100…100, as `CameraRaw::texture`.
+    pub texture: f32,
+    /// −100…100, as `CameraRaw::dehaze`.
+    pub dehaze: f32,
 }
 
 /// Develops a raw file with `tuning` applied at the raw stage: Exposure as develop exposure,
-/// Temperature / Tint as gains on the camera's as-shot white-balance multipliers (the same
-/// gains the Camera Raw filter applies to RGB). The second value is `false` when the file has
+/// Shadows, Highlights, Clarity, Texture and Dehaze in linear light before the tone curve, Temperature / Tint as gains on the
+/// camera's as-shot white-balance multipliers (the same gains the Camera Raw filter applies to
+/// RGB). The second value is `false` when the file has
 /// no as-shot white balance: Temperature / Tint were then not applied, and the caller keeps
 /// them as RGB adjustments.
 pub fn import_raw_tuned(name: &str, bytes: &[u8], tuning: &RawTuning) -> Result<(ImportResult, bool), IoError> {
@@ -65,13 +79,18 @@ pub fn import_raw_tuned(name: &str, bytes: &[u8], tuning: &RawTuning) -> Result<
         return Err(IoError::Raw(RawError::Malformed(format!("exposure {} EV is out of range", tuning.exposure))));
     }
     let sensor = photocraft_raw::decode(bytes, &limits()).map_err(IoError::Raw)?;
-    let mut opts = DevelopOptions { limits: limits(), ..Default::default() };
-    // Use the same camera rendering as normal import. Fit at the camera's default WB and
-    // exposure before applying user controls, so the fit cannot cancel their adjustments.
-    if sensor.color.calibrations.is_empty() {
-        opts.camera_look = fit_preview_look(bytes, &sensor, &opts).ok();
-    }
-    opts.exposure = exposure;
+    let slider = |v: f32| if v.is_finite() { v.clamp(-100.0, 100.0) } else { 0.0 };
+    let tone = photocraft_raw::Tone {
+        shadows: slider(tuning.shadows),
+        highlights: slider(tuning.highlights),
+        clarity: slider(tuning.clarity),
+        texture: slider(tuning.texture),
+        dehaze: slider(tuning.dehaze),
+    };
+    // The colour rendering the default open used (a look fitted to the camera's JPEG for files
+    // without colour calibration), so re-developing changes only what the sliders change.
+    let camera_look = default_look(bytes, &sensor);
+    let mut opts = DevelopOptions { limits: limits(), exposure, tone, camera_look, ..Default::default() };
     let wb_applied = match sensor.camera_wb {
         Some(m) => {
             let g = wb_gains(tuning.temperature, tuning.tint);
@@ -86,10 +105,45 @@ pub fn import_raw_tuned(name: &str, bytes: &[u8], tuning: &RawTuning) -> Result<
     } else {
         "estimated white balance".into()
     };
-    let summary = format!("developed in Camera Raw (exposure {:+.2} EV, {wb})", tuning.exposure);
+    let tone = [("shadows", tone.shadows), ("highlights", tone.highlights), ("clarity", tone.clarity), ("texture", tone.texture), ("dehaze", tone.dehaze)]
+        .iter()
+        .filter(|(_, v)| *v != 0.0)
+        .map(|(k, v)| format!(", {k} {v:+.0}"))
+        .collect::<String>();
+    let summary = format!("developed in Camera Raw (exposure {:+.2} EV{tone}, {wb})", tuning.exposure);
     Ok((developed_document(name, format, dev, &summary)?, wb_applied))
 }
 
+/// The tone curve `bytes` develop with by default: the fitted look's for a file without colour
+/// calibration (see [`import_raw_with`]), else the camera profile's (empty: none, or not a raw
+/// this crate decodes). For previews of the open-time raw-stage sliders
+/// ([`photocraft_raw::retone`]), in linear-light knots.
+pub fn tone_curve(bytes: &[u8]) -> Vec<[f32; 2]> {
+    let Ok(sensor) = photocraft_raw::decode(bytes, &limits()) else { return Vec::new() };
+    match default_look(bytes, &sensor) {
+        Some(look) => look.tone.as_ref().map(look_knots).unwrap_or_default(),
+        None => sensor.tone_curve,
+    }
+}
+
+/// A fitted look's tone curve as knots for [`photocraft_raw::retone`] (which reads them
+/// log-linearly): sampled densely enough that the two agree within a fraction of a code value.
+fn look_knots(t: &photocraft_raw::ToneCurve) -> Vec<[f32; 2]> {
+    const N: usize = 256;
+    (1..=N).map(|i| (i as f64 / N as f64).powi(2)).map(|x| [x as f32, t.eval(x) as f32]).collect()
+}
+
+/// The look a default open develops `bytes` with: fitted to the embedded JPEG when the file has
+/// no colour calibration, is not monochrome and the fit clearly helps (as [`import_raw_with`]
+/// does), else `None`. It is fitted at the camera's own white balance and exposure, so a
+/// re-develop's sliders are not fitted away.
+fn default_look(bytes: &[u8], sensor: &Sensor) -> Option<CameraLook> {
+    if !sensor.color.calibrations.is_empty() || sensor.is_monochrome() {
+        return None;
+    }
+    fit_preview_look(bytes, sensor, &DevelopOptions { limits: limits(), ..Default::default() }).ok()
+}
+
 /// "Canon" + "Canon EOS 80D" and "NIKON CORPORATION" + "NIKON D3200" read as the model alone:
 /// the model already starts with the make's first word.
 fn camera_name(make: Option<&str>, model: Option<&str>) -> String {
@@ -133,10 +187,23 @@ pub fn import_raw(name: &str, bytes: &[u8]) -> Result<ImportResult, IoError> {
 /// the fit grid is at most `PROXY_EDGE` cells and wants about two pixels per cell).
 const FIT_PREVIEW_EDGE: u32 = 2 * photocraft_raw::PROXY_EDGE as u32;
 
+/// The colour space of a raw's decoded preview when it is not sRGB: its own ICC profile, else the
+/// one the raw's EXIF states (a Sony body set to Adobe RGB writes no profile into the JPEG).
+/// `None` means sRGB.
+fn preview_profile(raw: &[u8], icc: Option<&[u8]>) -> Result<Option<Cow<'static, Profile>>, String> {
+    let src = match icc {
+        Some(icc) => Cow::Owned(Profile::parse(icc).map_err(|e| format!("the preview's ICC profile does not parse: {e}"))?),
+        None if photocraft_raw::embedded_preview_color_space(raw) == Some(PreviewColorSpace::AdobeRgb) => Cow::Borrowed(Builtin::AdobeRgbCompat.profile()),
+        None => return Ok(None),
+    };
+    Ok((!src.same_colors(Builtin::Srgb.profile())).then_some(src))
+}
+
 /// Fits the colour of a decoded raw to the camera's embedded JPEG (see
 /// [`photocraft_raw::fit_look`]): picks the smallest preview at least
 /// `FIT_PREVIEW_EDGE` pixels long (else the largest), decodes it, turns it upright and
-/// converts it to sRGB when it carries another ICC profile. `Err` says why there is no fit.
+/// converts it to sRGB when it is in another colour space ([`preview_profile`]). `Err` says
+/// why there is no fit.
 pub fn fit_preview_look(raw: &[u8], sensor: &Sensor, opts: &DevelopOptions) -> Result<CameraLook, String> {
     let previews = photocraft_raw::embedded_previews(raw);
     let long = |p: &photocraft_raw::Preview| p.width.max(p.height);
@@ -152,15 +219,11 @@ pub fn fit_preview_look(raw: &[u8], sensor: &Sensor, opts: &DevelopOptions) -> R
     }
     let (w, h) = img.dimensions();
     let mut rgb: Cow<[u8]> = Cow::Borrowed(img.data());
-    if let Some(icc) = img.icc.as_deref() {
-        let srgb = Builtin::Srgb.profile();
-        let src = Profile::parse(icc).map_err(|e| format!("the preview's ICC profile does not parse: {e}"))?;
-        if !src.same_colors(srgb) {
-            let t = Transform::new(&src, srgb, Intent::RelativeColorimetric, false).map_err(|e| e.to_string())?;
-            let mut out = vec![0u8; rgb.len()];
-            t.convert_u8(&rgb, 3, &mut out, 3, false);
-            rgb = Cow::Owned(out);
-        }
+    if let Some(src) = preview_profile(raw, img.icc.as_deref())? {
+        let t = Transform::new(&src, Builtin::Srgb.profile(), Intent::RelativeColorimetric, false).map_err(|e| e.to_string())?;
+        let mut out = vec![0u8; rgb.len()];
+        t.convert_u8(&rgb, 3, &mut out, 3, false);
+        rgb = Cow::Owned(out);
     }
     photocraft_raw::fit_look(sensor, opts, &Reference { width: w, height: h, rgb: &rgb }).map_err(|e| e.to_string())
 }
@@ -223,4 +286,29 @@ mod tests {
         assert_eq!(camera_name(None, Some("X")), "X");
         assert_eq!(camera_name(Some("Panasonic"), Some("DC-G9")), "Panasonic DC-G9");
     }
+
+    /// A Sony body set to Adobe RGB says so only in the raw's EXIF (ColorSpace Uncalibrated, InteropIndex "R03"):
+    /// its preview, which has no ICC profile, is read as Adobe RGB for the colour fit, not as sRGB.
+    #[test]
+    fn a_preview_without_a_profile_takes_the_raws_exif_colour_space() {
+        use photocraft_raw::testgen::{TiffBuilder, Val};
+        let raw = |color_space: u16, index: &str| {
+            let mut t = TiffBuilder::default();
+            let interop = t.ifd(vec![(0x0001, Val::Ascii(index.into()))]);
+            let exif = t.ifd(vec![(0xA001, Val::Short(vec![color_space])), (0xA005, Val::Ifds(vec![interop]))]);
+            t.chain = vec![t.ifd(vec![(271, Val::Ascii("SONY".into())), (34665, Val::Ifds(vec![exif]))])];
+            t.build()
+        };
+        let adobe = raw(0xFFFF, "R03");
+        let srgb = raw(1, "R98");
+        assert!(preview_profile(&adobe, None).unwrap().unwrap().same_colors(Builtin::AdobeRgbCompat.profile()));
+        assert!(preview_profile(&srgb, None).unwrap().is_none());
+        assert!(preview_profile(b"not a raw", None).unwrap().is_none(), "unstated: sRGB");
+        // the preview's own profile wins over the raw's EXIF
+        let srgb_icc = Builtin::Srgb.profile().to_bytes().to_vec();
+        assert!(preview_profile(&adobe, Some(srgb_icc.as_slice())).unwrap().is_none());
+        let p3_icc = Builtin::DisplayP3.profile().to_bytes().to_vec();
+        assert!(preview_profile(&srgb, Some(p3_icc.as_slice())).unwrap().unwrap().same_colors(Builtin::DisplayP3.profile()));
+        assert!(preview_profile(&adobe, Some(b"not an ICC profile")).is_err());
+    }
 }
diff --git a/crates/io/src/smart_map.rs b/crates/io/src/smart_map.rs
index f1fb78e910..ab9349fbde 100644
--- a/crates/io/src/smart_map.rs
+++ b/crates/io/src/smart_map.rs
@@ -18,6 +18,9 @@
 //! to their command id and dialog parameters; any other filter becomes a
 //! [`UNSUPPORTED_FILTER`] entry that keeps its descriptor verbatim (hex in `params.psd`), so it is
 //! listed, can be hidden, reordered or deleted, and is written back unchanged.
+//!
+//! Camera Raw and Displace keep their whole item as a template next to the editable settings
+//! (Displace's carries the embedded displacement map, see `displace_map.rs`).
 
 use photocraft_color::{BlendMode, ColorMode, PixelFormat, SampleType};
 use photocraft_doc::{LayerMask, SmartFilter};
@@ -34,6 +37,10 @@ use crate::blocks::{enum_of, get_desc, num};
 
 #[path = "camera_raw_map.rs"]
 mod camera_raw;
+#[path = "displace_map.rs"]
+mod displace;
+
+pub use displace::embedded_map as displace_embedded_map;
 
 /// Command id of a Photoshop smart filter PhotoCraft does not implement. Its params hold the
 /// filter's name, Photoshop filter id and descriptor (`psd`, hex); it renders as a pass-through.
@@ -312,10 +319,10 @@ pub fn filter_from_item(item: &Descriptor) -> SmartFilter {
     let class = fltr.map(|f| String::from_utf8_lossy(f.class_id.as_bytes()).into_owned());
     let filter_id = int(item, "filterID").unwrap_or(0);
     let class = class.or_else(|| KNOWN.iter().find(|k| k.filter_id == filter_id).map(|k| k.class.to_string()));
-    let known = if class.as_deref() == Some(camera_raw::CLASS) {
-        camera_raw::import_params(item).map(|p| (camera_raw::COMMAND, p))
-    } else {
-        class.as_deref().and_then(|c| known_params(c, fltr))
+    let known = match class.as_deref() {
+        Some(camera_raw::CLASS) => camera_raw::import_params(item).map(|p| (camera_raw::COMMAND, p)),
+        Some(displace::CLASS) => displace::import_params(item).map(|p| (displace::COMMAND, p)),
+        c => c.and_then(|c| known_params(c, fltr)),
     };
     let (command, params) = match known {
         Some((c, p)) => (c.to_string(), p),
@@ -460,6 +467,12 @@ pub fn item_for_filter(f: &SmartFilter) -> Result<Descriptor, String> {
         set(&mut d, "enab", Value::Boolean(f.visible));
         return Ok(d);
     }
+    if f.command == displace::COMMAND {
+        let mut d = displace::export_item(&f.params)?;
+        set(&mut d, "blendOptions", blend_options(f));
+        set(&mut d, "enab", Value::Boolean(f.visible));
+        return Ok(d);
+    }
     if f.command == UNSUPPORTED_FILTER {
         let raw = f.params.get("psd").and_then(J::as_str).and_then(from_hex).ok_or("its filter data is missing")?;
         let mut d = Descriptor::from_bytes(&raw).map_err(|e| format!("its filter data is unreadable ({e})"))?;
@@ -526,7 +539,9 @@ pub struct PlacedSpec<'a> {
     pub filter_fx: Option<Descriptor>,
 }
 
-/// Where the source corners land (top-left, top-right, bottom-right, bottom-left), as x, y pairs.
+/// Where the frame corners land (top-left, top-right, bottom-right, bottom-left), as x, y pairs.
+/// The frame is [`crate::blocks::placed_frame`] for an affine placement (the inverse of
+/// `parse_smart`), the source rect for a projective one (as `parse_smart_perspective` reads it).
 fn quad_points(s: &PlacedSpec<'_>) -> [f64; 8] {
     let (w, h) = s.size;
     let [a, b, c, d, e, f] = s.transform.m;
@@ -534,8 +549,9 @@ fn quad_points(s: &PlacedSpec<'_>) -> [f64; 8] {
         Some(p) => photocraft_algo::transform::Homography(*p).apply(x, y),
         None => (a * x + c * y + e, b * x + d * y + f),
     };
+    let [x0, y0, x1, y1] = if s.perspective.is_some() { [0.0, 0.0, w, h] } else { crate::blocks::placed_frame(s.warp, w, h) };
     let mut out = [0.0; 8];
-    for (i, (x, y)) in [(0.0, 0.0), (w, 0.0), (w, h), (0.0, h)].into_iter().enumerate() {
+    for (i, (x, y)) in [(x0, y0), (x1, y0), (x1, y1), (x0, y1)].into_iter().enumerate() {
         (out[2 * i], out[2 * i + 1]) = map(x, y);
     }
     out
@@ -817,6 +833,28 @@ pub fn uuid_from(seed: &[u8]) -> String {
 mod tests {
     use super::*;
 
+    fn count(hay: &[u8], needle: &[u8]) -> usize {
+        hay.windows(needle.len()).filter(|w| *w == needle).count()
+    }
+
+    /// A freshly built placed layer writes `warp` (key and class) as a length-4 string, as
+    /// Photoshop does; the code form is a different key to Photoshop.
+    #[test]
+    fn fresh_placed_warp_is_a_string_id() {
+        let spec =
+            PlacedSpec { idnt: "id", placed: "id", transform: Affine::IDENTITY, perspective: None, size: (10.0, 10.0), dpi: 72.0, warp: None, filter_fx: None };
+        let mut warnings = Vec::new();
+        let sold = sold_bytes(None, &spec, &mut warnings);
+        let plld = plld_bytes(&spec, &mut warnings);
+        // `SoLd`: the `warp` key and the warp descriptor's class; `PlLd`: the descriptor's class.
+        for (bytes, n) in [(&sold, 2), (&plld, 1)] {
+            assert_eq!(count(bytes, b"\0\0\0\x04warp"), n);
+            assert_eq!(count(bytes, b"\0\0\0\0warp"), 0);
+        }
+        let d = sold_descriptor(&sold).unwrap();
+        assert!(matches!(d.get("warp"), Some(Value::Descriptor(w)) if w.class_id == Id::Str(b"warp".to_vec())));
+    }
+
     fn sf(command: &str, params: J) -> SmartFilter {
         SmartFilter { command: command.into(), params, blend: BlendMode::Normal, opacity: 1.0, visible: true }
     }
@@ -1058,6 +1096,28 @@ mod tests {
         }
     }
 
+    /// Export writes `Trnf` as the image of the custom warp's control-point box, the inverse of
+    /// import: a spilled mesh comes back with the same transform and the quad Photoshop expects.
+    #[test]
+    fn warp_control_box_quad_round_trips() {
+        use photocraft_geom::warp::BezierMesh;
+        let mut mesh = BezierMesh::identity([0.0, 0.0, 50.0, 25.0], 1, 1);
+        mesh.points[0] = [-10.0, -5.0];
+        mesh.points[15] = [60.0, 25.0];
+        let mut warp = Warp::preset(WarpStyle::Custom, 0.0, [0.0, 0.0, 50.0, 25.0]);
+        warp.mesh = Some(mesh);
+        let transform = Affine { m: [2.0, 0.0, 0.0, 2.0, 120.0, 210.0] };
+        let spec = PlacedSpec { idnt: "i", placed: "p", transform, perspective: None, size: (50.0, 25.0), dpi: 72.0, warp: Some(&warp), filter_fx: None };
+        let sold = sold_bytes(None, &spec, &mut Vec::new());
+        let p = parse_sold(&sold).expect("parses");
+        let Some(Value::List(q)) = p.descriptor.get("Trnf") else { panic!("no Trnf") };
+        let q: Vec<f64> = q.iter().filter_map(|v| num(Some(v))).collect();
+        assert_eq!(q, [100.0, 200.0, 240.0, 200.0, 240.0, 260.0, 100.0, 260.0]);
+        assert_eq!(p.transform, transform);
+        // The imported quad reads as unmoved, so the template's `Trnf` is kept as stored.
+        assert!(!quad_moved(&p.descriptor, &spec));
+    }
+
     #[test]
     fn hex_and_uuid() {
         assert_eq!(from_hex(&to_hex(&[0, 1, 0xab, 0xff])), Some(vec![0, 1, 0xab, 0xff]));
diff --git a/crates/io/src/svg.rs b/crates/io/src/svg.rs
index b6a7741d6e..04fc4bee3a 100644
--- a/crates/io/src/svg.rs
+++ b/crates/io/src/svg.rs
@@ -15,7 +15,7 @@ use std::sync::{Arc, OnceLock};
 use photocraft_color::blend::BlendMode;
 use photocraft_color::{Color, ColorMode, PixelFormat, SampleType};
 use photocraft_doc::effects::GradientStyle;
-use photocraft_doc::vector::{FillRule, Knot, LineCap, LineJoin, Path, PathOp, ShapeLayer, ShapeStroke, StrokeAlign, Subpath};
+use photocraft_doc::vector::{FillRule, Knot, LineCap, LineJoin, Path, PathOp, ShapeLayer, ShapeStroke, StrokeAlign, Subpath, VectorMask};
 use photocraft_doc::{Document, Fill, Group, Layer, LayerContent, MAX_GROUP_DEPTH};
 use photocraft_geom::{Point, Rect, Size};
 use photocraft_raster::Surface;
@@ -348,8 +348,11 @@ impl Conv {
     fn convert_node(&mut self, node: &usvg::Node, out: &mut Vec<Layer>, depth: usize, rec: usize, parent: tiny_skia::Transform) {
         match node {
             usvg::Node::Group(g) => {
+                // A clip-path of one plain path becomes the group's vector mask (#4266); others
+                // are rasterised with the group.
+                let clip = g.clip_path().and_then(|cp| self.clip_mask(g, cp));
                 let dropped: [(bool, &'static str); 3] =
-                    [(!g.filters().is_empty(), "filter"), (g.clip_path().is_some(), "clip-path"), (g.mask().is_some(), "mask")];
+                    [(!g.filters().is_empty(), "filter"), (g.clip_path().is_some() && clip.is_none(), "clip-path"), (g.mask().is_some(), "mask")];
                 let too_deep = self.max_group_depth.is_some_and(|limit| depth >= limit) || depth >= MAX_GROUP_DEPTH || rec >= MAX_RECURSION;
                 if dropped.iter().any(|d| d.0) || too_deep {
                     for (yes, what) in dropped {
@@ -366,7 +369,7 @@ impl Conv {
                 }
                 // A group that only carries a transform (baked into its paths by usvg) or that
                 // usvg inserted for its own bookkeeping adds nothing to the layer tree.
-                let plain = g.id().is_empty() && g.opacity().get() >= 1.0 && g.blend_mode() == usvg::BlendMode::Normal;
+                let plain = clip.is_none() && g.id().is_empty() && g.opacity().get() >= 1.0 && g.blend_mode() == usvg::BlendMode::Normal;
                 let children = self.convert_children(g.children(), if plain { depth } else { depth + 1 }, rec + 1, g.abs_transform());
                 if children.is_empty() {
                     return;
@@ -376,9 +379,14 @@ impl Conv {
                     return;
                 }
                 let only_id = g.opacity().get() >= 1.0 && g.blend_mode() == usvg::BlendMode::Normal;
-                if only_id && children.len() == 1 {
+                // A lone child takes the group's name (and its clip, when it has no vector mask of
+                // its own).
+                if only_id && children.len() == 1 && (clip.is_none() || children.iter().all(|c| c.vector_mask.is_none())) {
                     if let Some(mut child) = children.into_iter().next() {
-                        child.name = g.id().to_string();
+                        if !g.id().is_empty() {
+                            child.name = g.id().to_string();
+                        }
+                        child.vector_mask = clip.or(child.vector_mask);
                         out.push(child);
                     }
                     return;
@@ -386,6 +394,7 @@ impl Conv {
                 let mut l = Layer::new(self.name(g.id(), 1), LayerContent::Group(Group { children, expanded: false, artboard: None }));
                 l.opacity = g.opacity().get();
                 l.blend = blend(g.blend_mode());
+                l.vector_mask = clip;
                 out.push(l);
             }
             usvg::Node::Path(p) => out.extend(self.shape_layer(node, p, parent)),
@@ -412,6 +421,29 @@ impl Conv {
         }
     }
 
+    /// The vector mask for group `g` clipped by `cp`, when the clip is one visible path with no
+    /// clip of its own: what resvg draws for the clip (the group's transform, then the clip's,
+    /// then the path), in canvas pixels, with the clip rule as its fill rule.
+    fn clip_mask(&self, g: &usvg::Group, cp: &usvg::ClipPath) -> Option<VectorMask> {
+        if cp.clip_path().is_some() {
+            return None;
+        }
+        let [usvg::Node::Path(p)] = cp.root().children() else { return None };
+        if !p.is_visible() {
+            return None;
+        }
+        let ts = g.abs_transform().pre_concat(cp.transform()).post_concat(self.global);
+        let subpaths = knots(&(*p.data()).clone().transform(ts)?);
+        if subpaths.is_empty() {
+            return None;
+        }
+        let fill_rule = match p.fill().map(|f| f.rule()) {
+            Some(usvg::FillRule::EvenOdd) => FillRule::EvenOdd,
+            _ => FillRule::NonZero,
+        };
+        Some(VectorMask::new(Path { subpaths, fill_rule, inverted: false }))
+    }
+
     /// A path as a shape layer, or a pixel layer when its paint is a pattern.
     fn shape_layer(&mut self, node: &usvg::Node, p: &usvg::Path, parent: tiny_skia::Transform) -> Option<Layer> {
         if !p.is_visible() {
@@ -688,6 +720,54 @@ mod tests {
         assert!(r.warnings.iter().all(|w| !w.contains("font")), "{:?}", r.warnings);
     }
 
+    /// #4266: a group clipped by one path (the PhotoCraft icon's rounded square) stays editable
+    /// shapes with the clip as its vector mask, and looks as resvg draws the drawing; a clip of
+    /// two shapes is still rasterised, with the warning.
+    #[test]
+    fn a_single_path_clip_becomes_the_groups_vector_mask() {
+        let svg = br##"<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64">
+            <defs><clipPath id="c"><rect x="4" y="4" width="40" height="40" rx="10"/></clipPath></defs>
+            <g transform="translate(8 6)" clip-path="url(#c)">
+              <rect width="64" height="64" fill="#2f7bf5"/>
+              <circle cx="40" cy="40" r="20" fill="#efe9dc"/>
+            </g></svg>"##;
+        let r = import_svg("t", svg).unwrap();
+        assert!(r.warnings.iter().all(|w| !w.contains("clip-path")), "{:?}", r.warnings);
+        let [group] = r.document.layers.as_slice() else { panic!("one group: {:?}", r.document.layers.len()) };
+        let LayerContent::Group(g) = &group.content else { panic!("a group") };
+        assert_eq!(g.children.len(), 2);
+        assert!(g.children.iter().all(|c| matches!(c.content, LayerContent::Shape(_))), "editable shapes");
+        let mask = group.vector_mask.as_ref().expect("the clip as a vector mask");
+        let xs: Vec<f64> = mask.path.subpaths.iter().flat_map(|s| s.knots.iter().map(|k| k.anchor.x)).collect();
+        let (lo, hi) = (xs.iter().copied().fold(f64::MAX, f64::min), xs.iter().copied().fold(f64::MIN, f64::max));
+        assert!((lo - 12.0).abs() < 1e-3 && (hi - 52.0).abs() < 1e-3, "in the group's space: {lo}..{hi}");
+        // Pixel for pixel what resvg draws, but for anti-aliasing along the edges.
+        let ours = photocraft_compose::flatten(&r.document).to_rgba8().pixels;
+        let tree = parse(svg).unwrap().tree;
+        let mut pm = tiny_skia::Pixmap::new(64, 64).unwrap();
+        resvg::render(&tree, tiny_skia::Transform::default(), &mut pm.as_mut());
+        let theirs: Vec<u8> = pm
+            .pixels()
+            .iter()
+            .flat_map(|p| {
+                let c = p.demultiply();
+                [c.red(), c.green(), c.blue(), c.alpha()]
+            })
+            .collect();
+        let off = ours.chunks(4).zip(theirs.chunks(4)).filter(|(a, b)| a.iter().zip(*b).any(|(x, y)| x.abs_diff(*y) > 48)).count();
+        assert!(off < 64, "{off} pixels differ");
+        // The report's file: PhotoCraft's own icon opens without the clip-path warning.
+        let icon = import_svg("photocraft.svg", include_bytes!("../../../assets/app-icon/photocraft.svg")).unwrap();
+        assert!(icon.warnings.iter().all(|w| !w.contains("clip-path")), "{:?}", icon.warnings);
+        assert!(icon.document.layers.iter().any(|l| l.vector_mask.is_some()), "its rounded square is a vector mask");
+        // Two shapes in the clip: rasterised, and said so.
+        let two = br##"<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64">
+            <defs><clipPath id="c"><rect width="20" height="20"/><rect x="30" width="20" height="20"/></clipPath></defs>
+            <g clip-path="url(#c)"><rect width="64" height="64"/><rect width="9" height="9" fill="red"/></g></svg>"##;
+        let r = import_svg("t", two).unwrap();
+        assert!(r.warnings.iter().any(|w| w.contains("clip-path")), "{:?}", r.warnings);
+    }
+
     #[test]
     fn huge_drawings_scale_to_the_side_limit() {
         let tree = parse(b"<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 100000 50000\"/>").unwrap().tree;
diff --git a/crates/io/src/text_import.rs b/crates/io/src/text_import.rs
index 9159f704dd..9272f0b5b7 100644
--- a/crates/io/src/text_import.rs
+++ b/crates/io/src/text_import.rs
@@ -11,7 +11,7 @@ pub(crate) const MAX_RENDER_PIXELS: u64 = 64 * 1024 * 1024;
 /// Renders `t` from its model unless its ink would exceed [`MAX_RENDER_PIXELS`].
 fn render_bounded(eng: &mut photocraft_text::TextEngine, t: &mut TextLayer, dpi: f32, format: photocraft_color::PixelFormat) {
     let layout = eng.layout(t, dpi);
-    let warp = photocraft_text::render::layout_warp(&layout, t.warp.as_ref());
+    let warp = photocraft_text::render::layout_deform(&layout, t);
     let ink = photocraft_text::render::ink_rect_warped(&layout, &t.transform, warp.as_ref());
     if u64::from(ink.width()).saturating_mul(u64::from(ink.height())) > MAX_RENDER_PIXELS {
         t.cache = Some(photocraft_raster::Surface::new(photocraft_color::PixelFormat { alpha: true, ..format }));
@@ -36,10 +36,16 @@ pub(crate) fn prepare(doc: &mut Document) {
                     let mut changed = false;
                     for r in &mut t.runs {
                         if let Some(ps) = r.style.postscript_name.clone()
-                            && !eng.fonts.has_family(&r.style.font_family)
+                            && !eng.fonts.faces(&r.style.font_family).iter().any(|f| f.postscript_name.as_deref() == Some(&ps))
                         {
                             let f = eng.fonts.resolve_postscript(&ps);
-                            if f.exact || eng.fonts.has_family(&f.family) {
+                            // Keep installed families, including legacy names whose faces are
+                            // indexed under a typographic family. An exact face may recover a
+                            // truncated hyphenated family; a heuristic only fills a missing one.
+                            let installed = eng.fonts.has_family(&r.style.font_family);
+                            let exact_recovery =
+                                f.exact && (!installed || f.family.strip_prefix(&r.style.font_family).is_some_and(|suffix| suffix.starts_with('-')));
+                            if exact_recovery || (!installed && eng.fonts.has_family(&f.family)) {
                                 r.style.font_family = f.family;
                                 r.style.weight = f.weight;
                                 r.style.italic = f.italic;
diff --git a/crates/io/src/tiff_layers.rs b/crates/io/src/tiff_layers.rs
index 3142bc1a8c..8a5810e922 100644
--- a/crates/io/src/tiff_layers.rs
+++ b/crates/io/src/tiff_layers.rs
@@ -201,7 +201,8 @@ pub(crate) fn export_layered(doc: &Document, opts: &ExportOptions, ctl: &photocr
     let big = doc.size.width > 30_000 || doc.size.height > 30_000;
     // The PSD exporter renders the composite we need for the TIFF itself: unmatted (the TIFF
     // keeps straight alpha) and uncompressed (its planes are interleaved below).
-    let psd_opts = PsdExportOptions { force_psb: opts.force_psb || big, merged_matte: false, merged_compression: Compression::Raw };
+    let psd_opts =
+        PsdExportOptions { force_psb: opts.force_psb || big, merged_matte: false, merged_compression: Compression::Raw, maximize_compatibility: true };
     let (file, w) = crate::with_span(ctl, 0.0, TIFF_MODEL_DONE, |ctl| crate::psd_export::document_to_psd_interruptible(doc, &psd_opts, ctl));
     // A cancelled conversion stops early with an incomplete model: never encode it.
     ctl.check().map_err(|_| IoError::Cancelled)?;
@@ -212,7 +213,8 @@ pub(crate) fn export_layered(doc: &Document, opts: &ExportOptions, ctl: &photocr
     ctl.progress(TIFF_LAYERS_DONE);
     warnings.extend(w.into_iter().map(|w| format!("layer data: {w}")));
     // The profile and XMP are written as TIFF tags, not as resources. EXIF stays a resource
-    // (1058): the TIFF codec has no EXIF directory, and the PSD importer reads it back from there.
+    // (1058), which the PSD importer reads back unchanged; a block rebuilt from the TIFF's own
+    // Exif directory keeps only the Exif, GPS and descriptive tags.
     let resources: Vec<ImageResource> = file.resources.iter().filter(|r| !matches!(r.id, ids::ICC_PROFILE | ids::XMP)).cloned().collect();
     let resources = resources_to_bytes(&resources)?;
 
@@ -234,10 +236,10 @@ pub(crate) fn export_layered(doc: &Document, opts: &ExportOptions, ctl: &photocr
     let mut img = Image::from_raw(w, h, layout, sample, data)?;
     img.icc = doc.icc_profile.as_ref().map(|i| i.to_vec());
     img.meta = codecs::Metadata {
-        // EXIF is deliberately not set here: the TIFF codec has no EXIF directory, so the tags
-        // above carry it as resource 1058 and the importer reads them back from there. Handing the
-        // codec a second copy in `meta.exif` bought nothing and made the export claim it would
-        // drop metadata it had in fact kept (#1545).
+        // EXIF is deliberately not set here: the tags above carry it as resource 1058 and the
+        // importer reads it back from there unchanged. A second copy in `meta.exif` (the codec's
+        // Exif directory) would be read back in its place, rebuilt without the thumbnail and IFD0
+        // orientation (#1545).
         xmp: doc.metadata.xmp.clone().filter(|_| opts.xmp == crate::XmpEmbed::All),
         text: if opts.xmp == crate::XmpEmbed::All { doc.metadata.text.clone() } else { Vec::new() },
         dpi: Some((doc.resolution_dpi, doc.resolution_dpi)),
diff --git a/crates/io/tests/cmyk_composite_export.rs b/crates/io/tests/cmyk_composite_export.rs
new file mode 100644
index 0000000000..9f537dabfd
--- /dev/null
+++ b/crates/io/tests/cmyk_composite_export.rs
@@ -0,0 +1,269 @@
+use photocraft_cms::{Builtin, Intent, Profile, Transform};
+use photocraft_codecs::{ChannelLayout, SampleType as CodecSample, decode};
+use photocraft_color::{ColorMode, SampleType};
+use photocraft_doc::{Document, Layer, LayerContent};
+use photocraft_geom::Size;
+use photocraft_io::{ExportOptions, document_to_image, export};
+use photocraft_raster::Surface;
+
+fn document(depth: SampleType, alpha: f32) -> Document {
+    let mut doc = Document::new("CMYK composite", Size::new(8, 8), ColorMode::Cmyk, depth);
+    doc.icc_profile = Some(Builtin::CoatedCmyk.profile().to_bytes());
+    let surface = Surface::with_default(doc.pixel_format(), &[0.3, 0.6, 0.1, 0.2, alpha]);
+    doc.layers.push(Layer::new("Ink", LayerContent::Raster(surface)));
+    doc.layers.push(Layer::new("Empty", LayerContent::Raster(Surface::new(doc.pixel_format()))));
+    doc
+}
+
+fn tag(bytes: &[u8], id: u16) -> Option<u16> {
+    assert_eq!(&bytes[..2], b"II");
+    let start = usize::try_from(u32::from_le_bytes(bytes[4..8].try_into().unwrap())).unwrap();
+    let count = usize::from(u16::from_le_bytes(bytes[start..start + 2].try_into().unwrap()));
+    bytes[start + 2..]
+        .as_chunks::<12>()
+        .0
+        .iter()
+        .take(count)
+        .find_map(|entry| (u16::from_le_bytes(entry[..2].try_into().unwrap()) == id).then(|| u16::from_le_bytes(entry[8..10].try_into().unwrap())))
+}
+
+#[test]
+fn tiff_keeps_cmyk_profile_depth_and_straight_alpha_when_composited() {
+    for (depth, sample) in [(SampleType::U8, CodecSample::U8), (SampleType::U16, CodecSample::U16), (SampleType::F32, CodecSample::F32)] {
+        for alpha in [1.0, 0.5] {
+            let doc = document(depth, alpha);
+
+            let result = export(&doc, "tiff", &ExportOptions::default()).unwrap();
+
+            let image = decode(&result.bytes).unwrap();
+            assert_eq!(image.layout(), if alpha == 1.0 { ChannelLayout::Cmyk } else { ChannelLayout::CmykA });
+            assert_eq!(image.sample_type(), sample);
+            assert_eq!(image.icc.as_deref(), doc.icc_profile.as_deref().map(Vec::as_slice));
+            assert_eq!(tag(&result.bytes, 262), Some(5));
+            assert_eq!(tag(&result.bytes, 277), Some(if alpha == 1.0 { 4 } else { 5 }));
+            assert_eq!(tag(&result.bytes, 338), if alpha == 1.0 { None } else { Some(2) });
+            if alpha < 1.0 {
+                assert!(image.to_normalized().as_chunks::<5>().0.iter().all(|px| (px[4] - alpha).abs() < 0.004));
+                let opaque = document_to_image(&document(depth, 1.0), &mut Vec::new()).unwrap().to_normalized();
+                for (px, color) in image.to_normalized().as_chunks::<5>().0.iter().zip(opaque.as_chunks::<4>().0) {
+                    assert!(px[..4].iter().zip(color).all(|(a, b)| (a - b).abs() < 0.004));
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn tiff_keeps_true_zero_alpha_when_composited() {
+    for (depth, sample) in [(SampleType::U8, CodecSample::U8), (SampleType::U16, CodecSample::U16), (SampleType::F32, CodecSample::F32)] {
+        let doc = document(depth, 0.0);
+
+        let result = export(&doc, "tiff", &ExportOptions::default()).unwrap();
+
+        let image = decode(&result.bytes).unwrap();
+        assert_eq!(image.layout(), ChannelLayout::CmykA);
+        assert_eq!(image.sample_type(), sample);
+        assert_eq!(image.icc.as_deref(), doc.icc_profile.as_deref().map(Vec::as_slice));
+        assert_eq!(tag(&result.bytes, 262), Some(5));
+        assert_eq!(tag(&result.bytes, 277), Some(5));
+        assert_eq!(tag(&result.bytes, 338), Some(2));
+        assert!(image.to_normalized().as_chunks::<5>().0.iter().all(|px| px[4].abs() < f32::EPSILON));
+    }
+}
+
+#[test]
+fn psd_keeps_cmyk_mode_depth_and_profile_when_composited() {
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        let doc = document(depth, 0.5);
+
+        let result = export(&doc, "psd", &ExportOptions::default()).unwrap();
+
+        let back = photocraft_io::import("composite.psd", &result.bytes).unwrap().document;
+        assert_eq!(back.mode, ColorMode::Cmyk);
+        assert_eq!(back.depth, depth);
+        assert_eq!(back.icc_profile, doc.icc_profile);
+        assert_eq!(back.layer_count(), doc.layer_count());
+    }
+}
+
+#[test]
+fn jpeg_keeps_four_components_profile_and_zero_ink_matte_when_composited() {
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        for alpha in [1.0, 0.5, 0.0] {
+            let doc = document(depth, alpha);
+            let mut opts = ExportOptions::default();
+            opts.encode.jpeg_quality = 100;
+
+            let result = export(&doc, "jpg", &opts).unwrap();
+
+            let image = decode(&result.bytes).unwrap();
+            assert_eq!(image.layout(), ChannelLayout::Cmyk);
+            assert_eq!(image.icc.as_deref(), doc.icc_profile.as_deref().map(Vec::as_slice));
+            let adobe = result.bytes.windows(5).position(|bytes| bytes == b"Adobe").unwrap();
+            assert_eq!(result.bytes[adobe + 11], 0);
+            let mut marker = 2;
+            while result.bytes[marker + 1] != 192 {
+                let length = usize::from(u16::from_be_bytes(result.bytes[marker + 2..marker + 4].try_into().unwrap()));
+                marker += length + 2;
+            }
+            assert_eq!(result.bytes[marker + 9], 4);
+            let expected = document_to_image(&doc, &mut Vec::new()).unwrap();
+            for (px, source) in image.to_normalized().as_chunks::<4>().0.iter().zip(expected.to_normalized().chunks_exact(expected.layout().channels())) {
+                for channel in 0..4 {
+                    let ink = source[channel] * if expected.layout().has_alpha() { source[4] } else { 1.0 };
+                    assert!((px[channel] - ink).abs() < 0.015, "{px:?} vs {source:?}");
+                }
+            }
+            if depth != SampleType::U8 {
+                assert!(result.warnings.iter().any(|warning| warning.contains("bit")), "{:?}", result.warnings);
+            }
+        }
+    }
+}
+
+#[test]
+fn composite_uses_distinctive_document_profile_on_every_worker() {
+    let params = photocraft_cms::synth::CmykParams {
+        description: "Export synthetic uncoated".into(),
+        tvi: [0.26, 0.26, 0.26, 0.3],
+        grid_a2b: 5,
+        grid_b2a: 9,
+        ..Default::default()
+    };
+    let profile = photocraft_cms::synth::cmyk_profile(&params);
+    let mut doc = document(SampleType::F32, 0.5);
+    doc.size = Size::new(64, 64);
+    doc.icc_profile = Some(profile.to_bytes());
+    let rgb = photocraft_compose::flatten(&doc);
+    let transform = Transform::new(Builtin::Srgb.profile(), &profile, Intent::RelativeColorimetric, true).unwrap();
+    let fallback = Transform::new(Builtin::Srgb.profile(), Builtin::CoatedCmyk.profile(), Intent::RelativeColorimetric, true).unwrap();
+    let mut expected = [0.0; 4];
+    transform.eval_fast(&rgb.px[0][..3], &mut expected);
+    let mut wrong = [0.0; 4];
+    fallback.eval_fast(&rgb.px[0][..3], &mut wrong);
+    assert!(expected.iter().zip(wrong).any(|(a, b)| (a - b).abs() > 0.02));
+    assert!(photocraft_io::pixels::bands(rgb.px.len()).len() > 1);
+
+    let image = document_to_image(&doc, &mut Vec::new()).unwrap();
+
+    assert_eq!(image.layout(), ChannelLayout::CmykA);
+    for px in image.to_normalized().as_chunks::<5>().0 {
+        assert!(px[..4].iter().zip(expected).all(|(a, b)| (a - b).abs() < 0.00001), "{px:?} vs {expected:?}");
+    }
+    for extension in ["tiff", "jpg"] {
+        let encoded = export(&doc, extension, &ExportOptions::default()).unwrap();
+        assert_eq!(decode(&encoded.bytes).unwrap().icc.as_deref(), doc.icc_profile.as_deref().map(Vec::as_slice));
+    }
+}
+
+#[test]
+fn cmyk_composite_rejects_invalid_non_cmyk_and_unusable_profiles() {
+    let without_tags = |prefix: &[u8]| {
+        let mut bytes = Builtin::CoatedCmyk.profile().to_bytes().to_vec();
+        let count = usize::try_from(u32::from_be_bytes(bytes[128..132].try_into().unwrap())).unwrap();
+        for entry in bytes[132..].as_chunks_mut::<12>().0.iter_mut().take(count) {
+            if &entry[..3] == prefix {
+                entry[..4].copy_from_slice(b"test");
+            }
+        }
+        std::sync::Arc::new(bytes)
+    };
+    for bytes in [std::sync::Arc::new(vec![1, 2, 3]), Builtin::Srgb.profile().to_bytes(), without_tags(b"B2A"), without_tags(b"A2B")] {
+        let mut doc = document(SampleType::U8, 1.0);
+        doc.icc_profile = Some(bytes);
+
+        for extension in ["tiff", "jpg"] {
+            assert!(export(&doc, extension, &ExportOptions::default()).is_err(), "accepted invalid profile for {extension}");
+        }
+        // RGB-only targets never write CMYK, so they still export (through the built-in profile).
+        assert!(export(&doc, "png", &ExportOptions::default()).is_ok(), "rejected invalid profile for png");
+    }
+}
+
+#[test]
+fn untagged_composite_embeds_coated_cmyk() {
+    let mut doc = document(SampleType::U8, 1.0);
+    doc.icc_profile = None;
+
+    let image = document_to_image(&doc, &mut Vec::new()).unwrap();
+
+    assert_eq!(image.layout(), ChannelLayout::Cmyk);
+    assert_eq!(image.icc.unwrap(), Builtin::CoatedCmyk.profile().to_bytes().as_slice());
+}
+
+#[test]
+fn native_samples_are_preserved_without_composite_roundtrip() {
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        let mut doc = document(depth, 0.5);
+        doc.layers.pop();
+        let LayerContent::Raster(surface) = &doc.layers[0].content else { panic!() };
+        let expected = surface.to_interleaved(doc.bounds());
+
+        let image = document_to_image(&doc, &mut Vec::new()).unwrap();
+
+        assert_eq!(image.data(), expected);
+    }
+}
+
+#[test]
+fn rgb_only_export_uses_direct_composite_not_reseparated_cmyk() {
+    let doc = document(SampleType::U16, 0.5);
+    let rgb = photocraft_compose::flatten(&doc);
+    let expected =
+        photocraft_codecs::Image::from_normalized(8, 8, ChannelLayout::Rgba, CodecSample::U16, &rgb.px.into_iter().flatten().collect::<Vec<_>>()).unwrap();
+
+    let result = export(&doc, "png", &ExportOptions::default()).unwrap();
+
+    let image = decode(&result.bytes).unwrap();
+    assert_eq!(image.data(), expected.data());
+    assert_eq!(Profile::parse(image.icc.as_ref().unwrap()).unwrap().color_space, photocraft_cms::ColorSpace::Rgb);
+}
+
+#[test]
+fn layered_tiff_keeps_its_existing_cmyk_psd_composite_path() {
+    let doc = document(SampleType::U16, 0.5);
+    let opts = ExportOptions { tiff_layers: true, ..Default::default() };
+
+    let result = export(&doc, "tiff", &opts).unwrap();
+
+    let image = decode(&result.bytes).unwrap();
+    assert_eq!(image.layout(), ChannelLayout::CmykA);
+    assert_eq!(image.icc.as_deref(), doc.icc_profile.as_deref().map(Vec::as_slice));
+    assert!(image.meta.photoshop_layers.is_some());
+    assert_eq!(tag(&result.bytes, 338), Some(2));
+    assert!(image.to_normalized().as_chunks::<5>().0.iter().all(|px| (px[4] - 0.5).abs() < 0.0001));
+}
+
+/// A tagged CMYK file's merged image reads through its own profile, as the compositor reads the
+/// layers, so the two are compared in the same colours (the oracle tests rely on it: psd-tools'
+/// tagged CMYK files were 95–100% off before).
+#[test]
+fn merged_composite_of_a_tagged_cmyk_file_reads_through_its_profile() {
+    use photocraft_cms::synth::{CmykParams, cmyk_profile};
+    use photocraft_color::convert::{CmykSpace, cmyk_to_rgb, with_cmyk_space};
+    let mut doc = Document::new("tagged", Size::new(6, 4), ColorMode::Cmyk, SampleType::U8);
+    let profile =
+        cmyk_profile(&CmykParams { description: "Merged Test CMYK".into(), tvi: [0.26, 0.26, 0.26, 0.3], grid_a2b: 5, grid_b2a: 9, ..Default::default() });
+    doc.icc_profile = Some(profile.to_bytes());
+    let mut surface = Surface::new(photocraft_color::PixelFormat::new(ColorMode::Cmyk, SampleType::U8, false));
+    for x in 0..6 {
+        for y in 0..4 {
+            surface.write_pixel(x, y, &[x as f32 / 5.0, y as f32 / 3.0, 0.4, (x * y) as f32 / 15.0]);
+        }
+    }
+    doc.layers.push(Layer::new("Background", LayerContent::Raster(surface)));
+    let psd = export(&doc, "psd", &ExportOptions::default()).unwrap();
+    let file = photocraft_psd::PsdFile::from_bytes(&psd.bytes).unwrap();
+    let merged = photocraft_io::merged_composite(&file).unwrap();
+    // The merged image's own inks (planar, 255 = no ink), shown through the file's profile.
+    let raw = file.decode_merged().unwrap();
+    let plane = 6 * 4;
+    let space = CmykSpace::for_profile(doc.icc_profile.as_ref());
+    assert!(space.is_some(), "a profile other than the built-in coated CMYK");
+    let shown: Vec<[f32; 3]> =
+        with_cmyk_space(space.as_ref(), || (0..plane).map(|i| cmyk_to_rgb(std::array::from_fn(|c| 1.0 - f32::from(raw[c * plane + i]) / 255.0))).collect());
+    let builtin: Vec<[f32; 3]> = (0..plane).map(|i| cmyk_to_rgb(std::array::from_fn(|c| 1.0 - f32::from(raw[c * plane + i]) / 255.0))).collect();
+    let apart = |a: &[[f32; 3]]| merged.iter().zip(a).flat_map(|(m, s)| (0..3).map(move |c| (m[c] - s[c]).abs())).fold(0.0f32, f32::max);
+    assert!(apart(&shown) < 1e-4, "merged image read through its profile: {}", apart(&shown));
+    assert!(apart(&builtin) > 0.01, "the built-in profile would show it differently");
+}
diff --git a/crates/io/tests/color.rs b/crates/io/tests/color.rs
index cb8acbd2e7..c5d4479904 100644
--- a/crates/io/tests/color.rs
+++ b/crates/io/tests/color.rs
@@ -179,3 +179,103 @@ fn rgb_fill_colours_separate_through_the_document_cmyk_profile() {
         }
     }
 }
+
+/// A two-stop version 1 `grdm` block whose stops are the PSD colour structures `a` and `b`.
+fn grdm_block(a: (u16, [u16; 4]), b: (u16, [u16; 4])) -> Vec<u8> {
+    let mut v = vec![0, 1, 0, 0];
+    v.extend_from_slice(&1u32.to_be_bytes()); // name: just the terminator
+    v.extend_from_slice(&[0, 0]);
+    v.extend_from_slice(&2u16.to_be_bytes());
+    for (t, (space, c)) in [(0u32, a), (4096, b)] {
+        v.extend_from_slice(&t.to_be_bytes());
+        v.extend_from_slice(&50u32.to_be_bytes());
+        v.extend_from_slice(&space.to_be_bytes());
+        for x in c {
+            v.extend_from_slice(&x.to_be_bytes());
+        }
+        v.extend_from_slice(&[0, 0]);
+    }
+    v.extend_from_slice(&2u16.to_be_bytes());
+    for t in [0u32, 4096] {
+        v.extend_from_slice(&t.to_be_bytes());
+        v.extend_from_slice(&50u32.to_be_bytes());
+        v.extend_from_slice(&255u16.to_be_bytes());
+    }
+    v.extend_from_slice(&2u16.to_be_bytes()); // expansion count
+    v.extend_from_slice(&0u16.to_be_bytes()); // smoothness
+    v
+}
+
+fn saved_grdm(bytes: &[u8]) -> Vec<u8> {
+    let f = photocraft_psd::PsdFile::from_bytes(bytes).unwrap();
+    f.layers().iter().find_map(|l| l.block(b"grdm")).map(|b| b.data.clone()).expect("grdm block")
+}
+
+#[test]
+fn gradient_maps_with_cmyk_lab_gray_stops_import_and_keep_their_space() {
+    use photocraft_cms::{Intent, Transform, synth};
+    use photocraft_doc::{Adjustment, Document, Layer, LayerContent};
+    let profile = synth::cmyk_profile(&synth::CmykParams { tvi: [0.26, 0.26, 0.26, 0.3], grid_a2b: 5, grid_b2a: 9, ..Default::default() });
+    let profile = Profile::parse(&profile.to_bytes()).unwrap();
+    let to_srgb = Transform::new(&profile, Builtin::Srgb.profile(), Intent::RelativeColorimetric, true).unwrap();
+    // First stop 60 % cyan + 40 % black (stored inverted), second paper white.
+    let cmyk_stop = (2u16, [65535 - 39321, 65535, 65535, 65535 - 26214]);
+    let paper = (2u16, [65535; 4]);
+    let lab_dark = (7u16, [2000, 0, 0, 0]);
+    let lab_red = (7u16, [5000, 6000u16, 2000, 0]);
+    let gray_black = (8u16, [10000, 0, 0, 0]);
+    let gray_white = (8u16, [0, 0, 0, 0]);
+    for depth in SampleType::ALL {
+        for (mode, stops) in [(ColorMode::Cmyk, (cmyk_stop, paper)), (ColorMode::Lab, (lab_dark, lab_red)), (ColorMode::Grayscale, (gray_white, gray_black))] {
+            let block = grdm_block(stops.0, stops.1);
+            let mut doc = Document::new("map", photocraft_geom::Size::new(4, 2), mode, depth);
+            if mode == ColorMode::Cmyk {
+                doc.icc_profile = Some(profile.to_bytes());
+            }
+            let fmt = doc.pixel_format();
+            doc.layers.push(raster("Background", fmt, doc.bounds(), 3, false));
+            doc.layers.push(Layer::new("Map", LayerContent::Adjustment(Adjustment::Unsupported { psd_key: "grdm".into(), raw: block.clone() })));
+            let bytes = export(&doc, "x.psd", &ExportOptions::default()).unwrap().bytes;
+            let mut back = import("x.psd", &bytes).unwrap().document;
+            let LayerContent::Adjustment(Adjustment::GradientMap { stops: got, .. }) = &back.layers[1].content else {
+                panic!("{mode:?} {depth:?}: {:?}", back.layers[1].content);
+            };
+            let (first, last) = (got[0].1, got[got.len() - 1].1);
+            match mode {
+                ColorMode::Cmyk => {
+                    // Through the document's own profile, not the built-in coated CMYK.
+                    let mut expected = [0.0f32; 3];
+                    to_srgb.eval_fast(&[0.6, 0.0, 0.0, 0.4], &mut expected);
+                    assert!(first.iter().zip(expected).all(|(a, b)| (a - b).abs() < 1e-4), "{depth:?}: {first:?} vs {expected:?}");
+                    let builtin = photocraft_color::convert::cmyk_to_rgb([0.6, 0.0, 0.0, 0.4]);
+                    assert!(first.iter().zip(builtin).any(|(a, b)| (a - b).abs() > 1e-3), "the document profile is used");
+                }
+                ColorMode::Lab => {
+                    assert!(first.iter().all(|v| (v - first[0]).abs() < 1e-3) && first[0] < 0.3, "{first:?}");
+                    assert!(last[0] > last[1] + 0.2, "a = +60 is reddish: {last:?}");
+                }
+                // An inverting map, white to black.
+                _ => assert_eq!((first, last), ([1.0; 3], [0.0; 3])),
+            }
+            // The layer now renders: the composite differs from the background alone.
+            let with_map = photocraft_compose::flatten(&back).px;
+            let mut hidden = back.clone();
+            hidden.layers[1].visible = false;
+            assert!(max_diff(&with_map, &photocraft_compose::flatten(&hidden).px) > 0.01, "{mode:?} {depth:?}");
+            // Saving again keeps the block (and so the stops' colour space) byte for byte...
+            let again = export(&back, "x.psd", &ExportOptions::default()).unwrap().bytes;
+            assert_eq!(saved_grdm(&again), block, "{mode:?} {depth:?}");
+            // ...and so does toggling Reverse and Dither, which only flip their flags.
+            if let LayerContent::Adjustment(Adjustment::GradientMap { reverse, dither, .. }) = &mut back.layers[1].content {
+                *reverse = true;
+                *dither = true;
+            }
+            let flipped_file = export(&back, "x.psd", &ExportOptions::default()).unwrap().bytes;
+            let flipped = saved_grdm(&flipped_file);
+            assert_eq!(&flipped[2..4], &[1, 1]);
+            assert_eq!(flipped[4..], block[4..], "{mode:?} {depth:?}: stops keep their colour space");
+            let reopened = import("x.psd", &flipped_file).unwrap().document;
+            assert_eq!(reopened.layers[1].content, back.layers[1].content);
+        }
+    }
+}
diff --git a/crates/io/tests/common/mod.rs b/crates/io/tests/common/mod.rs
index f175badb35..28c1a01906 100644
--- a/crates/io/tests/common/mod.rs
+++ b/crates/io/tests/common/mod.rs
@@ -364,7 +364,12 @@ pub fn strict_block_errors(bytes: &[u8]) -> Vec<String> {
     if let Some(li) = &file.layer_info {
         let body = li.unpadded_len(v).unwrap_or(1);
         let pad = li.padding.as_ref().map_or(body % 2, |p| p.len() as u64);
-        if (body + pad) % 4 != 0 {
+        // In a global `Lr16`/`Lr32` block the padding to 4 follows the block, outside its length.
+        let after = match &file.layer_info_placement {
+            photocraft_psd::LayerInfoPlacement::GlobalBlock { padding, .. } => padding.as_ref().map_or((4 - (body + pad) % 4) % 4, |p| p.len() as u64),
+            photocraft_psd::LayerInfoPlacement::Section => 0,
+        };
+        if (body + pad + after) % 4 != 0 {
             errs.push(format!("layer info: {body} bytes + {pad} padding is not a multiple of 4"));
         }
     }
diff --git a/crates/io/tests/corpus.rs b/crates/io/tests/corpus.rs
index d45956dba8..776f27f89d 100644
--- a/crates/io/tests/corpus.rs
+++ b/crates/io/tests/corpus.rs
@@ -156,7 +156,7 @@ const PSD_TOOLS: Source = Source { label: "psd-tools corpus", dir: "corpus/psd-t
 
 /// Our Photoshop-authored oracles (256 files; https://github.com/storytold/photocraft-corpus),
 /// grouped by feature (`smart-filters`, `effects`, `text`, `adjustments/<mode><bits>`).
-const PHOTOSHOP: Source = Source { label: "photoshop oracles", dir: "corpus/photoshop", group_depth: 2, pass_floor: 133, roundtrip_floor: 258 };
+const PHOTOSHOP: Source = Source { label: "photoshop oracles", dir: "corpus/photoshop", group_depth: 2, pass_floor: 145, roundtrip_floor: 258 };
 
 /// The corpus directory; a missing corpus fails the test.
 fn locate(src: &Source) -> PathBuf {
diff --git a/crates/io/tests/flat.rs b/crates/io/tests/flat.rs
index 728f65d1f2..163ab8b3af 100644
--- a/crates/io/tests/flat.rs
+++ b/crates/io/tests/flat.rs
@@ -53,6 +53,70 @@ codec_rt!(tiff_gray8, "tiff", ColorMode::Grayscale, SampleType::U8, false, 0.0);
 codec_rt!(fits_rgb8, "fits", ColorMode::Rgb, SampleType::U8, false, 0.0);
 codec_rt!(fits_gray16, "fit", ColorMode::Grayscale, SampleType::U16, false, 0.0);
 codec_rt!(fits_rgb32, "fits", ColorMode::Rgb, SampleType::F32, false, 0.0);
+codec_rt!(dpx_gray8, "dpx", ColorMode::Grayscale, SampleType::U8, false, 0.0);
+codec_rt!(dpx_rgb16, "dpx", ColorMode::Rgb, SampleType::U16, false, 0.0);
+codec_rt!(dpx_rgba16, "dpx", ColorMode::Rgb, SampleType::U16, true, 0.0);
+
+fn indexed_bmp_8() -> Vec<u8> {
+    const FILE_HEADER_SIZE: usize = 14;
+    const INFO_HEADER_SIZE: usize = 40;
+    const PALETTE_ENTRY_SIZE: usize = 4;
+    const PALETTE: [[u8; 3]; 2] = [[10, 20, 30], [200, 100, 50]];
+    const PIXEL_ROW: [u8; 4] = [0, 1, 0, 0];
+    let pixel_offset = FILE_HEADER_SIZE + INFO_HEADER_SIZE + PALETTE.len() * PALETTE_ENTRY_SIZE;
+    let file_size = pixel_offset + PIXEL_ROW.len();
+    let mut bytes = Vec::with_capacity(file_size);
+    bytes.extend_from_slice(b"BM");
+    bytes.extend_from_slice(&(file_size as u32).to_le_bytes());
+    bytes.extend_from_slice(&[0; 4]);
+    bytes.extend_from_slice(&(pixel_offset as u32).to_le_bytes());
+    bytes.extend_from_slice(&(INFO_HEADER_SIZE as u32).to_le_bytes());
+    bytes.extend_from_slice(&2i32.to_le_bytes());
+    bytes.extend_from_slice(&1i32.to_le_bytes());
+    bytes.extend_from_slice(&1u16.to_le_bytes());
+    bytes.extend_from_slice(&8u16.to_le_bytes());
+    bytes.extend_from_slice(&0u32.to_le_bytes());
+    bytes.extend_from_slice(&(PIXEL_ROW.len() as u32).to_le_bytes());
+    bytes.extend_from_slice(&0i32.to_le_bytes());
+    bytes.extend_from_slice(&0i32.to_le_bytes());
+    bytes.extend_from_slice(&(PALETTE.len() as u32).to_le_bytes());
+    bytes.extend_from_slice(&0u32.to_le_bytes());
+    for [r, g, b] in PALETTE {
+        bytes.extend_from_slice(&[b, g, r, 0]);
+    }
+    bytes.extend_from_slice(&PIXEL_ROW);
+    bytes
+}
+
+#[test]
+fn indexed_bmp_opens_with_its_color_table() {
+    let doc = import("indexed.bmp", &indexed_bmp_8()).unwrap().document;
+    assert_eq!(doc.mode, ColorMode::Indexed);
+    assert_eq!(doc.depth, SampleType::U8);
+    assert_eq!(doc.color_table.as_ref().unwrap().colors.get(..2), Some(&[[10, 20, 30], [200, 100, 50]][..]));
+    let px = doc.layers[0].surface().unwrap().rgba(1, 0);
+    assert!((px[0] - 200.0 / 255.0).abs() < 1e-6);
+    assert!((px[1] - 100.0 / 255.0).abs() < 1e-6);
+    assert!((px[2] - 50.0 / 255.0).abs() < 1e-6);
+}
+
+/// A palette PNG opens in Indexed Color mode with its whole colour table and its transparent
+/// entry, as in Photoshop (#4804).
+#[test]
+fn indexed_png_opens_with_its_color_table() {
+    let pal = [[10, 20, 30], [200, 100, 50], [7, 8, 9], [0, 255, 0]];
+    let png = photocraft_codecs::encode_png_indexed(2, 2, &[1, 0, 2, 1], &pal, Some(2), None).unwrap();
+    let doc = import("indexed.png", &png).unwrap().document;
+    assert_eq!(doc.mode, ColorMode::Indexed);
+    assert_eq!(doc.depth, SampleType::U8);
+    let table = doc.color_table.as_ref().unwrap();
+    assert_eq!(table.colors, pal, "every entry, used or not");
+    assert_eq!(table.transparent, Some(2));
+    let s = doc.layers[0].surface().unwrap();
+    let px = s.rgba(0, 0);
+    assert!((px[0] - 200.0 / 255.0).abs() < 1e-6 && (px[3] - 1.0).abs() < 1e-6);
+    assert_eq!(s.rgba(0, 1)[3], 0.0, "the tRNS entry is transparent");
+}
 
 /// FITS header cards travel as the document's text metadata, so an astro frame keeps its
 /// OBJECT, EXPTIME and the rest through an edit.
@@ -68,6 +132,25 @@ fn fits_header_cards_round_trip_as_text() {
     }
 }
 
+/// DPX header fields travel as the document's text metadata and come back on a DPX export at the
+/// chosen bit depth; the transfer characteristic is reported when the frame is opened (#1049).
+#[test]
+fn dpx_header_fields_and_encoding_notes_round_trip_through_the_document() {
+    let mut d = single(ColorMode::Rgb, SampleType::U16, false);
+    d.metadata.text = vec![("DPX:Project".into(), "Reel 7".into()), ("DPX:Transfer".into(), "3".into()), ("DPX:TimeCode".into(), "01:00:00:12".into())];
+    let mut opts = ExportOptions::default();
+    opts.encode.dpx_bits = Some(DpxBits::Bits10);
+    let r = export(&d, "a.dpx", &opts).unwrap();
+    assert!(r.bytes.starts_with(b"SDPX"));
+    assert_eq!(r.bytes[803], 10, "bits per sample");
+    let back = import("a.dpx", &r.bytes).unwrap();
+    for kv in &d.metadata.text {
+        assert!(back.document.metadata.text.contains(kv), "{kv:?}: {:?}", back.document.metadata.text);
+    }
+    assert!(back.warnings.iter().any(|w| w.contains("transfer characteristic: logarithmic (3)")), "{:?}", back.warnings);
+    assert_eq!(back.document.depth, SampleType::U16);
+}
+
 /// EXR stores linear light: a linear document round-trips exactly; an sRGB (untagged) one is
 /// linearised on export and comes back tagged linear sRGB with the same colours.
 #[test]
@@ -460,6 +543,73 @@ fn non_srgb_rgb_is_converted_to_srgb_for_formats_without_a_profile() {
     }
 }
 
+/// A linear gray document needs the same display encoding as linear RGB when its profile
+/// cannot be embedded. Check decoded samples against the transfer function independently.
+#[test]
+fn linear_gray_exports_without_profiles_use_display_encoding() {
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        let mut d = columns(ColorMode::Grayscale, depth, &[&[0.25, 1.0], &[0.5, 1.0]]);
+        d.icc_profile = Some(photocraft_cms::builtin::linear_gray().to_bytes());
+        let stored = column_pixels(&d, 2);
+        for ext in ["tga", "bmp", "gif", "qoi"] {
+            let r = export(&d, ext, &ExportOptions::default()).unwrap();
+            let img = photocraft_codecs::decode(&r.bytes).unwrap();
+            let values = img.to_normalized();
+            let stride = img.layout().channels();
+            for (i, src) in stored.iter().enumerate() {
+                let expected = photocraft_color::convert::linear_to_srgb(src[0]);
+                assert!(
+                    (values[16 * i * stride] - expected).abs() <= 1.5 / 255.0,
+                    "{depth:?} {ext} pixel {i}: got {}, expected {expected}",
+                    values[16 * i * stride]
+                );
+            }
+            assert!(r.warnings.iter().any(|w| w.contains("converted to sGray")), "{depth:?} {ext}: {:?}", r.warnings);
+        }
+    }
+}
+
+#[test]
+fn default_gray_exports_without_profiles_keep_samples() {
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        for icc in [None, Some(photocraft_cms::Builtin::SGray.profile().to_bytes())] {
+            let mut d = columns(ColorMode::Grayscale, depth, &[&[0.25, 1.0], &[0.5, 1.0]]);
+            d.icc_profile = icc;
+            let stored = column_pixels(&d, 2);
+            for ext in ["tga", "bmp", "gif", "qoi"] {
+                let r = export(&d, ext, &ExportOptions::default()).unwrap();
+                let img = photocraft_codecs::decode(&r.bytes).unwrap();
+                let values = img.to_normalized();
+                let stride = img.layout().channels();
+                for (i, src) in stored.iter().enumerate() {
+                    assert!((values[16 * i * stride] - src[0]).abs() <= 1.0 / 255.0, "{depth:?} {ext} pixel {i}");
+                }
+                assert!(!r.warnings.iter().any(|w| w.contains("converted to sGray")), "{depth:?} {ext}: {:?}", r.warnings);
+            }
+        }
+    }
+}
+
+#[test]
+fn linear_gray_export_preserves_alpha_and_embeddable_profiles() {
+    for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        let mut d = columns(ColorMode::Grayscale, depth, &[&[0.25, 0.5]]);
+        d.icc_profile = Some(photocraft_cms::builtin::linear_gray().to_bytes());
+        let stored = column_pixels(&d, 1);
+        let r = export(&d, "tga", &ExportOptions::default()).unwrap();
+        let img = photocraft_codecs::decode(&r.bytes).unwrap();
+        assert_eq!(img.layout(), photocraft_codecs::ChannelLayout::GrayA);
+        let values = img.to_normalized();
+        let expected = photocraft_color::convert::linear_to_srgb(stored[0][0]);
+        assert!((values[0] - expected).abs() <= 1.5 / 255.0, "{depth:?}: gray {} vs {expected}", values[0]);
+        assert!((values[1] - stored[0][1]).abs() <= 1.0 / 255.0, "{depth:?}: alpha changed");
+        let r = export(&d, "png", &ExportOptions::default()).unwrap();
+        let back = import("gray.png", &r.bytes).unwrap().document;
+        assert_eq!(back.icc_profile, d.icc_profile, "{depth:?}: PNG keeps linear gray ICC");
+        assert_colors(&column_pixels(&back, 1), &stored, 1.0 / 255.0, "PNG keeps gray samples");
+    }
+}
+
 /// #518: a JPEG cut off inside its image data opens with a warning, never silently.
 #[test]
 fn truncated_jpeg_imports_with_a_warning() {
@@ -831,3 +981,20 @@ fn tga_default_bits_follow_the_alpha_channels() {
     assert_eq!(tga_default_bits(&with_alpha_channel(d, "Alpha 1")), TgaBits::Bits32);
     assert_eq!((TgaBits::from_bits(24), TgaBits::from_bits(32), TgaBits::from_bits(16)), (Some(TgaBits::Bits24), Some(TgaBits::Bits32), None));
 }
+
+#[test]
+fn a_lab_document_with_one_layer_is_not_reported_as_flattened() {
+    // Lab always goes through the sRGB composite, but a lone layer loses nothing to it.
+    let d = single(ColorMode::Lab, SampleType::U8, false);
+    for ext in ["tif", "png", "jpg"] {
+        let r = export(&d, ext, &ExportOptions::default()).unwrap();
+        assert!(r.warnings.iter().all(|w| !w.contains("flattened")), "{ext}: {:?}", r.warnings);
+        assert!(r.warnings.iter().any(|w| w.contains("Lab composite written as sRGB")), "{ext}: {:?}", r.warnings);
+    }
+    // Two layers are flattened, and say so.
+    let mut two = single(ColorMode::Lab, SampleType::U8, false);
+    let fmt = two.pixel_format();
+    two.layers.push(raster("Top", fmt, two.bounds(), 5, true));
+    let r = export(&two, "tif", &ExportOptions::default()).unwrap();
+    assert!(r.warnings.iter().any(|w| w.contains("2 layer(s) flattened")), "{:?}", r.warnings);
+}
diff --git a/crates/io/tests/krita_corpus.rs b/crates/io/tests/krita_corpus.rs
index cafbe2c718..b0b3a01d63 100644
--- a/crates/io/tests/krita_corpus.rs
+++ b/crates/io/tests/krita_corpus.rs
@@ -1,4 +1,4 @@
-//! Krita-authored oracles: OpenRaster (`.ora`) files whose archives carry
+//! Krita-authored oracles: OpenRaster (`.ora`) and Krita (`.kra`) files whose archives carry
 //! Krita's own rendering of the layer stack (`mergedimage.png`). The files are generated by
 //! `tools/krita-oracles/generate.py` in https://github.com/storytold/photocraft-corpus and are
 //! not bundled. Run with
@@ -47,6 +47,10 @@ const KNOWN: &[(&str, f32, &str)] = &[
     ("blend-lighter_color.ora", 0.02, "Krita weighs the channels differently when it picks the lighter colour; near-ties pick the other pixel"),
     ("blend-hard_mix_photoshop.ora", 0.02, "a channel sum of exactly 1 goes up in Photoshop's Hard Mix (ours) and down in Krita's"),
     ("depth-rgba-u16.ora", 1.0, "Krita blends this linear-light 16-bit document in linear light, but its ORA export stores sRGB 8-bit layers"),
+    ("blend-darker_color.kra", 0.02, "as for the .ora"),
+    ("blend-lighter_color.kra", 0.02, "as for the .ora"),
+    ("blend-hard_mix_photoshop.kra", 0.02, "as for the .ora"),
+    ("nodes-vector-unsupported.kra", 0.2, "vector layers are left out of .kra imports (reported); Krita's merged image has the shape"),
 ];
 
 fn run(ext: &str, tolerance: f32) {
@@ -85,3 +89,9 @@ fn run(ext: &str, tolerance: f32) {
 fn krita_ora_files_match_their_merged_image() {
     run("ora", 3.0 / 255.0);
 }
+
+#[test]
+#[ignore = "requires KRITA_TEST_DIR with Krita-authored .kra files"]
+fn krita_kra_files_match_their_merged_image() {
+    run("kra", 3.0 / 255.0);
+}
diff --git a/crates/io/tests/multichannel.rs b/crates/io/tests/multichannel.rs
new file mode 100644
index 0000000000..d6016070d1
--- /dev/null
+++ b/crates/io/tests/multichannel.rs
@@ -0,0 +1,142 @@
+//! Multichannel PSDs: alpha-type channels and the document's resources and global blocks survive
+//! an import → export → import round trip.
+
+use photocraft_doc::{ColorIndicates, Knot, NamedPath, Path, PathOp, Subpath};
+use photocraft_io::*;
+use photocraft_psd::resources::ImageResource;
+use photocraft_psd::{ColorMode, Compression, PsdFile, TaggedBlock, Version, testgen};
+
+/// DisplayInfo (1077) record: RGB colour, opacity (0..100) and kind (0/1 alpha, 2 spot).
+fn display_record(out: &mut Vec<u8>, rgb: [u16; 3], opacity: u16, kind: u8) {
+    out.extend_from_slice(&0u16.to_be_bytes());
+    for v in [rgb[0], rgb[1], rgb[2], 0] {
+        out.extend_from_slice(&v.to_be_bytes());
+    }
+    out.extend_from_slice(&opacity.to_be_bytes());
+    out.push(kind);
+}
+
+/// A two-channel Multichannel file: a cyan spot ink and an alpha channel (masked areas, red 50 %).
+fn file(depth: u16) -> PsdFile {
+    let mut f = testgen::merged_only(Version::Psd, ColorMode::Multichannel, depth, Compression::Rle, 9, 5);
+    let mut info = 1u32.to_be_bytes().to_vec();
+    display_record(&mut info, [0, 65535, 65535], 0, 2);
+    display_record(&mut info, [65535, 0, 0], 50, 1);
+    f.resources.push(ImageResource::new(1077, info));
+    f
+}
+
+fn roundtrip(d: &photocraft_doc::Document) -> (PsdFile, photocraft_doc::Document) {
+    let out = export(d, "x.psd", &ExportOptions::default()).unwrap();
+    let back = PsdFile::from_bytes(&out.bytes).unwrap();
+    let (doc, _) = psd_to_document(&back);
+    (back, doc)
+}
+
+#[test]
+fn alpha_type_channels_import_as_alpha_and_round_trip() {
+    for depth in [8, 16] {
+        let f = file(depth);
+        let (d, _) = psd_to_document(&f);
+        assert_eq!(d.channels.len(), 2);
+        assert_eq!(d.channels[0].spot.map(|(c, _)| c.to_rgb()), Some([0.0, 1.0, 1.0]));
+        let a = &d.channels[1];
+        assert_eq!(a.spot, None, "an alpha-type channel is not a spot ink ({depth}-bit)");
+        assert_eq!(a.color.to_rgb(), [1.0, 0.0, 0.0]);
+        assert!((a.opacity - 0.5).abs() < 1e-6);
+        assert_eq!(a.indicates, ColorIndicates::MaskedAreas);
+
+        // It still prints as black ink, so the composite is what a black spot channel gives.
+        let mut as_ink = d.clone();
+        as_ink.channels[1].spot = Some((photocraft_color::Color::BLACK, 0.0));
+        assert_eq!(photocraft_compose::flatten(&d).px, photocraft_compose::flatten(&as_ink).px);
+
+        // Saved back unchanged: same DisplayInfo, same planes, same channels on reopening.
+        let (back, d2) = roundtrip(&d);
+        assert_eq!(back.resource(1077).map(|r| r.data.clone()), f.resource(1077).map(|r| r.data.clone()));
+        assert_eq!(back.decode_merged().unwrap(), f.decode_merged().unwrap());
+        assert_eq!(d2.channels[1].spot, None);
+        assert_eq!(d2.channels[1].indicates, ColorIndicates::MaskedAreas);
+        assert!((d2.channels[1].opacity - 0.5).abs() < 1e-6);
+        assert!(d2.channels[0].spot.is_some());
+    }
+}
+
+#[test]
+fn resources_and_global_blocks_survive_a_save() {
+    let mut f = file(8);
+    let iptc = vec![0x1c, 2, 0, 0, 2, 0, 4];
+    let print_flags = vec![0, 0, 0, 0, 0, 0, 0, 1, 0];
+    let seed = 7u32.to_be_bytes().to_vec();
+    let alpha_ids = [0u32, 1].iter().flat_map(|v| v.to_be_bytes()).collect::<Vec<u8>>();
+    f.resources.push(ImageResource::new(1028, iptc.clone()));
+    f.resources.push(ImageResource::new(1011, print_flags.clone()));
+    f.resources.push(ImageResource::new(1044, seed.clone()));
+    f.resources.push(ImageResource::new(1053, alpha_ids.clone()));
+    // A target-layer index describes layers, which a Multichannel document doesn't have.
+    f.resources.push(ImageResource::new(1024, vec![0, 0]));
+    let fmsk = vec![0, 0, 0, 0, 0, 50];
+    f.global_blocks.push(TaggedBlock::new(*b"FMsk", fmsk.clone()));
+    let (mut d, _) = psd_to_document(&f);
+    d.guides.horizontal.push(2.0);
+    d.guides.vertical.push(3.0);
+    d.global_light.angle = 60.0;
+    let path =
+        Path::new(vec![Subpath { closed: true, op: PathOp::Combine, knots: vec![Knot::corner(1.0, 1.0), Knot::corner(8.0, 1.0), Knot::corner(4.0, 4.0)] }]);
+    d.paths.push(NamedPath { name: "Outline".into(), path, psd_raw: None });
+
+    let (back, d2) = roundtrip(&d);
+    let res = |id: u16| back.resource(id).map(|r| r.data.clone());
+    assert_eq!(res(1028), Some(iptc));
+    assert_eq!(res(1011), Some(print_flags));
+    assert_eq!(res(1044), Some(seed));
+    assert_eq!(res(1053), Some(alpha_ids));
+    assert_eq!(res(1024), None);
+    let blocks: Vec<_> = back.global_blocks.iter().filter(|b| &b.key == b"FMsk").collect();
+    assert_eq!(blocks.len(), 1);
+    assert_eq!(blocks[0].data, fmsk);
+    assert_eq!(d2.guides.horizontal, vec![2.0]);
+    assert_eq!(d2.guides.vertical, vec![3.0]);
+    assert_eq!(d2.global_light.angle, 60.0);
+    // The file's own saved path and the new one.
+    let names: Vec<&str> = d2.paths.iter().map(|p| p.name.as_str()).collect();
+    assert_eq!(names, ["Path 1", "Outline"]);
+    let anchors = |p: &Path| p.subpaths.iter().flat_map(|s| s.knots.iter().map(|k| (k.anchor.x, k.anchor.y))).collect::<Vec<_>>();
+    let (got, want) = (anchors(&d2.paths[1].path), anchors(&d.paths[1].path));
+    assert_eq!(got.len(), want.len());
+    assert!(got.iter().zip(&want).all(|(a, b)| (a.0 - b.0).abs() < 1e-3 && (a.1 - b.1).abs() < 1e-3), "{got:?}");
+    assert_eq!(back.decode_merged().unwrap(), f.decode_merged().unwrap());
+
+    // Alpha identifiers that no longer match the channels are not written.
+    d.channels.pop();
+    let (back, _) = roundtrip(&d);
+    assert!(back.resource(1053).is_none());
+}
+
+/// A Photoshop Multichannel file: its alpha-type channel stays an alpha channel and a save keeps
+/// every resource except the thumbnail (regenerated) and every document-level block.
+#[cfg(feature = "corpus")]
+#[test]
+fn corpus_multichannel_round_trip_keeps_channels_and_resources() {
+    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../corpus/psd/psd-tools/colormodes/4x4_16bit_multichannel.psd");
+    assert!(path.is_file(), "{} is missing: run `cargo xtask corpus --all`", path.display());
+    let bytes = std::fs::read(&path).unwrap();
+    let f = PsdFile::from_bytes(&bytes).unwrap();
+    let (d, _) = psd_to_document(&f);
+    let alpha: Vec<_> = d.channels.iter().filter(|c| c.spot.is_none()).collect();
+    assert!(!alpha.is_empty(), "the file's alpha-type channel imports as an alpha channel");
+    for a in &alpha {
+        assert_eq!(a.indicates, ColorIndicates::MaskedAreas);
+        assert_eq!(a.color.to_rgb(), [1.0, 0.0, 0.0]);
+        assert!((a.opacity - 0.5).abs() < 1e-6);
+    }
+    let (back, d2) = roundtrip(&d);
+    assert_eq!(back.resource(1077).map(|r| r.data.clone()), f.resource(1077).map(|r| r.data.clone()));
+    assert_eq!(back.decode_merged().unwrap(), f.decode_merged().unwrap());
+    assert_eq!(d2.channels.iter().filter(|c| c.spot.is_none()).count(), alpha.len());
+    let mut lost: Vec<u16> = f.resources.iter().map(|r| r.id).filter(|id| back.resource(*id).is_none()).collect();
+    lost.retain(|id| *id != 1036);
+    assert!(lost.is_empty(), "resources lost on save: {lost:?}");
+    let keys = |f: &PsdFile| f.global_blocks.iter().map(|b| b.key).collect::<Vec<_>>();
+    assert_eq!(keys(&back), keys(&f));
+}
diff --git a/crates/io/tests/pcraft_manifest_name.rs b/crates/io/tests/pcraft_manifest_name.rs
new file mode 100644
index 0000000000..285fa02203
--- /dev/null
+++ b/crates/io/tests/pcraft_manifest_name.rs
@@ -0,0 +1,38 @@
+//! A `.pcraft` bundle's manifest reports the file it is in (#3312): writing a document to a new
+//! name must not leave the previous one inside, on every path that produces `.pcraft` bytes.
+
+mod common;
+
+use common::*;
+use photocraft_color::{ColorMode, SampleType};
+use photocraft_format::zip::ZipReader;
+use photocraft_io::*;
+
+fn doc() -> photocraft_doc::Document {
+    let mut d = gen_doc(ColorMode::Rgb, SampleType::U8, Features::PIXELS);
+    d.name = "FirstTest.psd".into();
+    d
+}
+
+/// `document.name` as the bundle actually stores it.
+fn manifest_name(bytes: &[u8]) -> String {
+    let archive = ZipReader::new(bytes).expect("zip");
+    let manifest: serde_json::Value = serde_json::from_slice(&archive.read_by_name("manifest.json", usize::MAX).expect("manifest")).expect("manifest json");
+    manifest["document"]["name"].as_str().expect("document.name").to_string()
+}
+
+/// Save As to a new name: the written file names itself, so reopening it agrees with the session
+/// that wrote it instead of reporting the file it came from.
+#[test]
+fn export_names_the_manifest_after_the_file() {
+    let r = export(&doc(), "/tmp/somewhere/_nametest.pcraft", &ExportOptions::default()).expect("export");
+    assert_eq!(manifest_name(&r.bytes), "_nametest.pcraft");
+    assert_eq!(photocraft_format::load_from_bytes(&r.bytes).expect("load").name, "_nametest.pcraft");
+}
+
+/// A bare extension names no file and leaves the document's own name alone.
+#[test]
+fn a_bare_extension_names_no_file() {
+    let r = export(&doc(), "pcraft", &ExportOptions::default()).expect("export");
+    assert_eq!(manifest_name(&r.bytes), "FirstTest.psd");
+}
diff --git a/crates/io/tests/psd_background.rs b/crates/io/tests/psd_background.rs
new file mode 100644
index 0000000000..d24d24409e
--- /dev/null
+++ b/crates/io/tests/psd_background.rs
@@ -0,0 +1,39 @@
+//! A PSD's Background is recognised by its structure (the bottom record, transparency-protected,
+//! stored without a transparency channel), whatever its name in the Photoshop language that
+//! saved the file.
+
+use photocraft_io::psd_to_document;
+use photocraft_psd::{ColorMode, Compression, PsdFile, TaggedBlock, Version, testgen};
+
+/// `testgen::layered` with its bottom layer turned into a Photoshop Background named `name`.
+fn file(name: &str, transparency_channel: bool) -> PsdFile {
+    let mut f = testgen::layered(Version::Psd, ColorMode::Rgb, 8, Compression::Rle);
+    let bottom = f.layers_mut().first_mut().unwrap();
+    bottom.name = name.bytes().filter(u8::is_ascii).collect();
+    bottom.blocks.retain(|b| &b.key != b"luni" && &b.key != b"lspf");
+    bottom.blocks.push(TaggedBlock::unicode_name(name));
+    bottom.flags.set_transparency_protected(true);
+    if !transparency_channel {
+        bottom.channels.retain(|c| c.id != -1);
+    }
+    f
+}
+
+#[test]
+fn a_localized_background_is_the_background() {
+    for name in ["Hintergrund", "背景", "Arrière-plan"] {
+        let (d, _) = psd_to_document(&file(name, false));
+        let bg = d.background().unwrap_or_else(|| panic!("{name}: no Background"));
+        assert_eq!(bg.name, name);
+        assert!(bg.locks.transparency && bg.locks.position, "{name}");
+        assert_eq!(bg.id, d.layers[0].id);
+    }
+}
+
+#[test]
+fn a_protected_layer_with_transparency_is_not_the_background() {
+    // Lock Transparent Pixels on an ordinary bottom layer: it keeps its transparency channel.
+    let (d, _) = psd_to_document(&file("Background", true));
+    assert!(d.layers[0].locks.transparency);
+    assert!(d.background().is_none());
+}
diff --git a/crates/io/tests/psd_font_identity.rs b/crates/io/tests/psd_font_identity.rs
new file mode 100644
index 0000000000..39a51c147d
--- /dev/null
+++ b/crates/io/tests/psd_font_identity.rs
@@ -0,0 +1,126 @@
+//! #3833: hyphens inside an installed family must survive PSD save/reopen and editing.
+//! The fixtures rename the OFL bundled fonts in memory; no proprietary fonts are needed.
+
+use photocraft_color::{ColorMode, SampleType};
+use photocraft_doc::{
+    Document, Layer, LayerContent, TextLayer,
+    text::{CharStyle, TextRun},
+};
+use photocraft_geom::Size;
+use photocraft_text::fonts::{INTER_REGULAR, JETBRAINS_MONO_REGULAR};
+
+fn renamed_font(source: &[u8], family: &str, ps: &str) -> Vec<u8> {
+    font_with_names(source, &[(1, family), (2, "Regular"), (6, ps), (16, family), (17, "Regular")])
+}
+
+fn font_with_names(source: &[u8], names: &[(u16, &str)]) -> Vec<u8> {
+    let mut bytes = source.to_vec();
+    let count = u16::from_be_bytes(bytes[4..6].try_into().unwrap()) as usize;
+    let record = (0..count).map(|i| 12 + i * 16).find(|r| &bytes[*r..*r + 4] == b"name").unwrap();
+    let mut table = Vec::new();
+    let mut strings = Vec::new();
+    for value in [0u16, names.len() as u16, (6 + names.len() * 12) as u16] {
+        table.extend(value.to_be_bytes());
+    }
+    for &(id, value) in names {
+        let encoded: Vec<_> = value.encode_utf16().flat_map(u16::to_be_bytes).collect();
+        for n in [3, 1, 0x409, id, encoded.len() as u16, strings.len() as u16] {
+            table.extend(n.to_be_bytes());
+        }
+        strings.extend(encoded);
+    }
+    table.extend(strings);
+    let offset = bytes.len() as u32;
+    bytes[record + 8..record + 12].copy_from_slice(&offset.to_be_bytes());
+    bytes[record + 12..record + 16].copy_from_slice(&(table.len() as u32).to_be_bytes());
+    bytes.extend(table);
+    bytes
+}
+
+fn roundtrip(family: &str, ps: Option<&str>, install_prefix: bool) {
+    let actual_ps = ps.map(str::to_string).unwrap_or_else(|| format!("{family}-Book").replace(' ', ""));
+    {
+        let mut engine = photocraft_text::shared().lock().unwrap();
+        engine.fonts.register_font_data(renamed_font(&JETBRAINS_MONO_REGULAR, family, &actual_ps));
+        if install_prefix {
+            let prefix = family.split_once('-').unwrap().0;
+            engine.fonts.register_font_data(renamed_font(&INTER_REGULAR, prefix, &format!("{prefix}-Regular")));
+        }
+    }
+    roundtrip_registered_fonts(family, ps);
+}
+
+fn roundtrip_registered_fonts(family: &str, ps: Option<&str>) {
+    let mut doc = Document::new("fonts", Size::new(256, 64), ColorMode::Rgb, SampleType::U8);
+    let mut original = TextLayer {
+        text: "Wide WWW iii".into(),
+        runs: vec![TextRun {
+            len: 12,
+            style: CharStyle { font_family: family.into(), postscript_name: ps.map(str::to_string), size_pt: 24.0, ..Default::default() },
+        }],
+        ..Default::default()
+    };
+    original.sync_summary();
+    photocraft_text::shared().lock().unwrap().render_layer(&mut original, doc.resolution_dpi, doc.pixel_format());
+    doc.layers.push(Layer::new("type", LayerContent::Text(original.clone())));
+    let bytes = photocraft_io::export(&doc, "fonts.psd", &Default::default()).unwrap().bytes;
+    let mut reopened = photocraft_io::import("fonts.psd", &bytes).unwrap().document;
+    let LayerContent::Text(text) = &mut reopened.layers[0].content else { panic!("expected editable text") };
+    assert!(text.cache.is_some(), "opening retains the original appearance");
+    let before = original.cache.as_ref().unwrap();
+    let opened = text.cache.as_ref().unwrap();
+    assert_eq!(opened.read_region(before.content_bounds()), before.read_region(before.content_bounds()), "PSD pixels retain the original font before editing");
+    assert_eq!(text.font_family, family, "the Character panel must show the installed family");
+    assert_eq!(text.char_runs()[0].style.font_family, family);
+    assert_eq!(text.char_runs()[0].style.weight, original.char_runs()[0].style.weight);
+    assert_eq!(text.char_runs()[0].style.italic, original.char_runs()[0].style.italic);
+    if let Some(ps) = ps {
+        assert_eq!(text.char_runs()[0].style.postscript_name.as_deref(), Some(ps));
+    }
+    // Editing drops the PSD pixels and regenerates them from the reopened model.
+    text.text.push('!');
+    text.runs[0].len += 1;
+    text.cache = None;
+    text.psd_raw = None;
+    original.text.push('!');
+    original.runs[0].len += 1;
+    let mut engine = photocraft_text::shared().lock().unwrap();
+    let expected = engine.layout(&original, doc.resolution_dpi);
+    let actual = engine.layout(text, doc.resolution_dpi);
+    assert!((expected.lines[0].x1 - actual.lines[0].x1).abs() < 0.01, "editing must keep the same font outlines");
+    engine.render_layer(text, doc.resolution_dpi, doc.pixel_format());
+    engine.render_layer(&mut original, doc.resolution_dpi, doc.pixel_format());
+    let edited = text.cache.as_ref().unwrap();
+    let expected_pixels = original.cache.as_ref().unwrap();
+    assert_eq!(edited.content_bounds(), expected_pixels.content_bounds());
+    assert_eq!(edited.read_region(expected_pixels.content_bounds()), expected_pixels.read_region(expected_pixels.content_bounds()));
+}
+
+#[test]
+fn family_only_hyphenated_font_survives_psd_reopen_and_edit() {
+    roundtrip("FOT-NewRodin Pro", None, false);
+}
+
+#[test]
+fn exact_postscript_identity_wins_over_installed_prefix_family() {
+    roundtrip("Prefix-Hyphenated Pro", Some("Prefix-Book"), true);
+}
+
+#[test]
+fn installed_family_survives_a_face_indexed_under_its_typographic_family() {
+    const FAMILY: &str = "Indexed Alias";
+    const PS: &str = "IndexedAlias-Regular";
+    {
+        let mut engine = photocraft_text::shared().lock().unwrap();
+        // The requested family exists, but its exact PostScript face is listed under the
+        // typographic family, as with system fonts that separate legacy and typographic names.
+        engine.fonts.register_font_data(renamed_font(&INTER_REGULAR, FAMILY, "IndexedAlias-Other"));
+        engine.fonts.register_font_data(font_with_names(&JETBRAINS_MONO_REGULAR, &[(1, FAMILY), (2, "Regular"), (6, PS), (16, "Indexed"), (17, "Regular")]));
+        assert!(engine.fonts.has_family(FAMILY));
+        assert!(engine.fonts.faces(FAMILY).iter().all(|face| face.postscript_name.as_deref() != Some(PS)));
+        let exact = engine.fonts.resolve_postscript(PS);
+        assert!(exact.exact);
+        assert_eq!(exact.family, "Indexed");
+    }
+    roundtrip_registered_fonts(FAMILY, Some(PS));
+}
diff --git a/crates/io/tests/psd_layer_block_length.rs b/crates/io/tests/psd_layer_block_length.rs
new file mode 100644
index 0000000000..acb4a6b15c
--- /dev/null
+++ b/crates/io/tests/psd_layer_block_length.rs
@@ -0,0 +1,61 @@
+//! The global `Lr16` / `Lr32` block of a 16/32-bit export declares the exact length of the layer
+//! data, and its padding to 4 bytes follows outside that length (#4654).
+//!
+//! Photoshop writes these blocks this way. Readers that check the block length exactly (Unity's
+//! PSD Importer, "Incorrect length for InfoLayers") reject a block whose length counts the padding.
+
+mod common;
+
+use common::Features;
+use photocraft_color::{ColorMode, SampleType};
+use photocraft_io::*;
+use photocraft_psd::PsdFile;
+
+fn be(b: &[u8], at: usize, long: bool) -> usize {
+    if long { u64::from_be_bytes(b[at..at + 8].try_into().unwrap()) as usize } else { u32::from_be_bytes(b[at..at + 4].try_into().unwrap()) as usize }
+}
+
+/// Walks the raw file to the first global block and returns (key, declared length, the bytes
+/// after the data up to the next block or the end of the section).
+fn first_global_block(bytes: &[u8]) -> ([u8; 4], usize, Vec<u8>) {
+    let psb = be(bytes, 4, false) >> 16 == 2;
+    let mut p = 26;
+    p += 4 + be(bytes, p, false); // color mode data
+    p += 4 + be(bytes, p, false); // image resources
+    let lw = if psb { 8 } else { 4 };
+    let end = p + lw + be(bytes, p, psb);
+    p += lw;
+    p += lw + be(bytes, p, psb); // classic layer info
+    p += 4 + be(bytes, p, false); // global layer mask
+    let key: [u8; 4] = bytes[p + 4..p + 8].try_into().unwrap();
+    let len = be(bytes, p + 8, psb);
+    let data_end = p + 8 + if psb { 8 } else { 4 } + len;
+    let next = (data_end..end).find(|&q| bytes.get(q..q + 4).is_some_and(|s| s == b"8BIM" || s == b"8B64")).unwrap_or(end);
+    (key, len, bytes[data_end..next].to_vec())
+}
+
+#[test]
+fn lr16_lr32_length_excludes_padding() {
+    let mut unaligned = 0;
+    for (depth, key) in [(SampleType::U16, *b"Lr16"), (SampleType::F32, *b"Lr32")] {
+        for mode in [ColorMode::Rgb, ColorMode::Grayscale] {
+            for features in [Features::PIXELS, Features::ALL] {
+                let doc = common::gen_doc(mode, depth, features);
+                for path in ["x.psd", "x.psb"] {
+                    let name = format!("{depth:?} {mode:?} {path}");
+                    let bytes = export(&doc, path, &ExportOptions::default()).expect("export").bytes;
+                    let file = PsdFile::from_bytes(&bytes).expect("reparse");
+                    let body = file.layer_info.as_ref().expect("layers").unpadded_len(file.header.version).unwrap() as usize;
+                    let (k, len, after) = first_global_block(&bytes);
+                    assert_eq!(k, key, "{name}: first global block");
+                    assert_eq!(len, body, "{name}: declared length vs layer data");
+                    assert_eq!(after, vec![0; (4 - body % 4) % 4], "{name}: padding after the block");
+                    unaligned += usize::from(!body.is_multiple_of(4));
+                }
+            }
+        }
+    }
+    // Only a body that is not already a multiple of 4 tells padding inside the length apart from
+    // padding after it.
+    assert!(unaligned > 0, "no case exercises the padding");
+}
diff --git a/crates/io/tests/psd_maximize_compatibility.rs b/crates/io/tests/psd_maximize_compatibility.rs
new file mode 100644
index 0000000000..c8f277f6ee
--- /dev/null
+++ b/crates/io/tests/psd_maximize_compatibility.rs
@@ -0,0 +1,115 @@
+//! Preferences › File Handling › Maximize PSD and PSB File Compatibility: turned off, a layered
+//! PSD/PSB stores Photoshop's white placeholder instead of the merged image and says so in
+//! resource 1057 (`has_real_merged_data = false`). Layers, alpha channels and the Quick Mask are
+//! written as usual, so the file reopens the same.
+
+use photocraft_color::{ColorMode, PixelFormat, SampleType};
+use photocraft_doc::{AlphaChannel, Document, Layer};
+use photocraft_geom::{Rect, Size};
+use photocraft_io::{ExportOptions, export, import};
+use photocraft_psd::PsdFile;
+use photocraft_raster::Surface;
+
+fn compat_off() -> ExportOptions {
+    ExportOptions { psd_maximize_compatibility: false, ..Default::default() }
+}
+
+fn parse(bytes: &[u8]) -> PsdFile {
+    PsdFile::from_bytes(bytes).expect("parse")
+}
+
+/// A `w`×`h` document of `mode`/`depth` holding one layer of `rgba` over the whole canvas.
+fn filled(mode: ColorMode, depth: SampleType, w: u32, h: u32, rgba: [f32; 4]) -> Document {
+    let mut d = Document::new("compat", Size::new(w, h), mode, depth);
+    let fmt = d.pixel_format();
+    let mut px = vec![0.0; fmt.channels()];
+    photocraft_raster::from_rgba_into(&fmt, rgba, &mut px);
+    let mut layer = Layer::raster("pixels", fmt);
+    layer.surface_mut().unwrap().fill_rect(Rect::new(0, 0, w as i32, h as i32), &px);
+    d.layers.push(layer);
+    d
+}
+
+/// An 8-bit RGB document whose layer is seeded noise, alpha included: its merged image barely
+/// compresses, unlike the placeholder.
+fn noisy(w: u32, h: u32) -> Document {
+    let mut d = Document::new("noise", Size::new(w, h), ColorMode::Rgb, SampleType::U8);
+    let fmt = d.pixel_format();
+    let mut state = 0x2545_f491_u32;
+    let mut next = || {
+        state ^= state << 13;
+        state ^= state >> 17;
+        state ^= state << 5;
+        (state & 0xff) as f32 / 255.0
+    };
+    let vals: Vec<f32> = (0..(w * h) as usize * fmt.channels()).map(|_| next()).collect();
+    let mut layer = Layer::raster("noise", fmt);
+    layer.surface_mut().unwrap().write_region(Rect::new(0, 0, w as i32, h as i32), &vals);
+    d.layers.push(layer);
+    d
+}
+
+#[test]
+fn off_writes_the_white_placeholder_and_flags_it() {
+    let d = noisy(96, 64);
+    for name in ["x.psd", "x.psb"] {
+        let no_previews = |o: ExportOptions| ExportOptions { image_previews: false, ..o };
+        let on = export(&d, name, &no_previews(ExportOptions::default())).unwrap();
+        let off = export(&d, name, &no_previews(compat_off())).unwrap();
+        let (real, placeholder) = (parse(&on.bytes), parse(&off.bytes));
+        assert_eq!(real.has_real_merged_data(), Some(true), "{name}");
+        assert_eq!(placeholder.has_real_merged_data(), Some(false), "{name}");
+        assert!(real.merged_has_alpha() && !placeholder.merged_has_alpha(), "{name}: the placeholder has no alpha");
+        assert!(placeholder.composite_rgba8().unwrap().data.iter().all(|&b| b == 255), "{name}: opaque white");
+        assert_eq!(real.layers(), placeholder.layers(), "{name}: the layers are written the same");
+        assert!(off.bytes.len() * 3 < on.bytes.len() * 2, "{name}: {} bytes without the merged image, {} with it", off.bytes.len(), on.bytes.len());
+    }
+}
+
+/// The placeholder is exactly the white a real merged image would store, in every colour model
+/// and depth PSD has: CMYK white is no ink, Lab white is L 100 with neutral a*/b*.
+#[test]
+fn the_placeholder_is_the_white_a_real_merged_image_stores() {
+    use ColorMode::{Cmyk, Grayscale, Lab, Rgb};
+    use SampleType::{F32, U8, U16};
+    for (mode, depth) in
+        [(Rgb, U8), (Rgb, U16), (Rgb, F32), (Grayscale, U8), (Grayscale, U16), (Grayscale, F32), (Cmyk, U8), (Cmyk, U16), (Lab, U8), (Lab, U16)]
+    {
+        let d = filled(mode, depth, 9, 5, [1.0; 4]);
+        let real = parse(&export(&d, "x.psd", &ExportOptions::default()).unwrap().bytes);
+        let placeholder = parse(&export(&d, "x.psd", &compat_off()).unwrap().bytes);
+        assert_eq!(placeholder.has_real_merged_data(), Some(false), "{mode:?} {depth:?}");
+        assert!(!real.merged_has_alpha(), "{mode:?} {depth:?}: an opaque document");
+        assert_eq!(placeholder.header, real.header, "{mode:?} {depth:?}");
+        assert_eq!(placeholder.decode_merged().unwrap(), real.decode_merged().unwrap(), "{mode:?} {depth:?}");
+    }
+}
+
+#[test]
+fn layers_and_alpha_channels_reopen_unchanged() {
+    let mut d = noisy(32, 16);
+    let mut selection = Surface::new(PixelFormat::new(ColorMode::Grayscale, SampleType::U8, false));
+    selection.fill_rect(Rect::new(0, 0, 10, 16), &[1.0]);
+    d.channels.push(AlphaChannel::new("Alpha 1", selection.clone()));
+    d.quick_mask = Some(AlphaChannel::new("Quick Mask", selection));
+    let reopen = |opts: &ExportOptions| {
+        let r = import("x.psd", &export(&d, "x.psd", opts).unwrap().bytes).unwrap();
+        assert!(r.warnings.is_empty(), "{:?}", r.warnings);
+        r.document
+    };
+    let (on, off) = (reopen(&ExportOptions::default()), reopen(&compat_off()));
+    assert_eq!(off.layers.len(), 1);
+    assert_eq!(off.channels, on.channels, "alpha channels follow the placeholder");
+    assert_eq!(off.quick_mask, on.quick_mask);
+    let canvas = d.bounds();
+    assert_eq!(photocraft_compose::render(&off, canvas).px, photocraft_compose::render(&on, canvas).px, "the same image");
+}
+
+/// Without layer records the merged image is the only copy of the pixels, so it stays real.
+#[test]
+fn a_file_without_layers_keeps_its_real_merged_image() {
+    let d = Document::new("empty", Size::new(8, 8), ColorMode::Rgb, SampleType::U8);
+    let file = parse(&export(&d, "x.psd", &compat_off()).unwrap().bytes);
+    assert!(file.layers().is_empty());
+    assert_eq!(file.has_real_merged_data(), Some(true));
+}
diff --git a/crates/io/tests/psd_roundtrip_bytes.rs b/crates/io/tests/psd_roundtrip_bytes.rs
new file mode 100644
index 0000000000..dccd57856d
--- /dev/null
+++ b/crates/io/tests/psd_roundtrip_bytes.rs
@@ -0,0 +1,28 @@
+//! The parallel RLE/decode paths must not change output bytes: a document exported by this
+//! branch re-exports byte-equal after a decode/encode cycle, and matches main's exporter
+//! (verified by the corpus round-trip floors in `corpus.rs`; here the byte-equality of the
+//! codec layer itself is pinned).
+
+use photocraft_psd::compression::{Compression, PlaneLayout, decode_planes, encode_planes};
+use photocraft_psd::header::Version;
+
+#[test]
+fn encode_decode_planes_round_trip_exactly() {
+    let mut data: u64 = 0x0123_4567_89ab_cdef;
+    let mut next = move || {
+        data ^= data << 13;
+        data ^= data >> 7;
+        data ^= data << 17;
+        data
+    };
+    for (version, planes, w, h, depth) in
+        [(Version::Psd, 1usize, 640usize, 480usize, 8u16), (Version::Psb, 1, 15000, 10000, 8), (Version::Psd, 4, 513, 65, 8), (Version::Psb, 3, 64, 2049, 16)]
+    {
+        let layout = PlaneLayout { planes, width: w, height: h, depth, version };
+        let n = layout.decoded_len().expect("size");
+        let pattern: Vec<u8> = if h % 2 == 0 { vec![42u8; n] } else { (0..n).map(|i| ((i as u64 ^ next()) % 251) as u8).collect() };
+        let encoded = encode_planes(Compression::Rle, &pattern, &layout).expect("encode");
+        let decoded = decode_planes(Compression::Rle, &encoded, &layout).expect("decode");
+        assert_eq!(decoded, pattern, "{version:?} {planes}x{w}x{h} d{depth}");
+    }
+}
diff --git a/crates/io/tests/psd_style_sheets.rs b/crates/io/tests/psd_style_sheets.rs
new file mode 100644
index 0000000000..0634dd3f9c
--- /dev/null
+++ b/crates/io/tests/psd_style_sheets.rs
@@ -0,0 +1,225 @@
+//! #3795: a PSD type layer's alignment and character attributes can come from its style sheets
+//! rather than its runs. A run's `Properties` / `StyleSheetData` hold only its overrides; the rest
+//! comes from the paragraph style its `Name` names in `ParagraphSheetSet`, the character style in
+//! `StyleSheetSet` (by name, or the paragraph's `DefaultStyleSheet`), then the Normal sheets.
+//! Reading only the Normal sheets left a centred paragraph style read as Left, so starting an
+//! edit re-laid the text out half a line to the side.
+
+use photocraft_doc::text::TextAlign;
+use photocraft_geom::Affine;
+use photocraft_psd::descriptor::{Descriptor, Id, UnicodeString, Value as D};
+use photocraft_text::engine_data::Value as E;
+use photocraft_text::psd::{TySh, text_layer_from_tysh, write_tysh};
+
+fn real(v: f64) -> E {
+    E::Real(v)
+}
+
+fn d(kv: Vec<(&str, E)>) -> E {
+    E::Dict(kv.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
+}
+
+/// Photoshop-shaped EngineData for one paragraph of point text. `para` is the paragraph run's
+/// `ParagraphSheet`, `style` the character run's `StyleSheet`; the sheet sets are the
+/// `ResourceDict`'s, with Normal at index 0.
+fn engine(text: &str, para: E, style: E, para_set: Vec<E>, style_set: Vec<E>) -> E {
+    let ed_text = format!("{text}\r");
+    let n = ed_text.encode_utf16().count() as i64;
+    let res = d(vec![
+        (
+            "FontSet",
+            E::Array(vec![d(vec![("Name", E::String("Inter-Regular".into())), ("Script", E::Int(0)), ("FontType", E::Int(1)), ("Synthetic", E::Int(0))])]),
+        ),
+        ("StyleSheetSet", E::Array(style_set)),
+        ("ParagraphSheetSet", E::Array(para_set)),
+        ("TheNormalStyleSheet", E::Int(0)),
+        ("TheNormalParagraphSheet", E::Int(0)),
+    ]);
+    d(vec![
+        (
+            "EngineDict",
+            d(vec![
+                ("Editor", d(vec![("Text", E::String(ed_text))])),
+                ("ParagraphRun", d(vec![("RunArray", E::Array(vec![d(vec![("ParagraphSheet", para)])])), ("RunLengthArray", E::Array(vec![E::Int(n)]))])),
+                ("StyleRun", d(vec![("RunArray", E::Array(vec![d(vec![("StyleSheet", style)])])), ("RunLengthArray", E::Array(vec![E::Int(n)]))])),
+                (
+                    "Rendered",
+                    d(vec![(
+                        "Shapes",
+                        d(vec![(
+                            "Children",
+                            E::Array(vec![d(vec![
+                                ("ShapeType", E::Int(0)),
+                                ("Cookie", d(vec![("Photoshop", d(vec![("ShapeType", E::Int(0)), ("PointBase", E::Array(vec![real(0.0), real(0.0)]))]))])),
+                            ])]),
+                        )]),
+                    )]),
+                ),
+            ]),
+        ),
+        ("ResourceDict", res),
+    ])
+}
+
+fn normal_char(size: f64) -> E {
+    d(vec![
+        ("Name", E::String("Normal RGB".into())),
+        ("StyleSheetData", d(vec![("Font", E::Int(0)), ("FontSize", real(size)), ("AutoLeading", E::Bool(true))])),
+    ])
+}
+
+fn para_sheet(name: &str, justification: i64, default_style: i64) -> E {
+    d(vec![("Name", E::String(name.into())), ("DefaultStyleSheet", E::Int(default_style)), ("Properties", d(vec![("Justification", E::Int(justification))]))])
+}
+
+fn layer(text: &str, ed: &E) -> photocraft_doc::TextLayer {
+    let desc = Descriptor::new("TxLr")
+        .with("Txt ", D::Text(UnicodeString::new_nul(text)))
+        .with("Ornt", D::Enumerated { type_id: Id::new("Ornt"), value: Id::new("Hrzn") })
+        .with("TextIndex", D::Integer(0))
+        .with("EngineData", D::RawData(photocraft_text::engine_data::write(ed)));
+    let data = write_tysh(&TySh { transform: Affine::translate(450.0, 300.0), text: desc, warp: None, bounds: [0.0; 4] });
+    let mut t = text_layer_from_tysh(&data, 72.0).expect("parses");
+    // Import keeps the block, as for a layer read from a file.
+    t.psd_raw = Some(std::sync::Arc::new(data));
+    t
+}
+
+/// The paragraph run names a centred (or right-aligned) paragraph style and overrides nothing.
+#[test]
+fn alignment_from_the_paragraph_style_the_run_names() {
+    for (j, want) in [(2, TextAlign::Center), (1, TextAlign::Right)] {
+        let ed = engine(
+            "LOREM IPSUM",
+            d(vec![("Name", E::String("Title".into())), ("DefaultStyleSheet", E::Int(0)), ("Properties", d(vec![]))]),
+            d(vec![("StyleSheetData", d(vec![]))]),
+            vec![para_sheet("Normal RGB", 0, 0), para_sheet("Title", j, 0)],
+            vec![normal_char(48.0)],
+        );
+        let t = layer("LOREM IPSUM", &ed);
+        assert_eq!(t.paragraphs[0].style.align, want, "Justification {j} from the paragraph style");
+        // Laid out around the anchor like Photoshop draws it.
+        let b = photocraft_text::TextEngine::new().layout(&t, 72.0).bounds().unwrap();
+        match want {
+            TextAlign::Center => assert!((b[0] + b[2]).abs() < 1.0, "centred on the anchor: {b:?}"),
+            _ => assert!(b[2].abs() < 1.0, "ends at the anchor: {b:?}"),
+        }
+    }
+}
+
+/// A run's own value still wins over its paragraph style, and an unknown style name or an
+/// out-of-range sheet index falls back to Normal.
+#[test]
+fn run_overrides_win_and_bad_references_fall_back_to_normal() {
+    let ed = engine(
+        "Text",
+        d(vec![("Name", E::String("Title".into())), ("DefaultStyleSheet", E::Int(0)), ("Properties", d(vec![("Justification", E::Int(1))]))]),
+        d(vec![("StyleSheetData", d(vec![]))]),
+        vec![para_sheet("Normal RGB", 0, 0), para_sheet("Title", 2, 0)],
+        vec![normal_char(48.0)],
+    );
+    assert_eq!(layer("Text", &ed).paragraphs[0].style.align, TextAlign::Right);
+    let ed = engine(
+        "Text",
+        d(vec![("Name", E::String("Missing".into())), ("DefaultStyleSheet", E::Int(9)), ("Properties", d(vec![]))]),
+        d(vec![("Name", E::String("Missing".into())), ("StyleSheetData", d(vec![]))]),
+        vec![para_sheet("Normal RGB", 2, 0)],
+        vec![normal_char(30.0)],
+    );
+    let t = layer("Text", &ed);
+    assert_eq!(t.paragraphs[0].style.align, TextAlign::Center, "Normal's alignment");
+    assert!((t.runs[0].style.size_pt - 30.0).abs() < 0.01, "Normal's size: {}", t.runs[0].style.size_pt);
+}
+
+/// Character attributes from the paragraph's default character style (`DefaultStyleSheet`) and
+/// from a character style the run names.
+#[test]
+fn character_attributes_from_the_style_sheets() {
+    let big = d(vec![("Name", E::String("Big".into())), ("StyleSheetData", d(vec![("FontSize", real(72.0))]))]);
+    let ed = engine(
+        "Text",
+        d(vec![("DefaultStyleSheet", E::Int(1)), ("Properties", d(vec![]))]),
+        d(vec![("StyleSheetData", d(vec![]))]),
+        vec![para_sheet("Normal RGB", 0, 0)],
+        vec![normal_char(12.0), big.clone()],
+    );
+    assert!((layer("Text", &ed).runs[0].style.size_pt - 72.0).abs() < 0.01, "the paragraph's default character style");
+    let ed = engine(
+        "Text",
+        d(vec![("DefaultStyleSheet", E::Int(0)), ("Properties", d(vec![]))]),
+        d(vec![("Name", E::String("Big".into())), ("StyleSheetData", d(vec![]))]),
+        vec![para_sheet("Normal RGB", 0, 0)],
+        vec![normal_char(12.0), big],
+    );
+    let t = layer("Text", &ed);
+    assert!((t.runs[0].style.size_pt - 72.0).abs() < 0.01, "the named character style: {}", t.runs[0].style.size_pt);
+    // Other attributes still come from Normal.
+    assert_eq!(
+        t.runs[0].style.font_family,
+        layer(
+            "Text",
+            &engine(
+                "Text",
+                d(vec![("Properties", d(vec![]))]),
+                d(vec![("StyleSheetData", d(vec![]))]),
+                vec![para_sheet("Normal RGB", 0, 0)],
+                vec![normal_char(12.0)]
+            )
+        )
+        .runs[0]
+            .style
+            .font_family
+    );
+}
+
+/// Export writes every run fully resolved and keeps the sheet sets: a round trip reads the same
+/// alignment and size, with one entry per sheet.
+#[test]
+fn styles_from_sheets_survive_a_round_trip() {
+    use photocraft_color::{ColorMode, SampleType};
+    use photocraft_doc::{Document, Layer, LayerContent, Size};
+    let ed = engine(
+        "LOREM IPSUM",
+        d(vec![("Name", E::String("Title".into())), ("DefaultStyleSheet", E::Int(1)), ("Properties", d(vec![]))]),
+        d(vec![("StyleSheetData", d(vec![]))]),
+        vec![para_sheet("Normal RGB", 0, 0), para_sheet("Title", 2, 1)],
+        vec![normal_char(12.0), d(vec![("Name", E::String("Big".into())), ("StyleSheetData", d(vec![("FontSize", real(48.0))]))])],
+    );
+    let mut t = layer("LOREM IPSUM", &ed);
+    let mut doc = Document::new("t", Size::new(900, 600), ColorMode::Rgb, SampleType::U8);
+    doc.resolution_dpi = 72.0;
+    photocraft_text::TextEngine::new().render_layer(&mut t, 72.0, doc.pixel_format());
+    doc.layers.push(Layer::new("t", LayerContent::Text(t)));
+    let bytes = photocraft_io::export(&doc, "t.psd", &Default::default()).unwrap().bytes;
+    let back = photocraft_io::import("t.psd", &bytes).unwrap().document;
+    let LayerContent::Text(bt) = &back.layers[0].content else { panic!("not a type layer") };
+    assert_eq!(bt.paragraphs[0].style.align, TextAlign::Center);
+    assert!((bt.runs[0].style.size_pt - 48.0).abs() < 0.01, "{}", bt.runs[0].style.size_pt);
+}
+
+/// A layer that inherits its alignment and size from sheets it no longer links to (a document
+/// without those styles) keeps them through export: runs are written with what they inherited.
+#[test]
+fn unlinked_runs_keep_their_inherited_style_on_export() {
+    use photocraft_color::{ColorMode, SampleType};
+    use photocraft_doc::{Document, Layer, LayerContent, Size};
+    let ed = engine(
+        "LOREM IPSUM",
+        d(vec![("Name", E::String("Title".into())), ("DefaultStyleSheet", E::Int(1)), ("Properties", d(vec![]))]),
+        d(vec![("StyleSheetData", d(vec![]))]),
+        vec![para_sheet("Normal RGB", 0, 0), para_sheet("Title", 2, 1)],
+        vec![normal_char(12.0), d(vec![("Name", E::String("Big".into())), ("StyleSheetData", d(vec![("FontSize", real(48.0))]))])],
+    );
+    let mut t = layer("LOREM IPSUM", &ed);
+    assert!(t.psd_raw.is_some());
+    let mut doc = Document::new("t", Size::new(900, 600), ColorMode::Rgb, SampleType::U8);
+    doc.resolution_dpi = 72.0;
+    photocraft_text::TextEngine::new().render_layer(&mut t, 72.0, doc.pixel_format());
+    doc.layers.push(Layer::new("t", LayerContent::Text(t)));
+    // No `text_styles_map::import`: the document has no styles and the runs link to none.
+    let bytes = photocraft_io::export(&doc, "t.psd", &Default::default()).unwrap().bytes;
+    let back = photocraft_io::import("t.psd", &bytes).unwrap().document;
+    let LayerContent::Text(bt) = &back.layers[0].content else { panic!("not a type layer") };
+    assert_eq!(bt.paragraphs[0].style.align, TextAlign::Center);
+    assert!((bt.runs[0].style.size_pt - 48.0).abs() < 0.01, "{}", bt.runs[0].style.size_pt);
+}
diff --git a/crates/io/tests/psd_type_bounds.rs b/crates/io/tests/psd_type_bounds.rs
index 4ae925ec12..8fabe8be24 100644
--- a/crates/io/tests/psd_type_bounds.rs
+++ b/crates/io/tests/psd_type_bounds.rs
@@ -112,8 +112,8 @@ fn tysh_with_font(text: &str, runs: &[Run], box_bounds: Option<[f64; 4]>, transf
         .with("boundingBox", rect("boundingBox"))
         .with("TextIndex", D::Integer(0))
         .with("EngineData", D::RawData(photocraft_text::engine_data::write(&engine_data(text, runs, box_bounds, font))));
-    let bounds = [ink[0].floor() as i32, ink[1].floor() as i32, ink[2].ceil() as i32, ink[3].ceil() as i32];
-    write_tysh(&TySh { transform, text: desc, warp: None, bounds })
+    // Unwarped type: Photoshop writes four zero f32s after the warp descriptor.
+    write_tysh(&TySh { transform, text: desc, warp: None, bounds: [0.0; 4] })
 }
 
 struct Case {
@@ -261,7 +261,7 @@ fn imported_type_layers_keep_their_full_bounds() {
         // Model: size in points at the document resolution, transform and shape as written.
         assert!((t.runs[0].style.size_pt - c.size_pt).abs() < 0.01, "{}: size {} pt, want {}", c.name, t.runs[0].style.size_pt, c.size_pt);
         assert_eq!(t.transform, c.transform, "{}", c.name);
-        match (c.box_bounds, t.shape) {
+        match (c.box_bounds, t.shape.clone()) {
             (None, TextShape::Point) => {}
             (Some(b), TextShape::Box { x, y, width, height }) => {
                 assert_eq!([x, y, x + width, y + height].map(f64::from), b, "{}", c.name)
diff --git a/crates/io/tests/psd_type_photoshop_bytes.rs b/crates/io/tests/psd_type_photoshop_bytes.rs
new file mode 100644
index 0000000000..98524892c4
--- /dev/null
+++ b/crates/io/tests/psd_type_photoshop_bytes.rs
@@ -0,0 +1,74 @@
+//! Type-layer bytes we write match what Photoshop 2026 writes for the same settings, checked
+//! against Photoshop-authored files in `corpus/photoshop` (feature `corpus`; fetched by
+//! `cargo xtask corpus --all`, a missing corpus fails):
+//! - EngineData `AntiAlias` numbers for every anti-aliasing mode;
+//! - the four f32 values that end a `TySh` block (zeros unwarped, text-space bounds warped);
+//! - the version info resource (1057).
+
+#![cfg(feature = "corpus")]
+
+use std::path::{Path, PathBuf};
+
+use photocraft_psd::PsdFile;
+use photocraft_psd::descriptor::Value as D;
+use photocraft_text::engine_data::Value as E;
+
+fn corpus(rel: &str) -> PsdFile {
+    let path: PathBuf = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../corpus/photoshop").join(rel);
+    let bytes = std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e} (run `cargo xtask corpus --all`)", path.display()));
+    PsdFile::from_bytes(&bytes).unwrap()
+}
+
+fn first_tysh(f: &PsdFile) -> Vec<u8> {
+    f.layers().iter().find_map(|l| l.block(b"TySh")).map(|b| b.data.clone()).unwrap()
+}
+
+fn engine_antialias(tysh: &[u8]) -> Option<f64> {
+    let t = photocraft_text::psd::parse_tysh(tysh)?;
+    photocraft_text::psd::engine_data(&t.text)?.path(&["EngineDict", "AntiAlias"]).and_then(E::as_f64)
+}
+
+fn rect(t: &photocraft_text::psd::TySh, key: &str) -> [f32; 4] {
+    let Some(D::Descriptor(d)) = t.text.get(key) else { panic!("no {key}") };
+    ["Left", "Top ", "Rght", "Btom"].map(|k| match d.get(k) {
+        Some(D::UnitFloat { value, .. }) => *value as f32,
+        other => panic!("{k}: {other:?}"),
+    })
+}
+
+#[test]
+fn engine_data_antialias_matches_photoshop() {
+    for name in ["none", "crisp", "strong", "smooth", "sharp"] {
+        let raw = first_tysh(&corpus(&format!("text/antialias-{name}.psd")));
+        let mut layer = photocraft_text::psd::text_layer_from_tysh(&raw, 72.0).unwrap();
+        layer.psd_raw = None;
+        let ours = photocraft_text::psd::build_tysh(&layer, 72.0, None);
+        assert_eq!(engine_antialias(&ours), engine_antialias(&raw), "{name}");
+    }
+}
+
+#[test]
+fn tysh_trailing_bounds_match_photoshop() {
+    for (file, warped) in [("text/warp-arc-50.psd", true), ("text/antialias-smooth.psd", false)] {
+        let raw = first_tysh(&corpus(file));
+        let theirs = photocraft_text::psd::parse_tysh(&raw).unwrap();
+        let mut layer = photocraft_text::psd::text_layer_from_tysh(&raw, 72.0).unwrap();
+        assert_eq!(layer.warp.is_some(), warped, "{file}");
+        layer.psd_raw = None;
+        let ours = photocraft_text::psd::parse_tysh(&photocraft_text::psd::build_tysh(&layer, 72.0, Some(rect(&theirs, "bounds")))).unwrap();
+        assert_eq!(ours.bounds, theirs.bounds, "{file}");
+        if warped {
+            assert_eq!(theirs.bounds, rect(&theirs, "bounds"), "{file}");
+        } else {
+            assert_eq!(theirs.bounds, [0.0; 4], "{file}");
+        }
+    }
+}
+
+#[test]
+fn version_info_matches_photoshop() {
+    for file in ["text/antialias-smooth.psd", "text/warp-arc-50.psd"] {
+        let theirs = corpus(file);
+        assert_eq!(photocraft_psd::resources::version_info_resource(true).data, theirs.resource(1057).unwrap().data, "{file}");
+    }
+}
diff --git a/crates/io/tests/psd_vertical_type.rs b/crates/io/tests/psd_vertical_type.rs
index e69f725da7..93cd1a8858 100644
--- a/crates/io/tests/psd_vertical_type.rs
+++ b/crates/io/tests/psd_vertical_type.rs
@@ -34,7 +34,7 @@ fn text(doc: &Document) -> &TextLayer {
 #[test]
 fn vertical_orientation_round_trips_through_psd() {
     for shape in [TextShape::Point, TextShape::Box { x: -200.0, y: 0.0, width: 220.0, height: 300.0 }] {
-        let doc = doc_with(shape);
+        let doc = doc_with(shape.clone());
         let ink = text(&doc).cache.as_ref().unwrap().content_bounds();
         assert!(ink.height() > ink.width(), "{shape:?}: {ink:?}");
         let out = photocraft_io::export(&doc, "v.psd", &Default::default()).unwrap();
diff --git a/crates/io/tests/raw.rs b/crates/io/tests/raw.rs
index d0bc370dbc..d9e31a87c1 100644
--- a/crates/io/tests/raw.rs
+++ b/crates/io/tests/raw.rs
@@ -94,6 +94,18 @@ fn unsupported_raw_without_preview_is_a_clear_error() {
     }
 }
 
+#[test]
+fn cr3_opens_its_upright_camera_jpeg_with_explicit_preview_warning() {
+    let img = Image::from_u8(32, 20, ChannelLayout::Rgb, vec![180; 32 * 20 * 3]).unwrap();
+    let jpeg = photocraft_codecs::encode(&img, Format::Jpeg, &EncodeOptions::default()).unwrap();
+    let raw = photocraft_raw::testgen::cr3_preview(&jpeg, 6);
+    let r = import("shot.cr3", &raw).unwrap();
+    assert_eq!((r.document.size.width, r.document.size.height), (20, 32));
+    assert_eq!(r.document.depth, SampleType::U8);
+    assert!(r.warnings[0].contains("8-bit, not the raw sensor data"));
+    assert!(r.warnings[0].contains("CR3"));
+}
+
 #[test]
 fn truncated_raws_do_not_panic() {
     let b = nef_with_preview();
@@ -214,7 +226,11 @@ fn camera_raw_tuning_keeps_the_default_look_and_applies_user_gains_after_fitting
     assert!(fitted(&normal.warnings));
     let sensor = decode(&bytes, &Default::default()).unwrap();
     let look = fit_preview_look(&bytes, &sensor, &DevelopOptions::default()).unwrap();
-    for tuning in [RawTuning::default(), RawTuning { exposure: 0.5, ..Default::default() }, RawTuning { exposure: -0.5, temperature: 20.0, tint: -15.0 }] {
+    for tuning in [
+        RawTuning::default(),
+        RawTuning { exposure: 0.5, ..Default::default() },
+        RawTuning { exposure: -0.5, temperature: 20.0, tint: -15.0, ..Default::default() },
+    ] {
         let (got, applied) = import_raw_tuned("camera.nef", &bytes, &tuning).unwrap();
         assert!(applied && fitted(&got.warnings) && !fallback(&got.warnings), "{:?}", got.warnings);
         assert_eq!(got.document.depth, SampleType::U16);
@@ -283,3 +299,28 @@ fn truncated_raws_with_a_fittable_preview_do_not_panic() {
         let _ = photocraft_io::raw::import_raw_tuned("x.nef", &b[..n], &Default::default());
     }
 }
+
+/// The open-time Camera Raw re-develop keeps the colour rendering the default open used: a raw
+/// without calibration gets the same look fitted to its JPEG, so neutral settings give the same
+/// pixels, and the previews' tone curve is the look's.
+#[test]
+fn a_re_develop_keeps_the_fitted_look() {
+    let (w, h) = (480, 320);
+    let cam = patches(w, h);
+    let nef = nef_uncompressed(&cam, w, h, Some(camera_rendering(&cam, w, h)));
+    let opened = import("DSC_0003.NEF", &nef).unwrap();
+    let (again, _) = photocraft_io::raw::import_raw_tuned("DSC_0003.NEF", &nef, &Default::default()).unwrap();
+    assert!(fitted(&again.warnings), "{:?}", again.warnings);
+    let pixels = |d: &photocraft_doc::Document| {
+        let s = d.layers[0].surface().unwrap();
+        let mut px = vec![[0.0f32; 4]; w * h];
+        s.read_rgba_into(photocraft_geom::Rect::new(0, 0, w as i32, h as i32), &mut px);
+        px
+    };
+    assert_eq!(pixels(&opened.document), pixels(&again.document));
+    let curve = photocraft_io::raw::tone_curve(&nef);
+    assert!(curve.len() > 2 && curve.windows(2).all(|k| k[1][0] > k[0][0] && k[1][1] >= k[0][1]), "{curve:?}");
+    // The camera's brightening curve: mid-grey comes out lighter.
+    let mid = curve.iter().find(|k| k[0] >= 0.18).unwrap();
+    assert!(mid[1] > mid[0], "{mid:?}");
+}
diff --git a/crates/io/tests/resolution_axes.rs b/crates/io/tests/resolution_axes.rs
index bc069d7f30..58b67d93c4 100644
--- a/crates/io/tests/resolution_axes.rs
+++ b/crates/io/tests/resolution_axes.rs
@@ -27,7 +27,7 @@ fn png_with_unequal_axes_reports_the_dropped_vertical_resolution() {
     assert!((r.document.resolution_dpi - 300.0).abs() < 0.01, "{}", r.document.resolution_dpi);
     let notes = resolution_notes(&r);
     assert_eq!(notes.len(), 1, "{:?}", r.warnings);
-    assert!(notes[0].contains("150.01") && notes[0].contains("300.00"), "{notes:?}");
+    assert!(notes[0].contains("150.00") && notes[0].contains("300.00"), "{notes:?}");
 }
 
 #[test]
diff --git a/crates/io/tests/roundtrip.rs b/crates/io/tests/roundtrip.rs
index 3e2403f2e4..6502079f20 100644
--- a/crates/io/tests/roundtrip.rs
+++ b/crates/io/tests/roundtrip.rs
@@ -305,7 +305,10 @@ fn psd_raw_resources_and_global_blocks_preserved() {
     d.metadata.psd_global_blocks.push((*b"8BIM", *b"Patt", std::sync::Arc::new(vec![7; 6])));
     d.metadata.psd_global_blocks.push((*b"8B64", *b"lnk2", std::sync::Arc::new(vec![1, 2])));
     let back = roundtrip(&d);
-    assert_eq!(back.metadata, d.metadata);
+    // A PSD holds no `8B64` blocks (Photoshop refuses the file): a kept PSB block is written as `8BIM`.
+    let mut expected = d.metadata.clone();
+    expected.psd_global_blocks[1].0 = *b"8BIM";
+    assert_eq!(back.metadata, expected);
 }
 
 #[test]
@@ -550,3 +553,55 @@ fn blend_if_round_trips_as_blending_ranges() {
     assert!(back.layers[1].blend_if.is_default());
     assert_eq!(back.layers[2].blend_if.get(1)[0], BlendRange { black: [1, 2], white: [3, 4] });
 }
+
+#[test]
+fn psd_16bit_layers_with_compatibility_section_open_visible() {
+    use photocraft_doc::{Document, Layer, LayerContent, Size};
+    use photocraft_geom::Rect;
+    use photocraft_raster::Surface;
+
+    // A 16-bit document with multiple distinct user layers.
+    let mut doc = Document::new("Test16", Size::new(50, 50), ColorMode::Rgb, SampleType::U16);
+    let fmt = doc.pixel_format();
+
+    let bg_data = vec![255u8; 50 * 50 * 8];
+    let bg_surf = Surface::from_interleaved(fmt, Rect::new(0, 0, 50, 50), &bg_data);
+    let mut bg = Layer::new("Background", LayerContent::Raster(bg_surf));
+    bg.visible = true;
+    doc.layers.push(bg);
+
+    let fg_data = vec![128u8; 20 * 20 * 8];
+    let fg_surf = Surface::from_interleaved(fmt, Rect::new(10, 10, 30, 30), &fg_data);
+    let mut fg = Layer::new("Foreground", LayerContent::Raster(fg_surf));
+    fg.visible = true;
+    doc.layers.push(fg);
+
+    let exported = export(&doc, "test.psd", &ExportOptions::default()).expect("export");
+    let bytes = exported.bytes;
+
+    let cmd_len = u32::from_be_bytes(bytes[26..30].try_into().unwrap()) as usize;
+    let res_pos = 30 + cmd_len;
+    let res_len = u32::from_be_bytes(bytes[res_pos..res_pos + 4].try_into().unwrap()) as usize;
+    let lm_pos = res_pos + 4 + res_len;
+    let lm_len = u32::from_be_bytes(bytes[lm_pos..lm_pos + 4].try_into().unwrap()) as usize;
+    let li_pos = lm_pos + 4;
+
+    // Simulate Photoshop's 16-bit format: an empty/compatibility layer info section (count = 0)
+    // before the global Lr16 block (#4928).
+    let mut modified = bytes;
+    let new_lm_len = (lm_len + 4) as u32;
+    modified[lm_pos..lm_pos + 4].copy_from_slice(&new_lm_len.to_be_bytes());
+    modified[li_pos..li_pos + 4].copy_from_slice(&4u32.to_be_bytes());
+    modified.splice(li_pos + 4..li_pos + 4, [0u8, 0, 0, 0]);
+
+    let imported = import("test.psd", &modified).expect("import").document;
+
+    // Must import the 16-bit layers from Lr16 ("Background" and "Foreground").
+    assert_eq!(imported.layers.len(), 2);
+    assert_eq!(imported.layers[0].name, "Background");
+    assert_eq!(imported.layers[1].name, "Foreground");
+    assert!(imported.layers[0].visible);
+    assert!(imported.layers[1].visible);
+    assert!(imported.layers[0].surface().unwrap().tile_count() > 0);
+    assert!(imported.layers[1].surface().unwrap().tile_count() > 0);
+}
diff --git a/crates/io/tests/smart_contents_identity.rs b/crates/io/tests/smart_contents_identity.rs
index 632547b0d4..5a0714b3d8 100644
--- a/crates/io/tests/smart_contents_identity.rs
+++ b/crates/io/tests/smart_contents_identity.rs
@@ -199,3 +199,153 @@ fn independent_unavailable_link_retains_separate_preserved_record() {
     let (again, _) = round_trip(&doc, "psd");
     assert_eq!(after.to_bytes().unwrap(), again.to_bytes().unwrap());
 }
+
+/// A `PlLd`-only placed layer (Photoshop CS2, #2465) whose embedded file is missing still gets its
+/// source id and placement (at an assumed 100 % scale); an unreadable `PlLd` is reported.
+#[test]
+fn plld_only_layers_without_their_file_or_with_a_broken_record() {
+    let (mut file, _) = round_trip(&fixture(), "psd");
+    file.global_blocks.retain(|b| !matches!(&b.key, b"lnk2" | b"lnk3" | b"lnkD"));
+    let rotated = Affine { m: [0.0, 1.0, -1.0, 0.0, 6.0, 1.0] };
+    let spec =
+        smart_map::PlacedSpec { idnt: "missing", placed: "", transform: rotated, perspective: None, size: (3.0, 2.0), dpi: 72.0, warp: None, filter_fx: None };
+    let mut record = file.layers()[0].clone();
+    record.blocks.retain(|b| !matches!(&b.key, b"SoLd" | b"SoLE" | b"PlLd"));
+    let mut broken = record.clone();
+    record.blocks.push(TaggedBlock::new(*b"PlLd", smart_map::plld_bytes(&spec, &mut Vec::new())));
+    broken.blocks.push(TaggedBlock::new(*b"PlLd", b"plcL\0\0\0\x03\x05ab\0\0".to_vec()));
+    *file.layers_mut() = vec![record, broken];
+    let (doc, warnings) = photocraft_io::psd_to_document(&file);
+    let LayerContent::Smart(a) = &doc.layers[0].content else { panic!("PlLd layer is not a smart object") };
+    assert_eq!(a.source, SmartSource::Linked { path: "missing".into() });
+    for (x, y) in a.transform.m.iter().zip(rotated.m) {
+        assert!((x - y).abs() < 1e-12, "{:?} vs {rotated:?}", a.transform);
+    }
+    let LayerContent::Smart(b) = &doc.layers[1].content else { panic!("broken PlLd layer is not a smart object") };
+    assert_eq!(b.source, SmartSource::Linked { path: String::new() });
+    assert_eq!(warnings.iter().filter(|w| w.contains("(PlLd) could not be read")).count(), 1, "{warnings:?}");
+}
+
+/// Photoshop CS2 can warp a smart object and keeps the warp in `PlLd`, after the corners. A
+/// `PlLd`-only layer imports with that warp, so re-rendering it from its now-available source
+/// (Free Transform, Image Size, mode changes) keeps it warped. A warp that can't be read leaves
+/// the contents unavailable, so the warped pixels stay the rendering (#2465).
+#[test]
+fn plld_only_layers_keep_their_warp() {
+    use photocraft_geom::warp::{Warp, WarpStyle};
+    let (mut file, _) = round_trip(&fixture(), "psd");
+    let bulge = Warp::preset(WarpStyle::Bulge, 35.0, [0.0, 0.0, 2.0, 2.0]);
+    let spec = |warp| smart_map::PlacedSpec {
+        idnt: "missing",
+        placed: "",
+        transform: Affine { m: [2.0, 0.0, 0.0, 2.0, 1.0, 0.0] },
+        perspective: None,
+        size: (2.0, 2.0),
+        dpi: 72.0,
+        warp,
+        filter_fx: None,
+    };
+    let mut record = file.layers()[0].clone();
+    record.blocks.retain(|b| !matches!(&b.key, b"SoLd" | b"SoLE" | b"PlLd"));
+    let (mut warped, mut flat, mut broken) = (record.clone(), record.clone(), record);
+    warped.blocks.push(TaggedBlock::new(*b"PlLd", smart_map::plld_bytes(&spec(Some(&bulge)), &mut Vec::new())));
+    flat.blocks.push(TaggedBlock::new(*b"PlLd", smart_map::plld_bytes(&spec(None), &mut Vec::new())));
+    // The warp descriptor cut short: a warp is stored but can't be read.
+    let mut cut = smart_map::plld_bytes(&spec(Some(&bulge)), &mut Vec::new());
+    cut.truncate(cut.len() - 40);
+    broken.blocks.push(TaggedBlock::new(*b"PlLd", cut));
+    *file.layers_mut() = vec![warped, flat, broken];
+    let (doc, warnings) = photocraft_io::psd_to_document(&file);
+    let sm = |i: usize| match &doc.layers[i].content {
+        LayerContent::Smart(s) => s,
+        _ => panic!("layer {i} is not a smart object"),
+    };
+    assert_eq!(sm(0).warp, Some(bulge));
+    assert_eq!(sm(0).source, SmartSource::Linked { path: "missing".into() });
+    assert_eq!((sm(1).warp.as_ref(), &sm(1).source), (None, &SmartSource::Linked { path: "missing".into() }));
+    assert_eq!(sm(2).source, SmartSource::Linked { path: String::new() }, "unreadable warp: contents unavailable");
+    assert!(sm(2).cache.is_some());
+    assert_eq!(warnings.iter().filter(|w| w.contains("warp (PlLd) could not be read")).count(), 1, "{warnings:?}");
+}
+
+/// A linked smart object with both `SoLE` and `PlLd` is read from `SoLE`: `PlLd` alone is
+/// Photoshop CS2's record (#2465).
+#[test]
+fn sole_wins_over_plld() {
+    let (mut file, _) = round_trip(&fixture(), "psd");
+    let spec = smart_map::PlacedSpec {
+        idnt: "plld-only",
+        placed: "",
+        transform: Affine::IDENTITY,
+        perspective: None,
+        size: (2.0, 2.0),
+        dpi: 72.0,
+        warp: None,
+        filter_fx: None,
+    };
+    let mut record = file.layers()[0].clone();
+    let sold = record.block(b"SoLd").expect("the fixture has SoLd").data.clone();
+    let (id, _) = photocraft_io::blocks::parse_smart(b"SoLd", &sold);
+    assert!(!id.is_empty() && id != "plld-only");
+    record.blocks.retain(|b| !matches!(&b.key, b"SoLd" | b"SoLE" | b"PlLd"));
+    record.blocks.push(TaggedBlock::new(*b"PlLd", smart_map::plld_bytes(&spec, &mut Vec::new())));
+    record.blocks.push(TaggedBlock::new(*b"SoLE", sold.clone()));
+    *file.layers_mut() = vec![record];
+    let (doc, _) = photocraft_io::psd_to_document(&file);
+    let LayerContent::Smart(sm) = &doc.layers[0].content else { panic!("not a smart object") };
+    assert_eq!(sm.source, SmartSource::Linked { path: id });
+    assert_eq!(sm.psd_raw.as_deref(), Some(&sold));
+}
+
+/// A CS2 `PlLd`-only layer with a custom warp whose control points spill past its source frames
+/// that control-point box with its corners, as `SoLd`'s `Trnf` does (#3677): it imports with the
+/// same placement as the equivalent `SoLd` layer. Unedited, it saves its `PlLd` record verbatim
+/// (no `SoLd` added) and reopens in the same place (#2465).
+#[test]
+fn plld_only_spilled_custom_warp_places_like_sold_and_round_trips_verbatim() {
+    use photocraft_geom::warp::{BezierMesh, Warp};
+    let (mut file, _) = round_trip(&fixture(), "psd");
+    let mut record = file.layers()[0].clone();
+    let (id, _) = photocraft_io::blocks::parse_smart(b"SoLd", &record.block(b"SoLd").expect("the fixture has SoLd").data);
+    assert!(!id.is_empty());
+    // The embedded source is 2 × 2; the mesh reaches from (-1, -0.5) to (3, 2.5).
+    let bounds = [0.0, 0.0, 2.0, 2.0];
+    let mut mesh = BezierMesh::identity(bounds, 1, 1);
+    mesh.points[0] = [-1.0, -0.5];
+    mesh.points[15] = [3.0, 2.5];
+    let warp = Warp::custom(mesh, bounds);
+    let t = Affine { m: [1.5, 0.0, 0.0, 1.5, 4.0, 1.0] };
+    let spec =
+        smart_map::PlacedSpec { idnt: &id, placed: "p", transform: t, perspective: None, size: (2.0, 2.0), dpi: 72.0, warp: Some(&warp), filter_fx: None };
+    record.blocks.retain(|b| !matches!(&b.key, b"SoLd" | b"SoLE" | b"PlLd"));
+    let (mut with_sold, mut cs2) = (record.clone(), record);
+    with_sold.blocks.push(TaggedBlock::new(*b"SoLd", smart_map::sold_bytes(None, &spec, &mut Vec::new())));
+    let plld = smart_map::plld_bytes(&spec, &mut Vec::new());
+    cs2.blocks.push(TaggedBlock::new(*b"PlLd", plld.clone()));
+    *file.layers_mut() = vec![with_sold, cs2];
+
+    let (doc, warnings) = photocraft_io::psd_to_document(&file);
+    assert!(!warnings.iter().any(|w| w.contains("PlLd")), "{warnings:?}");
+    let sm = |d: &Document, i: usize| match &d.layers[i].content {
+        LayerContent::Smart(s) => s.clone(),
+        _ => panic!("layer {i} is not a smart object"),
+    };
+    let close = |a: Affine, b: Affine| a.m.iter().zip(b.m).all(|(x, y)| (x - y).abs() < 1e-9);
+    let (a, b) = (sm(&doc, 0), sm(&doc, 1));
+    assert!(close(a.transform, t), "SoLd: {:?} vs {t:?}", a.transform);
+    assert!(close(b.transform, a.transform), "PlLd {:?} vs SoLd {:?}", b.transform, a.transform);
+    assert_eq!((&b.source, &b.warp, b.perspective), (&a.source, &a.warp, a.perspective));
+    assert_eq!(b.warp.as_ref(), Some(&warp));
+    assert_eq!(b.source, SmartSource::Linked { path: id.clone() });
+
+    // Unedited: the CS2 record is written back as it was, with no SoLd, and reopens in place.
+    let out = export(&doc, "psd", &ExportOptions::default()).unwrap();
+    let saved = PsdFile::from_bytes(&out.bytes).unwrap();
+    let rec = &saved.layers()[1];
+    assert_eq!(rec.block(b"PlLd").map(|b| &b.data), Some(&plld));
+    assert!(rec.block(b"SoLd").is_none(), "an unedited PlLd-only layer gained a SoLd");
+    let again = import("psd", &out.bytes).unwrap().document;
+    let c = sm(&again, 1);
+    assert!(close(c.transform, t), "{:?} vs {t:?}", c.transform);
+    assert_eq!(c.warp.as_ref(), Some(&warp));
+}
diff --git a/crates/io/tests/svg.rs b/crates/io/tests/svg.rs
index adbdf08a03..d1baf418fa 100644
--- a/crates/io/tests/svg.rs
+++ b/crates/io/tests/svg.rs
@@ -148,10 +148,11 @@ fn gradients_are_approximated_with_a_warning() {
 
 #[test]
 fn clip_paths_masks_filters_patterns_and_images_are_rasterised() {
+    // A clip of one path becomes a vector mask (#4266); one of two shapes is still rasterised.
     let r = open(&format!(
         "<svg {NS} width=\"60\" height=\"30\">\
            <defs>\
-             <clipPath id=\"c\"><rect width=\"10\" height=\"30\"/></clipPath>\
+             <clipPath id=\"c\"><rect width=\"10\" height=\"30\"/><rect x=\"26\" width=\"2\" height=\"30\"/></clipPath>\
              <pattern id=\"p\" width=\"4\" height=\"4\" patternUnits=\"userSpaceOnUse\"><rect width=\"2\" height=\"4\" fill=\"black\"/></pattern>\
            </defs>\
            <g id=\"clipped\" clip-path=\"url(#c)\"><rect width=\"30\" height=\"30\" fill=\"#ff0000\"/></g>\
diff --git a/crates/io/tests/tiff_layers.rs b/crates/io/tests/tiff_layers.rs
index 913ab2f39e..56e51bf9f9 100644
--- a/crates/io/tests/tiff_layers.rs
+++ b/crates/io/tests/tiff_layers.rs
@@ -127,7 +127,7 @@ fn exif() -> Vec<u8> {
 }
 
 /// #1545: a layered TIFF carries EXIF as Photoshop resource 1058 and reads it back, so it must
-/// not report a loss it never makes. A flat TIFF really does lose the tags and still says so.
+/// not report a loss it never makes. A flat TIFF writes it as its own tags and keeps it too.
 #[test]
 fn layered_tiff_keeps_exif_without_claiming_a_loss() {
     let mut d = gen_doc(ColorMode::Rgb, SampleType::U8, Features::PIXELS);
@@ -140,9 +140,13 @@ fn layered_tiff_keeps_exif_without_claiming_a_loss() {
     let kept = back.metadata.exif.as_deref().expect("EXIF survives the layered export");
     assert!(kept.windows(ARTIST.len()).any(|w| w == ARTIST), "the Artist tag did not survive: {kept:?}");
 
-    // The control from the issue: the flat path drops it for real, and keeps reporting that.
+    // The flat path writes the EXIF block's tags as the TIFF's own (here IFD0's Artist, which
+    // reads back as the document's Artist text), so it reports no loss either.
     let flat = tiff(&d, false);
-    assert!(flat.warnings.iter().any(|w| w.contains("EXIF")), "a flat TIFF really does lose EXIF: {:?}", flat.warnings);
+    assert!(!flat.warnings.iter().any(|w| w.contains("EXIF")), "a flat TIFF keeps EXIF: {:?}", flat.warnings);
+    let back = import("x.tif", &flat.bytes).unwrap().document;
+    let artist = std::str::from_utf8(ARTIST).unwrap().trim_end_matches('\0');
+    assert!(back.metadata.text.iter().any(|(k, v)| k == "Artist" && v == artist), "{:?}", back.metadata.text);
 }
 
 #[test]
diff --git a/crates/ops/src/lib.rs b/crates/ops/src/lib.rs
index 0f29cf8e98..a20b841c17 100644
--- a/crates/ops/src/lib.rs
+++ b/crates/ops/src/lib.rs
@@ -5,8 +5,8 @@
 //! stores whole-document snapshots per transaction, which is simple, obviously correct, and the
 //! same approach Photoshop's History panel exposes to users (one state per step).
 //!
-//! Memory is bounded by `max_states` plus an approximate byte budget. Only tiles *not shared*
-//! with the current document count against it.
+//! Memory is bounded by `max_states` plus an approximate byte budget. The current document's
+//! tiles and tiles only history holds count against it, including selection masks.
 #![forbid(unsafe_code)]
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
@@ -248,7 +248,7 @@ impl History {
     }
 }
 
-/// Bytes of the pixel tiles of `doc` (layers, masks, alpha channels) not already in `seen`.
+/// Bytes of the pixel tiles of `doc` (layers, masks, alpha channels, selection) not already in `seen`.
 fn tile_bytes(doc: &Document, seen: &mut HashSet<usize>) -> usize {
     let mut n = 0usize;
     tiles::surfaces(doc, |surface| {
@@ -408,6 +408,85 @@ mod tests {
         assert_eq!(h.unique_bytes(&cur), 256 * 256 * 4);
     }
 
+    #[test]
+    fn selection_tiles_count_current_and_history_without_double_counting() {
+        use photocraft_doc::{PixelFormat, Surface};
+        for depth in SampleType::ALL {
+            let mut doc = Document::new("selection", Size::new(300, 64), ColorMode::Rgb, depth);
+            let mut selection = Surface::new(PixelFormat::new(ColorMode::Grayscale, depth, false));
+            selection.write_pixel(1, 1, &[1.0]);
+            selection.write_pixel(257, 1, &[1.0]);
+            doc.selection = Some(selection);
+            let mut cur = Arc::new(doc);
+            let tile = match depth {
+                SampleType::U8 => 65_536,
+                SampleType::U16 => 131_072,
+                SampleType::F32 => 262_144,
+            };
+            let mut h = History { max_bytes: usize::MAX, ..History::default() };
+            assert_eq!(h.pixel_bytes(&cur), 2 * tile, "current selection counts without any history");
+            assert_eq!(h.unique_bytes(&cur), 0);
+            edit(&mut h, &mut cur, "Rename", |doc| doc.name = "renamed".into());
+            assert_eq!(h.pixel_bytes(&cur), 2 * tile, "the shared selection tiles count once");
+            edit(&mut h, &mut cur, "Selection", |doc| {
+                doc.selection.as_mut().unwrap().write_pixel(1, 1, &[0.5]);
+            });
+            assert_eq!(h.pixel_bytes(&cur), 3 * tile, "only the changed selection tile is copied");
+            assert_eq!(h.unique_bytes(&cur), tile);
+            h.trim(&cur);
+            assert_counter(&h, &cur);
+            let selected_value = cur.selection.as_ref().unwrap().sample_channel(1, 1, 0);
+            edit(&mut h, &mut cur, "Deselect", |doc| doc.selection = None);
+            assert_eq!(h.pixel_bytes(&cur), 3 * tile, "deselecting leaves the previous masks in history");
+            assert_eq!(h.unique_bytes(&cur), 3 * tile);
+            assert_counter(&h, &cur);
+            cur = h.undo(cur).unwrap().0;
+            assert_eq!(cur.selection.as_ref().unwrap().sample_channel(1, 1, 0), selected_value);
+            assert_eq!(h.pixel_bytes(&cur), 3 * tile);
+            assert_eq!(h.unique_bytes(&cur), tile);
+            assert_counter(&h, &cur);
+            // Coalescing can change the current mask without recording another state.
+            Arc::make_mut(&mut cur).selection.as_mut().unwrap().write_pixel(257, 1, &[0.25]);
+            assert_eq!(h.pixel_bytes(&cur), 4 * tile);
+            assert_eq!(h.trim(&cur), 0);
+            assert_counter(&h, &cur);
+            cur = h.redo(cur).unwrap().0;
+            assert!(cur.selection.is_none());
+            assert_eq!(h.pixel_bytes(&cur), 4 * tile);
+            assert_counter(&h, &cur);
+        }
+    }
+
+    #[test]
+    fn selection_byte_budget_drops_old_masks_and_keeps_the_last_undo() {
+        use photocraft_doc::{PixelFormat, Surface};
+        for depth in SampleType::ALL {
+            let mut doc = Document::new("selection", Size::new(64, 64), ColorMode::Rgb, depth);
+            doc.selection = Some(Surface::new(PixelFormat::new(ColorMode::Grayscale, depth, false)));
+            let mut cur = Arc::new(doc);
+            let tile = 256 * 256 * depth.bytes();
+            let mut h = History::default();
+            for i in 1..=6 {
+                edit(&mut h, &mut cur, "Selection", |doc| {
+                    doc.selection.as_mut().unwrap().write_pixel(1, 1, &[i as f32 / 8.0]);
+                });
+            }
+            assert_eq!(h.pixel_bytes(&cur), 6 * tile);
+            h.max_bytes = 3 * tile;
+            assert_eq!(h.trim(&cur), 4);
+            assert_eq!(h.past_len(), 2);
+            assert_eq!(h.pixel_bytes(&cur), 3 * tile);
+            assert_eq!(h.unique_bytes(&cur), 2 * tile);
+            assert_counter(&h, &cur);
+            h.max_bytes = 1;
+            assert_eq!(h.trim(&cur), 1);
+            assert_eq!(h.past_len(), 1, "the most recent undo survives even below one mask's size");
+            assert_eq!(h.pixel_bytes(&cur), 2 * tile);
+            cur = h.undo(cur).unwrap().0;
+            assert_counter(&h, &cur);
+        }
+    }
+
     fn assert_counter(h: &History, current: &Document) {
         let counter = h.tiles.as_ref().expect("budget initializes the counter");
         let total = tile_bytes(current, &mut HashSet::new()).saturating_add(h.unique_bytes(current));
@@ -419,15 +498,138 @@ mod tests {
         assert_eq!(counter.bytes_with(&empty), retained as u128);
     }
 
+    fn video_document(depth: SampleType, frames: usize) -> Document {
+        let mut doc = Document::new("video", Size::new(64, 64), ColorMode::Rgb, depth);
+        let mut layer = Layer::raster("Video", doc.pixel_format());
+        let footage: Vec<_> = (0..frames)
+            .map(|i| {
+                let mut surface = photocraft_doc::Surface::new(doc.pixel_format());
+                surface.write_pixel(1, 1, &[i as f32 / frames as f32, 0.0, 0.0, 1.0]);
+                surface
+            })
+            .collect();
+        layer.content = photocraft_doc::LayerContent::Raster(footage[0].clone());
+        layer.video = Some(photocraft_doc::VideoData::new(footage, 24.0));
+        doc.layers.push(layer);
+        doc
+    }
+
+    #[test]
+    fn video_memory_counts_originals_and_deduplicates_displayed_frames() {
+        for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+            let mut doc = video_document(depth, 3);
+            let tile = doc.layers[0].surface().unwrap().tiles().next().unwrap().1.bytes().len();
+            let video = doc.layers[0].video.as_mut().unwrap();
+            video.original_frames = Some(video.frames.clone());
+            // Original footage and the displayed frame alias the stack, except this painted frame.
+            video.frames[2].write_pixel(1, 1, &[0.0, 1.0, 0.0, 1.0]);
+            let mut cur = Arc::new(doc);
+            let mut h = History { max_bytes: usize::MAX, ..History::default() };
+            assert_eq!(h.pixel_bytes(&cur), 4 * tile);
+            for name in ["A", "B"] {
+                edit(&mut h, &mut cur, "Rename", |doc| doc.name = name.into());
+                h.trim(&cur);
+            }
+            assert_counter(&h, &cur);
+            assert_eq!(h.pixel_bytes(&cur), 4 * tile);
+            assert_eq!(h.unique_bytes(&cur), 0);
+            // Rasterizing keeps the displayed frame; the rest of the clip survives only in undo.
+            edit(&mut h, &mut cur, "Rasterize", |doc| doc.layers[0].video = None);
+            assert_eq!(h.unique_bytes(&cur), 3 * tile);
+            assert_eq!(h.pixel_bytes(&cur), 4 * tile);
+            assert_counter(&h, &cur);
+            cur = h.undo(cur).unwrap().0;
+            assert_eq!(h.unique_bytes(&cur), 0);
+            assert_counter(&h, &cur);
+            cur = h.redo(cur).unwrap().0;
+            assert_eq!(h.unique_bytes(&cur), 3 * tile);
+            assert_counter(&h, &cur);
+            h.clear();
+            assert_eq!(h.pixel_bytes(&cur), tile);
+        }
+    }
+
+    #[test]
+    fn video_memory_budget_evicts_deleted_off_playhead_frames() {
+        for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
+            let mut cur = Arc::new(video_document(depth, 6));
+            let tile = cur.layers[0].surface().unwrap().tiles().next().unwrap().1.bytes().len();
+            let mut h = History::default();
+            for _ in 0..4 {
+                edit(&mut h, &mut cur, "Delete Frame", |doc| {
+                    doc.layers[0].video.as_mut().unwrap().frames.remove(1);
+                });
+            }
+            assert_eq!(h.pixel_bytes(&cur), 6 * tile);
+            assert_eq!(h.unique_bytes(&cur), 4 * tile);
+            h.max_bytes = 3 * tile;
+            assert_eq!(h.trim(&cur), 3);
+            assert_eq!(h.past_len(), 1);
+            assert_eq!(h.pixel_bytes(&cur), 3 * tile);
+            assert_eq!(h.unique_bytes(&cur), tile);
+            assert_counter(&h, &cur);
+            cur = h.undo(cur).unwrap().0;
+            assert_eq!(cur.layers[0].video.as_ref().unwrap().frames.len(), 3);
+            assert_counter(&h, &cur);
+            cur = h.redo(cur).unwrap().0;
+            assert_eq!(cur.layers[0].video.as_ref().unwrap().frames.len(), 2);
+            assert_counter(&h, &cur);
+            // A budget below the remaining clip still keeps the latest step undoable.
+            h.max_bytes = 1;
+            assert_eq!(h.trim(&cur), 0);
+            assert!(h.can_undo());
+        }
+    }
+
+    /// A pattern fill or layer style copies its pattern into the document, so the pattern's tiles
+    /// count like layer pixels, shared ones once; undoing that step leaves them to the redo states.
+    #[test]
+    fn document_patterns_count_as_document_pixels() {
+        use photocraft_doc::{Pattern, Surface};
+        for depth in SampleType::ALL {
+            let tile = 4 * 256 * 256 * depth.bytes();
+            let mut cur = Arc::new(Document::new("patterns", Size::new(64, 64), ColorMode::Rgb, depth));
+            let mut h = History { max_bytes: usize::MAX, ..History::default() };
+            for name in ["A", "B"] {
+                edit(&mut h, &mut cur, "Rename", |doc| doc.name = name.into());
+                h.trim(&cur);
+            }
+            let mut surface = Surface::new(cur.pixel_format());
+            surface.write_pixel(1, 1, &[0.0, 0.0, 1.0, 1.0]);
+            let pattern = Pattern::new("Pattern", surface, 4, 4);
+            edit(&mut h, &mut cur, "Pattern Fill", |doc| doc.patterns.push(pattern));
+            assert_eq!(h.pixel_bytes(&cur), tile, "the document's pattern");
+            assert_eq!(h.unique_bytes(&cur), 0);
+            assert_counter(&h, &cur);
+            edit(&mut h, &mut cur, "Rename", |doc| doc.name = "C".into());
+            assert_eq!(h.pixel_bytes(&cur), tile, "shared with history, it counts once");
+            assert_counter(&h, &cur);
+            for _ in 0..2 {
+                cur = h.undo(cur).unwrap().0;
+                assert_counter(&h, &cur);
+            }
+            assert!(cur.patterns.is_empty());
+            assert_eq!(h.unique_bytes(&cur), tile, "only the redo states hold the pattern");
+            assert_eq!(h.pixel_bytes(&cur), tile);
+            cur = h.redo(cur).unwrap().0;
+            assert_eq!(h.unique_bytes(&cur), 0);
+            assert_counter(&h, &cur);
+            h.clear();
+            assert_eq!(h.pixel_bytes(&cur), tile);
+        }
+    }
+
     #[test]
     fn counter_tracks_eviction_undo_redo_branching_purge_and_clones() {
         for depth in [SampleType::U8, SampleType::U16, SampleType::F32] {
             let mut cur = Arc::new(Document::with_background("h", Size::new(300, 64), ColorMode::Rgb, depth, Color::WHITE));
+            Arc::make_mut(&mut cur).selection = Some(photocraft_doc::Surface::new(photocraft_doc::PixelFormat::GRAY8));
             let mut h = History::new(4);
             h.max_bytes = usize::MAX;
             for i in 0..8 {
                 edit(&mut h, &mut cur, "Paint", |doc| {
                     doc.layers[0].surface_mut().unwrap().write_pixel(1, 1, &[i as f32 / 10.0, 0.0, 0.0, 1.0]);
+                    doc.selection.as_mut().unwrap().write_pixel(1, 1, &[i as f32 / 10.0]);
                 });
                 h.trim(&cur);
                 if i >= 1 {
@@ -464,6 +666,7 @@ mod tests {
         gray.write_pixel(1, 1, &[1.0]);
         doc.layers[0].mask = Some(LayerMask { surface: gray.clone(), ..LayerMask::reveal_all() });
         doc.channels.push(AlphaChannel::new("alpha", gray.clone()));
+        doc.selection = Some(gray.clone());
         doc.quick_mask = Some(AlphaChannel::new("quick", gray));
         doc.layers.push(doc.layers[0].clone());
         let mut cur = Arc::new(doc);
diff --git a/crates/ops/src/tiles.rs b/crates/ops/src/tiles.rs
index 59d73cb50e..b8d27775f9 100644
--- a/crates/ops/src/tiles.rs
+++ b/crates/ops/src/tiles.rs
@@ -19,10 +19,24 @@ pub(crate) fn surfaces(doc: &Document, mut visit: impl FnMut(&Surface)) {
         if let Some(mask) = &layer.mask {
             visit(&mask.surface);
         }
+        if let Some(video) = &layer.video {
+            // Undo retains the whole clip, not only the displayed frame. Visit aliases too:
+            // Tiles tracks every owner and counts their shared allocations only once.
+            for frame in video.frames.iter().chain(video.original_frames.iter().flatten()) {
+                visit(frame);
+            }
+        }
     }
     for channel in doc.channels.iter().chain(&doc.quick_mask) {
         visit(&channel.surface);
     }
+    // A pattern fill or layer style copies its pattern into the document.
+    for pattern in &doc.patterns {
+        visit(&pattern.surface);
+    }
+    if let Some(selection) = &doc.selection {
+        visit(selection);
+    }
 }
 
 impl Tiles {
diff --git a/crates/paint/src/bg_erase.rs b/crates/paint/src/bg_erase.rs
index 14b3df3964..ec0ce0907b 100644
--- a/crates/paint/src/bg_erase.rs
+++ b/crates/paint/src/bg_erase.rs
@@ -71,36 +71,41 @@ pub fn apply_background_eraser(target: &mut Surface, stroke: &Stroke, bs: &BgEra
     let mut stroke = stroke.clone();
     stroke.brush.opacity = 1.0;
     stroke.brush.erase = false;
+    // The pixels before the stroke, taken at the first dab. Sampling and matching read these, so a
+    // dab landing on pixels earlier dabs already erased still samples and matches (#1280).
+    let mut orig: Option<Region> = None;
     apply_dab_stroke(target, &stroke, selection, false, 0, |work: &mut Region, fp| {
         let r = fp.rect.intersect(&work.rect);
         if r.is_empty() {
             return;
         }
+        let orig = &*orig.get_or_insert_with(|| work.clone());
         let (cx, cy) = (fp.dab.center.x.floor() as i32, fp.dab.center.y.floor() as i32);
-        // The hotspot's colour (None where it is already transparent or off the working area).
-        let hotspot = |work: &Region| -> Option<Vec<f32>> {
-            if !work.rect.contains(cx, cy) {
+        // The hotspot's colour (None where it was transparent before the stroke or is off the
+        // working area).
+        let hotspot = || -> Option<Vec<f32>> {
+            if !orig.rect.contains(cx, cy) {
                 return None;
             }
-            let p = work.px(cx, cy);
+            let p = orig.px(cx, cy);
             (p[a] > 0.0).then(|| p[..nc].to_vec())
         };
         let sampled = match bs.sampling {
-            Sampling::Continuous => hotspot(work),
-            Sampling::Once => once.get_or_insert_with(|| hotspot(work)).clone(),
+            Sampling::Continuous => hotspot(),
+            Sampling::Once => once.get_or_insert_with(hotspot).clone(),
             Sampling::BackgroundSwatch => Some(swatch.clone()),
         };
         let Some(sampled) = sampled else { return };
         let (w, h) = (r.width() as usize, r.height() as usize);
-        // Per-pixel match weight. Erasing only lowers alpha, so the working copy still holds the
-        // pre-stroke colours.
+        // Per-pixel match weight from the pre-stroke colours: the contiguous fill passes through
+        // pixels this stroke already erased.
         let mut weight = vec![0.0f32; w * h];
         for y in r.y0..r.y1 {
             for x in r.x0..r.x1 {
                 if fp.at(x, y) <= 0.0 {
                     continue;
                 }
-                let p = work.px(x, y);
+                let p = orig.px(x, y);
                 if p[a] <= 0.0 {
                     continue;
                 }
@@ -246,6 +251,27 @@ mod tests {
         assert_eq!(t, s);
     }
 
+    #[test]
+    fn one_pass_clears_the_whole_stroke_when_dabs_overlap_erased_pixels() {
+        // #1280: later dabs land their hotspot on pixels earlier dabs already erased.
+        let fmt = PixelFormat::RGBA8;
+        let mut s = Surface::new(fmt);
+        s.fill_rect(Rect::new(0, 0, 60, 30), &from_rgba(&fmt, GREEN));
+        let mut st = stroke(&[(10.0, 15.0), (50.0, 15.0)]);
+        st.brush.size = 20.0;
+        for sampling in [Sampling::Continuous, Sampling::Once] {
+            let mut t = s.clone();
+            let bs = BgEraseSettings { sampling, limits: Limits::Contiguous, ..Default::default() };
+            apply_background_eraser(&mut t, &st, &bs, None);
+            // Everything within radius − 1 of the line.
+            for y in 6..24 {
+                for x in 10..51 {
+                    assert_eq!(alpha(&t, x, y), 0.0, "{sampling:?} ({x}, {y}) left behind");
+                }
+            }
+        }
+    }
+
     #[test]
     fn selection_limits_and_degenerate_inputs() {
         let fmt = PixelFormat::RGBA8;
diff --git a/crates/paint/src/brush.rs b/crates/paint/src/brush.rs
index 25ebea5ef2..0dd4d21d65 100644
--- a/crates/paint/src/brush.rs
+++ b/crates/paint/src/brush.rs
@@ -270,7 +270,7 @@ pub struct Texture {
     pub scale: f32,
     /// -1..1 (Photoshop's -150..150 mapped to ±1).
     pub brightness: f32,
-    /// -1..1.
+    /// -1..1: Photoshop's -50..0 mapped to -1..0 and its 0..100 to 0..1.
     pub contrast: f32,
     /// Apply the texture to every dab (enables depth jitter) instead of once to the stroke.
     pub each_tip: bool,
@@ -281,6 +281,21 @@ pub struct Texture {
     pub depth_jitter: Dynamic,
 }
 
+impl Texture {
+    /// A pattern value (0..1) after Brightness, Contrast and Invert: the value the mode combines
+    /// with the brush. Measured against Photoshop (#3340): Brightness shifts the pattern by
+    /// `brightness / 255` (±150 moves it 150 levels of 255, not all the way to white or black);
+    /// positive Contrast steepens it around mid-grey by `1 / (1 − c/100)` after the shift (100 is
+    /// a threshold), negative Contrast flattens it by `1 + c/100` before the shift; Invert is last.
+    pub fn level(&self, v: f32) -> f32 {
+        let b = if self.brightness.is_finite() { self.brightness.clamp(-1.0, 1.0) * (150.0 / 255.0) } else { 0.0 };
+        let c = if self.contrast.is_finite() { self.contrast.clamp(-1.0, 1.0) } else { 0.0 };
+        let x = if c >= 0.0 { (v + b - 0.5) / (1.0 - c).max(1e-4) + 0.5 } else { (v - 0.5) * (1.0 + c / 2.0) + 0.5 + b };
+        let x = if x.is_finite() { x.clamp(0.0, 1.0) } else { 0.5 };
+        if self.invert { 1.0 - x } else { x }
+    }
+}
+
 impl Default for Texture {
     fn default() -> Self {
         Self {
@@ -426,6 +441,8 @@ impl Default for Pose {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct Smoothing {
+    /// Switch smoothing off without discarding its amount or mode. Old presets remain enabled.
+    pub enabled: bool,
     /// 0..1.
     pub amount: f32,
     /// Lazy-mouse: paint only when the pointer pulls a string of `amount × 100 px` taut.
@@ -440,7 +457,7 @@ pub struct Smoothing {
 
 impl Default for Smoothing {
     fn default() -> Self {
-        Self { amount: 0.0, pulled_string: false, catch_up: true, catch_up_on_end: true, adjust_for_zoom: true }
+        Self { enabled: true, amount: 0.0, pulled_string: false, catch_up: true, catch_up_on_end: true, adjust_for_zoom: true }
     }
 }
 
@@ -469,6 +486,11 @@ pub struct BrushSettings {
     pub pressure_opacity: bool,
     /// Straight RGBA colour (display RGB). Commands fill it from the foreground colour.
     pub color: [f32; 4],
+    /// The inks `color` was picked as (its sRGB colour, the CMYK values), for a CMYK target: the
+    /// stroke paints exactly these, since an sRGB round trip does not give them back (#4344).
+    /// Only valid while `color` is that sRGB colour; ignored with Color Dynamics.
+    #[serde(skip)]
+    pub color_cmyk: Option<([f32; 3], [f32; 4])>,
     /// Background colour for Color Dynamics' foreground/background jitter.
     pub background: [f32; 4],
     /// Erase instead of paint.
@@ -528,6 +550,7 @@ impl Default for BrushSettings {
             pressure_size: true,
             pressure_opacity: false,
             color: [0.0, 0.0, 0.0, 1.0],
+            color_cmyk: None,
             background: [1.0, 1.0, 1.0, 1.0],
             erase: false,
             mode: BlendMode::Normal,
@@ -651,4 +674,55 @@ pub struct BrushPreset {
     /// folders of Photoshop's Brushes panel; e.g. an imported `.abr` file's own folders.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub folder: Vec<String>,
+    /// What picking the preset brings besides the tip and its sections: the New Brush Preset
+    /// dialog's boxes.
+    #[serde(default, skip_serializing_if = "PresetCaptures::is_default")]
+    pub captures: PresetCaptures,
+}
+
+/// The New Brush Preset dialog's boxes, kept with the preset. The default is a preset made
+/// without the dialog (a built-in, an import, an older save): picking it brings its size and tool
+/// settings, as it always did, and leaves the foreground colour alone.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct PresetCaptures {
+    /// Capture Brush Size in Preset. Off: picking the preset keeps the tool's size.
+    pub size: bool,
+    /// Include Tool Settings: the options bar's mode, opacity, flow and pressure buttons. Off:
+    /// picking the preset keeps the tool's.
+    pub tool_settings: bool,
+    /// Include Color: picking the preset sets the foreground colour to the brush's `color`.
+    pub color: bool,
+}
+
+impl Default for PresetCaptures {
+    fn default() -> Self {
+        Self { size: true, tool_settings: true, color: false }
+    }
+}
+
+impl PresetCaptures {
+    pub fn is_default(&self) -> bool {
+        *self == Self::default()
+    }
+}
+
+impl BrushPreset {
+    /// The tool's brush once this preset is picked while `current` is the tool's brush: the
+    /// preset's brush ([`BrushSettings::picked_over`]), with the size and tool settings it didn't
+    /// capture left as they were.
+    pub fn picked_over(&self, current: &BrushSettings) -> BrushSettings {
+        let mut b = self.brush.clone().picked_over(current);
+        if !self.captures.size {
+            b.size = current.size;
+        }
+        if !self.captures.tool_settings {
+            b.mode = current.mode;
+            b.opacity = current.opacity;
+            b.flow = current.flow;
+            b.pressure_size = current.pressure_size;
+            b.pressure_opacity = current.pressure_opacity;
+        }
+        b
+    }
 }
diff --git a/crates/paint/src/brush_tests.rs b/crates/paint/src/brush_tests.rs
index 61772e4ea1..284b7ae3b9 100644
--- a/crates/paint/src/brush_tests.rs
+++ b/crates/paint/src/brush_tests.rs
@@ -6,7 +6,7 @@ use photocraft_raster::Surface;
 
 use crate::brush::*;
 use crate::dynamics::{Smoother, smooth_points};
-use crate::render::{BrushContext, StrokeRenderer, mask_combine, render_stroke};
+use crate::render::{BrushContext, StrokeRenderer, mask_combine, render_stroke, texture_combine};
 use crate::tile::GrayTile;
 use crate::{Dab, Stroke, StrokePoint, dabs};
 
@@ -80,10 +80,12 @@ fn hardness_profile_is_monotonic() {
     for h in [0.0f32, 0.5, 1.0] {
         let b = BrushSettings { hardness: h, ..brush() };
         let r = raster(&b, &Dab::round(Point::new(50.0, 50.0), 20.0, 1.0));
-        let prof: Vec<f32> = (0..22).map(|i| at(&r, 50 + i, 50)).collect();
+        // A soft tip paints past its 20 px radius, as Photoshop's does, out to its reach.
+        let n = crate::tip_reach(20.0, h).ceil() as i32 + 1;
+        let prof: Vec<f32> = (0..n).map(|i| at(&r, 50 + i, 50)).collect();
         assert!(prof.windows(2).all(|w| w[1] <= w[0] + 1e-6), "h={h} {prof:?}");
         assert!(prof[0] > 0.99);
-        assert_eq!(prof[21], 0.0);
+        assert!(*prof.last().unwrap() < 0.002, "h={h} {prof:?}");
         let mid = at(&r, 60, 50);
         if h == 1.0 {
             assert!(mid > 0.99);
@@ -103,7 +105,7 @@ fn hard_edge_is_sharp() {
     let band = prof.iter().filter(|&&a| (0.01..0.99).contains(&a)).count();
     assert!(band <= 3, "hardness 1 rim is {band} px wide: {prof:?}");
     assert!(prof[17] > 0.99, "translucent inside the rim: {prof:?}");
-    assert_eq!(*prof.last().unwrap(), 0.0);
+    assert!(*prof.last().unwrap() < 0.01, "{prof:?}");
     // A soft tip spreads the same crossing over many pixels instead.
     let soft = BrushSettings { hardness: 0.0, ..brush() };
     let rs = raster(&soft, &Dab::round(Point::new(50.0, 50.0), 20.0, 1.0));
@@ -525,7 +527,9 @@ fn texture_modulates_coverage() {
     b.texture.invert = false;
     b.texture.brightness = 1.0;
     let s = paint(&b, &line(20.0, 80.0, 30.0), 100, 60);
-    assert!(s.rgba(46, 30)[3] > 0.9);
+    // +150 lifts a black texel by 150 levels of 255, not to white (#3340).
+    let lifted = s.rgba(46, 30)[3];
+    assert!((lifted - 150.0 / 255.0).abs() < 0.02, "{lifted}");
     // All modes keep zero coverage at zero and stay in range.
     for m in [
         MaskMode::Multiply,
@@ -544,6 +548,12 @@ fn texture_modulates_coverage() {
             let v = mask_combine(m, 0.7, t, 0.8);
             assert!((0.0..=1.0).contains(&v), "{m:?}");
         }
+        for t in [0.0, 0.3, 1.0] {
+            assert_eq!(texture_combine(m, 0.0, t, 1.0), 0.0, "{m:?}");
+            let v = texture_combine(m, 0.7, t, 0.8);
+            assert!((0.0..=1.0).contains(&v), "{m:?}");
+        }
+        assert!((0.0..=1.0).contains(&texture_combine(m, 0.7, f32::NAN, f32::INFINITY)), "{m:?}");
         // Full-white texture never reduces multiply-like masks below the brush.
         assert!(mask_combine(m, 0.6, 1.0, 1.0) >= 0.6 - 1e-5 || matches!(m, MaskMode::Overlay), "{m:?}");
     }
@@ -555,6 +565,98 @@ fn texture_modulates_coverage() {
     assert!(d.iter().any(|x| x.depth < 0.6));
 }
 
+/// Texture Brightness and Contrast as Photoshop applies them, measured by stroking a 0..255 grey
+/// ramp pattern in Multiply mode at 100 % depth (the stroke's opacity is then the pattern value):
+/// (setting, ramp value, opacity read back), in levels of 255 (#3340).
+#[test]
+fn texture_brightness_and_contrast_match_photoshop() {
+    let level = |brightness: f32, contrast: f32, invert: bool, v: f32| {
+        // The model's ranges: brightness ±150 → ±1; contrast -50..0 → -1..0, 0..100 → 0..1.
+        let c = if contrast < 0.0 { contrast / 50.0 } else { contrast / 100.0 };
+        let t = Texture { brightness: brightness / 150.0, contrast: c, invert, ..Default::default() };
+        t.level(v / 255.0) * 255.0
+    };
+    for (b, c, inv, v, want) in [
+        (87.0, 0.0, false, 8.0, 95.0),
+        (87.0, 0.0, false, 200.0, 255.0),
+        (-87.0, 0.0, false, 104.0, 17.0),
+        (150.0, 0.0, false, 8.0, 158.0),
+        (0.0, 50.0, false, 104.0, 81.0),
+        (0.0, 50.0, false, 136.0, 145.0),
+        (0.0, -50.0, false, 8.0, 67.0),
+        (0.0, -50.0, false, 248.0, 188.0),
+        (0.0, 100.0, false, 120.0, 0.0),
+        (0.0, 100.0, false, 136.0, 255.0),
+        // Positive contrast after the shift, negative contrast before it.
+        (40.0, 50.0, false, 104.0, 161.0),
+        (40.0, 50.0, false, 40.0, 33.0),
+        (-40.0, -30.0, false, 120.0, 82.0),
+        (-40.0, -30.0, false, 248.0, 172.0),
+        // Invert comes last.
+        (40.0, 0.0, true, 8.0, 207.0),
+        (0.0, 50.0, true, 72.0, 238.0),
+    ] {
+        let got = level(b, c, inv, v);
+        assert!((got - want).abs() <= 2.0, "brightness {b}, contrast {c}, invert {inv}, ramp {v}: {got} (Photoshop {want})");
+    }
+}
+
+/// The Texture modes that differ from the Dual Brush's, against single Photoshop dabs over a
+/// 0..255 ramp: (mode, depth, brush coverage, ramp value, opacity read back), in levels of 255.
+#[test]
+fn texture_modes_match_photoshop() {
+    use MaskMode::*;
+    for (m, d, v, t, want) in [
+        // Height: a low depth paints the dark valleys only, more depth fills the pattern.
+        (Height, 0.0, 255.0, 8.0, 0.0),
+        (Height, 0.01, 255.0, 8.0, 28.0),
+        (Height, 0.05, 255.0, 8.0, 148.0),
+        (Height, 0.05, 255.0, 136.0, 20.0),
+        (Height, 0.13, 255.0, 8.0, 255.0),
+        (Height, 0.13, 255.0, 152.0, 244.0),
+        (Height, 0.13, 255.0, 248.0, 148.0),
+        (Height, 0.13, 186.0, 88.0, 201.0),
+        (Height, 0.13, 142.0, 104.0, 116.0),
+        (Height, 0.25, 255.0, 248.0, 255.0),
+        // Linear Height: graded by the pattern while the reach stays below its top.
+        (LinearHeight, 0.01, 255.0, 152.0, 15.0),
+        (LinearHeight, 0.05, 255.0, 8.0, 151.0),
+        (LinearHeight, 0.05, 255.0, 152.0, 63.0),
+        (LinearHeight, 0.10, 255.0, 72.0, 240.0),
+        (LinearHeight, 0.13, 101.0, 120.0, 82.0),
+        (LinearHeight, 0.13, 142.0, 104.0, 130.0),
+        // Subtract: the light parts take paint away.
+        (Subtract, 1.0, 255.0, 8.0, 247.0),
+        (Subtract, 1.0, 255.0, 248.0, 7.0),
+        (Subtract, 0.5, 224.0, 72.0, 188.0),
+        // Color Burn / Color Dodge below full depth.
+        (ColorBurn, 0.5, 224.0, 72.0, 207.0),
+        (ColorDodge, 0.5, 99.0, 120.0, 130.0),
+        // Unchanged modes.
+        (Multiply, 0.13, 255.0, 8.0, 223.0),
+        (Darken, 0.5, 255.0, 8.0, 131.0),
+    ] {
+        let got = texture_combine(m, v / 255.0, t / 255.0, d) * 255.0;
+        assert!((got - want).abs() <= 3.0, "{m:?} depth {d}, coverage {v}, ramp {t}: {got} (Photoshop {want})");
+    }
+}
+
+/// #3340: an imported Height-mode brush at a low depth with a darkened pattern painted nothing.
+#[test]
+fn low_depth_height_texture_paints() {
+    let tile = GrayTile::from_fn(8, 8, |x, y| if (x + y) % 2 == 0 { 0.45 } else { 0.6 });
+    for mode in [MaskMode::Height, MaskMode::LinearHeight] {
+        let b = BrushSettings {
+            size: 40.0,
+            texture: Texture { enabled: true, pattern: Pattern::Tile(tile.clone()), mode, depth: 0.13, brightness: -87.0 / 150.0, ..Default::default() },
+            ..brush()
+        };
+        let s = paint(&b, &line(20.0, 80.0, 30.0), 100, 60);
+        let a = s.rgba(50, 30)[3];
+        assert!(a > 0.95, "{mode:?}: {a}");
+    }
+}
+
 #[test]
 fn dual_brush_intersects() {
     // Dual tip: small dabs far apart → the stroke survives only where they land.
@@ -656,6 +758,39 @@ fn smoothing_modes() {
     assert!(out.last().unwrap().x < 70.0, "{}", out.last().unwrap().x);
 }
 
+#[test]
+fn disabled_smoothing_keeps_its_settings_and_paints_unsmoothed_at_every_depth() {
+    let pts = vec![StrokePoint::new(10.0, 20.0, 1.0), StrokePoint::new(30.0, 8.0, 0.5), StrokePoint::new(50.0, 20.0, 0.8)];
+    for pulled_string in [false, true] {
+        let smoothing = Smoothing { enabled: false, amount: 0.8, pulled_string, ..Default::default() };
+        let got = smooth_points(&smoothing, 1.0, &pts);
+        assert_eq!(got.len(), pts.len());
+        for (a, b) in got.iter().zip(&pts) {
+            assert_eq!((a.x, a.y, a.pressure), (b.x, b.y, b.pressure));
+        }
+        let b = BrushSettings { size: 9.0, smoothing: smoothing.clone(), ..brush() };
+        let zero = BrushSettings { smoothing: Smoothing { amount: 0.0, ..smoothing.clone() }, ..b.clone() };
+        for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA16, PixelFormat::RGBA32F] {
+            let (mut off, mut reference) = (Surface::new(fmt), Surface::new(fmt));
+            render_stroke(&mut off, &b, &pts, None, false, 1.0);
+            render_stroke(&mut reference, &zero, &pts, None, false, 1.0);
+            for y in 0..40 {
+                for x in 0..64 {
+                    assert_eq!(off.pixel(x, y), reference.pixel(x, y), "{fmt:?} at {x},{y}");
+                }
+            }
+        }
+        // Disabling is not an amount=0 rewrite: saving and re-enabling recover the same mode.
+        let mut back: Smoothing = serde_json::from_value(serde_json::to_value(&smoothing).unwrap()).unwrap();
+        assert_eq!(back, smoothing);
+        back.enabled = true;
+        assert!(smooth_points(&back, 1.0, &pts).iter().zip(&pts).any(|(a, b)| a.x != b.x || a.y != b.y));
+    }
+    // Existing brush JSON has no switch and must retain its old smoothing behavior.
+    let legacy: Smoothing = serde_json::from_str(r#"{"amount":0.8,"pulledString":true}"#).unwrap();
+    assert!(legacy.enabled && legacy.amount == 0.8 && legacy.pulled_string);
+}
+
 #[test]
 fn smoothing_string_runs_from_the_lagging_brush_to_the_pointer() {
     // #3479: the canvas draws the line between the brush and the pointer.
@@ -857,6 +992,91 @@ fn tail_preview_shows_the_stroke_as_finishing_it_would() {
     assert!(r.tail_preview().is_none());
 }
 
+#[test]
+fn live_union_of_passes_matches_merging_the_finished_passes_after_every_chunk() {
+    // Symmetric painting previews the stroke and its mirrors with `composite_union_live`, which
+    // redraws only changed tiles; after every chunk the target must be exactly what finishing
+    // every pass and merging them with `composite_union_many` gives (the commit takes these pixels).
+    let base = BrushSettings { size: 14.0, hardness: 0.6, opacity: 0.6, ..brush() };
+    let mut brushes = vec![base.clone()];
+    brushes.push(BrushSettings { smoothing: Smoothing { amount: 0.7, ..Default::default() }, ..base.clone() });
+    let mut b = base.clone();
+    b.dual_brush.enabled = true;
+    b.dual_brush.size = 6.0;
+    b.dual_brush.scatter = 1.5;
+    brushes.push(b);
+    let mut b = base.clone();
+    b.color_dynamics.enabled = true;
+    b.color_dynamics.hue_jitter = 0.5;
+    brushes.push(b);
+    brushes.push(BrushSettings { wet_edges: true, ..base.clone() });
+    brushes.push(BrushSettings { mode: BlendMode::Dissolve, ..base.clone() });
+    brushes.push(BrushSettings { erase: true, ..base.clone() });
+    let mut b = base.clone();
+    b.texture.enabled = true;
+    b.texture.each_tip = false;
+    brushes.push(b);
+    let stroke: Vec<StrokePoint> = (0..40).map(|i| StrokePoint::new(30.0 + i as f64 * 3.7, 40.0 + 25.0 * (i as f64 / 5.0).sin(), 1.0)).collect();
+    // Mirrors about x = 100 and y = 75; the first point sits near the vertical axis so passes overlap.
+    let mirror = |fx: bool, fy: bool| -> Vec<StrokePoint> {
+        stroke.iter().map(|p| StrokePoint::new(if fx { 200.0 - p.x } else { p.x }, if fy { 150.0 - p.y } else { p.y }, p.pressure)).collect()
+    };
+    let paths = [stroke.clone(), mirror(true, false), mirror(false, true), mirror(true, true)];
+    let area = Rect::new(-20, -20, 240, 190);
+    let mut sel = Surface::new(PixelFormat::new(ColorMode::Grayscale, SampleType::F32, false));
+    let sel_rect = Rect::new(0, 0, 160, 120);
+    sel.write_region(sel_rect, &(0..160 * 120).map(|i| ((i % 160) as f32 / 120.0).min(1.0)).collect::<Vec<_>>());
+    for sample in [SampleType::U8, SampleType::U16, SampleType::F32] {
+        let fmt = PixelFormat::new(ColorMode::Rgb, sample, true);
+        let mut pre = Surface::new(fmt);
+        let fill = Rect::new(10, 10, 190, 140);
+        let n = fmt.channels();
+        let px: Vec<f32> =
+            (0..fill.width() * fill.height()).flat_map(|i| [(i % 7) as f32 / 7.0, 0.5, (i % 13) as f32 / 13.0, 0.8].into_iter().take(n)).collect();
+        pre.write_region(fill, &px);
+        for (bi, b) in brushes.iter().enumerate() {
+            // (passes included at each chunk, selection): two passes from the start; four, of
+            // which two join part-way.
+            for (four, selection) in [(false, None), (true, None), (true, Some(&sel))] {
+                let mut renderers: Vec<StrokeRenderer> = (0..4).map(|_| StrokeRenderer::new(b, Some(fmt), 1.0)).collect();
+                let mut live = crate::render::UnionLive::default();
+                let mut target = pre.clone();
+                let (mut at, mut chunk, mut merged) = (0, 1, 0);
+                while at < stroke.len() {
+                    let end = (at + chunk).min(stroke.len());
+                    for (r, path) in renderers.iter_mut().zip(&paths) {
+                        r.push(&path[at..end]);
+                    }
+                    let count = if four && at >= 12 { 4 } else { 2 };
+                    let full = merged != count;
+                    merged = count;
+                    let mut passes: Vec<&mut StrokeRenderer> = renderers.iter_mut().take(count).collect();
+                    StrokeRenderer::composite_union_live(&mut passes, &mut live, full, &pre, &mut target, selection, false);
+                    let finished: Vec<StrokeRenderer> = renderers
+                        .iter()
+                        .take(count)
+                        .map(|r| {
+                            let mut r = r.clone();
+                            r.finish();
+                            r
+                        })
+                        .collect();
+                    let mut expected = pre.clone();
+                    finished[0].composite_union_many(&finished[1..], &pre, &mut expected, selection, false);
+                    assert!(
+                        target.read_region(area) == expected.read_region(area),
+                        "{sample:?}, brush {bi}, four {four}, selection {}, points ..{end}",
+                        selection.is_some()
+                    );
+                    assert_eq!(live.bounds(), finished.iter().fold(Rect::EMPTY, |r, f| r.union(&f.bounds())));
+                    at = end;
+                    chunk = chunk % 3 + 1;
+                }
+            }
+        }
+    }
+}
+
 // ---------- Tilt Scale, Brush Projection, speed spacing, locks, mixer transfer ----------
 
 /// Coverage extent (pixels above half coverage) of a rasterised dab along x and y through its centre.
@@ -1065,7 +1285,9 @@ fn huge_scatter_is_capped_and_renders_at_every_depth() {
         let ctx = BrushContext::new(&b);
         for d in &capped.0 {
             let r = ctx.dab_rect(d, false);
-            assert!(!r.is_empty() && r.width() <= 24 && r.height() <= 24, "{r:?}");
+            // A 20 px soft tip reaches about 1.6 radii (see `tip_reach`).
+            let side = 2 * (crate::tip_reach(10.0, b.hardness).ceil() as u32 + 1) + 2;
+            assert!(!r.is_empty() && r.width() <= side && r.height() <= side, "{r:?} vs {side}");
         }
         for sample in [SampleType::U8, SampleType::U16, SampleType::F32] {
             let mut s = Surface::new(PixelFormat::new(ColorMode::Rgb, sample, true));
@@ -1149,14 +1371,32 @@ fn a_tiny_dabs_coverage_does_not_depend_on_where_it_lands_in_a_pixel() {
 }
 
 #[test]
-fn the_tip_falls_off_from_the_hard_core_to_zero_at_the_edge() {
+fn the_tip_matches_photoshops_measured_dabs() {
     use crate::tip_falloff;
+    // Photoshop 27.11, single 40 px dabs (R = 20): mean alpha over rings 0.1 R wide starting at
+    // the given fraction of the radius (area-weighted, as measured).
+    let measured: [(f32, [(f32, f32); 4]); 3] = [
+        (0.0, [(0.2, 0.861), (0.5, 0.509), (0.9, 0.129), (1.2, 0.027)]),
+        (0.5, [(0.6, 0.97), (0.8, 0.561), (1.0, 0.135), (1.2, 0.012)]),
+        (1.0, [(0.8, 1.0), (0.9, 0.821), (1.2, 0.0), (1.3, 0.0)]),
+    ];
+    for (h, rings) in measured {
+        for (lo, want) in rings {
+            let (mut sum, mut area) = (0.0, 0.0);
+            for k in 0..64 {
+                let r = (lo + 0.1 * (k as f32 + 0.5) / 64.0) * 20.0;
+                sum += tip_falloff(r, 20.0, h) * r;
+                area += r;
+            }
+            let got = sum / area;
+            assert!((got - want).abs() < 0.05, "hardness {h} ring at {lo} R: {got} vs {want}");
+        }
+    }
     assert_eq!(tip_falloff(0.0, 10.0, 0.0), 1.0);
-    assert_eq!(tip_falloff(10.0, 10.0, 0.0), 0.0);
     assert_eq!(tip_falloff(4.0, 10.0, 0.5), 1.0, "inside the hard core");
-    let v: Vec<f32> = (0..=20).map(|i| tip_falloff(i as f32 * 0.5, 10.0, 0.0)).collect();
+    let v: Vec<f32> = (0..=40).map(|i| tip_falloff(i as f32 * 0.5, 10.0, 0.0)).collect();
     assert!(v.windows(2).all(|w| w[1] <= w[0]), "{v:?}");
-    assert!((tip_falloff(5.0, 10.0, 0.0) - 0.75f32.powi(4)).abs() < 1e-6);
+    assert_eq!(tip_falloff(crate::tip_reach(10.0, 0.0) * 4.0, 10.0, 0.0), 0.0, "far past the reach");
 }
 
 #[test]
@@ -1167,7 +1407,8 @@ fn half_coverage_radius_is_the_tips_50_percent_contour() {
         let d = half_coverage_radius(10.5, h);
         assert!((tip_falloff(d, 10.5, h) - 0.5).abs() < 1e-3, "hardness {h}: ring at {d}");
     }
-    assert_eq!(half_coverage_radius(10.5, 1.0), 10.5);
+    // A hard tip's ring is its edge.
+    assert!((half_coverage_radius(10.5, 1.0) - 10.5).abs() < 0.5);
     assert!(half_coverage_radius(10.5, f32::NAN).is_finite());
 }
 
@@ -1215,3 +1456,18 @@ fn dithering_never_moves_an_exact_colour_or_an_untouched_pixel() {
     }
     assert_eq!(s.rgba(50, 5), [1.0, 1.0, 1.0, 1.0], "far from the stroke: untouched");
 }
+
+#[test]
+fn an_aliased_stroke_at_partial_opacity_is_one_flat_colour() {
+    // 30% of red 219/41/61 over white lands between 8-bit levels (244.2, 190.7, 196.8); dithering
+    // used to scatter the Pencil's line over several neighbouring levels.
+    let mut s = Surface::with_default(PixelFormat::RGBA8, &[1.0, 1.0, 1.0, 1.0]);
+    let color = [219.0 / 255.0, 41.0 / 255.0, 61.0 / 255.0, 1.0];
+    let b = BrushSettings { size: 1.0, aliased: true, opacity: 0.3, color, pressure_size: false, ..Default::default() };
+    render_stroke(&mut s, &b, &line(2.0, 60.0, 5.0), None, false, 1.0);
+    let first = s.rgba(3, 5);
+    assert_ne!(first, [1.0, 1.0, 1.0, 1.0], "the line was painted");
+    for x in 3..60 {
+        assert_eq!(s.rgba(x, 5), first, "pixel {x} of the Pencil line");
+    }
+}
diff --git a/crates/paint/src/dynamics.rs b/crates/paint/src/dynamics.rs
index 6fd4440264..25354dd6d5 100644
--- a/crates/paint/src/dynamics.rs
+++ b/crates/paint/src/dynamics.rs
@@ -62,7 +62,7 @@ impl Smoother {
     }
 
     fn active(&self) -> bool {
-        self.cfg.amount > 0.0
+        self.cfg.enabled && self.cfg.amount > 0.0
     }
 
     /// Feed one input point; returns the brush positions to paint through.
diff --git a/crates/paint/src/lib.rs b/crates/paint/src/lib.rs
index 74e4389f1e..4dc07b6604 100644
--- a/crates/paint/src/lib.rs
+++ b/crates/paint/src/lib.rs
@@ -33,11 +33,11 @@ pub mod symmetry;
 pub mod tile;
 
 pub use brush::{
-    BrushPreset, BrushSettings, ColorDynamics, Control, DualBrush, Dynamic, MAX_BRUSH_SIZE, MAX_SCATTER, MaskMode, Pattern, PatternStyle, Pose, Scattering,
-    SectionLocks, ShapeDynamics, Smoothing, Texture, TipShape, Transfer,
+    BrushPreset, BrushSettings, ColorDynamics, Control, DualBrush, Dynamic, MAX_BRUSH_SIZE, MAX_SCATTER, MaskMode, Pattern, PatternStyle, Pose, PresetCaptures,
+    Scattering, SectionLocks, ShapeDynamics, Smoothing, Texture, TipShape, Transfer,
 };
 pub use mixer::MixerSettings;
-pub use render::{BrushContext, StrokeRenderer, grid_center, grid_square, render_stroke};
+pub use render::{BrushContext, StrokeRenderer, UnionLive, grid_center, grid_square, render_stroke};
 pub use tile::{GrayTile, StoredTile};
 
 /// One input sample. Missing stylus data defaults to "mouse": full pressure, no tilt/rotation.
@@ -138,42 +138,78 @@ pub fn dabs(stroke: &Stroke) -> Vec<Dab> {
     out
 }
 
-/// Opacity of a round tip at distance `d` from its centre, without edge anti-aliasing: 1 in the
-/// hard core (`hardness` of the radius), then a Gaussian-like fall to 0 at the radius:
-/// `(1 - t²)⁴`, which tracks `exp(-4.6 t²)` closely but is exact (no `exp`, the same on every
-/// platform), reaches exactly 0 at the edge and leaves it flat. A soft tip keeps most of its area
-/// faint, so a stroke of overlapping dabs (Flow builds up) stays about as soft as one dab, as in
-/// Photoshop; the old smoothstep kept so much near the centre that strokes came out hard.
+/// Photoshop's round tip, measured (Photoshop 27.11, single dabs at Spacing 1000 %, hardness 0–100
+/// at 40 px and checked at 100, 9 and 3 px): a solid core of radius `r0 · R`, then a Gaussian
+/// shoulder `exp(-((d − r0) / s)²)` of width `s · R`, both by hardness (0, 0.1, … 1). A soft tip
+/// reaches well past its nominal radius (hardness 0 is a Gaussian of σ ≈ 0.47 R: 8 % at 1.05 R).
+const TIP_SHAPE: [(f32, f32); 11] =
+    [(0.00, 0.664), (0.14, 0.58), (0.28, 0.50), (0.40, 0.44), (0.52, 0.36), (0.63, 0.29), (0.70, 0.24), (0.78, 0.19), (0.84, 0.15), (0.89, 0.11), (1.00, 0.0)];
+
+/// Photoshop's anti-aliased edge: the shoulder never narrows below this many pixels, and the core
+/// stays this far inside the radius (a hardness-100 tip is a disc with a ~1 px soft edge at any size).
+const TIP_EDGE_PX: f32 = 1.2;
+
+/// The core radius and shoulder width (both in pixels) of a round tip of `radius` and `hardness`.
+#[inline]
+pub fn tip_shape(radius: f32, hardness: f32) -> (f32, f32) {
+    let h = if hardness.is_nan() { 0.0 } else { hardness.clamp(0.0, 1.0) } * 10.0;
+    let i = (h.floor() as usize).min(9);
+    let t = h - i as f32;
+    let (a, b) = (TIP_SHAPE[i], TIP_SHAPE[i + 1]);
+    let (r0, s) = (a.0 + (b.0 - a.0) * t, a.1 + (b.1 - a.1) * t);
+    let radius = if radius.is_finite() { radius.max(0.0) } else { 0.0 };
+    // A tip of a few pixels keeps a narrower edge, so a small hard dab stays solid in the middle.
+    // Never sharper than a quarter pixel, the small-tip supersampling step.
+    let edge = TIP_EDGE_PX.min(0.3 * radius).max(0.25);
+    ((r0 * radius).min(radius - edge).max(0.0), (s * radius).max(edge).max(1e-3))
+}
+
+/// `exp(-u)` as `(1 − u/64)⁶⁴` by six squarings: within 1/255 of `exp` where it matters, exact
+/// arithmetic (the same on every platform) and exactly 0 from `u = 64`.
+#[inline]
+fn soft_exp(u: f32) -> f32 {
+    let mut g = (1.0 - u / 64.0).clamp(0.0, 1.0);
+    for _ in 0..6 {
+        g *= g;
+    }
+    g
+}
+
+/// Opacity of a round tip at distance `d` from its centre, edge included (see [`tip_shape`]).
 #[inline]
 pub fn tip_falloff(d: f32, radius: f32, hardness: f32) -> f32 {
-    let inner = radius * hardness.clamp(0.0, 1.0);
-    if d <= inner || radius - inner < 1e-3 {
+    let (r0, s) = tip_shape(radius, hardness);
+    if d <= r0 {
         return 1.0;
     }
-    let t = ((d - inner) / (radius - inner)).clamp(0.0, 1.0);
-    let s = 1.0 - t * t;
-    let s2 = s * s;
-    s2 * s2
+    let x = (d - r0) / s;
+    soft_exp(x * x)
+}
+
+/// How far from its centre a round tip still paints (where [`tip_falloff`] drops below ~0.1 %).
+#[inline]
+pub fn tip_reach(radius: f32, hardness: f32) -> f32 {
+    let (r0, s) = tip_shape(radius, hardness);
+    r0 + 2.6 * s
 }
 
 /// Distance from the centre where [`tip_falloff`] drops to 50 %: the contour Preferences ›
-/// Cursors › Normal Brush Tip outlines. It inverts `(1 - t²)⁴ = ½`, so `t = √(1 - ½^¼) ≈ 0.399`
-/// of the way from the hard core (`hardness · radius`) to the edge.
+/// Cursors › Normal Brush Tip outlines. `(1 − u/64)⁶⁴ = ½` at `u = 64 (1 − ½^(1/64))`.
 #[inline]
 pub fn half_coverage_radius(radius: f32, hardness: f32) -> f32 {
-    let h = if hardness.is_nan() { 0.0 } else { hardness.clamp(0.0, 1.0) };
-    let t = (1.0 - 0.5f32.sqrt().sqrt()).sqrt();
-    radius * (h + t * (1.0 - h))
+    let (r0, s) = tip_shape(radius, hardness);
+    let u = 64.0 * (1.0 - 0.5f32.powf(1.0 / 64.0));
+    r0 + s * u.sqrt()
 }
 
-/// Coverage of a round dab at distance `d` from its centre (anti-aliased edge, hardness falloff).
+/// Coverage of a round dab at distance `d` from its centre.
 #[inline]
 pub fn dab_coverage(d: f32, radius: f32, hardness: f32) -> f32 {
-    if d >= radius + 0.5 {
+    // NaN distances paint nothing.
+    if d.is_nan() || d >= tip_reach(radius, hardness) + 0.5 {
         return 0.0;
     }
-    let edge = ((radius + 0.5 - d).clamp(0.0, 1.0)).min(1.0);
-    edge * tip_falloff(d, radius, hardness)
+    tip_falloff(d, radius, hardness)
 }
 
 /// Rasterize a stroke onto `target`, optionally limited by a selection (grayscale coverage surface).
@@ -229,7 +265,9 @@ mod tests {
         assert_eq!(dab_coverage(20.0, 10.0, 1.0), 0.0);
         let soft_mid = dab_coverage(5.0, 10.0, 0.0);
         assert!(soft_mid > 0.2 && soft_mid < 0.8);
-        assert!(dab_coverage(9.9, 10.0, 1.0) > 0.5);
+        // A hard tip is opaque to just inside its radius and gone 1 px outside it.
+        assert!(dab_coverage(8.5, 10.0, 1.0) > 0.99 && dab_coverage(9.5, 10.0, 1.0) > 0.5);
+        assert!(dab_coverage(11.0, 10.0, 1.0) < 0.05);
     }
 
     #[test]
diff --git a/crates/paint/src/presets.rs b/crates/paint/src/presets.rs
index 621565188d..f711d0eb51 100644
--- a/crates/paint/src/presets.rs
+++ b/crates/paint/src/presets.rs
@@ -11,7 +11,7 @@ use crate::procedural::{bristle_tip, chalk_tip, charcoal_tip, grass_tip, leaf_ti
 pub const GROUPS: [&str; 4] = ["General", "Dry Media", "Wet Media", "Special Effects"];
 
 fn preset(group: &str, name: &str, brush: BrushSettings) -> BrushPreset {
-    BrushPreset { name: name.to_string(), brush, builtin: true, group: group.to_string(), folder: Vec::new() }
+    BrushPreset { name: name.to_string(), brush, builtin: true, group: group.to_string(), folder: Vec::new(), captures: Default::default() }
 }
 
 fn pressure() -> Dynamic {
@@ -107,7 +107,9 @@ fn dry_media(base: &BrushSettings) -> Vec<BrushPreset> {
                 spacing: 0.12,
                 shape_dynamics: ShapeDynamics { enabled: true, size: pressure_min(0.5), angle: Dynamic::controlled(Control::Direction), ..Default::default() },
                 transfer: transfer(pressure_min(0.3), Dynamic::default()),
-                texture: Texture { mode: MaskMode::Subtract, ..paper(5, 0.7) },
+                // Subtract takes paint away where the pattern is light (#3340); inverting keeps
+                // these presets as they were designed, with the dark parts taking it away.
+                texture: Texture { mode: MaskMode::Subtract, invert: true, ..paper(5, 0.7) },
                 ..base.clone()
             },
         ),
@@ -129,6 +131,7 @@ fn dry_media(base: &BrushSettings) -> Vec<BrushPreset> {
                     pattern: Pattern::Procedural { style: PatternStyle::Canvas, size: 64, seed: 2 },
                     depth: 0.55,
                     mode: MaskMode::Subtract,
+                    invert: true,
                     ..Default::default()
                 },
                 ..base.clone()
@@ -379,6 +382,7 @@ fn special_effects(base: &BrushSettings) -> Vec<BrushPreset> {
                     enabled: true,
                     pattern: Pattern::Procedural { style: PatternStyle::Canvas, size: 64, seed: 1 },
                     mode: MaskMode::Subtract,
+                    invert: true,
                     depth: 0.7,
                     ..Default::default()
                 },
diff --git a/crates/paint/src/render.rs b/crates/paint/src/render.rs
index aa6bd0b963..5f59aafad1 100644
--- a/crates/paint/src/render.rs
+++ b/crates/paint/src/render.rs
@@ -10,7 +10,7 @@
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
-use photocraft_color::{BlendMode, PixelFormat, SampleType};
+use photocraft_color::{BlendMode, ColorMode, PixelFormat, SampleType};
 use photocraft_geom::Rect;
 use photocraft_raster::{Surface, from_rgba_into, to_rgba};
 
@@ -19,7 +19,7 @@ use crate::dynamics::DabGenerator;
 use crate::retouch::{Footprint, alpha_index, over_native};
 use crate::rng::hash2;
 use crate::tile::{Mips, PatternImage};
-use crate::{Dab, StrokePoint, dab_coverage, tip_falloff};
+use crate::{Dab, StrokePoint, dab_coverage, tip_falloff, tip_reach};
 
 /// Salt of the 8-bit dither's per-pixel noise.
 const DITHER_SALT: u64 = 0x0000_6469_7468_6572;
@@ -108,6 +108,40 @@ pub fn mask_combine(mode: MaskMode, v: f32, t: f32, d: f32) -> f32 {
     r.clamp(0.0, 1.0)
 }
 
+/// How far a Height-mode dab at full depth and coverage reaches into the pattern, in pattern
+/// ranges (measured against Photoshop, #3340).
+const HEIGHT_REACH: f32 = 12.0;
+
+/// Combine brush coverage `v` with a Texture pattern value `t` at `depth` (Brush Settings ›
+/// Texture). Where it differs from [`mask_combine`] (still used for the Dual Brush) it follows
+/// Photoshop as measured with single dabs over a grey ramp (#3340):
+/// - Subtract takes `depth × t` away, so a white pattern removes the most paint.
+/// - Color Dodge and Color Burn move the pattern toward their neutral colour as depth falls.
+/// - Height treats the pattern as a height field the brush presses into: the paint reaches
+///   `12 × depth × v` and fills whatever lies below that, so a low depth paints only the dark
+///   valleys, from about 17 % the whole pattern is under the paint, and a brighter pattern
+///   takes paint away.
+/// - Linear Height is Height, but where the reach stays below the top of the pattern the paint
+///   fades with the pattern instead of being cut off.
+pub fn texture_combine(mode: MaskMode, v: f32, t: f32, d: f32) -> f32 {
+    if v <= 0.0 {
+        return 0.0;
+    }
+    let r = match mode {
+        MaskMode::Subtract => v - d * t,
+        MaskMode::ColorDodge => v / (1.0 - d * t).max(1e-3),
+        MaskMode::ColorBurn => 1.0 - (1.0 - v) / (1.0 - d + d * t).max(1e-3),
+        // Photoshop steps the depth in 1/255ths here, which shows at the lowest depths.
+        MaskMode::Height => HEIGHT_REACH * (d * 255.0).round() / 255.0 * v - t,
+        MaskMode::LinearHeight => {
+            let reach = HEIGHT_REACH * (d * 255.0).round() / 255.0 * v;
+            if reach < 1.0 { reach * (1.0 - t) } else { reach - t }
+        }
+        _ => mask_combine(mode, v, t, d),
+    };
+    if r.is_finite() { r.clamp(0.0, 1.0) } else { 0.0 }
+}
+
 /// A stroke-ready brush: the settings plus prepared tip mips and texture.
 #[derive(Clone, Debug)]
 pub struct BrushContext {
@@ -129,11 +163,8 @@ fn prepare_pattern(b: &BrushSettings) -> Option<Arc<PatternImage>> {
             _ => return None,
         },
     };
-    let (br, ct) = (t.brightness.clamp(-1.0, 1.0), t.contrast.clamp(-1.0, 1.0));
     for v in &mut img.data {
-        let mut x = (*v - 0.5) * (1.0 + ct) + 0.5 + br;
-        x = x.clamp(0.0, 1.0);
-        *v = if t.invert { 1.0 - x } else { x };
+        *v = t.level(*v);
     }
     Some(Arc::new(img))
 }
@@ -182,7 +213,16 @@ impl BrushContext {
     /// Bounding rectangle of a dab (rotated sampled tips need the corner reach).
     pub fn dab_rect(&self, d: &Dab, dual: bool) -> Rect {
         let sampled = if dual { self.dual_tip.is_some() } else { self.tip.is_some() };
-        let reach = if sampled { d.radius * std::f32::consts::SQRT_2 } else { d.radius };
+        let hardness = if dual { self.brush.dual_brush.hardness } else { self.brush.hardness };
+        // A computed soft tip paints past its nominal radius (see `tip_shape`).
+        let aliased = self.brush.aliased && !dual;
+        let reach = if sampled {
+            d.radius * std::f32::consts::SQRT_2
+        } else if aliased {
+            d.radius
+        } else {
+            crate::tip_reach(d.radius, hardness).max(d.radius)
+        };
         rect_around(d, reach)
     }
 
@@ -194,7 +234,7 @@ impl BrushContext {
 
     /// [`rasterize`](Self::rasterize); with `depth`, Wet Edges is left out of `out` and each
     /// painted pixel's depth inside the dab (`1 − rn`) goes to `depth`, for the stroke to apply it.
-    fn rasterize_into(&self, d: &Dab, dual: bool, rect: Rect, out: &mut Vec<f32>, mut depth: Option<&mut Vec<f32>>) {
+    pub fn rasterize_into(&self, d: &Dab, dual: bool, rect: Rect, out: &mut Vec<f32>, mut depth: Option<&mut Vec<f32>>) {
         let (w, h) = (rect.width() as usize, rect.height() as usize);
         out.clear();
         out.resize(w * h, 0.0);
@@ -220,7 +260,8 @@ impl BrushContext {
         let r = d.radius;
         let ro = d.roundness.max(0.5 / r).min(1.0);
         let rm = (r * ro).max(0.5);
-        let reach2 = (rm + 0.5) * (rm + 0.5);
+        let reach = if aliased || mips.is_some() { rm } else { crate::tip_reach(rm, hardness).max(rm) };
+        let reach2 = (reach + 0.5) * (reach + 0.5);
         // Sampled-tip mapping.
         let (level, inv_scale, tw, th) = match mips {
             Some(m) => {
@@ -244,7 +285,7 @@ impl BrushContext {
         // sampling only the pixel centre made a tiny dab's total coverage swing with its sub-pixel
         // position, and thin lines beaded.
         let small = mips.is_none() && !aliased && rm < SMALL_TIP_RADIUS;
-        let small_reach2 = (rm + 0.75) * (rm + 0.75);
+        let small_reach2 = (reach + 0.75) * (reach + 0.75);
         // Keep ordinary computed tips separate from the feature loop, so their dense rows
         // can be vectorised without the per-pixel sampled-mask and stroke-depth branches.
         if !(mips.is_some() || small || (aliased && b.square) || noise || tex_tip || wet)
@@ -288,12 +329,9 @@ impl BrushContext {
                             for sx in SUBPIXEL {
                                 let (su, sv) = to_tip(dx + sx, dy + sy);
                                 let sd = ((su * ro).powi(2) + sv * sv).sqrt();
-                                // Each sample anti-aliases over its own quarter pixel, so the
-                                // covered area changes smoothly with the dab's position.
-                                let inside = ((rm - sd) * 4.0 + 0.5).clamp(0.0, 1.0);
-                                if inside > 0.0 {
-                                    sum += inside * tip_falloff(sd.min(rm), rm, hardness);
-                                }
+                                // Each sample takes the tip's own edge, so the covered area
+                                // changes smoothly with the dab's position.
+                                sum += tip_falloff(sd, rm, hardness);
                             }
                         }
                         (sum / (SUBPIXEL.len() * SUBPIXEL.len()) as f32, d2.sqrt() / rm)
@@ -326,7 +364,7 @@ impl BrushContext {
                     val += (hard - val) * 0.7;
                 }
                 if tex_tip {
-                    val = mask_combine(b.texture.mode, val, self.texture_at(x, y), d.depth);
+                    val = texture_combine(b.texture.mode, val, self.texture_at(x, y), d.depth);
                 }
                 if wet {
                     val *= wet_factor(rn);
@@ -356,7 +394,7 @@ impl BrushContext {
     /// [`stroke_mask`](Self::stroke_mask) with Wet Edges from the stroke's depth at the pixel
     /// (the deepest any dab reaches it, see [`CoverageMap::depth`]).
     #[inline]
-    fn stroke_mask_wet(&self, c: f32, depth: Option<f32>, dual: Option<f32>, x: i32, y: i32) -> f32 {
+    pub fn stroke_mask_wet(&self, c: f32, depth: Option<f32>, dual: Option<f32>, x: i32, y: i32) -> f32 {
         let b = &self.brush;
         let mut m = match depth {
             Some(dp) => c * wet_factor(1.0 - dp),
@@ -366,7 +404,7 @@ impl BrushContext {
             m = mask_combine(b.dual_brush.mode, m, dv, 1.0);
         }
         if self.texture.is_some() && !b.texture.each_tip {
-            m = mask_combine(b.texture.mode, m, self.texture_at(x, y), b.texture.depth.clamp(0.0, 1.0));
+            m = texture_combine(b.texture.mode, m, self.texture_at(x, y), b.texture.depth.clamp(0.0, 1.0));
         }
         m
     }
@@ -491,6 +529,13 @@ impl CoverageMap {
         v
     }
 
+    /// The finished coverage over the tiles `keys`: `tail`'s copy of a tile where finishing the
+    /// stroke changes it (see [`StrokeRenderer::tail_preview`]), else this map's own.
+    fn finished_subset(&self, tail: Option<&Self>, keys: &HashSet<(i32, i32)>) -> Self {
+        let tile = |k: &(i32, i32)| tail.and_then(|t| t.tiles.get(k)).or_else(|| self.tiles.get(k)).map(|t| (*k, t.clone()));
+        Self { tiles: keys.iter().filter_map(tile).collect(), nc: self.nc, bounds: tail.map_or(self.bounds, |t| t.bounds), dirty: HashSet::new() }
+    }
+
     /// Union two passes of the same brush stroke without applying opacity twice where they
     /// overlap. The stronger coverage wins, including its per-dab colour when present.
     fn union_max(&mut self, other: &Self) {
@@ -527,6 +572,21 @@ impl CoverageMap {
 // Stroke renderer
 // ---------------------------------------------------------------------------
 
+/// What [`StrokeRenderer::composite_union_live`] drew last: the coverage tiles of the passes'
+/// smoothing tails (redrawn without them next time) and the merged bounds.
+#[derive(Clone, Debug, Default)]
+pub struct UnionLive {
+    tail_keys: HashSet<(i32, i32)>,
+    bounds: Rect,
+}
+
+impl UnionLive {
+    /// The merged bounds of the finished passes, as last drawn.
+    pub fn bounds(&self) -> Rect {
+        self.bounds
+    }
+}
+
 /// Incremental stroke rendering: feed points, composite dirty tiles from the pre-stroke pixels.
 #[derive(Clone, Debug)]
 pub struct StrokeRenderer {
@@ -570,6 +630,105 @@ impl StrokeRenderer {
         }
         merged.composite(pre, target, selection, lock_transparency, true)
     }
+
+    /// Coverage tiles (stroke and Dual Brush) changed since the last call or composite, into
+    /// `keys`; forgets them.
+    fn drain_dirty_into(&mut self, keys: &mut HashSet<(i32, i32)>) {
+        keys.extend(self.cov.dirty.drain());
+        if let Some(d) = self.dual.as_mut() {
+            keys.extend(d.dirty.drain());
+        }
+    }
+
+    /// Every coverage tile (stroke and Dual Brush), into `keys`.
+    fn keys_into(&self, keys: &mut HashSet<(i32, i32)>) {
+        keys.extend(self.cov.tiles.keys());
+        if let Some(d) = &self.dual {
+            keys.extend(d.tiles.keys());
+        }
+    }
+
+    /// Live preview of a stroke painted as several passes (the stroke, then its symmetry
+    /// mirrors): leaves `target` as finishing every pass now and compositing them with
+    /// [`composite_union_many`](Self::composite_union_many) over `pre` would, but redraws only the
+    /// coverage tiles that changed since the previous call (new dabs, and the smoothing tail now
+    /// and before). `full` redraws every tile: on the first call, or when a pass joins. Returns
+    /// the damaged rectangle.
+    pub fn composite_union_live(
+        passes: &mut [&mut Self],
+        live: &mut UnionLive,
+        full: bool,
+        pre: &Surface,
+        target: &mut Surface,
+        selection: Option<&Surface>,
+        lock_transparency: bool,
+    ) -> Rect {
+        let mut keys = std::mem::take(&mut live.tail_keys);
+        for p in passes.iter_mut() {
+            p.drain_dirty_into(&mut keys);
+            if full {
+                p.keys_into(&mut keys);
+            }
+        }
+        let tails: Vec<_> = passes.iter().map(|p| p.tail_preview()).collect();
+        let mut tail_keys = HashSet::new();
+        for t in tails.iter().flatten() {
+            t.keys_into(&mut tail_keys);
+        }
+        keys.extend(&tail_keys);
+        let mut merged: Option<Self> = None;
+        for (p, t) in passes.iter().zip(&tails) {
+            let cov = p.cov.finished_subset(t.as_ref().map(|t| &t.cov), &keys);
+            let dual = p.dual.as_ref().map(|d| d.finished_subset(t.as_ref().and_then(|t| t.dual.as_ref()), &keys));
+            match merged.as_mut() {
+                None => {
+                    merged = Some(Self {
+                        ctx: p.ctx.clone(),
+                        generator: p.generator.clone(),
+                        cov,
+                        dual,
+                        fmt: p.fmt,
+                        per_dab_color: p.per_dab_color,
+                        dabs_done: p.dabs_done,
+                        scratch: Vec::new(),
+                        depth_scratch: Vec::new(),
+                        dab_buf: Vec::new(),
+                        dual_buf: Vec::new(),
+                        all_dabs: None,
+                    })
+                }
+                Some(m) => {
+                    m.cov.union_max(&cov);
+                    if let (Some(to), Some(from)) = (&mut m.dual, &dual) {
+                        to.union_max(from);
+                    }
+                }
+            }
+        }
+        let Some(mut merged) = merged else { return Rect::EMPTY };
+        let (before, after) = (live.bounds, merged.bounds());
+        // Back to the pre-stroke pixels where the previous call drew and nothing covers now.
+        let mut keys: Vec<_> = keys.into_iter().collect();
+        keys.sort_unstable();
+        let mut dmg = Rect::EMPTY;
+        let mut region = Vec::new();
+        for &(tx, ty) in &keys {
+            let tile = Rect::new(tx * COV_TILE, ty * COV_TILE, (tx + 1) * COV_TILE, (ty + 1) * COV_TILE);
+            let old = tile.intersect(&before);
+            if !old.is_empty() {
+                pre.read_region_into(old, &mut region);
+                target.write_region(old, &region);
+                dmg = dmg.union(&old);
+            }
+            if merged.cov.tiles.contains_key(&(tx, ty)) {
+                dmg = dmg.union(&tile.intersect(&after));
+            }
+        }
+        merged.composite(pre, target, selection, lock_transparency, true);
+        live.tail_keys = tail_keys;
+        live.bounds = after;
+        dmg
+    }
     /// `fmt` = target pixel format (needed for per-dab colour); `zoom` for smoothing.
     pub fn new(brush: &BrushSettings, fmt: Option<PixelFormat>, zoom: f32) -> Self {
         let per_dab_color = brush.color_dynamics.enabled && !brush.erase && fmt.is_some();
@@ -814,12 +973,21 @@ impl StrokeRenderer {
         let opacity = b.opacity.clamp(0.0, 1.0);
         let mut src = [0.0f32; 8];
         from_rgba_into(&fmt, b.color, &mut src);
+        // A colour picked as CMYK paints its inks as they are in a CMYK target (#4344).
+        if let (ColorMode::Cmyk, Some((rgb, inks))) = (fmt.mode, b.color_cmyk)
+            && rgb == [b.color[0], b.color[1], b.color[2]]
+        {
+            src[..4].copy_from_slice(&inks);
+        }
         if let Some(a) = a_idx {
             src[a] = b.color[3];
         }
         // 8-bit targets: the pixels the stroke changes are dithered as they are quantised, so
-        // soft, low-flow strokes don't band (see `dither8`).
-        let dither = fmt.sample == SampleType::U8;
+        // soft, low-flow strokes don't band (see `dither8`). Aliased strokes (the Pencil, the
+        // Eraser's Pencil and Block modes) paint every pixel by the same amount, so they have no
+        // gradient to band and are not dithered: a Pencil line at partial opacity is one flat
+        // colour, as in Photoshop, not grain that a tolerance-0 Magic Wand or Paint Bucket trips on.
+        let dither = fmt.sample == SampleType::U8 && !b.aliased;
         let mut dmg = Rect::EMPTY;
         let mut region = Vec::new();
         for (tx, ty) in keys {
@@ -921,8 +1089,8 @@ fn rasterize_round(d: &Dab, rect: Rect, out: &mut [f32], hardness: f32, aliased:
     let ro = d.roundness.max(0.5 / d.radius).min(1.0);
     let rm = (d.radius * ro).max(0.5);
     let w = rect.width() as usize;
-    let reach2 = (rm + 0.5) * (rm + 0.5);
-    let inner = rm * hardness.clamp(0.0, 1.0);
+    let reach = if aliased { rm } else { tip_reach(rm, hardness).max(rm) };
+    let reach2 = (reach + 0.5) * (reach + 0.5);
     for (yy, row) in out.chunks_exact_mut(w).enumerate() {
         let dy = (rect.y0 + yy as i32) as f32 + 0.5 - cy;
         if aliased {
@@ -931,25 +1099,12 @@ fn rasterize_round(d: &Dab, rect: Rect, out: &mut [f32], hardness: f32, aliased:
                 let d2 = (dx * ro).powi(2) + dy * dy;
                 *dst = if d2 < reach2 && d2.sqrt() <= rm { d.alpha } else { 0.0 };
             }
-        } else if rm - inner < 1e-3 {
-            for (xx, dst) in row.iter_mut().enumerate() {
-                let dx = (rect.x0 + xx as i32) as f32 + 0.5 - cx;
-                let d2 = (dx * ro).powi(2) + dy * dy;
-                let edge = ((rm + 0.5 - d2.sqrt()).clamp(0.0, 1.0)).min(1.0);
-                *dst = if d2 >= reach2 || edge <= 0.0 { 0.0 } else { edge * d.alpha };
-            }
         } else {
             for (xx, dst) in row.iter_mut().enumerate() {
                 let dx = (rect.x0 + xx as i32) as f32 + 0.5 - cx;
                 let d2 = (dx * ro).powi(2) + dy * dy;
-                let dd = d2.sqrt();
-                let edge = ((rm + 0.5 - dd).clamp(0.0, 1.0)).min(1.0);
-                let t = ((dd - inner) / (rm - inner)).clamp(0.0, 1.0);
-                let s = 1.0 - t * t;
-                let s2 = s * s;
-                let falloff = if dd <= inner { 1.0 } else { s2 * s2 };
-                let val = edge * falloff;
-                *dst = if d2 >= reach2 || val <= 0.0 { 0.0 } else { val * d.alpha };
+                let val = if d2 >= reach2 { 0.0 } else { tip_falloff(d2.sqrt(), rm, hardness) };
+                *dst = if val <= 0.0 { 0.0 } else { val * d.alpha };
             }
         }
     }
diff --git a/crates/paint/src/render_reference.rs b/crates/paint/src/render_reference.rs
index 3811e7c998..10172e6fea 100644
--- a/crates/paint/src/render_reference.rs
+++ b/crates/paint/src/render_reference.rs
@@ -30,7 +30,8 @@ impl BrushContext {
         let r = d.radius;
         let ro = d.roundness.max(0.5 / r).min(1.0);
         let rm = (r * ro).max(0.5);
-        let reach2 = (rm + 0.5) * (rm + 0.5);
+        let reach = if aliased || mips.is_some() { rm } else { crate::tip_reach(rm, hardness).max(rm) };
+        let reach2 = (reach + 0.5) * (reach + 0.5);
         // Sampled-tip mapping.
         let (level, inv_scale, tw, th) = match mips {
             Some(m) => {
@@ -54,7 +55,7 @@ impl BrushContext {
         // sampling only the pixel centre made a tiny dab's total coverage swing with its sub-pixel
         // position, and thin lines beaded.
         let small = mips.is_none() && !aliased && rm < SMALL_TIP_RADIUS;
-        let small_reach2 = (rm + 0.75) * (rm + 0.75);
+        let small_reach2 = (reach + 0.75) * (reach + 0.75);
         for yy in 0..h {
             let y = rect.y0 + yy as i32;
             let dy = y as f32 + 0.5 - cy;
@@ -80,12 +81,7 @@ impl BrushContext {
                             for sx in SUBPIXEL {
                                 let (su, sv) = to_tip(dx + sx, dy + sy);
                                 let sd = ((su * ro).powi(2) + sv * sv).sqrt();
-                                // Each sample anti-aliases over its own quarter pixel, so the
-                                // covered area changes smoothly with the dab's position.
-                                let inside = ((rm - sd) * 4.0 + 0.5).clamp(0.0, 1.0);
-                                if inside > 0.0 {
-                                    sum += inside * tip_falloff(sd.min(rm), rm, hardness);
-                                }
+                                sum += tip_falloff(sd, rm, hardness);
                             }
                         }
                         (sum / (SUBPIXEL.len() * SUBPIXEL.len()) as f32, d2.sqrt() / rm)
diff --git a/crates/paint/src/retouch.rs b/crates/paint/src/retouch.rs
index 0129c31638..9ef837c0c0 100644
--- a/crates/paint/src/retouch.rs
+++ b/crates/paint/src/retouch.rs
@@ -102,7 +102,8 @@ pub fn dab_rect(d: &Dab) -> Rect {
 
 /// Rasterize one dab's coverage.
 pub fn footprint(d: &Dab, index: usize, hardness: f32) -> Footprint {
-    let rect = dab_rect(d);
+    // A soft tip paints past its nominal radius.
+    let rect = crate::render::rect_around(d, crate::tip_reach(d.radius, hardness).max(d.radius));
     let (cx, cy) = (d.center.x as f32, d.center.y as f32);
     let mut cov = Vec::with_capacity(rect.width() as usize * rect.height() as usize);
     for y in rect.y0..rect.y1 {
@@ -554,7 +555,7 @@ mod tests {
     }
 
     #[test]
-    fn footprint_stays_inside_the_full_size_ring() {
+    fn footprint_stays_inside_the_tips_reach() {
         let radius = 10.5f32;
         for hardness in [1.0, 0.5, 0.0] {
             let dab = Dab::round(Point::new(32.0, 32.0), radius, 1.0);
@@ -569,8 +570,9 @@ mod tests {
                     }
                     painted += 1;
                     farthest = farthest.max(dist);
+                    let reach = f64::from(crate::tip_reach(radius, hardness));
                     assert!(
-                        dist < radius as f64 + 0.5,
+                        dist < reach.max(radius as f64) + 0.5,
                         "hardness {hardness}: pixel ({x}, {y}) at {dist} px from \
                          the centre is painted past the Full Size ring of \
                          {radius} px"
diff --git a/crates/paint/src/tile.rs b/crates/paint/src/tile.rs
index 6152411c91..38ca38410e 100644
--- a/crates/paint/src/tile.rs
+++ b/crates/paint/src/tile.rs
@@ -6,11 +6,14 @@
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// A grayscale bitmap, row-major, 1 = full.
+///
+/// The samples are shared: cloning a tile (brush settings are cloned on every pointer event of a
+/// stroke, #4534) copies a pointer, not a sampled tip that may be thousands of pixels across.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct GrayTile {
     pub width: u32,
     pub height: u32,
-    pub data: Vec<u16>,
+    pub data: std::sync::Arc<[u16]>,
 }
 
 impl GrayTile {
@@ -22,7 +25,7 @@ impl GrayTile {
                 data.push(q16(f(x, y)));
             }
         }
-        Self { width, height, data }
+        Self { width, height, data: data.into() }
     }
     /// Build from 0..1 floats (`width × height`).
     pub fn from_f32(width: u32, height: u32, v: &[f32]) -> Self {
@@ -47,7 +50,7 @@ impl GrayTile {
     pub fn preview(&self, max_side: u32) -> GrayTile {
         let q8 = |v: u32| ((v + 128) / 257 * 257) as u16;
         if !self.is_valid() {
-            return GrayTile { width: 1, height: 1, data: vec![0] };
+            return GrayTile { width: 1, height: 1, data: vec![0].into() };
         }
         let (w, h) = (self.width as usize, self.height as usize);
         let max = max_side.max(1) as usize;
@@ -64,7 +67,8 @@ impl GrayTile {
                 }
             }
         }
-        let data = sum.iter().zip(&cnt).map(|(s, c)| q8(if *c > 0 { (*s / u64::from(*c)) as u32 } else { 0 })).collect();
+        let data: Vec<u16> = sum.iter().zip(&cnt).map(|(s, c)| q8(if *c > 0 { (*s / u64::from(*c)) as u32 } else { 0 })).collect();
+        let data = data.into();
         GrayTile { width: nw as u32, height: nh as u32, data }
     }
 }
@@ -141,7 +145,7 @@ struct GrayTileIn {
 impl Serialize for GrayTile {
     fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         let mut bytes = Vec::with_capacity(self.data.len() * 2);
-        for v in &self.data {
+        for v in self.data.iter() {
             bytes.extend_from_slice(&v.to_le_bytes());
         }
         let enc = b64_encode(&bytes);
@@ -164,7 +168,7 @@ impl<'de> Deserialize<'de> for GrayTile {
         if n == 0 || data.len() != n {
             return Err(D::Error::custom(format!("tile data has {} samples, expected {}×{}", data.len(), t.width, t.height)));
         }
-        Ok(GrayTile { width: t.width, height: t.height, data })
+        Ok(GrayTile { width: t.width, height: t.height, data: data.into() })
     }
 }
 
@@ -300,6 +304,20 @@ impl PatternImage {
 mod tests {
     use super::*;
 
+    /// Cloning a tile (and the brush settings holding it, on every pointer event of a stroke)
+    /// shares its samples instead of copying them (#4534).
+    #[test]
+    fn clones_share_their_samples() {
+        let t = GrayTile::from_fn(64, 32, |x, y| ((x + y) % 7) as f32 / 6.0);
+        let c = t.clone();
+        assert!(std::sync::Arc::ptr_eq(&t.data, &c.data));
+        assert_eq!(t, c);
+        let brush = crate::brush::BrushSettings { tip: crate::brush::TipShape::Sampled(t.clone()), ..Default::default() };
+        let copy = brush.clone();
+        let crate::brush::TipShape::Sampled(ct) = &copy.tip else { panic!("sampled") };
+        assert!(std::sync::Arc::ptr_eq(&t.data, &ct.data), "the settings' clone shares the tip");
+    }
+
     #[test]
     fn base64_round_trip() {
         for n in 0..10 {
@@ -315,7 +333,7 @@ mod tests {
         let back: GrayTile = serde_json::from_str(&j).unwrap();
         assert_eq!(back, t);
         let f: GrayTile = serde_json::from_str(r#"{"width":2,"height":1,"data":[0.0,1.0]}"#).unwrap();
-        assert_eq!(f.data, vec![0, 65535]);
+        assert_eq!(f.data, vec![0, 65535].into());
         assert!(serde_json::from_str::<GrayTile>(r#"{"width":2,"height":2,"data":[0.0,1.0]}"#).is_err());
     }
 
@@ -329,8 +347,8 @@ mod tests {
         assert!(p.data.iter().all(|v| v % 257 == 0), "8-bit levels");
         // Small tiles keep their size; invalid ones never panic.
         assert_eq!(GrayTile::from_fn(5, 3, |_, _| 0.5).preview(96).width, 5);
-        assert!(GrayTile { width: 4, height: 4, data: vec![1] }.preview(96).is_valid());
-        assert!(GrayTile { width: 0, height: 0, data: vec![] }.preview(0).is_valid());
+        assert!(GrayTile { width: 4, height: 4, data: vec![1].into() }.preview(96).is_valid());
+        assert!(GrayTile { width: 0, height: 0, data: vec![].into() }.preview(0).is_valid());
     }
 
     #[test]
diff --git a/crates/psd/README.md b/crates/psd/README.md
index 7de5529952..02b76e5a7f 100644
--- a/crates/psd/README.md
+++ b/crates/psd/README.md
@@ -109,6 +109,7 @@ testgen::{all_cases, merged_only, layered, small, sample_descriptor, pattern_pla
 | RGBA8 extraction | ✓ | – | – | RGB / gray / CMYK layers; merged image also supports indexed / bitmap / duotone |
 | Builder | – | ✓ | – | RGB / gray / CMYK at 8/16 bit, masks, groups, blend modes, opacity, fill, visibility, clipping |
 | Patterns | ✓ | ✓ | ✓ | `Patt` / `Pat2` / `Pat3`, `.pat`, and `.abr` embedded patterns; non-empty tiles allow in-bounds channel subrectangles, decoded size is capped and PackBits expansion is input-bounded |
+| Actions (`.atn`) | ✓ | ✓ | ✓ | `atn::parse` / `atn::write`: version-16 sets (Photoshop 6+): actions with function key, modifiers and colour; steps with event code or string name, panel name, enabled/dialog flags and their descriptor. Exact round trip; version-12 (Photoshop 5) files are rejected as unsupported |
 
 Pattern channel subrectangles are padded with zeroes to the tile rectangle. All channel
 metadata and the total padded size are checked against `MAX_DECODED_BYTES` before any
diff --git a/crates/psd/examples/atn_dump.rs b/crates/psd/examples/atn_dump.rs
new file mode 100644
index 0000000000..8a39bbb121
--- /dev/null
+++ b/crates/psd/examples/atn_dump.rs
@@ -0,0 +1,84 @@
+//! Print the actions and steps of `.atn` files, one event per line, with the top-level keys of
+//! each step's descriptor: `cargo run -p photocraft-psd --example atn_dump -- set.atn…`
+//!
+//! Handy when adding a Photoshop event to the engine's `.atn` import table: it shows the event
+//! id, the panel name and the parameter keys Photoshop recorded.
+
+use photocraft_psd::atn;
+use photocraft_psd::descriptor::{Descriptor, ReferenceItem, Value};
+
+fn summary(v: &Value) -> String {
+    match v {
+        Value::Integer(i) => i.to_string(),
+        Value::Double(d) => format!("{d}"),
+        Value::UnitFloat { unit, value } => format!("{value}{}", String::from_utf8_lossy(unit)),
+        Value::Boolean(b) => b.to_string(),
+        Value::Text(t) => format!("{:?}", t.to_string_lossy()),
+        Value::Enumerated { type_id, value } => format!("{}.{}", String::from_utf8_lossy(type_id.as_bytes()), String::from_utf8_lossy(value.as_bytes())),
+        Value::Descriptor(d) | Value::GlobalObject(d) => format!("{{{}}}", keys(d)),
+        Value::List(l) => format!("[{}]", l.iter().map(summary).collect::<Vec<_>>().join(", ")),
+        Value::Reference(r) => format!("ref[{}]", r.iter().map(reference).collect::<Vec<_>>().join(" ")),
+        other => format!("{other:?}").chars().take(40).collect(),
+    }
+}
+
+fn id(i: &photocraft_psd::descriptor::Id) -> String {
+    String::from_utf8_lossy(i.as_bytes()).trim().to_string()
+}
+
+fn reference(item: &ReferenceItem) -> String {
+    match item {
+        ReferenceItem::Property { class, key } => format!("prop({},{})", id(&class.class_id), id(key)),
+        ReferenceItem::Class(c) => format!("Clss({})", id(&c.class_id)),
+        ReferenceItem::Enumerated { class, type_id, value } => format!("Enmr({},{}.{})", id(&class.class_id), id(type_id), id(value)),
+        ReferenceItem::Offset { class, offset } => format!("rele({},{offset})", id(&class.class_id)),
+        ReferenceItem::Identifier { class, id: v } => format!("Idnt({},{v})", id(&class.class_id)),
+        ReferenceItem::Index { class, index } => format!("indx({},{index})", id(&class.class_id)),
+        ReferenceItem::Name { class, name } => format!("name({},{:?})", id(&class.class_id), name.to_string_lossy()),
+    }
+}
+
+fn keys(d: &Descriptor) -> String {
+    d.items.iter().map(|(k, v)| format!("{}={}", String::from_utf8_lossy(k.as_bytes()), summary(v))).collect::<Vec<_>>().join(" ")
+}
+
+fn main() {
+    let mut failed = false;
+    for path in std::env::args().skip(1) {
+        let bytes = match std::fs::read(&path) {
+            Ok(b) => b,
+            Err(e) => {
+                eprintln!("{path}: {e}");
+                failed = true;
+                continue;
+            }
+        };
+        match atn::parse(&bytes) {
+            Ok(f) => {
+                println!(
+                    "== {path}: set {:?}, {} actions{}",
+                    f.name.to_string_lossy(),
+                    f.actions.len(),
+                    if f.warnings.is_empty() { String::new() } else { format!(" ({})", f.warnings.join("; ")) }
+                );
+                for a in &f.actions {
+                    println!("  action {:?} ({} steps)", a.name.to_string_lossy(), a.items.len());
+                    for item in &a.items {
+                        let flags = format!("{}{}", if item.enabled { "" } else { " off" }, if item.with_dialog { " dialog" } else { "" });
+                        match &item.descriptor {
+                            Some(d) => println!("    {:<22} {:<28}{flags}  {}", item.event.id(), item.dictionary, keys(d)),
+                            None => println!("    {:<22} {:<28}{flags}", item.event.id(), item.dictionary),
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                println!("== {path}: {e}");
+                failed = true;
+            }
+        }
+    }
+    if failed {
+        std::process::exit(1);
+    }
+}
diff --git a/crates/psd/fuzz/.gitignore b/crates/psd/fuzz/.gitignore
index 1a45eee776..5c404b9583 100644
--- a/crates/psd/fuzz/.gitignore
+++ b/crates/psd/fuzz/.gitignore
@@ -2,3 +2,4 @@ target
 corpus
 artifacts
 coverage
+Cargo.lock
diff --git a/crates/psd/fuzz/Cargo.toml b/crates/psd/fuzz/Cargo.toml
index 86f0f51c0c..1c874bf4f0 100644
--- a/crates/psd/fuzz/Cargo.toml
+++ b/crates/psd/fuzz/Cargo.toml
@@ -98,3 +98,10 @@ path = "fuzz_targets/resources.rs"
 test = false
 doc = false
 bench = false
+
+[[bin]]
+name = "atn"
+path = "fuzz_targets/atn.rs"
+test = false
+doc = false
+bench = false
diff --git a/crates/psd/fuzz/fuzz_targets/atn.rs b/crates/psd/fuzz/fuzz_targets/atn.rs
new file mode 100644
index 0000000000..3bb1777c8a
--- /dev/null
+++ b/crates/psd/fuzz/fuzz_targets/atn.rs
@@ -0,0 +1,14 @@
+//! Fuzz the `.atn` actions parser: any input must return `Ok` or `Err`, never panic, and
+//! anything that parses must survive a write and parse back equal.
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use photocraft_psd::atn;
+
+fuzz_target!(|data: &[u8]| {
+    if let Ok(f) = atn::parse(data) {
+        let bytes = atn::write(&f).expect("a parsed set is writable");
+        let again = atn::parse(&bytes).expect("a written set parses");
+        assert_eq!(again.actions, f.actions);
+    }
+});
diff --git a/crates/psd/src/atn.rs b/crates/psd/src/atn.rs
new file mode 100644
index 0000000000..2d8bf9990f
--- /dev/null
+++ b/crates/psd/src/atn.rs
@@ -0,0 +1,426 @@
+//! Photoshop Actions files (`.atn`): one action set, its actions and their steps.
+//!
+//! Implemented clean-room from Adobe's "Photoshop File Formats" specification (the *Actions*
+//! and *Descriptor structure* sections) and observation of files Photoshop writes. No code was
+//! copied. All numbers are big-endian; strings are the Unicode strings of descriptors (u32
+//! code-unit count + UTF-16BE, usually NUL-terminated) unless noted.
+//!
+//! ```text
+//! file   := version u32 (16), set name UnicodeString, expanded u8, count u32, count × action
+//! action := function key u16 (0 = none, n = Fn), shift u8, command u8, colour u16,
+//!           name UnicodeString, expanded u8, count u32, count × item
+//! item   := expanded u8, enabled u8, with dialog u8, dialog options u8,
+//!           event kind [4]: "TEXT" (u32 length + ASCII event name) | "long" (4-char event code),
+//!           dictionary name (u32 length + ASCII: the name the Actions panel shows),
+//!           has descriptor i32 (-1 = a descriptor follows, 0 = none), [descriptor]
+//! ```
+//!
+//! The descriptor is a plain ActionDescriptor body ([`Descriptor`], no version prefix): the
+//! event's parameters, exactly as Photoshop's own "Make", "Set", "Gaussian Blur"… events
+//! carry them. Photoshop 5-era files (version 12) use a different, undocumented layout and are
+//! rejected as unsupported.
+//!
+//! [`parse`] never panics: every count is bounds-checked against the bytes left, descriptor
+//! nesting is bounded, and allocations are capped. [`write`] produces the same layout, so
+//! `parse(write(f)) == f`, and `write(parse(b)) == b` for files Photoshop wrote.
+
+use crate::descriptor::{Descriptor, UnicodeString};
+use crate::error::{PsdError, Result};
+use crate::io::{Reader, WriteExt};
+
+/// The only version this module reads and writes (Photoshop 6 and every later release).
+pub const VERSION: u32 = 16;
+/// Most actions read from one set (Photoshop's own sets hold a few dozen).
+pub const MAX_ACTIONS: usize = 10_000;
+/// Most steps read from one action.
+pub const MAX_ITEMS: usize = 100_000;
+
+/// A parsed action set.
+#[derive(Debug, Clone, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct AtnFile {
+    /// The set's name (the Actions panel folder).
+    pub name: UnicodeString,
+    /// Whether the set is shown expanded in the Actions panel.
+    pub expanded: bool,
+    /// The actions, in panel order.
+    pub actions: Vec<AtnAction>,
+    /// Problems that did not stop the parse (trailing bytes…).
+    #[cfg_attr(feature = "serde", serde(default))]
+    pub warnings: Vec<String>,
+}
+
+/// One action of a set.
+#[derive(Debug, Clone, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct AtnAction {
+    /// Function key that plays the action: 0 = none, `n` = F`n`.
+    pub function_key: u16,
+    /// Shift modifier of the function key.
+    pub shift: bool,
+    /// Command (Control on Windows) modifier of the function key.
+    pub command: bool,
+    /// Button Mode colour index (0 = none, then red, orange, yellow, green, blue, violet, gray).
+    pub color: u16,
+    /// The action's name.
+    pub name: UnicodeString,
+    /// Whether the action is shown expanded in the Actions panel.
+    pub expanded: bool,
+    /// The steps, in playback order.
+    pub items: Vec<AtnItem>,
+}
+
+/// One step of an action: a Photoshop event with its parameters.
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct AtnItem {
+    /// Whether the step's parameters are shown expanded in the Actions panel.
+    pub expanded: bool,
+    /// The panel's check mark: a switched-off step is skipped by playback.
+    pub enabled: bool,
+    /// The panel's dialog toggle: playback shows the step's dialog.
+    pub with_dialog: bool,
+    /// Dialog options (0 = none, 2 = show the dialog, 3 = don't show), kept verbatim.
+    pub dialog_options: u8,
+    /// The event.
+    pub event: AtnEvent,
+    /// The name the Actions panel shows for the step ("Gaussian Blur", "Make", …).
+    pub dictionary: String,
+    /// The event's parameters; `None` for events without any.
+    pub descriptor: Option<Descriptor>,
+}
+
+impl Default for AtnItem {
+    fn default() -> Self {
+        AtnItem {
+            expanded: false,
+            enabled: true,
+            with_dialog: false,
+            dialog_options: 0,
+            event: AtnEvent::Code(*b"    "),
+            dictionary: String::new(),
+            descriptor: None,
+        }
+    }
+}
+
+/// A Photoshop event id: a four-character code (`GsnB`) or a string name (`trim`).
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum AtnEvent {
+    /// Stored as `long` + 4 bytes.
+    Code([u8; 4]),
+    /// Stored as `TEXT` + length-prefixed ASCII.
+    Name(String),
+}
+
+impl AtnEvent {
+    /// The event id as text: the code's four characters, or the name.
+    pub fn id(&self) -> String {
+        match self {
+            AtnEvent::Code(c) => String::from_utf8_lossy(c).into_owned(),
+            AtnEvent::Name(n) => n.clone(),
+        }
+    }
+    /// `true` if the event is the code or name `s`.
+    pub fn is(&self, s: &str) -> bool {
+        match self {
+            AtnEvent::Code(c) => c == s.as_bytes(),
+            AtnEvent::Name(n) => n == s,
+        }
+    }
+}
+
+/// Reads a u32 length + ASCII bytes (event and dictionary names).
+fn read_ascii(r: &mut Reader<'_>) -> Result<String> {
+    let n = r.u32()?;
+    Ok(String::from_utf8_lossy(r.bytes_u64(u64::from(n))?).into_owned())
+}
+
+fn write_ascii(out: &mut Vec<u8>, s: &str) -> Result<()> {
+    let n = u32::try_from(s.len()).map_err(|_| PsdError::LimitExceeded("action name too long"))?;
+    out.put_u32(n);
+    out.put(s.as_bytes());
+    Ok(())
+}
+
+fn read_item(r: &mut Reader<'_>) -> Result<AtnItem> {
+    let expanded = r.u8()? != 0;
+    let enabled = r.u8()? != 0;
+    let with_dialog = r.u8()? != 0;
+    let dialog_options = r.u8()?;
+    let event = match &r.array::<4>()? {
+        b"TEXT" => AtnEvent::Name(read_ascii(r)?),
+        b"long" => AtnEvent::Code(r.array()?),
+        other => return Err(PsdError::invalid(format!("unknown event kind {:?}", String::from_utf8_lossy(other)))),
+    };
+    let dictionary = read_ascii(r)?;
+    let descriptor = match r.i32()? {
+        0 => None,
+        -1 => Some(Descriptor::read(r)?),
+        n => return Err(PsdError::invalid(format!("bad descriptor flag {n}"))),
+    };
+    Ok(AtnItem { expanded, enabled, with_dialog, dialog_options, event, dictionary, descriptor })
+}
+
+fn read_action(r: &mut Reader<'_>) -> Result<AtnAction> {
+    let function_key = r.u16()?;
+    let shift = r.u8()? != 0;
+    let command = r.u8()? != 0;
+    let color = r.u16()?;
+    let name = UnicodeString::read(r)?;
+    let expanded = r.u8()? != 0;
+    let n = r.u32()?;
+    // Each item needs at least its 4 flags, the event kind, two empty names and the descriptor flag.
+    r.check_count(u64::from(n), 20)?;
+    if n as usize > MAX_ITEMS {
+        return Err(PsdError::LimitExceeded("too many steps in one action"));
+    }
+    let mut items = Vec::with_capacity((n as usize).min(1024));
+    for _ in 0..n {
+        items.push(read_item(r)?);
+    }
+    Ok(AtnAction { function_key, shift, command, color, name, expanded, items })
+}
+
+/// Parses an `.atn` file.
+pub fn parse(data: &[u8]) -> Result<AtnFile> {
+    let mut r = Reader::new(data);
+    let version = r.u32()?;
+    if version != VERSION {
+        return Err(PsdError::Unsupported(format!("actions file version {version} (only version 16, Photoshop 6 and later, is supported)")));
+    }
+    let name = UnicodeString::read(&mut r)?;
+    let expanded = r.u8()? != 0;
+    let n = r.u32()?;
+    // Each action needs at least its key, modifiers, colour, an empty name, the flag and a count.
+    r.check_count(u64::from(n), 15)?;
+    if n as usize > MAX_ACTIONS {
+        return Err(PsdError::LimitExceeded("too many actions in one set"));
+    }
+    let mut actions = Vec::with_capacity((n as usize).min(256));
+    for _ in 0..n {
+        actions.push(read_action(&mut r)?);
+    }
+    let mut warnings = Vec::new();
+    if !r.is_empty() {
+        warnings.push(format!("{} trailing bytes ignored", r.remaining()));
+    }
+    Ok(AtnFile { name, expanded, actions, warnings })
+}
+
+fn write_item(out: &mut Vec<u8>, item: &AtnItem) -> Result<()> {
+    out.put_u8(u8::from(item.expanded));
+    out.put_u8(u8::from(item.enabled));
+    out.put_u8(u8::from(item.with_dialog));
+    out.put_u8(item.dialog_options);
+    match &item.event {
+        AtnEvent::Name(n) => {
+            out.put(b"TEXT");
+            write_ascii(out, n)?;
+        }
+        AtnEvent::Code(c) => {
+            out.put(b"long");
+            out.put(c);
+        }
+    }
+    write_ascii(out, &item.dictionary)?;
+    match &item.descriptor {
+        None => out.put_i32(0),
+        Some(d) => {
+            out.put_i32(-1);
+            d.write(out);
+        }
+    }
+    Ok(())
+}
+
+fn count(n: usize, what: &'static str) -> Result<u32> {
+    u32::try_from(n).map_err(|_| PsdError::LimitExceeded(what))
+}
+
+/// Writes an `.atn` file (version 16).
+pub fn write(f: &AtnFile) -> Result<Vec<u8>> {
+    let mut out = Vec::new();
+    out.put_u32(VERSION);
+    f.name.write(&mut out);
+    out.put_u8(u8::from(f.expanded));
+    out.put_u32(count(f.actions.len(), "too many actions")?);
+    for a in &f.actions {
+        out.put_u16(a.function_key);
+        out.put_u8(u8::from(a.shift));
+        out.put_u8(u8::from(a.command));
+        out.put_u16(a.color);
+        a.name.write(&mut out);
+        out.put_u8(u8::from(a.expanded));
+        out.put_u32(count(a.items.len(), "too many steps")?);
+        for item in &a.items {
+            write_item(&mut out, item)?;
+        }
+    }
+    Ok(out)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::descriptor::Value;
+
+    fn px(v: f64) -> Value {
+        Value::UnitFloat { unit: *b"#Pxl", value: v }
+    }
+
+    fn set() -> AtnFile {
+        let blur = AtnItem {
+            expanded: true,
+            enabled: true,
+            with_dialog: true,
+            dialog_options: 2,
+            event: AtnEvent::Code(*b"GsnB"),
+            dictionary: "Gaussian Blur".into(),
+            descriptor: Some(Descriptor::new("null").with("Rds ", px(2.5))),
+        };
+        let trim = AtnItem {
+            event: AtnEvent::Name("trim".into()),
+            dictionary: "Trim".into(),
+            descriptor: Some(
+                Descriptor { name: UnicodeString::new_nul("Trim"), class_id: crate::descriptor::Id::Str(b"trim".to_vec()), items: Vec::new() }
+                    .with(
+                        "trimBasedOn",
+                        Value::Enumerated { type_id: crate::descriptor::Id::new("trimBasedOn"), value: crate::descriptor::Id::new("topLeftPixelColor") },
+                    )
+                    .with("Top ", Value::Boolean(true)),
+            ),
+            ..Default::default()
+        };
+        let flatten = AtnItem { enabled: false, event: AtnEvent::Code(*b"Fltn"), dictionary: "Flatten Image".into(), ..Default::default() };
+        AtnFile {
+            name: UnicodeString::new_nul("Set ✓"),
+            expanded: true,
+            actions: vec![
+                AtnAction {
+                    function_key: 2,
+                    shift: true,
+                    command: false,
+                    color: 3,
+                    name: UnicodeString::new_nul("Soften"),
+                    expanded: true,
+                    items: vec![blur, flatten],
+                },
+                AtnAction { name: UnicodeString::new_nul("Tidy"), items: vec![trim], ..Default::default() },
+                AtnAction { name: UnicodeString::new_nul("Empty"), ..Default::default() },
+            ],
+            warnings: Vec::new(),
+        }
+    }
+
+    #[test]
+    fn round_trip() {
+        let f = set();
+        let bytes = write(&f).unwrap();
+        let parsed = parse(&bytes).unwrap();
+        assert_eq!(parsed, f);
+        assert_eq!(write(&parsed).unwrap(), bytes, "writing is stable");
+        assert_eq!(parsed.actions[0].items[0].event.id(), "GsnB");
+        assert!(parsed.actions[1].items[0].event.is("trim"));
+        assert_eq!(parsed.actions[1].items[0].event.id(), "trim");
+    }
+
+    /// The layout Photoshop writes for a one-step Trim action, assembled by hand from the
+    /// format description: field by field, so a mistake names the field.
+    #[test]
+    fn layout_matches_the_specification() {
+        let f = AtnFile {
+            name: UnicodeString::new_nul("Trim"),
+            expanded: false,
+            actions: vec![AtnAction {
+                name: UnicodeString::new_nul("Action 1"),
+                expanded: true,
+                items: vec![AtnItem {
+                    expanded: true,
+                    event: AtnEvent::Name("trim".into()),
+                    dictionary: "Trim".into(),
+                    descriptor: Some(Descriptor {
+                        name: UnicodeString::new_nul("Trim"),
+                        class_id: crate::descriptor::Id::Str(b"trim".to_vec()),
+                        items: Vec::new(),
+                    }),
+                    ..Default::default()
+                }],
+                ..Default::default()
+            }],
+            warnings: Vec::new(),
+        };
+        let mut expect = Vec::new();
+        expect.extend_from_slice(&[0, 0, 0, 16]); // version
+        expect.extend_from_slice(&[0, 0, 0, 5, 0, b'T', 0, b'r', 0, b'i', 0, b'm', 0, 0]); // set name
+        expect.push(0); // set collapsed
+        expect.extend_from_slice(&[0, 0, 0, 1]); // one action
+        expect.extend_from_slice(&[0, 0, 0, 0, 0, 0]); // no function key, no modifiers, no colour
+        expect.extend_from_slice(&[0, 0, 0, 9]);
+        for c in "Action 1\0".encode_utf16() {
+            expect.extend_from_slice(&c.to_be_bytes());
+        }
+        expect.push(1); // action expanded
+        expect.extend_from_slice(&[0, 0, 0, 1]); // one step
+        expect.extend_from_slice(&[1, 1, 0, 0]); // expanded, enabled, no dialog, options 0
+        expect.extend_from_slice(b"TEXT\0\0\0\x04trim");
+        expect.extend_from_slice(b"\0\0\0\x04Trim");
+        expect.extend_from_slice(&[0xff; 4]); // a descriptor follows
+        expect.extend_from_slice(&[0, 0, 0, 5, 0, b'T', 0, b'r', 0, b'i', 0, b'm', 0, 0]); // class name
+        expect.extend_from_slice(b"\0\0\0\x04trim"); // class id, length-4 string form
+        expect.extend_from_slice(&[0, 0, 0, 0]); // no items
+        assert_eq!(write(&f).unwrap(), expect);
+        assert_eq!(parse(&expect).unwrap(), f);
+    }
+
+    #[test]
+    fn truncation_never_parses_and_never_panics() {
+        let bytes = write(&set()).unwrap();
+        for cut in 0..bytes.len() {
+            assert!(parse(&bytes[..cut]).is_err(), "cut at {cut}/{}", bytes.len());
+        }
+        let mut padded = bytes.clone();
+        padded.extend_from_slice(b"junk");
+        let f = parse(&padded).unwrap();
+        assert_eq!(f.warnings, ["4 trailing bytes ignored"]);
+        assert_eq!(f.actions, set().actions);
+    }
+
+    #[test]
+    fn rejects_other_versions_and_bad_structure() {
+        let mut bytes = write(&set()).unwrap();
+        bytes[3] = 12;
+        assert!(matches!(parse(&bytes), Err(PsdError::Unsupported(_))));
+        // A count far beyond the data must fail before allocating.
+        let mut huge = vec![0, 0, 0, 16, 0, 0, 0, 0, 0];
+        huge.extend_from_slice(&u32::MAX.to_be_bytes());
+        assert!(matches!(parse(&huge), Err(PsdError::UnexpectedEof { .. })));
+        // Unknown event kinds and descriptor flags are reported, not guessed.
+        let mut bad_kind = write(&set()).unwrap();
+        let at = bad_kind.windows(4).position(|w| w == b"long").unwrap();
+        bad_kind[at..at + 4].copy_from_slice(b"what");
+        assert!(matches!(parse(&bad_kind), Err(PsdError::Invalid(_))));
+        let mut bad_flag = write(&set()).unwrap();
+        let at = bad_flag.windows(4).position(|w| w == [0xff; 4]).unwrap();
+        bad_flag[at..at + 4].copy_from_slice(&[0, 0, 0, 7]);
+        assert!(matches!(parse(&bad_flag), Err(PsdError::Invalid(_))));
+    }
+
+    #[test]
+    fn garbage_never_panics() {
+        let seed = write(&set()).unwrap();
+        let mut x: u32 = 0x9e37_79b9;
+        for i in 0..2000 {
+            let mut bytes = seed.clone();
+            for _ in 0..(i % 7 + 1) {
+                x ^= x << 13;
+                x ^= x >> 17;
+                x ^= x << 5;
+                let at = (x as usize) % bytes.len();
+                bytes[at] = (x >> 8) as u8;
+            }
+            let _ = parse(&bytes);
+        }
+    }
+}
diff --git a/crates/psd/src/compression.rs b/crates/psd/src/compression.rs
index d47408d28c..7ad2296fbc 100644
--- a/crates/psd/src/compression.rs
+++ b/crates/psd/src/compression.rs
@@ -8,7 +8,7 @@ use std::io::{Read, Write};
 
 use crate::error::{PsdError, Result};
 use crate::header::{Version, row_bytes};
-use crate::io::{Reader, WriteExt};
+use crate::io::Reader;
 
 /// Maximum number of decoded bytes a single decode call may produce: 8 GiB on
 /// 64-bit targets, 2 GiB elsewhere (the same budget as `photocraft-codecs`'
@@ -345,21 +345,62 @@ fn encode_rle(decoded: &[u8], layout: &PlaneLayout) -> Result<Vec<u8>> {
     let rows = layout.rows()?;
     let rb = layout.row_bytes();
     let cs = layout.count_size();
-    let mut out = vec![0u8; rows * cs];
-    let mut enc = Vec::new();
-    for row in 0..rows {
-        let start = enc.len();
-        packbits::encode(&decoded[row * rb..(row + 1) * rb], &mut enc);
-        let n = enc.len() - start;
-        if cs == 2 {
-            let n = u16::try_from(n).map_err(|_| PsdError::LimitExceeded("RLE row exceeds 65535 bytes (use PSB)"))?;
-            out[row * 2..row * 2 + 2].copy_from_slice(&n.to_be_bytes());
-        } else {
-            let n = u32::try_from(n).map_err(|_| PsdError::LimitExceeded("RLE row too large"))?;
-            out[row * 4..row * 4 + 4].copy_from_slice(&n.to_be_bytes());
+    if rows == 0 {
+        return Ok(Vec::new());
+    }
+    // Rows are independent, so they pack in parallel chunks and concatenate in order.
+    let threads = if cfg!(target_arch = "wasm32") { 1 } else { std::thread::available_parallelism().map_or(1, |v| v.get()).clamp(1, 32) };
+    let chunk_rows = rows.div_ceil(threads).max(1);
+    struct Chunk {
+        counts: Vec<u8>,
+        packed: Vec<u8>,
+    }
+    let pack_chunk = |first: usize, count: usize| -> Result<Chunk> {
+        let mut chunk = Chunk { counts: vec![0u8; count * cs], packed: Vec::new() };
+        for row in first..first + count {
+            let start = chunk.packed.len();
+            packbits::encode(&decoded[row * rb..(row + 1) * rb], &mut chunk.packed);
+            let n = chunk.packed.len() - start;
+            if cs == 2 {
+                let n = u16::try_from(n).map_err(|_| PsdError::LimitExceeded("RLE row exceeds 65535 bytes (use PSB)"))?;
+                chunk.counts[(row - first) * 2..(row - first) * 2 + 2].copy_from_slice(&n.to_be_bytes());
+            } else {
+                let n = u32::try_from(n).map_err(|_| PsdError::LimitExceeded("RLE row too large"))?;
+                chunk.counts[(row - first) * 4..(row - first) * 4 + 4].copy_from_slice(&n.to_be_bytes());
+            }
         }
+        Ok(chunk)
+    };
+    let chunk_list: Vec<Chunk> = if threads == 1 {
+        vec![pack_chunk(0, rows)?]
+    } else {
+        std::thread::scope(|scope| -> Result<Vec<Chunk>> {
+            let handles: Vec<_> = (0..threads)
+                .map(|t| {
+                    let first = t * chunk_rows;
+                    let count = chunk_rows.min(rows.saturating_sub(first));
+                    scope.spawn(move || pack_chunk(first, count))
+                })
+                .collect();
+            // Join every worker first, then surface the first error like the sequential
+            // path would instead of aborting the scope with a thread panic.
+            let mut all = Vec::with_capacity(threads);
+            for h in handles {
+                all.push(h.join().map_err(|_| PsdError::LimitExceeded("an RLE worker panicked"))??);
+            }
+            Ok(all)
+        })?
+    };
+    let packed_total: usize = chunk_list.iter().map(|c| c.packed.len()).sum();
+    let mut out = vec![0u8; rows * cs + packed_total];
+    let mut counts_at = 0usize;
+    let mut packed_at = rows * cs;
+    for chunk in &chunk_list {
+        out[counts_at..counts_at + chunk.counts.len()].copy_from_slice(&chunk.counts);
+        counts_at += chunk.counts.len();
+        out[packed_at..packed_at + chunk.packed.len()].copy_from_slice(&chunk.packed);
+        packed_at += chunk.packed.len();
     }
-    out.put(&enc);
     Ok(out)
 }
 
@@ -830,3 +871,79 @@ mod tests {
         assert!(zip_decompress(&[1, 2, 3, 4], 4).is_err());
     }
 }
+
+#[cfg(test)]
+mod parallel_rle_equivalence {
+    use super::*;
+
+    /// The parallel row packer's output must be byte-equal to a straightforward sequential
+    /// encoding of the same plane, across depths, row counts around the chunking and data
+    /// shapes (runs, noise, all-default).
+    #[test]
+    fn parallel_rle_matches_sequential() {
+        let mut data: u64 = 0x9e37_79b9_7f4a_7c15;
+        let mut next = move || {
+            data ^= data << 13;
+            data ^= data >> 7;
+            data ^= data << 17;
+            data
+        };
+        let layout_for = |rows: usize, rb: usize, version: Version| PlaneLayout { planes: 1, width: rb, height: rows, depth: 8, version };
+        for (rows, rb, version) in [
+            (0usize, 4usize, Version::Psd),
+            (1, 4, Version::Psd),
+            (7, 4, Version::Psb),
+            (64, 4, Version::Psd),
+            (65, 4, Version::Psb),  // chunk boundary
+            (513, 4, Version::Psd), // more rows than threads on most runners
+            (2049, 4, Version::Psb),
+            (2, 4, Version::Psd), // fewer rows than threads
+            (33, 3000, Version::Psd),
+            (31, 20000, Version::Psb),
+        ] {
+            let pattern: Vec<u8> = match rows % 3 {
+                0 => vec![7u8; rows * rb],                                   // long runs
+                1 => (0..rows * rb).map(|i| (i * 31 % 251) as u8).collect(), // noise-ish
+                _ => vec![0u8; rows * rb],                                   // all default
+            };
+            let pattern = if pattern.len() != rows * rb { vec![7u8; rows * rb] } else { pattern };
+            let mut data = pattern.clone();
+            if rows % 4 == 0 {
+                // sprinkle runs into the noise
+                for chunk in data.chunks_mut(97) {
+                    if let Some(f) = chunk.first_mut() {
+                        *f = 200;
+                    }
+                }
+            }
+            let _ = next();
+            let layout = layout_for(rows, rb, version);
+            let parallel = encode_rle(&data, &layout).expect("parallel encode");
+            let sequential = encode_rle_sequential(&data, &layout).expect("sequential encode");
+            assert_eq!(parallel, sequential, "rows {rows} rb {rb}");
+        }
+    }
+
+    /// The pre-parallel encoder, kept as the oracle.
+    fn encode_rle_sequential(decoded: &[u8], layout: &PlaneLayout) -> Result<Vec<u8>> {
+        let rows = layout.rows()?;
+        let rb = layout.row_bytes();
+        let cs = layout.count_size();
+        let mut out = vec![0u8; rows * cs];
+        let mut enc = Vec::new();
+        for row in 0..rows {
+            let start = enc.len();
+            packbits::encode(&decoded[row * rb..(row + 1) * rb], &mut enc);
+            let n = enc.len() - start;
+            if cs == 2 {
+                let n = u16::try_from(n).map_err(|_| PsdError::LimitExceeded("RLE row exceeds 65535 bytes (use PSB)"))?;
+                out[row * 2..row * 2 + 2].copy_from_slice(&n.to_be_bytes());
+            } else {
+                let n = u32::try_from(n).map_err(|_| PsdError::LimitExceeded("RLE row too large"))?;
+                out[row * 4..row * 4 + 4].copy_from_slice(&n.to_be_bytes());
+            }
+        }
+        out.extend_from_slice(&enc);
+        Ok(out)
+    }
+}
diff --git a/crates/psd/src/descriptor.rs b/crates/psd/src/descriptor.rs
index a2eab7ae52..632119a12d 100644
--- a/crates/psd/src/descriptor.rs
+++ b/crates/psd/src/descriptor.rs
@@ -44,6 +44,10 @@ impl UnicodeString {
     }
 }
 
+/// Four-character class and key ids Photoshop writes as length-4 strings, never as codes
+/// (`00000004 'warp'`, not `00000000 'warp'`).
+pub const STRING_IDS: [&str; 3] = ["warp", "list", "time"];
+
 /// A class / key / type identifier: a length-prefixed string, where a stored
 /// length of 0 means a 4-character code follows.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -57,10 +61,15 @@ pub enum Id {
 
 impl Id {
     /// Convenience constructor: 4-byte strings become [`Id::Code`], others
-    /// [`Id::Str`].
+    /// [`Id::Str`]. The four-character names Photoshop stores as length-4 strings
+    /// ([`STRING_IDS`]: `warp`, `list`, `time`) are [`Id::Str`] too: Photoshop treats the
+    /// string and the code as different keys and doesn't recognise the code form.
     pub fn new(s: &str) -> Self {
         let b = s.as_bytes();
-        if b.len() == 4 { Id::Code([b[0], b[1], b[2], b[3]]) } else { Id::Str(b.to_vec()) }
+        match b {
+            [a, b, c, d] if !STRING_IDS.contains(&s) => Id::Code([*a, *b, *c, *d]),
+            _ => Id::Str(b.to_vec()),
+        }
     }
     /// The identifier's bytes.
     pub fn as_bytes(&self) -> &[u8] {
@@ -140,10 +149,20 @@ pub enum ReferenceItem {
         /// Offset.
         offset: i32,
     },
-    /// `Idnt`
-    Identifier(u32),
-    /// `indx`
-    Index(u32),
+    /// `Idnt`: a class plus an identifier (Photoshop's layer ids in action references).
+    Identifier {
+        /// Class.
+        class: Class,
+        /// Identifier.
+        id: u32,
+    },
+    /// `indx`: a class plus a zero-based index.
+    Index {
+        /// Class.
+        class: Class,
+        /// Index.
+        index: u32,
+    },
     /// `name`
     Name {
         /// Class.
@@ -340,6 +359,15 @@ impl VersionedDescriptor {
     }
 }
 
+/// Most items preallocated for a file-declared count. `check_count` only
+/// guarantees a few bytes per item while parsed items are far larger, so the
+/// count must not drive the up-front reservation (or abort on allocation).
+const MAX_PREALLOC: usize = 4096;
+
+fn vec_for_count<T>(n: u32) -> Vec<T> {
+    Vec::with_capacity((n as usize).min(MAX_PREALLOC))
+}
+
 fn read_descriptor(r: &mut Reader<'_>, depth: usize) -> Result<Descriptor> {
     if depth > MAX_DEPTH {
         return Err(PsdError::LimitExceeded("descriptor nesting too deep"));
@@ -349,7 +377,7 @@ fn read_descriptor(r: &mut Reader<'_>, depth: usize) -> Result<Descriptor> {
     let n = r.u32()?;
     // Each item needs at least 5 (1-byte string key) + 4 (type) + 1 (bool).
     r.check_count(u64::from(n), 10)?;
-    let mut items = Vec::with_capacity(n as usize);
+    let mut items = vec_for_count(n);
     for _ in 0..n {
         let key = Id::read(r)?;
         let v = read_value(r, depth + 1)?;
@@ -371,7 +399,7 @@ fn read_typed_value(r: &mut Reader<'_>, ty: &[u8; 4], depth: usize) -> Result<Va
         b"obj " => {
             let n = r.u32()?;
             r.check_count(u64::from(n), 8)?;
-            let mut items = Vec::with_capacity(n as usize);
+            let mut items = vec_for_count(n);
             for _ in 0..n {
                 items.push(read_reference_item(r)?);
             }
@@ -382,7 +410,7 @@ fn read_typed_value(r: &mut Reader<'_>, ty: &[u8; 4], depth: usize) -> Result<Va
         b"VlLs" => {
             let n = r.u32()?;
             r.check_count(u64::from(n), 4)?;
-            let mut items = Vec::with_capacity(n as usize);
+            let mut items = vec_for_count(n);
             for _ in 0..n {
                 items.push(read_value(r, depth + 1)?);
             }
@@ -436,8 +464,8 @@ fn read_reference_item(r: &mut Reader<'_>) -> Result<ReferenceItem> {
         b"Clss" => ReferenceItem::Class(Class::read(r)?),
         b"Enmr" => ReferenceItem::Enumerated { class: Class::read(r)?, type_id: Id::read(r)?, value: Id::read(r)? },
         b"rele" => ReferenceItem::Offset { class: Class::read(r)?, offset: r.i32()? },
-        b"Idnt" => ReferenceItem::Identifier(r.u32()?),
-        b"indx" => ReferenceItem::Index(r.u32()?),
+        b"Idnt" => ReferenceItem::Identifier { class: Class::read(r)?, id: r.u32()? },
+        b"indx" => ReferenceItem::Index { class: Class::read(r)?, index: r.u32()? },
         b"name" => ReferenceItem::Name { class: Class::read(r)?, name: UnicodeString::read(r)? },
         other => {
             return Err(PsdError::Unsupported(format!("reference item type {:?}", String::from_utf8_lossy(other))));
@@ -538,13 +566,15 @@ fn write_reference_item(it: &ReferenceItem, out: &mut Vec<u8>) {
             class.write(out);
             out.put_i32(*offset);
         }
-        ReferenceItem::Identifier(v) => {
+        ReferenceItem::Identifier { class, id } => {
             out.put(b"Idnt");
-            out.put_u32(*v);
+            class.write(out);
+            out.put_u32(*id);
         }
-        ReferenceItem::Index(v) => {
+        ReferenceItem::Index { class, index } => {
             out.put(b"indx");
-            out.put_u32(*v);
+            class.write(out);
+            out.put_u32(*index);
         }
         ReferenceItem::Name { class, name } => {
             out.put(b"name");
@@ -562,6 +592,22 @@ mod tests {
         Class { name: UnicodeString::new(name), class_id: Id::new(id) }
     }
 
+    #[test]
+    fn declared_counts_do_not_drive_preallocation() {
+        assert!(vec_for_count::<Value>(u32::MAX).capacity() <= MAX_PREALLOC);
+        // A 1M-item list of booleans parses (items grow the vector as needed).
+        let n = 1_000_000u32;
+        let mut data = n.to_be_bytes().to_vec();
+        for _ in 0..n {
+            data.extend_from_slice(b"bool\x01");
+        }
+        let mut r = Reader::new(&data);
+        match read_typed_value(&mut r, b"VlLs", 0).unwrap() {
+            Value::List(v) => assert_eq!(v.len(), n as usize),
+            other => panic!("expected list, got {other:?}"),
+        }
+    }
+
     pub(crate) fn sample() -> Descriptor {
         Descriptor::new("null")
             .with("Nm  ", Value::Text(UnicodeString::new_nul("Hello \u{1F600}")))
@@ -580,8 +626,8 @@ mod tests {
                     ReferenceItem::Class(class("", "Dcmn")),
                     ReferenceItem::Enumerated { class: class("", "Lyr "), type_id: Id::new("Ordn"), value: Id::new("Trgt") },
                     ReferenceItem::Offset { class: class("", "Lyr "), offset: -1 },
-                    ReferenceItem::Identifier(7),
-                    ReferenceItem::Index(2),
+                    ReferenceItem::Identifier { class: class("", "Lyr "), id: 7 },
+                    ReferenceItem::Index { class: class("\0", "Lyr "), index: 2 },
                     ReferenceItem::Name { class: class("", "Lyr "), name: UnicodeString::new("Bg") },
                 ]),
             )
@@ -609,6 +655,34 @@ mod tests {
         assert_eq!(p.to_bytes(), b);
     }
 
+    /// `warp`, `list` and `time` are written as length-4 strings, as Photoshop writes them, both
+    /// as keys and as class ids; other four-character names stay codes. Reading accepts both
+    /// forms, and a code read from a file is written back as a code.
+    #[test]
+    fn photoshop_string_ids_are_written_as_strings() {
+        let str_id = |s: &str| [&[0, 0, 0, 4][..], s.as_bytes()].concat();
+        let code_id = |s: &str| [&[0, 0, 0, 0][..], s.as_bytes()].concat();
+        for name in STRING_IDS {
+            assert_eq!(Id::new(name), Id::Str(name.as_bytes().to_vec()));
+            let d = Descriptor::new(name).with(name, Value::Integer(1));
+            let b = d.to_bytes();
+            // Name (empty unicode string), then the class id; then the item count and the key.
+            assert_eq!(&b[4..12], &str_id(name)[..], "class {name}");
+            assert_eq!(&b[16..24], &str_id(name)[..], "key {name}");
+            let back = Descriptor::from_bytes(&b).unwrap();
+            assert_eq!(back, d);
+            assert!(back.class_id.is(name) && back.get(name).is_some());
+            // A file that wrote the code form keeps it, and lookups still find the key.
+            let mut coded = b.clone();
+            coded.splice(16..24, code_id(name));
+            let back = Descriptor::from_bytes(&coded).unwrap();
+            assert_eq!(back.get(name), Some(&Value::Integer(1)));
+            assert_eq!(back.to_bytes(), coded);
+        }
+        assert_eq!(Id::new("view"), Id::Code(*b"view"));
+        assert_eq!(Id::new("Txt "), Id::Code(*b"Txt "));
+    }
+
     #[test]
     fn versioned_roundtrip() {
         let v = VersionedDescriptor::new(sample());
@@ -731,8 +805,8 @@ pub(crate) mod proptests {
             arb_class().prop_map(ReferenceItem::Class),
             (arb_class(), arb_id(), arb_id()).prop_map(|(class, type_id, value)| ReferenceItem::Enumerated { class, type_id, value }),
             (arb_class(), any::<i32>()).prop_map(|(class, offset)| ReferenceItem::Offset { class, offset }),
-            any::<u32>().prop_map(ReferenceItem::Identifier),
-            any::<u32>().prop_map(ReferenceItem::Index),
+            (arb_class(), any::<u32>()).prop_map(|(class, id)| ReferenceItem::Identifier { class, id }),
+            (arb_class(), any::<u32>()).prop_map(|(class, index)| ReferenceItem::Index { class, index }),
             (arb_class(), arb_ustr()).prop_map(|(class, name)| ReferenceItem::Name { class, name }),
         ]
     }
diff --git a/crates/psd/src/file.rs b/crates/psd/src/file.rs
index 3c621bb25a..1e86665ad8 100644
--- a/crates/psd/src/file.rs
+++ b/crates/psd/src/file.rs
@@ -112,13 +112,30 @@ impl PsdFile {
             if s.remaining() >= 4 {
                 let n = s.u32()?;
                 global_layer_mask = Some(GlobalLayerMask { data: s.bytes_u64(u64::from(n))?.to_vec() });
-                let mut candidate_seen = layer_info.is_some();
+                let target_key = match header.depth {
+                    16 => Some(b"Lr16"),
+                    32 => Some(b"Lr32"),
+                    _ => None,
+                };
+                let mut candidate_seen = match target_key {
+                    Some(_) => false,
+                    None => layer_info.as_ref().is_some_and(|i| !i.layers.is_empty()),
+                };
                 let (blocks, trailing) = read_blocks_with(&mut s, header.version, 4, |index, signature, key, data, padding| {
-                    if candidate_seen || !matches!(&key, b"Lr16" | b"Lr32" | b"Layr") {
+                    let is_candidate = match target_key {
+                        Some(k) => &key == k,
+                        None => matches!(&key, b"Layr" | b"Lr16" | b"Lr32"),
+                    };
+                    if candidate_seen || !is_candidate {
                         return false;
                     }
                     candidate_seen = true;
-                    let Ok(info) = LayerInfo::read_body(data, header.version) else { return false };
+                    let Ok(info) = LayerInfo::read_body(data, header.version) else {
+                        if target_key.is_some() {
+                            layer_info = None;
+                        }
+                        return false;
+                    };
                     layer_info = Some(info);
                     layer_info_placement = LayerInfoPlacement::GlobalBlock { index, signature, key, padding: padding.clone() };
                     true
@@ -137,7 +154,11 @@ impl PsdFile {
     pub fn to_bytes(&self) -> Result<Vec<u8>> {
         let v = self.header.version;
         let psb = v.is_psb();
+        // Reserve the pixel data up front: appending it to an empty Vec reallocates and copies
+        // repeatedly. Everything else (headers, resources, records) is small by comparison.
+        let hint = self.layer_info.as_ref().map_or(0, LayerInfo::channel_data_len).saturating_add(self.image_data.data.len());
         let mut out = Vec::new();
+        out.try_reserve(hint).map_err(|_| PsdError::LimitExceeded("not enough memory to serialize the file"))?;
         self.header.write(&mut out);
         out.put_len(self.color_mode_data.len() as u64, false)?;
         out.put(&self.color_mode_data);
@@ -385,4 +406,32 @@ mod write_tests {
             }
         }
     }
+
+    #[test]
+    fn global_layers_prioritized_over_compatibility_section() {
+        for version in [Version::Psd, Version::Psb] {
+            for depth in [16, 32] {
+                let file = testgen::layered(version, ColorMode::Rgb, depth, Compression::Raw);
+                let key = if depth == 16 { *b"Lr16" } else { *b"Lr32" };
+                let mut lr_data = Vec::new();
+                file.layer_info.as_ref().unwrap().write_body(&mut lr_data, version).unwrap();
+
+                // Photoshop writes an empty (or 8-bit compatibility) Layer Info section
+                // alongside the global Lr16/Lr32 block (#4928).
+                let mut compat_file = file.clone();
+                compat_file.layer_info =
+                    Some(LayerInfo { layers: vec![LayerRecord { name: b"CompatibilityLayer".to_vec(), ..Default::default() }], ..Default::default() });
+                compat_file.layer_info_placement = LayerInfoPlacement::Section;
+                compat_file.global_blocks.insert(0, TaggedBlock::new(key, lr_data));
+
+                let bytes = compat_file.to_bytes().unwrap();
+                let parsed = PsdFile::from_bytes(&bytes).unwrap();
+
+                assert_eq!(parsed.layers().len(), file.layers().len());
+                assert_ne!(parsed.layers()[0].name(), "CompatibilityLayer");
+                assert_eq!(parsed.layers()[0].name(), file.layers()[0].name());
+                assert!(matches!(parsed.layer_info_placement, LayerInfoPlacement::GlobalBlock { key: k, .. } if k == key));
+            }
+        }
+    }
 }
diff --git a/crates/psd/src/image_data.rs b/crates/psd/src/image_data.rs
index 0f05eed909..fee0e18dc8 100644
--- a/crates/psd/src/image_data.rs
+++ b/crates/psd/src/image_data.rs
@@ -41,9 +41,15 @@ impl ImageData {
 
     /// Decodes and returns a single channel plane.
     pub fn decode_channel(&self, header: &Header, index: usize) -> Result<Vec<u8>> {
+        let invalid = || crate::error::PsdError::invalid(format!("no merged channel {index}"));
+        if index >= usize::from(header.channels) {
+            return Err(invalid());
+        }
+        let plane = header.row_bytes().checked_mul(header.height as usize).ok_or_else(invalid)?;
+        let start = index.checked_mul(plane).ok_or_else(invalid)?;
+        let end = start.checked_add(plane).ok_or_else(invalid)?;
         let all = self.decode(header)?;
-        let plane = header.row_bytes() * header.height as usize;
-        all.get(index * plane..(index + 1) * plane).map(<[u8]>::to_vec).ok_or_else(|| crate::error::PsdError::invalid(format!("no merged channel {index}")))
+        all.get(start..end).map(<[u8]>::to_vec).ok_or_else(invalid)
     }
 
     pub(crate) fn read(r: &mut Reader<'_>, header: &Header) -> Result<Self> {
@@ -55,3 +61,25 @@ impl ImageData {
         Ok(ImageData { compression, data })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::header::{ColorMode, Version};
+
+    #[test]
+    fn merged_channels_reject_invalid_indices_without_decoding_or_overflow() {
+        let header = Header::new(Version::Psd, 2, 1, 3, 8, ColorMode::Rgb);
+        let data = ImageData { compression: Compression::Raw, data: vec![10, 11, 20, 21, 30, 31] };
+        for (index, expected) in [(0, [10, 11]), (1, [20, 21]), (2, [30, 31])] {
+            assert_eq!(data.decode_channel(&header, index).unwrap(), expected.to_vec());
+        }
+        for index in [3, 4, usize::MAX] {
+            assert!(data.decode_channel(&header, index).is_err(), "invalid channel {index}");
+        }
+        // Reject an invalid index before trying to decode corrupt merged data.
+        let corrupt = ImageData { compression: Compression::Raw, data: vec![] };
+        let err = corrupt.decode_channel(&header, usize::MAX).unwrap_err().to_string();
+        assert!(err.contains("no merged channel"), "{err}");
+    }
+}
diff --git a/crates/psd/src/layer.rs b/crates/psd/src/layer.rs
index cee6758268..5450ed7e67 100644
--- a/crates/psd/src/layer.rs
+++ b/crates/psd/src/layer.rs
@@ -684,15 +684,25 @@ impl LayerInfo {
     /// block in 4-byte units (psd-tools) misread the blocks after a body that
     /// is only padded to even.
     pub fn pad_to(&mut self, version: Version, align: u64) -> Result<()> {
-        let align = align.max(1);
-        let len = self.unpadded_len(version)?;
-        self.padding = Some(vec![0; ((align - len % align) % align) as usize]);
+        self.padding = Some(vec![0; self.pad_len(version, align)?]);
         Ok(())
     }
 
-    /// Serializes the body (without a length field).
-    pub(crate) fn write_body(&self, out: &mut Vec<u8>, version: Version) -> Result<()> {
-        let start = out.len();
+    /// Number of zero bytes [`Self::pad_to`] would set, without touching `self`.
+    pub(crate) fn pad_len(&self, version: Version, align: u64) -> Result<usize> {
+        let align = align.max(1);
+        let len = self.unpadded_len(version)?;
+        Ok(((align - len % align) % align) as usize)
+    }
+
+    /// Bytes of channel data and their compression fields: the part of the body worth reserving up
+    /// front (the records are small next to the pixels). Saturates instead of overflowing.
+    pub(crate) fn channel_data_len(&self) -> usize {
+        self.layers.iter().flat_map(|l| &l.channels).filter(|c| c.compression.is_some()).fold(0usize, |n, c| n.saturating_add(2).saturating_add(c.data.len()))
+    }
+
+    /// Serializes the body without any trailing padding (the padding field is ignored).
+    pub(crate) fn write_unpadded(&self, out: &mut Vec<u8>, version: Version) -> Result<()> {
         let n = i16::try_from(self.layers.len()).map_err(|_| PsdError::LimitExceeded("more than 32767 layers"))?;
         out.put_i16(if self.merged_alpha { -n } else { n });
         for l in &self.layers {
@@ -706,6 +716,13 @@ impl LayerInfo {
                 }
             }
         }
+        Ok(())
+    }
+
+    /// Serializes the body (without a length field).
+    pub(crate) fn write_body(&self, out: &mut Vec<u8>, version: Version) -> Result<()> {
+        let start = out.len();
+        self.write_unpadded(out, version)?;
         match &self.padding {
             Some(p) => out.put(p),
             None => {
@@ -1022,6 +1039,37 @@ mod tests {
         assert_eq!(info.layers[0].decode_channel(0, 8, Version::Psd).unwrap(), Vec::<u8>::new());
     }
 
+    /// Padding without cloning the layers writes the same bytes as `pad_to` on a clone, and the
+    /// channel data length hint is exact.
+    #[test]
+    fn unpadded_write_matches_pad_to_on_a_clone() {
+        use crate::{ColorMode, Compression, testgen};
+        for version in [Version::Psd, Version::Psb] {
+            for depth in [8u16, 16, 32] {
+                for compression in [Compression::Raw, Compression::Rle] {
+                    let file = testgen::layered(version, ColorMode::Rgb, depth, compression);
+                    let mut info = file.layer_info.clone().unwrap();
+                    for align in [1u64, 2, 4, 8] {
+                        let mut cloned = info.clone();
+                        cloned.pad_to(version, align).unwrap();
+                        let mut want = Vec::new();
+                        cloned.write_body(&mut want, version).unwrap();
+                        let pad = info.pad_len(version, align).unwrap();
+                        let mut got = Vec::new();
+                        info.write_unpadded(&mut got, version).unwrap();
+                        assert!(got.len() >= info.channel_data_len());
+                        got.resize(got.len() + pad, 0);
+                        assert_eq!(got, want, "{version:?} {depth} {compression:?} align {align}");
+                    }
+                    info.padding = Some(vec![7, 7]);
+                    let mut with_padding = Vec::new();
+                    info.write_body(&mut with_padding, version).unwrap();
+                    assert!(with_padding.ends_with(&[7, 7]));
+                }
+            }
+        }
+    }
+
     #[test]
     fn nondefault_padding_kept() {
         let info = LayerInfo { padding: Some(vec![0, 0]), ..Default::default() };
diff --git a/crates/psd/src/lib.rs b/crates/psd/src/lib.rs
index 16d539b948..00d73c4003 100644
--- a/crates/psd/src/lib.rs
+++ b/crates/psd/src/lib.rs
@@ -43,6 +43,7 @@
 pub mod abr;
 pub mod aco;
 pub mod ase;
+pub mod atn;
 pub mod blend;
 pub mod builder;
 pub mod compression;
diff --git a/crates/psd/src/path.rs b/crates/psd/src/path.rs
index ea345b8ce4..79f055cb0b 100644
--- a/crates/psd/src/path.rs
+++ b/crates/psd/src/path.rs
@@ -155,7 +155,8 @@ impl PathData {
                 out.push(PsdSubpath {
                     closed: r.selector == selector::CLOSED_LENGTH,
                     operation: r.u16_at(2) as i16,
-                    knots: Vec::with_capacity(remaining.min(4096)),
+                    // No preallocation: the count is untrusted (u16) and PsdKnot is 56 bytes.
+                    knots: Vec::new(),
                 });
             } else if r.is_knot() {
                 let closed = r.selector <= 2;
@@ -261,6 +262,19 @@ mod tests {
         ]
     }
 
+    #[test]
+    fn subpaths_does_not_preallocate_from_untrusted_counts() {
+        let mut bytes = Vec::new();
+        for _ in 0..100_000 {
+            bytes.extend_from_slice(&selector::CLOSED_LENGTH.to_be_bytes());
+            bytes.extend_from_slice(&0xFFFFu16.to_be_bytes());
+            bytes.extend_from_slice(&[0u8; 22]);
+        }
+        let subs = PathData::from_bytes(&bytes).unwrap().subpaths();
+        assert_eq!(subs.len(), 100_000);
+        assert!(subs.iter().all(|s| s.knots.capacity() == 0));
+    }
+
     #[test]
     fn subpaths_roundtrip_and_bytes_are_stable() {
         let p = PathData::from_subpaths(&sample(), true);
diff --git a/crates/psd/src/patterns.rs b/crates/psd/src/patterns.rs
index 00e61934de..04d5c24c24 100644
--- a/crates/psd/src/patterns.rs
+++ b/crates/psd/src/patterns.rs
@@ -26,6 +26,11 @@ use crate::header::Version;
 
 /// Largest pattern edge accepted (Photoshop's own limit is far lower).
 const MAX_EDGE: u32 = 30_000;
+/// Budget for zero-padded channel planes summed over one pattern. Photoshop writes every channel
+/// at the pattern rectangle, so a smaller channel rectangle is only padding; without this cap a
+/// few hundred bytes (1x1 channels, a huge pattern rectangle) would allocate up to
+/// `MAX_DECODED_BYTES` of zeros. Matches `abr::MAX_TOTAL_BYTES`.
+const MAX_PADDED_PATTERN_BYTES: u64 = 512 << 20;
 // A PackBits run packet emits at most 128 bytes from a 2-byte packet.
 const MAX_RLE_EXPANSION: u64 = 64;
 
@@ -154,6 +159,7 @@ fn read_pattern(r: &mut Rd) -> Result<PsdPattern> {
     let mut channels = Vec::new();
     let mut depth = 8u16;
     let mut decoded_bytes = 0u64;
+    let mut padded_bytes = 0u64;
     for _ in 0..count + 2 {
         if v.p >= body.len() {
             break;
@@ -193,6 +199,12 @@ fn read_pattern(r: &mut Rd) -> Result<PsdPattern> {
         if decoded_bytes > MAX_DECODED_BYTES {
             return Err(PsdError::LimitExceeded("pattern data exceeds MAX_DECODED_BYTES"));
         }
+        if cw != w as usize || ch != h as usize {
+            padded_bytes = padded_bytes.checked_add(plane_bytes).ok_or(PsdError::LimitExceeded("pattern padded size overflow"))?;
+            if padded_bytes > MAX_PADDED_PATTERN_BYTES {
+                return Err(PsdError::LimitExceeded("padded pattern channels exceed MAX_PADDED_PATTERN_BYTES"));
+            }
+        }
         let _ = layout.decoded_len()?;
         let compression = if comp == 1 {
             Compression::Rle
@@ -554,13 +566,13 @@ mod tests {
         let vma = pattern_vma_rect_offset(4, &p);
         set_i32(&mut global, vma + 8, 30_000);
         set_i32(&mut global, vma + 12, 30_000);
-        assert!(matches!(parse_pattern_block(&global), Err(PsdError::LimitExceeded("pattern data exceeds MAX_DECODED_BYTES"))));
+        assert!(matches!(parse_pattern_block(&global), Err(PsdError::LimitExceeded(_))));
 
         let mut standalone = write_pat_file(std::slice::from_ref(&p)).unwrap();
         let vma = pattern_vma_rect_offset(10, &p);
         set_i32(&mut standalone, vma + 8, 30_000);
         set_i32(&mut standalone, vma + 12, 30_000);
-        assert!(matches!(parse_pat_file(&standalone), Err(PsdError::LimitExceeded("pattern data exceeds MAX_DECODED_BYTES"))));
+        assert!(matches!(parse_pat_file(&standalone), Err(PsdError::LimitExceeded(_))));
 
         let mut abr = crate::abr::write_v6(
             1,
@@ -658,6 +670,17 @@ mod tests {
         assert!(matches!(zeroed_pattern_plane(usize::MAX), Err(PsdError::LimitExceeded("not enough memory for the padded pattern channel"))));
     }
 
+    #[test]
+    fn tiny_channels_in_a_huge_pattern_rect_are_not_zero_padded_without_bound() {
+        // 3 channels of 5x3 padded to 30000x30000 would allocate 2.7 GB of zeros.
+        let p = pat(8, false);
+        let mut global = write_pattern_block(std::slice::from_ref(&p)).unwrap();
+        let vma = pattern_vma_rect_offset(4, &p);
+        set_i32(&mut global, vma + 8, 30_000);
+        set_i32(&mut global, vma + 12, 30_000);
+        assert!(matches!(parse_pattern_block(&global), Err(PsdError::LimitExceeded("padded pattern channels exceed MAX_PADDED_PATTERN_BYTES"))));
+    }
+
     #[test]
     fn zero_size_pattern_rectangles_are_rejected() {
         let p = pat(8, false);
diff --git a/crates/psd/src/pixels.rs b/crates/psd/src/pixels.rs
index 013d82176b..d4948457f9 100644
--- a/crates/psd/src/pixels.rs
+++ b/crates/psd/src/pixels.rs
@@ -31,35 +31,58 @@ pub fn f32_to_bytes(samples: &[f32]) -> Vec<u8> {
     samples.iter().flat_map(|s| s.to_be_bytes()).collect()
 }
 
+/// Allocates `len` bytes, reporting a machine without that much memory instead of aborting.
+fn try_buffer(len: usize) -> Result<Vec<u8>> {
+    let mut out = Vec::new();
+    out.try_reserve_exact(len).map_err(|_| PsdError::LimitExceeded("not enough memory for the converted plane"))?;
+    Ok(out)
+}
+
 /// Expands a 1-bit plane (MSB first, rows padded to bytes) to one byte per
-/// pixel (0 or 1).
-pub fn unpack_bits(bytes: &[u8], width: usize, height: usize) -> Vec<u8> {
+/// pixel (0 or 1). Errors with [`PsdError::LimitExceeded`] when the plane
+/// size overflows or cannot be allocated.
+pub fn unpack_bits(bytes: &[u8], width: usize, height: usize) -> Result<Vec<u8>> {
+    unpack_bits_with(bytes, width, height, |bit| bit)
+}
+
+/// Shared 1-bit expansion; `map` turns each bit (0 or 1) into the output byte.
+fn unpack_bits_with(bytes: &[u8], width: usize, height: usize, map: impl Fn(u8) -> u8) -> Result<Vec<u8>> {
+    let len = width.checked_mul(height).ok_or(PsdError::LimitExceeded("plane size overflow"))?;
     let rb = width.div_ceil(8);
-    let mut out = Vec::with_capacity(width * height);
+    let mut out = try_buffer(len)?;
     for y in 0..height {
         for x in 0..width {
-            let b = bytes.get(y * rb + x / 8).copied().unwrap_or(0);
-            out.push((b >> (7 - (x % 8))) & 1);
+            let b = y.checked_mul(rb).and_then(|row| bytes.get(row + x / 8)).copied().unwrap_or(0);
+            out.push(map((b >> (7 - (x % 8))) & 1));
         }
     }
-    out
+    Ok(out)
 }
 
 /// Converts one plane of samples at `depth` to 8-bit.
 pub fn plane_to_u8(bytes: &[u8], depth: u16, width: usize, height: usize) -> Result<Vec<u8>> {
     Ok(match depth {
-        1 => unpack_bits(bytes, width, height).into_iter().map(|b| if b == 1 { 0 } else { 255 }).collect(),
-        8 => bytes.to_vec(),
-        16 => bytes.as_chunks::<2>().0.iter().map(|b| ((u32::from(u16::from_be_bytes(*b)) * 255 + 32767) / 65535) as u8).collect(),
-        32 => bytes
-            .as_chunks::<4>()
-            .0
-            .iter()
-            .map(|b| {
+        1 => unpack_bits_with(bytes, width, height, |b| if b == 1 { 0 } else { 255 })?,
+        8 => {
+            let mut out = try_buffer(bytes.len())?;
+            out.extend_from_slice(bytes);
+            out
+        }
+        16 => {
+            let chunks = bytes.as_chunks::<2>().0;
+            let mut out = try_buffer(chunks.len())?;
+            out.extend(chunks.iter().map(|b| ((u32::from(u16::from_be_bytes(*b)) * 255 + 32767) / 65535) as u8));
+            out
+        }
+        32 => {
+            let chunks = bytes.as_chunks::<4>().0;
+            let mut out = try_buffer(chunks.len())?;
+            out.extend(chunks.iter().map(|b| {
                 let v = f32::from_be_bytes(*b);
                 if v.is_nan() { 0 } else { (v.clamp(0.0, 1.0) * 255.0).round() as u8 }
-            })
-            .collect(),
+            }));
+            out
+        }
         d => return Err(PsdError::Unsupported(format!("depth {d}"))),
     })
 }
@@ -282,6 +305,10 @@ impl PsdFile {
         h.validate()?;
         let (w, hh) = (h.width as usize, h.height as usize);
         let n = w.checked_mul(hh).ok_or(PsdError::LimitExceeded("composite size overflow"))?;
+        // Same budget as `Layer::rgba8`: refuse before decoding or converting any plane.
+        if n.checked_mul(4).is_none_or(|len| len as u64 > crate::compression::MAX_DECODED_BYTES) {
+            return Err(PsdError::LimitExceeded("RGBA output exceeds MAX_DECODED_BYTES"));
+        }
         let cc = color_channel_count(h.color_mode)?;
         if usize::from(h.channels) < cc {
             return Err(PsdError::invalid("fewer channels than the color mode requires"));
@@ -358,7 +385,7 @@ mod tests {
 
     #[test]
     fn unpack_bits_rows() {
-        assert_eq!(unpack_bits(&[0b1010_0000, 0b1000_0000], 3, 2), vec![1, 0, 1, 1, 0, 0]);
+        assert_eq!(unpack_bits(&[0b1010_0000, 0b1000_0000], 3, 2).unwrap(), vec![1, 0, 1, 1, 0, 0]);
     }
 
     #[test]
@@ -369,6 +396,26 @@ mod tests {
         assert!(plane_to_u8(&[], 12, 0, 0).is_err());
     }
 
+    /// A plane size that overflows or cannot be allocated is an error, not a panic or abort.
+    #[test]
+    fn plane_conversion_reports_absurd_sizes() {
+        assert!(matches!(unpack_bits(&[0], usize::MAX / 2, 4), Err(PsdError::LimitExceeded(_))));
+        assert!(matches!(plane_to_u8(&[0], 1, usize::MAX / 2, 4), Err(PsdError::LimitExceeded(_))));
+        assert!(matches!(unpack_bits(&[0], 1 << 40, 1 << 20), Err(PsdError::LimitExceeded(_))));
+    }
+
+    /// A bitmap composite whose RGBA output is over the decode budget is refused up front.
+    #[test]
+    fn composite_rgba8_checks_the_output_budget_first() {
+        let mut file = crate::testgen::small(Version::Psb, crate::Compression::Zip);
+        file.header.color_mode = ColorMode::Bitmap;
+        file.header.depth = 1;
+        file.header.channels = 1;
+        file.header.width = 60_000;
+        file.header.height = 60_000;
+        assert!(matches!(file.composite_rgba8(), Err(PsdError::LimitExceeded("RGBA output exceeds MAX_DECODED_BYTES"))));
+    }
+
     #[test]
     fn rgb_interleave_checks_planes_and_preserves_alpha() {
         let color = [Cow::Borrowed(&[1, 2][..]), Cow::Borrowed(&[3, 4][..]), Cow::Borrowed(&[5, 6][..])];
diff --git a/crates/psd/src/resources.rs b/crates/psd/src/resources.rs
index ba2674ba80..c20efbfc9e 100644
--- a/crates/psd/src/resources.rs
+++ b/crates/psd/src/resources.rs
@@ -250,15 +250,16 @@ pub(crate) fn write_section(out: &mut Vec<u8>, res: &[ImageResource]) -> Result<
     out.end_len(at, false)
 }
 
-/// Builds the data for a 1057 version info resource.
+/// Builds the data for a 1057 version info resource, with the writer and reader names Photoshop
+/// 2026 writes ("Adobe Photoshop", "Adobe Photoshop 2026"), without a NUL terminator.
 pub fn version_info_resource(has_real_merged_data: bool) -> ImageResource {
     ImageResource::new(
         ids::VERSION_INFO,
         VersionInfo {
             version: 1,
             has_real_merged_data,
-            writer: UnicodeString::new_nul("Adobe Photoshop"),
-            reader: UnicodeString::new_nul("Adobe Photoshop CS6"),
+            writer: UnicodeString::new("Adobe Photoshop"),
+            reader: UnicodeString::new("Adobe Photoshop 2026"),
             file_version: 1,
         }
         .to_bytes(),
@@ -365,4 +366,17 @@ mod tests {
             other => panic!("{other:?}"),
         }
     }
+
+    /// Byte for byte what Photoshop 2026 writes (every Photoshop-authored oracle in the corpus):
+    /// u32 count + UTF-16BE, no NUL terminator.
+    #[test]
+    fn version_info_matches_photoshop_bytes() {
+        let mut want = vec![0, 0, 0, 1, 1];
+        for s in ["Adobe Photoshop", "Adobe Photoshop 2026"] {
+            want.extend_from_slice(&(s.len() as u32).to_be_bytes());
+            want.extend(s.encode_utf16().flat_map(u16::to_be_bytes));
+        }
+        want.extend_from_slice(&[0, 0, 0, 1]);
+        assert_eq!(version_info_resource(true).data, want);
+    }
 }
diff --git a/crates/psd/src/shc.rs b/crates/psd/src/shc.rs
index dfe4855719..135fd33e62 100644
--- a/crates/psd/src/shc.rs
+++ b/crates/psd/src/shc.rs
@@ -50,14 +50,17 @@ fn read_name(r: &mut Reader<'_>) -> Result<String> {
     r.check_count(n, 2)?;
     let n = usize::try_from(n).map_err(|_| PsdError::LimitExceeded("contour name length"))?;
     let mut units = Vec::with_capacity(n.min(MAX_NAME_UNITS));
+    // The last unit read, not the last one kept: past the cap the counted null is read but not kept.
+    let mut last = None;
     for _ in 0..n {
         let u = r.u16()?;
+        last = Some(u);
         if units.len() < MAX_NAME_UNITS {
             units.push(u);
         }
     }
-    // A count that leaves out the terminator: the null follows (a point count is never 0).
-    if units.last() != Some(&0) && r.peek_rest().get(..2) == Some(&[0, 0]) {
+    // A count that leaves out the terminator: the null follows.
+    if last != Some(0) && r.peek_rest().get(..2) == Some(&[0, 0]) {
         r.u16()?;
     }
     while units.last() == Some(&0) {
@@ -128,7 +131,8 @@ pub fn write(contours: &[ShcContour]) -> Result<Vec<u8>> {
     for c in contours {
         let n = u16::try_from(c.points.len()).ok().filter(|n| usize::from(*n) <= MAX_POINTS).ok_or(PsdError::LimitExceeded("too many points in a contour"))?;
         out.put_u32(2);
-        let units: Vec<u16> = c.name.encode_utf16().take(MAX_NAME_UNITS).collect();
+        // Capped on a character boundary, so a surrogate pair is never split.
+        let units = crate::io::utf16_units(&c.name, MAX_NAME_UNITS);
         out.put_u32(units.len() as u32 + 1);
         for u in units {
             out.put_u16(u);
@@ -195,4 +199,53 @@ mod tests {
         let many = ShcContour { name: String::new(), points: vec![ShcPoint { input: 0.0, output: 0.0, continuous: true }; MAX_POINTS + 1] };
         assert!(write(&[many]).is_err());
     }
+
+    fn pts(n: usize) -> Vec<ShcPoint> {
+        (0..n).map(|i| ShcPoint { input: (i * 10) as f32, output: (i * 20) as f32, continuous: i % 2 == 0 }).collect()
+    }
+
+    #[test]
+    fn shc_name_cap_never_splits_a_surrogate_pair() {
+        let name = format!("{}\u{1F600}", "a".repeat(MAX_NAME_UNITS - 1));
+        let c = ShcContour { name, points: pts(2) };
+        let back = parse(&write(&[c]).unwrap()).unwrap();
+        assert_eq!(back[0].name, "a".repeat(MAX_NAME_UNITS - 1));
+    }
+
+    #[test]
+    fn shc_names_at_and_over_the_cap_keep_the_stream_in_sync() {
+        for len in [MAX_NAME_UNITS, MAX_NAME_UNITS + 1, MAX_NAME_UNITS * 3] {
+            for first_points in [0, 3] {
+                let long = ShcContour { name: "b".repeat(len), points: pts(first_points) };
+                let next = ShcContour { name: "Next".into(), points: pts(4) };
+                let back = parse(&write(&[long, next.clone()]).unwrap()).unwrap_or_else(|e| panic!("len {len}, points {first_points}: {e}"));
+                assert_eq!(back.len(), 2);
+                assert_eq!(back[0].name, "b".repeat(len.min(MAX_NAME_UNITS)));
+                assert_eq!(back[0].points.len(), first_points);
+                assert_eq!(back[1], next, "len {len}, points {first_points}");
+            }
+        }
+    }
+
+    #[test]
+    fn shc_name_count_without_null_at_the_cap_still_reads() {
+        // A hostile/foreign file: 1024 units counted, no null counted, null follows.
+        let mut v = b"8BFS".to_vec();
+        v.put_u16(1);
+        v.put_u32(1);
+        v.put_u32(1);
+        v.put_u32(MAX_NAME_UNITS as u32);
+        for _ in 0..MAX_NAME_UNITS {
+            v.put_u16(u16::from(b'c'));
+        }
+        v.put_u16(0);
+        v.put_u16(1);
+        v.put_u16(7);
+        v.put_u16(9);
+        v.put_u32(0);
+        v.put_u32(255);
+        let c = parse(&v).unwrap();
+        assert_eq!(c[0].name, "c".repeat(MAX_NAME_UNITS));
+        assert_eq!((c[0].points[0].input, c[0].points[0].output), (9.0, 7.0));
+    }
 }
diff --git a/crates/psd/src/tiff.rs b/crates/psd/src/tiff.rs
index 0d8f36888a..7c8b1940d5 100644
--- a/crates/psd/src/tiff.rs
+++ b/crates/psd/src/tiff.rs
@@ -155,10 +155,12 @@ impl ImageSourceData {
         let version = self.version;
         let mut blocks = Vec::with_capacity(self.global_blocks.len() + 2);
         if let Some(info) = &self.layer_info {
-            let mut info = info.clone();
-            info.pad_to(version, 4)?;
+            // Pad to 4 without cloning the layers (and all their pixel data) just to set `padding`.
+            let pad = info.pad_len(version, 4)?;
             let mut data = Vec::new();
-            info.write_body(&mut data, version)?;
+            data.try_reserve(info.channel_data_len().saturating_add(pad)).map_err(|_| PsdError::LimitExceeded("not enough memory for the layer data"))?;
+            info.write_unpadded(&mut data, version)?;
+            data.resize(data.len() + pad, 0);
             blocks.push(padded_block(self.layer_info_key, data));
         }
         if let Some(m) = &self.global_layer_mask {
diff --git a/crates/raster/src/lib.rs b/crates/raster/src/lib.rs
index c80dce82c8..ff45764980 100644
--- a/crates/raster/src/lib.rs
+++ b/crates/raster/src/lib.rs
@@ -81,6 +81,27 @@ impl Tile {
     pub fn bytes_mut(&mut self) -> &mut [u8] {
         &mut self.data
     }
+
+    /// Tile-local half-open bounds `(x0, y0, x1, y1)` of the pixels that differ from the encoded
+    /// pixel `dp` (one pixel of the tile's format), or `None` when every pixel equals it (or `dp`
+    /// is empty).
+    pub fn content_bounds(&self, dp: &[u8]) -> Option<(u16, u16, u16, u16)> {
+        let bpp = dp.len();
+        if bpp == 0 {
+            return None;
+        }
+        let ts = TILE_SIZE as usize;
+        let (mut x0, mut y0, mut x1, mut y1) = (usize::MAX, usize::MAX, 0usize, 0usize);
+        for (y, row) in self.data.chunks_exact(ts * bpp).enumerate() {
+            let Some(first) = row.chunks_exact(bpp).position(|px| px != dp) else { continue };
+            let last = ts - 1 - row.chunks_exact(bpp).rev().position(|px| px != dp).unwrap_or(0);
+            x0 = x0.min(first);
+            x1 = x1.max(last + 1);
+            y0 = y0.min(y);
+            y1 = y + 1;
+        }
+        (x0 != usize::MAX).then_some((x0 as u16, y0 as u16, x1 as u16, y1 as u16))
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -90,6 +111,49 @@ pub struct Surface {
     tiles: BTreeMap<TileCoord, Arc<Tile>>,
 }
 
+/// Tiles of one pixel value met while moving a surface ([`Surface::translated`]): each scanned
+/// once, and one tile kept per value so the targets share it.
+#[derive(Default)]
+struct UniformTiles {
+    /// Per source tile (by address): the index of its value's tile in `canonical`, or `None`.
+    of: std::collections::HashMap<*const Tile, Option<usize>>,
+    canonical: Vec<Arc<Tile>>,
+}
+
+impl UniformTiles {
+    /// The tile to share for a target reading window `r` of `s`, when every tile under it holds
+    /// one and the same pixel value (`r` must lie on existing tiles).
+    fn window(&mut self, s: &Surface, r: Rect) -> Option<Arc<Tile>> {
+        let bpp = s.format.bytes_per_pixel();
+        let mut found = None;
+        for c in r.tiles() {
+            let t = s.tiles.get(&c)?;
+            let k = self.value_of(t, bpp)?;
+            if found.is_some_and(|f| f != k) {
+                return None;
+            }
+            found = Some(k);
+        }
+        self.canonical.get(found?).cloned()
+    }
+
+    fn value_of(&mut self, t: &Arc<Tile>, bpp: usize) -> Option<usize> {
+        if let Some(k) = self.of.get(&Arc::as_ptr(t)) {
+            return *k;
+        }
+        let mut px = t.data.chunks_exact(bpp);
+        let k = px.next().filter(|p0| px.all(|p| p == *p0)).map(|p0| match self.canonical.iter().position(|c| c.data.get(..bpp) == Some(p0)) {
+            Some(k) => k,
+            None => {
+                self.canonical.push(t.clone());
+                self.canonical.len() - 1
+            }
+        });
+        self.of.insert(Arc::as_ptr(t), k);
+        k
+    }
+}
+
 impl PartialEq for Surface {
     fn eq(&self, other: &Self) -> bool {
         self.format == other.format && self.default_pixel == other.default_pixel && self.tiles == other.tiles
@@ -222,7 +286,6 @@ impl Surface {
 
     /// Exact bounds of pixels that differ from the default pixel.
     pub fn content_bounds(&self) -> Rect {
-        let bpp = self.format.bytes_per_pixel();
         if self.tiles.is_empty() {
             return Rect::EMPTY;
         }
@@ -235,25 +298,14 @@ impl Surface {
         }
         let mut order: Vec<(&TileCoord, &Arc<Tile>)> = self.tiles.iter().collect();
         order.sort_by_key(|(c, _)| (c.tx - gx0).min(gx1 - c.tx).min(c.ty - gy0).min(gy1 - c.ty));
-        let dp = &*self.default_pixel;
-        let ts = TILE_SIZE as usize;
         let mut out = Rect::EMPTY;
         for (c, t) in order {
             let origin = c.rect();
             if !out.is_empty() && out.contains_rect(&origin) {
                 continue;
             }
-            let (mut x0, mut y0, mut x1, mut y1) = (usize::MAX, usize::MAX, 0usize, 0usize);
-            for (y, row) in t.data.chunks_exact(ts * bpp).enumerate() {
-                let Some(first) = row.chunks_exact(bpp).position(|px| px != dp) else { continue };
-                let last = ts - 1 - row.chunks_exact(bpp).rev().position(|px| px != dp).unwrap_or(0);
-                x0 = x0.min(first);
-                x1 = x1.max(last + 1);
-                y0 = y0.min(y);
-                y1 = y + 1;
-            }
-            if x0 != usize::MAX {
-                out = out.union(&Rect::new(x0 as i32, y0 as i32, x1 as i32, y1 as i32).translate(origin.x0, origin.y0));
+            if let Some((x0, y0, x1, y1)) = t.content_bounds(&self.default_pixel) {
+                out = out.union(&Rect::new(x0.into(), y0.into(), x1.into(), y1.into()).translate(origin.x0, origin.y0));
             }
         }
         out
@@ -693,7 +745,10 @@ impl Surface {
     }
 
     /// The surface moved by whole pixels: its encoded samples copied tile to tile (no float
-    /// round trip, no intermediate buffer); moves by whole tiles share the tiles themselves.
+    /// round trip, no intermediate buffer); moves by whole tiles share the tiles themselves, and
+    /// a target tile read entirely from tiles of one single pixel value shares one such tile (the
+    /// inside of a solid fill stays one copy-on-write tile however often it moves). A tile it
+    /// copies that ends up holding only the default pixel isn't stored.
     /// `content` must hold every pixel that isn't the default one (`content_bounds`, say): only
     /// tiles it reaches are kept.
     pub fn translated(&self, dx: i32, dy: i32, content: Rect) -> Surface {
@@ -707,10 +762,29 @@ impl Surface {
         let bpp = self.format.bytes_per_pixel();
         let moved = content.translate(dx, dy);
         let targets: std::collections::BTreeSet<TileCoord> = sources().flat_map(|(c, _)| c.rect().translate(dx, dy).intersect(&moved).tiles()).collect();
+        let mut uniform = UniformTiles::default();
+        let zero = vec![0u8; bpp];
+        // One tile row of the default pixel, to compare a finished tile with a row at a time.
+        let default_row = self.default_pixel.repeat(TILE_SIZE.unsigned_abs() as usize);
         for dc in targets {
-            let mut tile = Tile::filled(&self.format, &self.default_pixel);
             let dr = dc.rect();
             let sr = dr.translate(dx.saturating_neg(), dy.saturating_neg());
+            // Every pixel of the target comes from a source tile (none from the default pixel).
+            // `sr` must be the exact preimage: an offset of `i32::MIN` saturates its negation.
+            let covered = sr.width() == TILE_SIZE.unsigned_abs()
+                && sr.height() == TILE_SIZE.unsigned_abs()
+                && sr.translate(dx, dy) == dr
+                && content.contains_rect(&sr)
+                && sr.tiles().all(|sc| self.tiles.contains_key(&sc));
+            if covered && let Some(shared) = uniform.window(self, sr) {
+                // A tile of only the default pixel is left out, as `prune` would.
+                if shared.data.get(..bpp) != Some(&*self.default_pixel) {
+                    out.tiles.insert(dc, shared);
+                }
+                continue;
+            }
+            // A covered target is overwritten whole, so skip filling it with the default pixel.
+            let mut tile = Tile::filled(&self.format, if covered { &zero } else { &self.default_pixel });
             for sc in sr.intersect(&content).tiles() {
                 let Some(st) = self.tiles.get(&sc) else { continue };
                 let part = sc.rect().intersect(&sr);
@@ -727,17 +801,64 @@ impl Surface {
                     }
                 }
             }
-            out.tiles.insert(dc, Arc::new(tile));
+            // A target that got only default pixels isn't stored, as `prune` would drop it. Checked
+            // after the copy, a row at a time: a tile with content stops at its first such row.
+            if tile.data.chunks(default_row.len()).any(|row| row != default_row) {
+                out.tiles.insert(dc, Arc::new(tile));
+            }
         }
         out
     }
 
+    /// Applies `f` to every colour sample (not alpha), including the default pixel: a tone-curve
+    /// change such as linearising when a document becomes 32-bit.
+    pub fn map_color(&mut self, f: impl Fn(f32) -> f32) {
+        let format = self.format;
+        let color = format.mode.color_channels();
+        let n = format.channels();
+        let mut dp = decode_pixel(&format, &self.default_pixel);
+        for v in dp.iter_mut().take(color) {
+            *v = f(*v);
+        }
+        encode_pixel(&format, &dp, &mut self.default_pixel);
+        let coords: Vec<TileCoord> = self.tiles.keys().copied().collect();
+        let px_count = (TILE_SIZE * TILE_SIZE) as usize;
+        // A tile shared by several coordinates (a filled background) is mapped once and stays
+        // shared (#4531). Keys are the original tiles, all alive until their coordinates are
+        // reached, so a freed address can't be mistaken for another original.
+        let mut done: std::collections::HashMap<*const Tile, Arc<Tile>> = std::collections::HashMap::new();
+        for c in coords {
+            let Some(key) = self.tiles.get(&c).map(Arc::as_ptr) else { continue };
+            if let Some(mapped) = done.get(&key) {
+                self.tiles.insert(c, mapped.clone());
+                continue;
+            }
+            let tile = self.tile_mut(c);
+            for i in 0..px_count {
+                for k in 0..color {
+                    let at = i * n + k;
+                    let v = read_sample(&tile.data, format.sample, at);
+                    write_sample(&mut tile.data, format.sample, at, f(v));
+                }
+            }
+            if let Some(mapped) = self.tiles.get(&c) {
+                done.insert(key, mapped.clone());
+            }
+        }
+    }
+
     /// Convert to another pixel format (depth and/or model; colour models via [`convert_pixel`]).
     pub fn convert(&self, to: PixelFormat) -> Surface {
         let mut out = Surface::with_default(to, &convert_pixel(&self.format, &to, &self.default_pixel()));
         let from_n = self.channels();
         let mut src = vec![0.0f32; from_n];
+        // Each distinct tile converts once; coordinates sharing it share the result (#4531).
+        let mut done: std::collections::HashMap<*const Tile, Arc<Tile>> = std::collections::HashMap::new();
         for (c, t) in &self.tiles {
+            if let Some(converted) = done.get(&Arc::as_ptr(t)) {
+                out.tiles.insert(*c, converted.clone());
+                continue;
+            }
             let dst = out.tile_mut(*c);
             let px_count = (TILE_SIZE * TILE_SIZE) as usize;
             for i in 0..px_count {
@@ -749,6 +870,9 @@ impl Surface {
                     write_sample(&mut dst.data, to.sample, i * to.channels() + k, *v);
                 }
             }
+            if let Some(converted) = out.tiles.get(c) {
+                done.insert(Arc::as_ptr(t), converted.clone());
+            }
         }
         out
     }
@@ -760,7 +884,12 @@ impl Surface {
         let mut src = Vec::new();
         src.try_reserve_exact(from_n).map_err(|_| AllocationError::NotEnoughMemory { bytes: from_n * std::mem::size_of::<f32>() })?;
         src.resize(from_n, 0.0f32);
+        let mut done: std::collections::HashMap<*const Tile, Arc<Tile>> = std::collections::HashMap::new();
         for (c, t) in &self.tiles {
+            if let Some(converted) = done.get(&Arc::as_ptr(t)) {
+                out.tiles.insert(*c, converted.clone());
+                continue;
+            }
             let dst = out.try_tile_mut(*c)?;
             let px_count = (TILE_SIZE * TILE_SIZE) as usize;
             for i in 0..px_count {
@@ -772,6 +901,9 @@ impl Surface {
                     write_sample(&mut dst.data, to.sample, i * to.channels() + k, *v);
                 }
             }
+            if let Some(converted) = out.tiles.get(c) {
+                done.insert(Arc::as_ptr(t), converted.clone());
+            }
         }
         Ok(out)
     }
@@ -891,6 +1023,43 @@ pub fn is_hdr(sample: SampleType) -> bool {
 
 #[cfg(test)]
 mod tests {
+    /// Distinct tile allocations in `s`.
+    fn distinct_tiles(s: &Surface) -> usize {
+        let mut seen: Vec<*const Tile> = s.tiles().map(|(_, t)| Arc::as_ptr(t)).collect();
+        seen.sort();
+        seen.dedup();
+        seen.len()
+    }
+
+    /// Converting or tone-mapping a surface keeps a shared tile shared (#4531) and gives the
+    /// same pixels as converting each pixel: a filled background is one tile across the grid,
+    /// plus some distinct tiles.
+    #[test]
+    fn conversion_keeps_shared_tiles_shared() {
+        let mut s = Surface::new(PixelFormat::RGBA8);
+        s.fill_rect(Rect::new(0, 0, 2048, 1024), &[0.9, 0.5, 0.2, 1.0]);
+        s.fill_rect(Rect::new(10, 10, 20, 20), &[0.1, 0.2, 0.3, 0.5]);
+        let shared_before = distinct_tiles(&s);
+        assert!(shared_before <= 2 && s.tile_count() == 32, "{shared_before} distinct of {}", s.tile_count());
+        let r = Rect::new(0, 0, 2048, 1024);
+        for to in [PixelFormat::RGBA16, PixelFormat::RGBA32F] {
+            for out in [s.convert(to), s.try_convert(to).expect("memory")] {
+                assert_eq!(distinct_tiles(&out), shared_before, "{to:?}: still shared");
+                assert_eq!(out.tile_count(), 32);
+                let (a, b) = (out.read_region(r), s.read_region(r));
+                for (pa, pb) in a.as_chunks::<4>().0.iter().zip(b.as_chunks::<4>().0) {
+                    let want = convert_pixel(&s.format(), &to, pb);
+                    assert!(pa.iter().zip(&want).all(|(x, y)| (x - y).abs() < 1e-6), "{to:?}: {pa:?} vs {want:?}");
+                }
+            }
+        }
+        let mut m = s.clone();
+        m.map_color(|v| v * 0.5);
+        assert_eq!(distinct_tiles(&m), shared_before, "map_color keeps it shared");
+        assert!((m.pixel(1000, 500)[0] - s.pixel(1000, 500)[0] * 0.5).abs() < 1.0 / 255.0);
+        assert_eq!(s.pixel(1000, 500), vec![s.pixel(1000, 500)[0], s.pixel(1000, 500)[1], s.pixel(1000, 500)[2], 1.0], "the source is untouched");
+    }
+
     use super::*;
     use photocraft_color::PixelFormat;
     use proptest::prelude::*;
@@ -1162,6 +1331,18 @@ mod tests {
         }
     }
 
+    #[test]
+    fn tile_content_bounds_scans_against_the_given_pixel() {
+        let mut s = Surface::new(PixelFormat::GRAY8);
+        s.write_pixel(3, 4, &[1.0]);
+        s.write_pixel(200, 9, &[1.0]);
+        let t = s.tile(TileCoord::new(0, 0)).expect("written tile");
+        assert_eq!(t.content_bounds(&[0]), Some((3, 4, 201, 10)));
+        assert_eq!(t.content_bounds(&[255]).map(|b| (b.0, b.1)), Some((0, 0)));
+        // A malformed pixel is no content, not a panic.
+        assert_eq!(t.content_bounds(&[]), None);
+    }
+
     #[test]
     fn translated_matches_reading_the_moved_pixels() {
         // Any offset (whole tiles, negative, across tile edges), every depth, a non-zero default.
@@ -1185,6 +1366,69 @@ mod tests {
             padded.fill_rect(Rect::new(2000, 2000, 2100, 2100), &s.default_pixel());
             assert_eq!(padded.translated(5, 5, s.content_bounds()).tile_count(), s.translated(5, 5, s.content_bounds()).tile_count());
         }
+        // A solid fill moved off the tile grid keeps sharing its one tile inside, at every depth
+        // and over a non-zero default pixel, and reads exactly like the copied pixels.
+        for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA16, PixelFormat::RGBA32F, PixelFormat::GRAY8] {
+            let mut s = Surface::with_default(fmt, &vec![0.25; fmt.channels()]);
+            let r = Rect::new(-300, -10, 1300, 1030);
+            s.fill_rect(r, &vec![0.75; fmt.channels()]);
+            let fill = s.tile(TileCoord::new(1, 1)).cloned().expect("an inner fill tile");
+            for (dx, dy) in [(10, 7), (-1, 0), (0, 300), (-257, 513)] {
+                let t = s.translated(dx, dy, s.content_bounds());
+                let moved = r.translate(dx, dy);
+                assert_eq!(t.read_region(moved.inflate(3)), s.read_region(moved.inflate(3).translate(-dx, -dy)), "{fmt:?} by ({dx}, {dy})");
+                // Targets read only from the fill's whole tiles (x -256..1280, y 0..1024).
+                let whole = Rect::new(-256, 0, 1280, 1024).translate(dx, dy);
+                let inner: Vec<_> = t.tiles().filter(|(c, _)| whole.contains_rect(&c.rect())).collect();
+                assert!(!inner.is_empty() && inner.iter().all(|(_, a)| Arc::ptr_eq(a, &fill)), "{fmt:?} by ({dx}, {dy}): inner tiles copied");
+            }
+            // Nudged back and forth, the inside keeps sharing one tile (copies of uniform edge
+            // tiles count as that value too) and the pixels stay exact.
+            let mut t = s.clone();
+            for k in 0..8 {
+                let d = if k % 2 == 0 { 10 } else { -10 };
+                t = t.translated(d, d / 2, t.content_bounds());
+            }
+            // (Targets whose last window read uniform tiles only: one tile in from the fill's whole
+            // tiles on the sides the last move came from.)
+            let inner: Vec<_> = t.tiles().filter(|(c, _)| Rect::new(-256, 0, 1024, 768).contains_rect(&c.rect())).map(|(_, a)| a).collect();
+            assert!(inner.len() >= 4 && inner.iter().all(|a| Arc::ptr_eq(a, inner[0])), "{fmt:?}: repeated moves copied the inside");
+            assert_eq!(t.read_region(r.inflate(3)), s.read_region(r.inflate(3)), "{fmt:?}: back where it started");
+        }
+        // Two solid fills of different values side by side: windows across the seam are
+        // copied (each tile is uniform, but not with the same value), the rest shared.
+        for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA32F] {
+            let mut s = Surface::new(fmt);
+            s.fill_rect(Rect::new(0, 0, 1024, 768), &vec![0.2; fmt.channels()]);
+            s.fill_rect(Rect::new(1024, 0, 2048, 768), &vec![0.9; fmt.channels()]);
+            let t = s.translated(10, 7, s.content_bounds());
+            let all = Rect::new(-20, -20, 2100, 800);
+            assert_eq!(t.read_region(all), s.read_region(all.translate(-10, -7)), "{fmt:?}: two fills");
+            let seam = t.tile(TileCoord::new(4, 1)).expect("seam tile");
+            let (left, right) = (t.tile(TileCoord::new(2, 1)).expect("left"), t.tile(TileCoord::new(6, 1)).expect("right"));
+            assert!(!Arc::ptr_eq(seam, left) && !Arc::ptr_eq(seam, right) && !Arc::ptr_eq(left, right), "{fmt:?}: seam aliased");
+        }
+        // An offset of i32::MIN saturates its negation, so the source window isn't the exact
+        // preimage: no shortcut may apply (a zero pre-fill would leak into the output).
+        let mut s = Surface::with_default(PixelFormat::GRAY8, &[0.5]);
+        s.fill_rect(Rect::new(i32::MAX - 1024, 0, i32::MAX - 512, 512), &[0.25]);
+        let (fill, default) = (s.sample_channel(i32::MAX - 600, 10, 0), s.default_pixel()[0]);
+        for (dx, dy) in [(i32::MIN, 1), (1, i32::MIN), (i32::MIN, 0)] {
+            let t = s.translated(dx, dy, s.content_bounds());
+            for (c, _) in t.tiles() {
+                assert!(t.read_region(c.rect()).iter().all(|v| *v == fill || *v == default), "({dx}, {dy}): tile {c:?} holds a pre-fill");
+            }
+        }
+        // One tile shared but not uniform: each target is copied, not aliased.
+        let mut s = Surface::new(PixelFormat::GRAY8);
+        s.write_pixel(3, 4, &[1.0]);
+        let odd = s.tile(TileCoord::new(0, 0)).cloned().expect("written tile");
+        let grid: Vec<_> = (0..9).map(|i| (TileCoord::new(i % 3, i / 3), odd.clone())).collect();
+        s.put_tiles(grid);
+        let t = s.translated(10, 7, s.content_bounds());
+        let all = Rect::new(-20, -20, 800, 800);
+        assert_eq!(t.read_region(all), s.read_region(all.translate(-10, -7)));
+        assert!(t.tiles().all(|(_, a)| !Arc::ptr_eq(a, &odd)));
         // Offsets at the limits don't panic.
         let mut s = Surface::new(PixelFormat::GRAY8);
         s.write_pixel(5, 5, &[1.0]);
@@ -1193,6 +1437,43 @@ mod tests {
         let _ = s.translated(i32::MIN + 1, 3, all);
     }
 
+    #[test]
+    fn translated_stores_no_tiles_of_only_the_default_pixel() {
+        let only_default = |t: &Surface| {
+            let dp = t.default_pixel();
+            t.tiles().filter(|(c, _)| t.read_region(c.rect()).chunks_exact(dp.len()).all(|p| p == dp.as_slice())).count()
+        };
+        // Two blocks a few tiles apart, moved off the tile grid and back: the default-pixel edges
+        // of their tiles land on tiles of their own, which aren't stored.
+        for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA16, PixelFormat::RGBA32F, PixelFormat::GRAY8] {
+            for default in [0.0, 0.25] {
+                let mut s = Surface::with_default(fmt, &vec![default; fmt.channels()]);
+                s.fill_rect(Rect::new(0, 0, 300, 300), &vec![1.0; fmt.channels()]);
+                s.fill_rect(Rect::new(2000, 1000, 2300, 1300), &vec![0.5; fmt.channels()]);
+                let all = Rect::new(-600, -600, 3000, 2000);
+                let mut t = s.clone();
+                for (dx, dy) in [(100, 56), (-100, -56), (10, 7), (-3, 40), (130, -90), (-137, 43)] {
+                    let moved = t.translated(dx, dy, t.content_bounds());
+                    assert_eq!(moved.read_region(all), t.read_region(all.translate(-dx, -dy)), "{fmt:?} over {default} by ({dx}, {dy})");
+                    assert_eq!(only_default(&moved), 0, "{fmt:?} over {default} by ({dx}, {dy})");
+                    t = moved;
+                }
+                assert_eq!(t.read_region(all), s.read_region(all), "{fmt:?} over {default}: back where it started");
+                assert_eq!(t.tile_count(), s.tile_count(), "{fmt:?} over {default}: back where it started");
+            }
+        }
+        // Stored tiles of the default pixel inside `content`: the targets that would share one of
+        // them (#4414's uniform windows) are left out too.
+        let mut s = Surface::with_default(PixelFormat::GRAY8, &[0.25]);
+        s.fill_rect(Rect::new(0, 0, 1024, 1024), &[0.25]);
+        s.write_pixel(600, 600, &[1.0]);
+        let content = Rect::new(0, 0, 1024, 1024);
+        let t = s.translated(10, 7, content);
+        assert_eq!(only_default(&t), 0);
+        assert_eq!(t.tile_count(), 1);
+        assert_eq!(t.read_region(Rect::new(-20, -20, 1100, 1100)), s.read_region(Rect::new(-30, -27, 1090, 1093)));
+    }
+
     proptest! {
         #[test]
         fn region_write_read_roundtrip(x in -600i32..600, y in -600i32..600, w in 1u32..90, h in 1u32..90, seed in any::<u32>()) {
diff --git a/crates/raw/README.md b/crates/raw/README.md
index 7bcfdcfe52..b8c75ebff6 100644
--- a/crates/raw/README.md
+++ b/crates/raw/README.md
@@ -45,6 +45,10 @@ Implemented only from public specifications, papers and observation of files:
   by observation of sample files (bit packing, page layout, sample justification; for RAF the
   three sample storages and the reversed order of the X-Trans / Bayer layout records, each
   verified by developing with every candidate phase against the camera's preview).
+* Panasonic RW2 RawFormat 3/4 (vendor-compressed): the fixed-rate 16 bytes per 14 pixels, the
+  predictor groups with per-parity predictors, the 2/4/8-bit field widths, the page-permuted
+  downward bit order and the black level sitting 15 counts above the recorded tags were all
+  established by observation of sample files.
 * Demosaicing: Malvar, He & Cutler (ICASSP 2004); Hirakawa & Parks, "Adaptive
   homogeneity-directed demosaicing" (IEEE TIP 2005); for X-Trans and other non-Bayer CFAs,
   gradient-weighted green interpolation (Lu & Tan, "Color filter array demosaicking: new method
@@ -71,11 +75,12 @@ camera colour tables were copied.
 | Nikon compressed NEF (compression 34713): lossless and lossy type 1 / 2, 12 and 14 bit | Decoded: fixed Huffman tables + maker-note `0x0096` seeds and curve (see `src/nefc.rs`). BlackLevel `0x003d` is read in 14-bit units. "Lossy after split" files are unsupported (preview fallback) |
 | Sony compressed ARW ("cRAW", SonyRawFileType 2) | Decoded: 11-bit min/max + 7-bit delta blocks, SonyToneCurve to 14 bits, the curve's 512 black level when no BlackLevel tag is written (the first-generation bodies, e.g. the ILCE-7) |
 | Panasonic / Leica RW2, RawFormat 5 (12- and 14-bit packed) | Decoded, with PanasonicRaw black / white / WB / sensor borders |
+| Panasonic / Leica RW2, RawFormat 3 and 4 (vendor-compressed, 12-bit) | Decoded; the black level is read 15 counts above the recorded tag; PanasonicRaw white / WB / sensor borders |
 | Olympus ORF, uncompressed 16-bit (E-1, E-400…) | Decoded, with ImageProcessing black / WB / ValidBits / crop |
-| Nikon "lossy after split" NEF, Sony "Compressed RAW 2", Pentax compressed PEF, RW2 RawFormat 4 and older, Olympus compressed ORF | Unsupported: no public description of these codes was found apart from GPL decoder source, which this crate may not use (clean-room). `photocraft-io` opens the embedded JPEG preview instead |
+| Nikon "lossy after split" NEF, Sony "Compressed RAW 2", Pentax compressed PEF, RW2 RawFormat 6 and newer, Olympus compressed ORF | Unsupported: no public description of these codes was found apart from GPL decoder source, which this crate may not use (clean-room). `photocraft-io` opens the embedded JPEG preview instead |
 | Fujifilm RAF, uncompressed (X-Trans I–V, GFX and Bayer bodies since about 2010) | Decoded: 16-bit containers (either byte order), 12-bit LSB-first packing, 14-bit packing in 32-bit words; X-Trans 6×6 or Bayer 2×2 layout, black, as-shot WB, crop, RawExposureBias, orientation from the preview's EXIF |
 | Fujifilm compressed RAF, early FinePix / SuperCCD RAF (no CFA TIFF) | Unsupported (no public description of the compression); preview fallback |
-| CR3 | Recognised, unsupported (preview fallback where a preview is found) |
+| CR3 | Native CRX unsupported; bounded JPEG-track/PRVW preview fallback with CMT1 orientation. I/O labels the result as an 8-bit camera preview |
 | X-Trans and other periodic non-Bayer CFAs (up to 16×16) | Demosaiced by one pattern-agnostic edge-directed method, whatever `Demosaic` is chosen |
 
 ## Development pipeline
@@ -91,6 +96,11 @@ camera colour tables were copied.
    16 bits.
 5. Orientation.
 
+Development validates public sensor/crop/CFA metadata before allocation. The working-memory
+limit checks peak live development buffers instead of summing disjoint phases. AHD limits
+simultaneous scratch bands only when required; normal load balancing and pixels are preserved.
+The default 2 GiB limit is unchanged and excludes caller-owned sensor/document storage.
+
 Files without colour calibration (CR2, NEF, ARW, RW2, ORF, RAF…) have no camera matrix. Every one of
 them carries a JPEG the camera rendered from the same sensor data, so `fit_look` estimates the
 camera's rendering per file: both the sensor data (white-balanced as `develop` does) and the
@@ -110,6 +120,10 @@ The D5100's measured image area is 4928 × 3264 at (8, 8) in a 4992 × 3280
 sensor plane; it removes the border without changing levels, WB or calibration.
 Measured image areas preserve an explicit file crop.
 
+For a slightly tighter camera JPEG, fitting can align the reference proxy using a bounded
+90–100% centred search on training cells. It requires a strong correlation improvement and
+retains the held-out colour gates; the developed crop and camera calibration are unchanged.
+
 Without a usable fit (no preview, an unrelated, monochrome or differently shaped one, or a fit that
 does not clearly help) the documented neutral fallback stays: the white-balanced camera channels are
 treated as linear sRGB primaries, with no tone curve (plausible but flat, greyish colours; converting
@@ -122,6 +136,14 @@ brightened shadows locally (Active D-Lighting), which one global curve cannot fo
 (preview decode included) takes about 50–70 ms on a 24 MP file. It is an estimate of the camera's
 look, not a measured calibration: picture styles and hue-dependent rendering are approximated.
 
+Cameras with a profile measured against Photoshop's Camera Raw (`src/cameras.rs`: the Nikon D4) carry
+a calibration, so no look is fitted for them. On 6 D4 NEFs against Photoshop 25.4's default Camera
+Raw rendering (quarter size, medians over the frames) the measured profile is 0.048 stop from its
+luminance with a mean CIE76 ΔE of 1.8; the look fitted to the embedded JPEG would be 0.30 stop and
+ΔE 6.4, as it follows the camera's picture style instead. The open-time re-develop
+(`photocraft-io`'s `import_raw_tuned`) and the tone curve its previews use (`tone_curve`) take the
+same look as the default open, so changing a slider does not change the colour rendering.
+
 ## Tools
 
 `cargo run --release -p photocraft-raw --example rawinfo -- [--dump] [--demosaic ahd] [--png DIR] FILE...`
diff --git a/crates/raw/fuzz/.gitignore b/crates/raw/fuzz/.gitignore
new file mode 100644
index 0000000000..ab0eaa1a49
--- /dev/null
+++ b/crates/raw/fuzz/.gitignore
@@ -0,0 +1,5 @@
+target/
+corpus/
+artifacts/
+coverage/
+Cargo.lock
diff --git a/crates/raw/src/cameras.rs b/crates/raw/src/cameras.rs
index 45eb542cb9..7439433c3e 100644
--- a/crates/raw/src/cameras.rs
+++ b/crates/raw/src/cameras.rs
@@ -11,10 +11,13 @@
 //! (2 px of optical black on the left, 50 + 8 on the right show as a purple stripe otherwise). The
 //! data is already black-subtracted (the darkest image pixels reach 0). Green saturates at
 //! 15546–15672 while red and blue reach 15687–16383, so one level of 15520 makes clipped
-//! highlights white without shifting the white balance. Matrix and curve were fitted to the
-//! camera's embedded JPEGs (Picture Control Standard, Active D-Lighting off; 52 frames, smooth
-//! areas, 4 × 4 means): on 15 held-out frames the development is 7.2/255 per channel off the
-//! camera's JPEG on average, against 34 without a profile.
+//! highlights white without shifting the white balance. Matrix, curve and black point copy
+//! Photoshop Camera Raw's default rendering of these files, measured black-box: 29 NEFs opened
+//! in Photoshop 25.4 against our own linear development of the same data (8 × 8 means, pixels
+//! clipped in neither). The matrix is our first ForwardMatrix (fitted to the camera's embedded
+//! JPEGs) times a linear-ProPhoto look matrix whose rows sum to 1; the curve applies per channel
+//! after it; the black point follows the frame's darkest tones ([`crate::tone`]). Median
+//! luminance difference to Camera Raw: 0.04 stop (0.29 with the camera-JPEG curve).
 //!
 //! Bodies whose full profile is not measured yet can still get their measured image area — the
 //! same alignment method, see [`IMAGE_AREAS`] — so their frames crop like the camera's JPEG.
@@ -22,39 +25,63 @@
 use crate::color::{Calibration, ColorInfo, IDENTITY, Mat3};
 use crate::sensor::{Rect, Sensor};
 
-const D4_FORWARD: Mat3 = [[0.644598, 0.0703598, 0.249262], [0.342249, 0.518929, 0.138822], [0.0568265, -0.269568, 1.03795]];
+const D4_FORWARD: Mat3 = [[0.639454, 0.260359, 0.0643991], [0.273094, 0.796492, -0.0695779], [0.00965321, -0.131427, 0.94699]];
+/// A third of the 0.1th percentile of the luminance, as Camera Raw renders D4 NEFs by default.
+const D4_BLACK_POINT: f32 = 0.33;
 const D4_COLOR: Mat3 = [[0.895936, -0.218092, -0.185988], [-1.09736, 2.06898, -0.0131889], [-0.26977, 0.393884, 0.687829]];
-const D4_TONE: [[f32; 2]; 31] = [
-    [0.005524272, 0.00285028],
-    [0.006569503, 0.00357083],
-    [0.0078125, 0.00447912],
-    [0.009290681, 0.00605813],
-    [0.01104854, 0.00841445],
-    [0.01313901, 0.011536],
-    [0.015625, 0.0165399],
-    [0.01858136, 0.0230234],
-    [0.02209709, 0.0319205],
-    [0.02627801, 0.0434858],
-    [0.03125, 0.0582138],
-    [0.03716272, 0.0771963],
-    [0.04419417, 0.0993894],
-    [0.05255603, 0.125058],
-    [0.0625, 0.157207],
-    [0.07432544, 0.194929],
-    [0.08838835, 0.236109],
-    [0.1051121, 0.279155],
-    [0.125, 0.329365],
-    [0.1486509, 0.388405],
-    [0.1767767, 0.457944],
-    [0.2102241, 0.52456],
-    [0.25, 0.598051],
-    [0.2973018, 0.668794],
-    [0.3535534, 0.749954],
-    [0.4204482, 0.815443],
-    [0.5, 0.870167],
-    [0.5946036, 0.907869],
-    [std::f32::consts::FRAC_1_SQRT_2, 0.939351],
-    [0.8408964, 0.970567],
+const D4_TONE: [[f32; 2]; 53] = [
+    [0.00012207031, 7.44377e-05],
+    [0.00014516688, 8.44049e-05],
+    [0.00017263349, 9.57067e-05],
+    [0.00020529698, 0.000108523],
+    [0.00024414062, 0.000123055],
+    [0.00029033376, 0.000123202],
+    [0.00034526698, 0.000123348],
+    [0.00041059396, 0.000142387],
+    [0.00048828125, 0.000164366],
+    [0.0005806675, 0.00020246],
+    [0.00069053395, 0.000249382],
+    [0.0008211879, 0.000310083],
+    [0.0009765625, 0.000385559],
+    [0.001161335, 0.000474115],
+    [0.0013810679, 0.00058301],
+    [0.0016423758, 0.000717142],
+    [0.001953125, 0.000882133],
+    [0.00232267, 0.00109054],
+    [0.0027621358, 0.00134818],
+    [0.0032847517, 0.00163655],
+    [0.00390625, 0.0019866],
+    [0.00464534, 0.00235945],
+    [0.0055242716, 0.00280228],
+    [0.0065695033, 0.00342616],
+    [0.0078125, 0.00418894],
+    [0.00929068, 0.00540942],
+    [0.011048543, 0.0069855],
+    [0.013139007, 0.00959286],
+    [0.015625, 0.0131734],
+    [0.01858136, 0.0181471],
+    [0.022097087, 0.0249987],
+    [0.026278013, 0.0336416],
+    [0.03125, 0.0452726],
+    [0.03716272, 0.0591889],
+    [0.044194173, 0.077383],
+    [0.052556027, 0.0990869],
+    [0.0625, 0.126878],
+    [0.07432544, 0.161688],
+    [0.088388346, 0.206049],
+    [0.10511205, 0.256563],
+    [0.125, 0.31946],
+    [0.14865088, 0.382637],
+    [0.17677669, 0.458308],
+    [0.2102241, 0.531942],
+    [0.25, 0.617405],
+    [0.29730177, 0.683279],
+    [0.35355338, 0.756182],
+    [0.4204482, 0.809073],
+    [0.5, 0.865664],
+    [0.59460354, 0.900869],
+    [std::f32::consts::FRAC_1_SQRT_2, 0.937507],
+    [0.8408964, 0.956434],
     [1.0, 1.0],
 ];
 
@@ -71,6 +98,8 @@ struct Profile {
     forward: Mat3,
     color: Mat3,
     tone: &'static [[f32; 2]],
+    /// Camera Raw's adaptive black-point factor ([`Sensor::black_point`]).
+    black_point: f32,
 }
 
 const PROFILES: &[Profile] = &[Profile {
@@ -83,6 +112,7 @@ const PROFILES: &[Profile] = &[Profile {
     forward: D4_FORWARD,
     color: D4_COLOR,
     tone: &D4_TONE,
+    black_point: D4_BLACK_POINT,
 }];
 
 /// A measured image area of a body whose remaining profile has not been
@@ -134,6 +164,7 @@ pub(crate) fn apply(s: &mut Sensor) {
         ..ColorInfo::default()
     };
     s.tone_curve = p.tone.to_vec();
+    s.black_point = p.black_point;
 }
 
 #[cfg(test)]
@@ -164,6 +195,7 @@ mod tests {
             baseline_exposure: 0.0,
             gain_maps: Vec::new(),
             tone_curve: Vec::new(),
+            black_point: 0.0,
             warnings: vec!["NEF: black level not recorded in a documented tag; assumed 0".into()],
         }
     }
@@ -181,6 +213,7 @@ mod tests {
         assert_eq!(s.color.calibrations.len(), 1);
         assert_eq!(s.color.calibrations[0].forward_matrix, Some(D4_FORWARD));
         assert_eq!(s.tone_curve.len(), D4_TONE.len());
+        assert_eq!(s.black_point, D4_BLACK_POINT);
         assert!(s.warnings.is_empty(), "the D4's black level is known: {:?}", s.warnings);
         // The profile gives a colour conversion for the as-shot white balance.
         assert!(s.color.balanced_to_xyz_d50([0.5, 1.0, 0.7]).is_some());
diff --git a/crates/raw/src/cr2.rs b/crates/raw/src/cr2.rs
index 5b3601222e..8e851c5d59 100644
--- a/crates/raw/src/cr2.rs
+++ b/crates/raw/src/cr2.rs
@@ -293,6 +293,7 @@ pub(crate) fn decode(t: &Tiff, limits: &Limits) -> Result<Sensor> {
         baseline_exposure: 0.0,
         gain_maps: Vec::new(),
         tone_curve: Vec::new(),
+        black_point: 0.0,
         warnings,
     })
 }
diff --git a/crates/raw/src/cr3.rs b/crates/raw/src/cr3.rs
new file mode 100644
index 0000000000..bb2119e7d4
--- /dev/null
+++ b/crates/raw/src/cr3.rs
@@ -0,0 +1,202 @@
+//! Bounded CR3 container reading, independently implemented from ISO BMFF and
+//! Laurent Clévy's public format description (canon_cr3/readme.md). This extracts
+//! camera JPEGs and orientation, not CRX sensor data. Never scan compressed data
+//! for JPEG signatures: offsets must come from a validated sample table or PRVW.
+
+use crate::preview::{Preview, candidate};
+use crate::tiff::{Tiff, tag};
+
+const META_UUID: &[u8] = &[0x85, 0xc0, 0xb6, 0x87, 0x82, 0x0f, 0x11, 0xe0, 0x81, 0x11, 0xf4, 0xce, 0x46, 0x2b, 0x6a, 0x48];
+const PREVIEW_UUID: &[u8] = &[0xea, 0xf4, 0x2b, 0x5e, 0x1c, 0x98, 0x4b, 0x88, 0xb9, 0xfb, 0xb7, 0xdc, 0x40, 0x6e, 0x4d, 0x16];
+const MAX_BOXES: usize = 8192;
+const MAX_DEPTH: usize = 12;
+
+fn u32_at(b: &[u8], p: usize) -> Option<u32> {
+    Some(u32::from_be_bytes(b.get(p..p.checked_add(4)?)?.try_into().ok()?))
+}
+
+fn u64_at(b: &[u8], p: usize) -> Option<u64> {
+    Some(u64::from_be_bytes(b.get(p..p.checked_add(8)?)?.try_into().ok()?))
+}
+
+struct BoxRef<'a> {
+    kind: &'a [u8],
+    body: &'a [u8],
+}
+
+/// Walks only complete sibling boxes, including extended lengths and a final
+/// zero-length box. Invalid lengths end this container; siblings never escape it.
+fn boxes<'a>(mut b: &'a [u8], budget: &mut usize, mut f: impl FnMut(BoxRef<'a>, &mut usize)) {
+    while b.len() >= 8 && *budget > 0 {
+        *budget -= 1;
+        let Some(n) = u32_at(b, 0) else {
+            return;
+        };
+        let (size, header) = match n {
+            0 => (b.len(), 8),
+            1 => {
+                let Some(size) = u64_at(b, 8).and_then(|n| usize::try_from(n).ok()) else {
+                    return;
+                };
+                (size, 16)
+            }
+            n => (n as usize, 8),
+        };
+        if size < header {
+            return;
+        }
+        let Some(body) = b.get(header..size) else {
+            return;
+        };
+        let Some(kind) = b.get(4..8) else {
+            return;
+        };
+        f(BoxRef { kind, body }, budget);
+        let Some(rest) = b.get(size..) else {
+            return;
+        };
+        b = rest;
+    }
+}
+
+#[derive(Default)]
+struct Track<'a> {
+    jpeg: bool,
+    sizes: Option<&'a [u8]>,
+    offsets: Option<(&'a [u8], bool)>,
+    mapping: bool,
+}
+
+/// Accept only a single JPEG sample description, with CRAW's fixed sample-entry
+/// header followed by an explicit JPEG codec box.
+fn jpeg_description(b: &[u8], budget: &mut usize) -> bool {
+    if u32_at(b, 0) != Some(0) || u32_at(b, 4) != Some(1) {
+        return false;
+    }
+    let mut jpeg = false;
+    if let Some(entries) = b.get(8..) {
+        boxes(entries, budget, |entry, budget| {
+            if entry.kind == b"CRAW"
+                && let Some(children) = entry.body.get(82..)
+            {
+                boxes(children, budget, |codec, _| {
+                    jpeg |= codec.kind == b"JPEG";
+                });
+            }
+        });
+    }
+    jpeg
+}
+
+fn track_boxes<'a>(b: &'a [u8], depth: usize, budget: &mut usize, t: &mut Track<'a>) {
+    if depth > MAX_DEPTH {
+        return;
+    }
+    boxes(b, budget, |item, budget| match item.kind {
+        b"mdia" | b"minf" | b"stbl" => track_boxes(item.body, depth + 1, budget, t),
+        b"stsd" => t.jpeg = jpeg_description(item.body, budget),
+        b"stsz" => t.sizes = Some(item.body),
+        b"co64" => t.offsets = Some((item.body, true)),
+        b"stco" => t.offsets = Some((item.body, false)),
+        // One entry, starting at chunk 1, one sample per chunk, description 1.
+        b"stsc" => t.mapping = item.body.len() == 20 && (0..5).all(|i| u32_at(item.body, i * 4) == Some(if i == 0 { 0 } else { 1 })),
+        _ => {}
+    });
+}
+
+fn track_preview<'a>(raw: &'a [u8], track: &'a [u8], budget: &mut usize, media: &[(usize, usize)]) -> Option<Preview<'a>> {
+    let mut t = Track::default();
+    track_boxes(track, 0, budget, &mut t);
+    if !t.jpeg || !t.mapping {
+        return None;
+    }
+    let sizes = t.sizes?;
+    let (offsets, wide) = t.offsets?;
+    // Burst sequences are deliberately not paired by ordinal index: their
+    // sample-to-chunk mapping and picture selection need a separate implementation.
+    if u32_at(sizes, 0) != Some(0) || u32_at(sizes, 8) != Some(1) || u32_at(offsets, 0) != Some(0) || u32_at(offsets, 4) != Some(1) {
+        return None;
+    }
+    let fixed = u32_at(sizes, 4)?;
+    let len = if fixed == 0 { u32_at(sizes, 12)? } else { fixed };
+    let off = if wide { u64_at(offsets, 8)? } else { u64::from(u32_at(offsets, 8)?) };
+    let off = usize::try_from(off).ok()?;
+    let end = off.checked_add(len as usize)?;
+    if !media.iter().any(|(start, stop)| off >= *start && end <= *stop) {
+        return None;
+    }
+    candidate(raw, off, len as usize)
+}
+
+#[derive(Default)]
+struct Found<'a> {
+    previews: Vec<Preview<'a>>,
+    orientation: Option<u16>,
+    media: Vec<(usize, usize)>,
+}
+
+fn walk<'a>(raw: &'a [u8], b: &'a [u8], depth: usize, budget: &mut usize, found: &mut Found<'a>) {
+    if depth > MAX_DEPTH {
+        return;
+    }
+    boxes(b, budget, |item, budget| match item.kind {
+        b"moov" => walk(raw, item.body, depth + 1, budget, found),
+        b"trak" => {
+            if found.previews.len() < 128 {
+                found.previews.extend(track_preview(raw, item.body, budget, &found.media));
+            }
+        }
+        b"uuid" => {
+            if item.body.get(..16) == Some(META_UUID)
+                && let Some(children) = item.body.get(16..)
+            {
+                walk(raw, children, depth + 1, budget, found);
+            } else if item.body.get(..16) == Some(PREVIEW_UUID)
+                && let Some(children) = item.body.get(24..)
+            {
+                walk(raw, children, depth + 1, budget, found);
+            }
+        }
+        b"PRVW" => {
+            if found.previews.len() < 128
+                && let Some(len) = u32_at(item.body, 12)
+                && let Some(p) = candidate(item.body, 16, len as usize)
+            {
+                found.previews.push(p);
+            }
+        }
+        b"CMT1" => {
+            if let Some(tiff) = Tiff::new(item.body)
+                && let Some(ifd) = tiff.ifd_at(tiff.first_ifd, 0)
+                && let Some(o) = tiff.tag_uint(&ifd, tag::ORIENTATION).filter(|o| (1..=8).contains(o))
+            {
+                found.orientation = Some(o as u16);
+            }
+        }
+        _ => {}
+    });
+}
+
+fn read(raw: &[u8]) -> Found<'_> {
+    let mut found = Found::default();
+    if raw.get(4..12) == Some(b"ftypcrx ") {
+        let mut budget = MAX_BOXES;
+        boxes(raw, &mut budget, |item, _| {
+            if item.kind == b"mdat" && found.media.len() < 128 {
+                let start = (item.body.as_ptr() as usize).saturating_sub(raw.as_ptr() as usize);
+                if let Some(end) = start.checked_add(item.body.len()) {
+                    found.media.push((start, end));
+                }
+            }
+        });
+        walk(raw, raw, 0, &mut budget, &mut found);
+    }
+    found
+}
+
+pub(crate) fn previews(raw: &[u8]) -> Vec<Preview<'_>> {
+    read(raw).previews
+}
+pub(crate) fn orientation(raw: &[u8]) -> Option<u16> {
+    read(raw).orientation
+}
diff --git a/crates/raw/src/demosaic.rs b/crates/raw/src/demosaic.rs
index 2689061b32..8b87f14a69 100644
--- a/crates/raw/src/demosaic.rs
+++ b/crates/raw/src/demosaic.rs
@@ -187,14 +187,14 @@ fn kernels(phase: [u8; 4], method: Demosaic, stride: usize) -> [[Vec<(isize, f32
 }
 
 /// Demosaics a padded CFA plane into interleaved RGB (`w × h × 3`).
-pub(crate) fn demosaic(p: &Padded, phase: [u8; 4], method: Demosaic, to_xyz: &Mat3) -> Vec<f32> {
+pub(crate) fn demosaic(p: &Padded, phase: [u8; 4], method: Demosaic, to_xyz: &Mat3, ahd_jobs: usize) -> Vec<f32> {
     let (w, h, s) = (p.w, p.h, p.stride);
     let mut out = vec![0.0f32; w * h * 3];
     if w == 0 || h == 0 || p.data.len() < s * (h + 2 * PAD) {
         return out;
     }
     if method == Demosaic::Ahd {
-        ahd(p, phase, to_xyz, &mut out);
+        ahd(p, phase, to_xyz, &mut out, ahd_jobs);
         return out;
     }
     let ks = kernels(phase, method, s);
@@ -460,7 +460,19 @@ const AHD_BAND: usize = 32;
 /// Extra band rows above and below the output rows.
 const M: usize = 3;
 
-fn ahd(p: &Padded, phase: [u8; 4], to_xyz: &Mat3, out: &mut [f32]) {
+/// Maximum scratch allocation of one AHD band: two green, RGB and Lab float
+/// planes and two byte homogeneity planes, including their border rows.
+pub(crate) fn ahd_scratch(w: u64, h: u64) -> u64 {
+    w.saturating_add(2 * PAD as u64).saturating_mul(h.min(AHD_BAND as u64).saturating_add(2 * M as u64)).saturating_mul(58)
+}
+
+pub(crate) fn ahd_bands(h: usize) -> usize {
+    h.div_ceil(AHD_BAND)
+}
+
+pub(crate) const AHD_TABLE_BYTES: u64 = (LABF_STEPS as u64 + 2) * 4;
+
+fn ahd(p: &Padded, phase: [u8; 4], to_xyz: &Mat3, out: &mut [f32], jobs: usize) {
     let (w, s) = (p.w, p.stride);
     let d = &p.data;
     // Colour at padded coordinates (PAD is even, so the phase is unchanged).
@@ -468,7 +480,7 @@ fn ahd(p: &Padded, phase: [u8; 4], to_xyz: &Mat3, out: &mut [f32]) {
     let white = [0.9642f32, 1.0, 0.8249];
     let m: [[f32; 3]; 3] = std::array::from_fn(|i| std::array::from_fn(|j| to_xyz[i][j] as f32 / white[i]));
     let labf = LabF::new();
-    par::chunks_mut(out, AHD_BAND * w * 3, |band, chunk| {
+    par::chunks_mut_limited(out, AHD_BAND * w * 3, jobs, |band, chunk| {
         let rows = chunk.len() / (w * 3);
         let n = rows + 2 * M;
         // Band row b ↔ padded row py(b); padded columns are used as is.
@@ -577,13 +589,24 @@ mod tests {
     use super::*;
     use crate::color::IDENTITY;
 
+    #[test]
+    fn ahd_band_concurrency_does_not_change_pixels() {
+        let (w, h) = (53, 103);
+        let cfa: Vec<f32> = (0..w * h).map(|i| ((i * 97 + i / w * 31) % 1009) as f32 / 1009.0).collect();
+        let p = Padded::from_plane(&cfa, w, h);
+        let one = demosaic(&p, [0, 1, 1, 2], Demosaic::Ahd, &IDENTITY, 1);
+        for jobs in [2, 3, 4, 128] {
+            assert_eq!(one, demosaic(&p, [0, 1, 1, 2], Demosaic::Ahd, &IDENTITY, jobs));
+        }
+    }
+
     /// Mosaics an RGB image with the given phase.
     fn mosaic(rgb: &[[f32; 3]], w: usize, h: usize, phase: [u8; 4]) -> Vec<f32> {
         (0..w * h).map(|i| rgb[i][phase[((i / w) & 1) * 2 + ((i % w) & 1)] as usize]).collect()
     }
 
     fn run(cfa: &[f32], w: usize, h: usize, phase: [u8; 4], m: Demosaic) -> Vec<f32> {
-        demosaic(&Padded::from_plane(cfa, w, h), phase, m, &IDENTITY)
+        demosaic(&Padded::from_plane(cfa, w, h), phase, m, &IDENTITY, par::workers())
     }
 
     fn psnr(a: &[f32], b: &[[f32; 3]], w: usize, h: usize, border: usize) -> f64 {
@@ -671,7 +694,7 @@ mod tests {
         let cfa: Vec<f32> = (0..w * h).map(|i| ((i * 7919) % 1000) as f32 / 1000.0).collect();
         for phase in [[0, 1, 1, 2], [1, 2, 0, 1]] {
             let p = Padded::from_plane(&cfa, w, h);
-            let fast = demosaic(&p, phase, Demosaic::Bilinear, &IDENTITY);
+            let fast = demosaic(&p, phase, Demosaic::Bilinear, &IDENTITY, par::workers());
             let ks = kernels(phase, Demosaic::Bilinear, p.stride);
             for y in 0..h {
                 for x in 0..w {
diff --git a/crates/raw/src/develop.rs b/crates/raw/src/develop.rs
index 8b69cc2919..e3ab70b0c7 100644
--- a/crates/raw/src/develop.rs
+++ b/crates/raw/src/develop.rs
@@ -1,12 +1,15 @@
 //! Raw development: linearize, subtract black, scale to white, white
 //! balance, clip highlights, demosaic, camera → XYZ (D50) → linear ProPhoto,
-//! exposure, gamma 1.8 encode to 16 bits, orientation.
+//! exposure, Dehaze, Shadows / Highlights / Clarity / Texture and the black
+//! point (`tone.rs`), the profile's tone curve, gamma 1.8 encode to 16 bits,
+//! orientation.
 
 use crate::color::{self, Mat3};
 use crate::demosaic::{Demosaic, PAD, Padded, Pattern, demosaic, demosaic_cfa};
 use crate::error::{RawError, Result};
 use crate::look::{CameraLook, ToneCurve};
 use crate::sensor::Sensor;
+use crate::tone::{Haze, Tone, ToneMap, black_level};
 use crate::{Limits, RawFormat, par};
 
 /// White balance choice.
@@ -30,6 +33,9 @@ pub struct DevelopOptions {
     pub exposure: f64,
     /// Apply the file's orientation (rotate / flip the pixels).
     pub orient: bool,
+    /// Camera Raw's Shadows, Highlights, Clarity, Texture and Dehaze, applied in linear light
+    /// before the tone curve.
+    pub tone: Tone,
     pub limits: Limits,
     /// A colour rendering fitted to the camera's own JPEG ([`crate::fit_look`]). When set it
     /// replaces the file's colour calibration (or the neutral fallback) and adds its tone curve.
@@ -43,6 +49,7 @@ impl Default for DevelopOptions {
             white_balance: WhiteBalance::default(),
             exposure: 0.0,
             orient: true,
+            tone: Tone::default(),
             limits: Limits::default(),
             camera_look: None,
         }
@@ -188,16 +195,31 @@ pub(crate) fn resolve_neutral(s: &Sensor, opts: &DevelopOptions, sc: &Scale, war
 /// Develops sensor data.
 pub fn develop_sensor(s: &Sensor, opts: &DevelopOptions) -> Result<Developed> {
     let c = s.crop;
-    if c.is_empty() || c.x + c.width > s.width || c.y + c.height > s.height || s.data.len() < s.width * s.height * s.samples {
+    let samples = s.width.checked_mul(s.height).and_then(|n| n.checked_mul(s.samples));
+    if c.is_empty()
+        || c.x.checked_add(c.width).is_none_or(|x| x > s.width)
+        || c.y.checked_add(c.height).is_none_or(|y| y > s.height)
+        || samples.is_none_or(|n| s.data.len() < n)
+    {
         return Err(RawError::malformed("crop lies outside the sensor data"));
     }
+    // LinearRaw can be monochrome (one sample) or RGB (three); CFA data needs one.
     if s.samples != 1 && s.samples != 3 {
         return Err(RawError::unsupported(format!("{} samples per pixel", s.samples)));
     }
-    // Working buffers: one f32 plane plus f32 RGB plus u16 RGB per pixel, and
-    // a green plane for non-Bayer patterns.
+    if let Some(cfa) = &s.cfa
+        && (s.samples != 1
+            || cfa.width == 0
+            || cfa.height == 0
+            || cfa.width > 16
+            || cfa.height > 16
+            || cfa.colors.len() != cfa.width * cfa.height
+            || cfa.colors.iter().any(|c| *c > 2))
+    {
+        return Err(RawError::malformed("invalid sensor CFA pattern"));
+    }
     let bayer = s.cfa.as_ref().is_none_or(|cfa| cfa.is_bayer());
-    opts.limits.check(c.width as u64, c.height as u64, if bayer { 4 + 12 + 6 } else { 4 + 4 + 12 + 6 })?;
+    let ahd_jobs = working_memory(c.width, c.height, s.cfa.is_some(), bayer, opts, par::workers())?;
     let mut warnings = s.warnings.clone();
     let sc = Scale::new(s);
 
@@ -297,7 +319,7 @@ pub fn develop_sensor(s: &Sensor, opts: &DevelopOptions) -> Result<Developed> {
             if bayer {
                 let p = cfa.phase(c.x, c.y);
                 pattern = Some(names(&p));
-                rgb = demosaic(&plane, p, opts.demosaic, &to_xyz);
+                rgb = demosaic(&plane, p, opts.demosaic, &to_xyz, ahd_jobs);
             } else {
                 let pat = Pattern::of(cfa, c.x, c.y);
                 pattern = Some(pat.colors.chunks(pat.w.max(1)).map(names).collect::<Vec<_>>().join("/"));
@@ -330,7 +352,24 @@ pub fn develop_sensor(s: &Sensor, opts: &DevelopOptions) -> Result<Developed> {
         }
     }
 
-    // Camera → ProPhoto, exposure, the look's tone curve, gamma 1.8, 16 bits.
+    // Camera → ProPhoto, exposure, Dehaze, Shadows / Highlights / Clarity / Texture and the black
+    // point, the look's (or the profile's) tone curve, gamma 1.8, 16 bits.
+    let y_row = color::rgb_to_xyz(color::ROMM, color::D50_XY)[1].map(|v| v as f32);
+    let lum = |v: &[f32; 3]| y_row[0] * v[0] + y_row[1] * v[1] + y_row[2] * v[2];
+    // Monochrome: the one sample, grey; no colour matrix.
+    let pro = |p: &[f32]| if mono { [grey_gain * p[0]; 3] } else { [0, 1, 2].map(|k| out_m[k][0] * p[0] + out_m[k][1] * p[1] + out_m[k][2] * p[2]) };
+    let haze = Haze::new(w, h, |i| pro(&rgb[i * 3..i * 3 + 3]), opts.tone.dehaze);
+    // Linear ProPhoto of pixel `i` after Dehaze.
+    let linear = |i: usize, p: &[f32]| {
+        let v = pro(p);
+        haze.as_ref().map_or(v, |z| z.apply(i % w, i / w, v))
+    };
+    let mut map = ToneMap::new(w, h, |i| lum(&linear(i, &rgb[i * 3..i * 3 + 3])), opts.tone, s.black_point);
+    if let (Some(m), Some(_)) = (&mut map, &haze) {
+        // The black point belongs to the default rendering: Dehaze does not move it (taken after
+        // Dehaze it fell to almost 0, and Dehaze darkened less than Photoshop's).
+        m.black = black_level(w, h, |i| lum(&pro(&rgb[i * 3..i * 3 + 3])), s.black_point);
+    }
     let mut out = vec![0u16; w * h * 3];
     let lut = match look {
         Some(l) => GammaLut::with_tone(l.tone.as_ref()),
@@ -339,13 +378,16 @@ pub fn develop_sensor(s: &Sensor, opts: &DevelopOptions) -> Result<Developed> {
     par::chunks_mut(&mut out, band * w * 3, |b, chunk| {
         let start = b * band * w * 3;
         let src = &rgb[start..start + chunk.len()];
-        for (o, p) in chunk.as_chunks_mut::<3>().0.iter_mut().zip(src.as_chunks::<3>().0) {
-            if mono {
-                *o = [lut.encode(grey_gain * p[0]); 3];
-                continue;
+        for (i, (o, p)) in chunk.as_chunks_mut::<3>().0.iter_mut().zip(src.as_chunks::<3>().0).enumerate() {
+            let mut v = linear(b * band * w + i, p);
+            if let Some(m) = &map {
+                let g = m.gain(i % w, b * band + i / w, lum(&v));
+                // The black point first, as Camera Raw: lifting before it would flatten the
+                // deepest shadows' contrast.
+                v = v.map(|c| m.unblack(c) * g);
             }
             for k in 0..3 {
-                o[k] = lut.encode(out_m[k][0] * p[0] + out_m[k][1] * p[1] + out_m[k][2] * p[2]);
+                o[k] = lut.encode(v[k]);
             }
         }
     });
@@ -373,6 +415,36 @@ pub fn develop_sensor(s: &Sensor, opts: &DevelopOptions) -> Result<Developed> {
     })
 }
 
+/// Checks the peak of the two development phases. The CFA and non-Bayer green
+/// planes are freed before the u16 output is allocated; AHD scratch is bounded
+/// by reducing simultaneous bands when needed. Sensor storage belongs to the
+/// caller and is checked separately by the decoder.
+fn working_memory(w: usize, h: usize, cfa: bool, bayer: bool, opts: &DevelopOptions, workers: usize) -> Result<usize> {
+    let limits = &opts.limits;
+    limits.check(w as u64, h as u64, 18)?;
+    let pixels = (w as u64).saturating_mul(h as u64);
+    let output = pixels.saturating_mul(18).saturating_add((GAMMA_STEPS as u64 + 2) * 4);
+    let mut peak = output;
+    let mut jobs = workers.max(1);
+    if cfa {
+        let plane = (w as u64).saturating_add(2 * PAD as u64).saturating_mul((h as u64).saturating_add(2 * PAD as u64)).saturating_mul(4);
+        let mut mosaic = pixels.saturating_mul(if bayer { 12 } else { 16 }).saturating_add(plane);
+        if bayer && opts.demosaic == Demosaic::Ahd {
+            mosaic = mosaic.saturating_add(crate::demosaic::AHD_TABLE_BYTES);
+            let scratch = crate::demosaic::ahd_scratch(w as u64, h as u64);
+            let available = limits.max_alloc.saturating_sub(mosaic) / scratch.max(1);
+            jobs = jobs.min(crate::demosaic::ahd_bands(h)).min(usize::try_from(available).unwrap_or(usize::MAX));
+            // At least one band must fit, even when no parallelism is available.
+            mosaic = mosaic.saturating_add(scratch.saturating_mul(jobs.max(1) as u64));
+        }
+        peak = peak.max(mosaic);
+    }
+    if peak > limits.max_alloc || usize::try_from(peak).is_err() {
+        return Err(RawError::LimitExceeded(format!("{peak} bytes of RAW working memory exceed {}", limits.max_alloc)));
+    }
+    Ok(jobs.max(1))
+}
+
 /// Gain-map factors (DNG OpcodeList2 GainMap) for data row `y`, columns
 /// `x0..x0 + w`, sample `k`; `None` when no map touches the row.
 fn gain_row(s: &Sensor, y: usize, x0: usize, w: usize, k: usize) -> Option<Vec<f32>> {
@@ -453,7 +525,7 @@ impl GammaLut {
 
 /// `curve` at linear `v`: linear interpolation between the points in log₂ of the input, a line
 /// through 0 below the first point, the last output beyond the last.
-fn tone(curve: &[[f32; 2]], v: f32) -> f32 {
+pub(crate) fn tone(curve: &[[f32; 2]], v: f32) -> f32 {
     let (Some(first), Some(last)) = (curve.first(), curve.last()) else { return v };
     if v <= first[0] {
         return if first[0] > 0.0 { v * first[1] / first[0] } else { first[1] };
@@ -517,6 +589,34 @@ pub(crate) fn orient(src: Vec<u16>, w: usize, h: usize, o: u16) -> (Vec<u16>, us
 mod tests {
     use super::*;
 
+    #[test]
+    fn hundred_megapixel_bayer_fits_without_raising_default_limits() {
+        let mut opts = DevelopOptions::default();
+        for method in [Demosaic::Bilinear, Demosaic::Mhc, Demosaic::Ahd] {
+            opts.demosaic = method;
+            for workers in [1, 10, 32, 128] {
+                let jobs = working_memory(11648, 8736, true, true, &opts, workers).unwrap();
+                assert!(jobs <= workers);
+                if method == Demosaic::Ahd && workers >= 32 {
+                    assert!(jobs < workers);
+                }
+            }
+        }
+        opts.limits.max_alloc = 1 << 30;
+        assert!(working_memory(11648, 8736, true, true, &opts, 1).is_err());
+    }
+
+    #[test]
+    fn working_memory_accounts_for_padding_and_at_least_one_ahd_band() {
+        let mut opts = DevelopOptions { demosaic: Demosaic::Ahd, ..Default::default() };
+        opts.limits.max_alloc = 100 * 100 * 22;
+        assert!(working_memory(100, 100, true, true, &opts, 1).is_err());
+        opts.demosaic = Demosaic::Mhc;
+        assert!(working_memory(100, 100, true, true, &opts, 1).is_ok());
+        opts.limits.max_alloc = 100 * 100 * 18;
+        assert!(working_memory(100, 100, false, true, &opts, 1).is_err());
+    }
+
     #[test]
     fn gamma_table_matches_powf() {
         let lut = GammaLut::new();
diff --git a/crates/raw/src/dng.rs b/crates/raw/src/dng.rs
index 5ff9fd14d1..e8422b5419 100644
--- a/crates/raw/src/dng.rs
+++ b/crates/raw/src/dng.rs
@@ -271,6 +271,7 @@ pub(crate) fn decode(t: &Tiff, limits: &Limits) -> Result<Sensor> {
         baseline_exposure: if baseline_exposure.is_finite() { baseline_exposure.clamp(-10.0, 10.0) } else { 0.0 },
         gain_maps,
         tone_curve: Vec::new(),
+        black_point: 0.0,
         warnings,
     })
 }
diff --git a/crates/raw/src/lib.rs b/crates/raw/src/lib.rs
index b9f4f1c6ec..0bccf8ffac 100644
--- a/crates/raw/src/lib.rs
+++ b/crates/raw/src/lib.rs
@@ -32,9 +32,9 @@
 //! tiles, CFA and LinearRaw), CR2 (lossless JPEG with Canon slices), uncompressed or
 //! lossless-JPEG TIFF/EP raws (NEF, ARW, PEF… when not vendor-compressed),
 //! Nikon compressed NEF (lossless and lossy), Sony compressed ARW (cRAW),
-//! Panasonic RW2 (RawFormat 5), uncompressed Olympus ORF and uncompressed
-//! Fujifilm RAF (Bayer and X-Trans). Everything else reports
-//! [`RawError::Unsupported`].
+//! Panasonic RW2 (RawFormat 5 packed and RawFormat 3/4 vendor-compressed),
+//! uncompressed Olympus ORF and uncompressed Fujifilm RAF (Bayer and
+//! X-Trans). Everything else reports [`RawError::Unsupported`].
 //!
 //! The crate is standalone (no workspace dependencies), does no I/O, builds for
 //! `wasm32-unknown-unknown` and never panics on hostile input: sizes are
@@ -46,6 +46,7 @@
 mod cameras;
 mod color;
 mod cr2;
+mod cr3;
 mod demosaic;
 mod develop;
 mod dng;
@@ -60,10 +61,12 @@ mod par;
 mod preview;
 mod raf;
 mod rw2;
+mod saturation;
 mod sensor;
 mod sony;
 mod tiff;
 mod tiffep;
+mod tone;
 
 #[cfg(feature = "testgen")]
 pub mod testgen;
@@ -74,14 +77,26 @@ pub use crate::develop::{DevelopOptions, Developed, RawInfo, WhiteBalance, devel
 pub use crate::error::RawError;
 pub use crate::look::{CameraLook, LookRejected, PROXY_EDGE, Reference, ToneCurve, fit_look};
 pub use crate::opcodes::GainMap;
-pub use crate::preview::{Preview, embedded_preview, embedded_previews};
+pub use crate::preview::{Preview, PreviewColorSpace, embedded_preview, embedded_preview_color_space, embedded_previews};
 pub use crate::sensor::{BlackLevels, Cfa, Rect, Sensor};
+pub use crate::tone::{Tone, retone};
 
 use crate::tiff::{Tiff, tag};
 
 /// Name of the output colour space of [`develop`].
 pub const OUTPUT_SPACE: &str = "ProPhoto RGB (ROMM primaries, D50, gamma 1.8)";
 
+/// The raw container's orientation, when recorded (CR3 metadata or TIFF IFD0).
+/// Useful for camera JPEGs that carry no orientation of their own.
+pub fn orientation(bytes: &[u8]) -> Option<u16> {
+    if bytes.get(4..12) == Some(b"ftypcrx ") {
+        return cr3::orientation(bytes);
+    }
+    let tiff = Tiff::new(bytes)?;
+    let ifd = tiff.ifd_at(tiff.first_ifd, 0)?;
+    tiff.tag_uint(&ifd, tag::ORIENTATION).filter(|o| (1..=8).contains(o)).map(|o| o as u16)
+}
+
 /// Camera raw container families.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum RawFormat {
@@ -228,7 +243,7 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Sensor, RawError> {
         _ => {
             let t = Tiff::new(bytes).ok_or(RawError::NotRaw)?;
             match format {
-                RawFormat::Dng => dng::decode(&t, limits),
+                RawFormat::Dng => dng::decode(&t, limits).map(lift_clipped),
                 RawFormat::Cr2 => cr2::decode(&t, limits),
                 RawFormat::Rw2 => rw2::decode(&t, limits),
                 RawFormat::Orf => orf::decode(&t, limits),
@@ -238,6 +253,13 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Sensor, RawError> {
     }
 }
 
+/// DNG writers can state a white level the sensor never reaches; samples stuck at the real saturation
+/// point are raised to it so they clip together (see `saturation.rs`).
+fn lift_clipped(mut s: Sensor) -> Sensor {
+    s.lift_clipped_samples();
+    s
+}
+
 /// Decodes a lossless JPEG (T.81 process 14) stream into `(width, height,
 /// components, samples)`; at most `max_samples` samples are allocated.
 /// Exposed for fuzzing and tools.
diff --git a/crates/raw/src/look.rs b/crates/raw/src/look.rs
index 98d2c38026..77a5d38089 100644
--- a/crates/raw/src/look.rs
+++ b/crates/raw/src/look.rs
@@ -26,6 +26,10 @@
 //! axis, the camera's rendering of white, still follows the JPEG). Cells with a
 //! clipped sensor sample, clipped or near-black JPEG pixels are left out of the
 //! fit; cells on strong edges get less weight.
+//! A bounded centered alignment (90–100% of the raw frame's dimensions) can
+//! account for a camera JPEG's tighter framing. It changes only the fit proxy,
+//! requires correlation ≥ 0.9 and an improvement ≥ 0.05, and preserves the
+//! developed crop. Alignment uses training cells; held-out cells stay out of it.
 //!
 //! The reference must show the same picture (lightness correlation ≥ 0.7 with
 //! the raw) in colour (≥ 2 % of the cells with chroma above 4). One cell in
@@ -194,10 +198,97 @@ struct Cell {
 /// Fits a [`CameraLook`] so that developing `s` with `opts` (white balance,
 /// baseline exposure) matches the camera's `reference` rendering of it.
 pub fn fit_look(s: &Sensor, opts: &DevelopOptions, reference: &Reference) -> Result<CameraLook, LookRejected> {
-    let (gw, cells) = grid(s, opts, reference)?;
+    let (gw, mut cells) = grid(s, opts, reference)?;
+    align_preview(&mut cells, gw, s.baseline_exposure);
     fit_cells(&cells, gw, s.baseline_exposure)
 }
 
+/// Camera JPEGs can show a slightly tighter frame (lens correction, for example).
+/// Align only the fit proxy, never the developed crop. Search a bounded centered
+/// crop of at most 10%, and require a strong, substantially improved match.
+fn align_preview(cells: &mut [Cell], w: usize, exposure: f64) {
+    if w == 0 || cells.len() < w || !cells.len().is_multiple_of(w) {
+        return;
+    }
+    let h = cells.len() / w;
+    let gain = 2f64.powf(if exposure.is_finite() { exposure.clamp(-10.0, 10.0) } else { 0.0 });
+    let fallback = color::scale(&color::mul(&color::xyz_d50_to_prophoto(), &color::srgb_to_xyz_d50()), gain);
+    let step = (w / 64).max(1);
+    let score = |scale: f64| {
+        let mut pairs = Vec::new();
+        for y in (0..h).step_by(step) {
+            for x in (0..w).step_by(step) {
+                if (x + 2 * y) % 3 == 0 {
+                    continue;
+                }
+                let Some(c) = cells.get(y * w + x) else { continue };
+                let Some((cam, clipped)) = aligned_camera(cells, w, h, x, y, scale) else { continue };
+                if clipped || c.ref_clipped >= 0.01 || c.lum <= 0.002 || c.edge_weight <= 0.05 || cam.iter().any(|v| !v.is_finite() || *v <= 1e-4) {
+                    continue;
+                }
+                let lum = color::apply(&PRO_TO_XYZ_Y_ROW, color::apply(&fallback, cam))[0];
+                pairs.push((lum.max(0.0).sqrt(), c.lum.sqrt()));
+            }
+        }
+        if pairs.len() < 100 { f64::NAN } else { correlation(&pairs) }
+    };
+    let original = score(1.0);
+    if !original.is_finite() {
+        return;
+    }
+    let (mut best, mut scale) = (original, 1.0);
+    for i in 0..5 {
+        let s = 0.9 + 0.02 * i as f64;
+        let r = score(s);
+        if r > best {
+            (best, scale) = (r, s);
+        }
+    }
+    if scale < 1.0 {
+        let center = scale;
+        for i in -7..=7 {
+            let s = (center + 0.0025 * f64::from(i)).clamp(0.9, 1.0);
+            let r = score(s);
+            if r > best {
+                (best, scale) = (r, s);
+            }
+        }
+    }
+    if best < 0.9 || best < original + 0.05 || scale >= 1.0 {
+        return;
+    }
+    let aligned: Vec<_> = (0..cells.len()).map(|i| aligned_camera(cells, w, h, i % w, i / w, scale)).collect();
+    for (c, aligned) in cells.iter_mut().zip(aligned) {
+        if let Some((cam, clipped)) = aligned {
+            c.cam = cam;
+            c.cam_clipped = clipped;
+        }
+    }
+}
+
+/// Bilinear interpolation on cell centers, retaining clipping information from
+/// every participating cell. Coordinates remain inside the bounded fit grid.
+fn aligned_camera(cells: &[Cell], w: usize, h: usize, x: usize, y: usize, scale: f64) -> Option<([f64; 3], bool)> {
+    let coord = |i: usize, n: usize| ((i as f64 + 0.5 - n as f64 / 2.0) * scale + n as f64 / 2.0 - 0.5).clamp(0.0, n.saturating_sub(1) as f64);
+    let (sx, sy) = (coord(x, w), coord(y, h));
+    let (x0, y0) = (sx.floor() as usize, sy.floor() as usize);
+    let (fx, fy) = (sx - x0 as f64, sy - y0 as f64);
+    let mut cam = [0.0; 3];
+    let mut clipped = false;
+    for (dx, dy, weight) in [(0, 0, (1.0 - fx) * (1.0 - fy)), (1, 0, fx * (1.0 - fy)), (0, 1, (1.0 - fx) * fy), (1, 1, fx * fy)] {
+        if weight <= 0.0 {
+            continue;
+        }
+        let index = y0.saturating_add(dy).min(h.saturating_sub(1)).checked_mul(w)?.checked_add(x0.saturating_add(dx).min(w.saturating_sub(1)))?;
+        let c = cells.get(index)?;
+        clipped |= c.cam_clipped;
+        for (out, v) in cam.iter_mut().zip(c.cam) {
+            *out += weight * v;
+        }
+    }
+    Some((cam, clipped))
+}
+
 /// The upright fit grid: (width in cells, cells row-major).
 fn grid(s: &Sensor, opts: &DevelopOptions, r: &Reference) -> Result<(usize, Vec<Cell>), LookRejected> {
     let c = s.crop;
@@ -817,6 +908,28 @@ mod tests {
         assert_ne!(d.rgb, plain.rgb);
     }
 
+    #[test]
+    fn tighter_camera_preview_aligns_for_color_without_changing_the_raw_crop() {
+        let (w, h) = (480, 320);
+        let (s, rgb) = shot(w, h, &true_matrix());
+        let (x0, y0, cw, ch) = (24, 16, 432, 288);
+        let mut tight = Vec::with_capacity(cw * ch * 3);
+        for y in y0..y0 + ch {
+            tight.extend_from_slice(&rgb[(y * w + x0) * 3..(y * w + x0 + cw) * 3]);
+        }
+        let reference = Reference { width: cw as u32, height: ch as u32, rgb: &tight };
+        let (gw, plain) = grid(&s, &wb_opts(), &reference).unwrap();
+        let before = fit_cells(&plain, gw, s.baseline_exposure);
+        let look = fit_look(&s, &wb_opts(), &reference).unwrap();
+        assert!(look.delta_e < 3.0, "{look:?}");
+        if let Ok(before) = before {
+            assert!(look.delta_e < before.delta_e * 0.5, "aligned {look:?}, before {before:?}");
+        }
+        let d = crate::develop_sensor(&s, &DevelopOptions { camera_look: Some(look), ..wb_opts() }).unwrap();
+        assert_eq!((d.width as usize, d.height as usize), (w, h));
+        assert_eq!(s.crop, crate::Rect::new(0, 0, w, h));
+    }
+
     #[test]
     fn follows_the_raw_orientation() {
         let (w, h) = (480, 320);
diff --git a/crates/raw/src/orf.rs b/crates/raw/src/orf.rs
index ba15926725..9271aff93d 100644
--- a/crates/raw/src/orf.rs
+++ b/crates/raw/src/orf.rs
@@ -150,6 +150,7 @@ pub(crate) fn decode(t: &Tiff, limits: &Limits) -> Result<Sensor> {
         baseline_exposure: 0.0,
         gain_maps: Vec::new(),
         tone_curve: Vec::new(),
+        black_point: 0.0,
         warnings,
     })
 }
diff --git a/crates/raw/src/par.rs b/crates/raw/src/par.rs
index a8e2c9f949..6d23fd70c4 100644
--- a/crates/raw/src/par.rs
+++ b/crates/raw/src/par.rs
@@ -12,6 +12,35 @@ pub(crate) fn chunks_mut<T: Send>(buf: &mut [T], chunk: usize, f: impl Fn(usize,
     buf.chunks_mut(chunk).enumerate().for_each(|(i, c)| f(i, c));
 }
 
+/// Native worker count (the browser builds run sequentially).
+pub(crate) fn workers() -> usize {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        rayon::current_num_threads()
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        1
+    }
+}
+
+/// Processes normal-sized chunks with at most `jobs` live scratch buffers.
+pub(crate) fn chunks_mut_limited<T: Send>(buf: &mut [T], chunk: usize, jobs: usize, f: impl Fn(usize, &mut [T]) + Sync + Send) {
+    let chunk = chunk.max(1);
+    // Each worker holds one band's scratch at a time. When the normal worker
+    // count fits, preserve Rayon's fine-grained load balancing.
+    if jobs >= workers() {
+        chunks_mut(buf, chunk, f);
+        return;
+    }
+    let per_group = buf.len().div_ceil(chunk).div_ceil(jobs.max(1)).max(1);
+    chunks_mut(buf, chunk.saturating_mul(per_group), |group, part| {
+        for (local, c) in part.chunks_mut(chunk).enumerate() {
+            f(group * per_group + local, c);
+        }
+    });
+}
+
 /// Maps `f` over `0..n`, keeping order.
 pub(crate) fn map<T: Send>(n: usize, f: impl Fn(usize) -> T + Sync + Send) -> Vec<T> {
     #[cfg(not(target_arch = "wasm32"))]
diff --git a/crates/raw/src/preview.rs b/crates/raw/src/preview.rs
index 4007706035..d5dd013310 100644
--- a/crates/raw/src/preview.rs
+++ b/crates/raw/src/preview.rs
@@ -41,13 +41,13 @@ fn dct_jpeg_size(b: &[u8]) -> Option<(u32, u32)> {
     None
 }
 
-fn candidate(data: &[u8], offset: usize, len: usize) -> Option<Preview<'_>> {
+pub(crate) fn candidate(data: &[u8], offset: usize, len: usize) -> Option<Preview<'_>> {
     let jpeg = data.get(offset..offset.checked_add(len)?)?;
     let (width, height) = dct_jpeg_size(jpeg)?;
     Some(Preview { jpeg, width, height })
 }
 
-/// The largest embedded JPEG preview of a raw file (TIFF-based raws and RAF).
+/// The largest embedded JPEG preview of a raw file (TIFF-based raws, RAF and CR3).
 pub fn embedded_preview(bytes: &[u8]) -> Option<Preview<'_>> {
     embedded_previews(bytes).into_iter().max_by_key(|p| u64::from(p.width) * u64::from(p.height))
 }
@@ -56,7 +56,9 @@ pub fn embedded_preview(bytes: &[u8]) -> Option<Preview<'_>> {
 /// full-size and a smaller rendering of the same picture).
 pub fn embedded_previews(bytes: &[u8]) -> Vec<Preview<'_>> {
     let mut found: Vec<Preview> = Vec::new();
-    if bytes.starts_with(crate::raf::MAGIC) {
+    if bytes.get(4..12) == Some(b"ftypcrx ") {
+        found = crate::cr3::previews(bytes);
+    } else if bytes.starts_with(crate::raf::MAGIC) {
         // RAF header: big-endian JPEG offset and length at bytes 84 and 88.
         if let Some((off, len)) = crate::raf::preview_range(bytes) {
             found.extend(candidate(bytes, off, len));
@@ -97,3 +99,72 @@ pub fn embedded_previews(bytes: &[u8]) -> Vec<Preview<'_>> {
     });
     found
 }
+
+/// The colour space a raw file states for its embedded previews, which carry no ICC profile of their own.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PreviewColorSpace {
+    Srgb,
+    AdobeRgb,
+}
+
+/// The colour space the raw's EXIF gives for the camera's JPEG rendering, for a preview that declares none itself:
+/// ColorSpace (0xA001) 1 = sRGB, or Uncalibrated (0xFFFF) with the Interoperability IFD's InteropIndex "R03", the
+/// DCF option file for Adobe RGB (as a Sony body set to Adobe RGB writes; Exif and DCF specifications). `None` when
+/// the file doesn't say, and for a DNG, whose EXIF describes the original capture while its previews are the
+/// converter's. A preview's own ICC profile takes precedence over this.
+pub fn embedded_preview_color_space(bytes: &[u8]) -> Option<PreviewColorSpace> {
+    let t = Tiff::new(bytes)?;
+    let ifd0 = t.ifd_at(t.first_ifd, 0)?;
+    if ifd0.has(tag::DNG_VERSION) {
+        return None;
+    }
+    let exif = t.ifd_at(t.tag_uint(&ifd0, tag::EXIF_IFD)? as usize, 0)?;
+    match t.tag_uint(&exif, tag::COLOR_SPACE)? {
+        1 => Some(PreviewColorSpace::Srgb),
+        0xFFFF => {
+            let interop = t.ifd_at(t.tag_uint(&exif, tag::INTEROP_IFD)? as usize, 0)?;
+            t.raw(interop.get(tag::INTEROP_INDEX)?)?.starts_with(b"R03").then_some(PreviewColorSpace::AdobeRgb)
+        }
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testgen::{TiffBuilder, Val};
+
+    /// A raw-like TIFF whose EXIF IFD has `color_space` and, when given, an Interoperability IFD with `index`.
+    fn raw_with(color_space: Option<u16>, index: Option<&str>, dng: bool) -> Vec<u8> {
+        let mut t = TiffBuilder::default();
+        let mut exif = Vec::new();
+        if let Some(cs) = color_space {
+            exif.push((tag::COLOR_SPACE, Val::Short(vec![cs])));
+        }
+        if let Some(index) = index {
+            let interop = t.ifd(vec![(tag::INTEROP_INDEX, Val::Ascii(index.into()))]);
+            exif.push((tag::INTEROP_IFD, Val::Ifds(vec![interop])));
+        }
+        let exif = t.ifd(exif);
+        let mut ifd0 = vec![(tag::MAKE, Val::Ascii("SONY".into())), (tag::EXIF_IFD, Val::Ifds(vec![exif]))];
+        if dng {
+            ifd0.push((tag::DNG_VERSION, Val::Byte(vec![1, 6, 0, 0])));
+        }
+        t.chain = vec![t.ifd(ifd0)];
+        t.build()
+    }
+
+    #[test]
+    fn exif_colour_space_of_the_previews() {
+        assert_eq!(embedded_preview_color_space(&raw_with(Some(1), Some("R98"), false)), Some(PreviewColorSpace::Srgb));
+        assert_eq!(embedded_preview_color_space(&raw_with(Some(0xFFFF), Some("R03"), false)), Some(PreviewColorSpace::AdobeRgb));
+        for (cs, index) in [(Some(0xFFFF), Some("R98")), (Some(0xFFFF), None), (Some(2), Some("R03")), (None, Some("R03"))] {
+            assert_eq!(embedded_preview_color_space(&raw_with(cs, index, false)), None, "{cs:?} {index:?}");
+        }
+        // a DNG's previews are the converter's, whatever the capture was
+        assert_eq!(embedded_preview_color_space(&raw_with(Some(0xFFFF), Some("R03"), true)), None);
+        for junk in [&b""[..], b"II*\0", b"II*\0\x08\0\0\0\xff\xff", b"not a tiff at all"] {
+            assert_eq!(embedded_preview_color_space(junk), None);
+        }
+    }
+}
diff --git a/crates/raw/src/raf.rs b/crates/raw/src/raf.rs
index dee720b6b4..cb794889d4 100644
--- a/crates/raw/src/raf.rs
+++ b/crates/raw/src/raf.rs
@@ -302,6 +302,7 @@ pub(crate) fn decode(bytes: &[u8], limits: &Limits) -> Result<Sensor> {
         baseline_exposure,
         gain_maps: Vec::new(),
         tone_curve: Vec::new(),
+        black_point: 0.0,
         warnings,
     })
 }
diff --git a/crates/raw/src/rw2.rs b/crates/raw/src/rw2.rs
index fe1e0b2ab9..c50d32c09c 100644
--- a/crates/raw/src/rw2.rs
+++ b/crates/raw/src/rw2.rs
@@ -1,5 +1,6 @@
-//! Panasonic / Leica RW2 with the bit-packed sensor layout (PanasonicRaw
-//! RawFormat 5, written by recent Lumix bodies).
+//! Panasonic / Leica RW2: the bit-packed stream of recent Lumix bodies
+//! (PanasonicRaw RawFormat 5) and the vendor-compressed stream of the earlier
+//! ones (RawFormat 3 and 4).
 //!
 //! The container is TIFF-like (`IIU\0`); IFD0 holds Panasonic's own tags,
 //! whose ids and meanings are public (ExifTool's PanasonicRaw table):
@@ -9,7 +10,7 @@
 //! WB{Red,Green,Blue}Level (0x24–0x26), RawFormat (0x2D) and RawDataOffset
 //! (0x118).
 //!
-//! The packing was established by observation of sample files:
+//! RawFormat 5 — the packing was established by observation of sample files:
 //!
 //! * From RawDataOffset the data is stored in pages of 0x4000 bytes, each
 //!   page split at 0x1FF8 with its second part first (the logical page is
@@ -19,8 +20,26 @@
 //!   the least significant bit up, the remaining top bits unused; rows are
 //!   whole blocks.
 //!
-//! The older RawFormat 4 (and earlier) store vendor-compressed data, which is
-//! not decoded.
+//! RawFormat 3 and 4 — the vendor-compressed layout, also established by
+//! observation of sample files (verified by decoding whole frames against the
+//! camera's embedded JPEG and the recorded levels):
+//!
+//! * The payload at RawDataOffset is a fixed-rate stream: 16 bytes per 14
+//!   pixels, so a row occupies `width / 14 * 16` bytes and rows are
+//!   byte-aligned. Bits are consumed down from the top of each 0x4000-byte
+//!   page, through the same page split as RawFormat 5 (`(i + 0x4000 - 0x2008)
+//!   % 0x4000`), reading fields LSB-first from the little-endian 16-bit word
+//!   the cursor points at.
+//! * Pixels arrive in groups of 14 with two predictors carried over from one
+//!   group to the next (even and odd columns). Every third pixel carries a
+//!   2-bit scale selector `sh` (0, 1, 2 or 4). The first value of each parity
+//!   is absolute (8 + 4 bits); the rest are 8-bit deltas around 0x80 scaled
+//!   by `sh`, wrapping in the low `sh` bits.
+//! * The decoded samples sit 15 counts above the recorded BlackLevel tags
+//!   (measured on the darkest pixels of sample files), so 15 is added when
+//!   they are read.
+//!
+//! Every other RawFormat value is not decoded.
 
 use crate::error::{RawError, Result};
 use crate::sensor::{BlackLevels, Cfa, Rect, Sensor};
@@ -44,6 +63,8 @@ const RAW_DATA_OFFSET: u16 = 0x0118;
 /// Page size and split point of the stored stream (observed).
 const PAGE: usize = 0x4000;
 const SPLIT: usize = 0x1FF8;
+/// Byte split of the vendor-compressed stream (observed).
+const COMPRESSED_SPLIT: usize = 0x2008;
 
 /// Physical offset (relative to RawDataOffset) of logical byte `i`.
 #[inline]
@@ -75,34 +96,13 @@ pub(crate) fn unpack_block(b: &[u8; 16], bits: u32, out: &mut [u16]) {
     }
 }
 
-pub(crate) fn decode(t: &Tiff, limits: &Limits) -> Result<Sensor> {
-    let ifd = t.ifd_at(t.first_ifd, 0).ok_or_else(|| RawError::malformed("RW2 has no IFD0"))?;
-    let raw_format = t.tag_uint(&ifd, RAW_FORMAT);
-    if raw_format != Some(5) {
-        let f = raw_format.map(|v| v.to_string()).unwrap_or_else(|| "unknown".into());
-        return Err(RawError::unsupported(format!("Panasonic RW2 raw format {f} (vendor-compressed) is not decoded yet")));
-    }
-    let width = t.tag_uint(&ifd, SENSOR_WIDTH).ok_or_else(|| RawError::malformed("RW2 has no sensor width"))? as usize;
-    let height = t.tag_uint(&ifd, SENSOR_HEIGHT).ok_or_else(|| RawError::malformed("RW2 has no sensor height"))? as usize;
-    let bits = t.tag_uint(&ifd, BITS_PER_SAMPLE).unwrap_or(12);
+/// Reads the bit-packed RawFormat 5 stream (`src` starts at RawDataOffset).
+fn decode_packed(src: &[u8], width: usize, height: usize, bits: u32) -> Result<Vec<u16>> {
     let ppb = pixels_per_block(bits).ok_or_else(|| RawError::unsupported(format!("Panasonic RW2 with {bits}-bit samples")))?;
     if !width.is_multiple_of(ppb) {
         return Err(RawError::unsupported(format!("Panasonic RW2 {width} pixels wide (not whole {ppb}-pixel blocks)")));
     }
-    limits.check(width as u64, height as u64, 2)?;
-    let cfa = match t.tag_uint(&ifd, CFA_PATTERN) {
-        Some(1) => "RGGB",
-        Some(2) => "GRBG",
-        Some(3) => "GBRG",
-        Some(4) => "BGGR",
-        _ => return Err(RawError::unsupported("Panasonic RW2 without a CFA pattern")),
-    };
-    let cfa = Cfa::bayer(cfa).ok_or_else(|| RawError::malformed("bad CFA"))?;
-    let offset =
-        t.tag_uint(&ifd, RAW_DATA_OFFSET).or_else(|| t.tag_uint(&ifd, tag::STRIP_OFFSETS)).ok_or_else(|| RawError::malformed("RW2 has no raw data offset"))?
-            as usize;
     let row_bytes = width / ppb * 16;
-    let src = t.data.get(offset..).ok_or_else(|| RawError::malformed("RW2 raw data lies outside the file"))?;
     let need = row_bytes * height;
     // Whole pages are stored; tolerate a short final page (its missing bytes read as 0).
     if src.len() < need.saturating_sub(PAGE) {
@@ -124,11 +124,138 @@ pub(crate) fn decode(t: &Tiff, limits: &Limits) -> Result<Sensor> {
             }
         }
     });
+    Ok(data)
+}
+
+/// LSB-first bit cursor of the vendor-compressed stream: it walks down from
+/// the top of each 0x4000-byte page (addressed through `COMPRESSED_SPLIT`)
+/// and refills by advancing one page.
+struct Bits<'a> {
+    buf: &'a [u8],
+    base: usize,
+    pos: usize,
+    nbits: u32,
+}
+
+impl<'a> Bits<'a> {
+    fn new(buf: &'a [u8], base: usize) -> Self {
+        Bits { buf, base, pos: 0, nbits: 0 }
+    }
+
+    #[inline]
+    fn get(&mut self, num: u32) -> u32 {
+        if num > self.nbits {
+            self.nbits += PAGE as u32 * 8;
+            self.pos += PAGE;
+        }
+        let mut at = ((self.nbits - num) >> 3) as usize ^ 0x3FF0;
+        at = (at + PAGE - COMPRESSED_SPLIT) % PAGE;
+        let at = self.base + at + self.pos - PAGE;
+        self.nbits -= num;
+        // Out-of-range reads (a page short at the end of the file) read as 0.
+        let lo = u32::from(self.buf.get(at).copied().unwrap_or(0));
+        let hi = u32::from(self.buf.get(at + 1).copied().unwrap_or(0));
+        ((lo | (hi << 8)) >> (self.nbits & 7)) & ((1u32 << num) - 1)
+    }
+}
+
+/// Decodes one row of the vendor-compressed stream.
+fn compressed_row(buf: &[u8], row_bytes: usize, row: usize, out: &mut [u16]) {
+    let skip = row_bytes * row;
+    let mut bits = Bits::new(buf, skip / PAGE * PAGE);
+    for _ in 0..(skip % PAGE) {
+        bits.get(8);
+    }
+    let mut sh: i32 = 0;
+    for group in out.as_chunks_mut::<14>().0 {
+        let mut pred = [0i32; 2];
+        let mut nonz = [0i32; 2];
+        for (i, px) in group.iter_mut().enumerate() {
+            if i % 3 == 2 {
+                sh = 4 >> (3 - bits.get(2));
+            }
+            let p = i & 1;
+            if nonz[p] != 0 {
+                let j = bits.get(8) as i32;
+                if j != 0 {
+                    pred[p] -= 0x80 << sh;
+                    if pred[p] < 0 || sh == 4 {
+                        pred[p] &= !(-1 << sh);
+                    }
+                    pred[p] += j << sh;
+                }
+            } else {
+                nonz[p] = bits.get(8) as i32;
+                if nonz[p] != 0 || i > 11 {
+                    pred[p] = (nonz[p] << 4) | bits.get(4) as i32;
+                }
+            }
+            *px = pred[p] as u16;
+        }
+    }
+}
+
+/// Reads the vendor-compressed RawFormat 3/4 stream (`src` starts at
+/// RawDataOffset).
+fn decode_compressed(src: &[u8], width: usize, height: usize, bits: u32) -> Result<Vec<u16>> {
+    if bits != 12 {
+        return Err(RawError::unsupported(format!("Panasonic RW2 with {bits}-bit compressed samples")));
+    }
+    if !width.is_multiple_of(14) {
+        return Err(RawError::unsupported(format!("Panasonic RW2 {width} pixels wide (not whole 14-pixel blocks)")));
+    }
+    let row_bytes = width / 14 * 16;
+    let need = row_bytes * height;
+    // Whole pages are stored; tolerate a short final page (its missing bytes read as 0).
+    if src.len() < need.saturating_sub(PAGE) {
+        return Err(RawError::malformed("RW2 raw data is truncated"));
+    }
+    let mut data = vec![0u16; width * height];
+    let band = par::band_rows(width);
+    par::chunks_mut(&mut data, band * width, |i, chunk| {
+        for (r, out) in chunk.chunks_exact_mut(width).enumerate() {
+            compressed_row(src, row_bytes, i * band + r, out);
+        }
+    });
+    Ok(data)
+}
+
+pub(crate) fn decode(t: &Tiff, limits: &Limits) -> Result<Sensor> {
+    let ifd = t.ifd_at(t.first_ifd, 0).ok_or_else(|| RawError::malformed("RW2 has no IFD0"))?;
+    let raw_format = t.tag_uint(&ifd, RAW_FORMAT);
+    let compressed = match raw_format {
+        Some(5) => false,
+        Some(3 | 4) => true,
+        other => {
+            let f = other.map(|v| v.to_string()).unwrap_or_else(|| "unknown".into());
+            return Err(RawError::unsupported(format!("Panasonic RW2 raw format {f} (vendor-compressed) is not decoded yet")));
+        }
+    };
+    let width = t.tag_uint(&ifd, SENSOR_WIDTH).ok_or_else(|| RawError::malformed("RW2 has no sensor width"))? as usize;
+    let height = t.tag_uint(&ifd, SENSOR_HEIGHT).ok_or_else(|| RawError::malformed("RW2 has no sensor height"))? as usize;
+    limits.check(width as u64, height as u64, 2)?;
+    let bits = t.tag_uint(&ifd, BITS_PER_SAMPLE).unwrap_or(12);
+    let cfa = match t.tag_uint(&ifd, CFA_PATTERN) {
+        Some(1) => "RGGB",
+        Some(2) => "GRBG",
+        Some(3) => "GBRG",
+        Some(4) => "BGGR",
+        _ => return Err(RawError::unsupported("Panasonic RW2 without a CFA pattern")),
+    };
+    let cfa = Cfa::bayer(cfa).ok_or_else(|| RawError::malformed("bad CFA"))?;
+    let offset =
+        t.tag_uint(&ifd, RAW_DATA_OFFSET).or_else(|| t.tag_uint(&ifd, tag::STRIP_OFFSETS)).ok_or_else(|| RawError::malformed("RW2 has no raw data offset"))?
+            as usize;
+    let src = t.data.get(offset..).ok_or_else(|| RawError::malformed("RW2 raw data lies outside the file"))?;
+    let data = if compressed { decode_compressed(src, width, height, bits)? } else { decode_packed(src, width, height, bits)? };
 
     let full = Rect::new(0, 0, width, height);
     let level = |tg: u16| t.tag_uint(&ifd, tg).map(f64::from);
     let mut warnings = Vec::new();
-    let black = match BLACK_LEVEL.map(level) {
+    // The compressed variants record a black level 15 counts below the decoded black.
+    let black_offset = if compressed { 15.0 } else { 0.0 };
+    let black_level = |tg: u16| t.tag_uint(&ifd, tg).map(|v| f64::from(v) + black_offset);
+    let black = match BLACK_LEVEL.map(black_level) {
         [Some(r), Some(g), Some(b)] => {
             let v = cfa.phase(0, 0).map(|c| [r, g, b][usize::from(c).min(2)] as f32);
             BlackLevels { rows: 2, cols: 2, values: v.to_vec(), delta_h: Vec::new(), delta_v: Vec::new() }
@@ -170,6 +297,7 @@ pub(crate) fn decode(t: &Tiff, limits: &Limits) -> Result<Sensor> {
         baseline_exposure: 0.0,
         gain_maps: Vec::new(),
         tone_curve: Vec::new(),
+        black_point: 0.0,
         warnings,
     })
 }
@@ -203,4 +331,76 @@ mod tests {
         assert_eq!(&out[..9], &[0x3FFF; 9]);
         assert_eq!(&out[9..], &[0; 3]);
     }
+
+    #[test]
+    fn compressed_bits_walk_down_pages() {
+        // A fresh cursor reads the word at 0x2007 first (the top of the first
+        // page under the compressed split), then walks down.
+        let mut buf = vec![0u8; 0x4000];
+        buf[0x2007] = 0xAC;
+        buf[0x2008] = 0x03;
+        buf[0x2006] = 0x11;
+        buf[0x2017] = 0x55;
+        // A 4-bit field starts in the high nibble of the top word.
+        let mut b = Bits::new(&buf, 0);
+        assert_eq!(b.get(4), 0xA);
+        let mut b = Bits::new(&buf, 0);
+        assert_eq!(b.get(8), 0xAC);
+        assert_eq!(b.get(8), 0x11);
+        // 16 bytes later the cursor wraps to the end of the next 16-byte run.
+        for _ in 0..14 {
+            b.get(8);
+        }
+        assert_eq!(b.get(8), 0x55);
+    }
+
+    #[test]
+    fn compressed_group_walks_predictors() {
+        // One 14-pixel group: both parities start absolute, a delta of 0x80
+        // keeps their value, and the scale selector is written before the
+        // delta of every third pixel. The test writer mirrors `Bits` so the
+        // fields land where the decoder reads them.
+        let mut buf = vec![0u8; 0x4000];
+        {
+            let mut w = TestWriter { buf: &mut buf, pos: 0, nbits: 0 };
+            w.put(0x10, 8);
+            w.put(0x5, 4);
+            w.put(0x2A, 8);
+            w.put(0xA, 4);
+            for i in 2..14 {
+                if i % 3 == 2 {
+                    w.put(0, 2);
+                }
+                w.put(0x80, 8);
+            }
+        }
+        let mut out = [0u16; 14];
+        compressed_row(&buf, 16, 0, &mut out);
+        assert_eq!(out, [0x105, 0x2AA, 0x105, 0x2AA, 0x105, 0x2AA, 0x105, 0x2AA, 0x105, 0x2AA, 0x105, 0x2AA, 0x105, 0x2AA]);
+    }
+
+    /// Mirror of [`Bits`] for unit tests: deposits fields where the reader
+    /// will pick them up.
+    struct TestWriter<'a> {
+        buf: &'a mut [u8],
+        pos: usize,
+        nbits: u32,
+    }
+
+    impl TestWriter<'_> {
+        fn put(&mut self, v: u32, num: u32) {
+            if num > self.nbits {
+                self.nbits += PAGE as u32 * 8;
+                self.pos += PAGE;
+            }
+            let mut at = ((self.nbits - num) >> 3) as usize ^ 0x3FF0;
+            at = (at + PAGE - COMPRESSED_SPLIT) % PAGE;
+            let at = at + self.pos - PAGE;
+            self.nbits -= num;
+            let cur = u32::from(self.buf[at]) | (u32::from(self.buf[at + 1]) << 8);
+            let cur = cur | ((v & ((1 << num) - 1)) << (self.nbits & 7));
+            self.buf[at] = cur as u8;
+            self.buf[at + 1] = (cur >> 8) as u8;
+        }
+    }
 }
diff --git a/crates/raw/src/saturation.rs b/crates/raw/src/saturation.rs
new file mode 100644
index 0000000000..a36692a3f6
--- /dev/null
+++ b/crates/raw/src/saturation.rs
@@ -0,0 +1,265 @@
+//! Sensors that clip below the stated white level.
+//!
+//! A DNG's `WhiteLevel` is what the writer says the samples top out at, not always where the sensor
+//! really saturates: a camera app can state 4095 for 12-bit data that piles up at 3567 (85 % of the
+//! range above black, storytold/photocraft#4348, as storytold/lightcraft#548). Development clips each
+//! channel at 1 after white balance, so samples stuck 15 % below the white level are not clipped
+//! together: red and blue (multiplied by more than green) reach 1, green stays at 0.85, and blown
+//! highlights turn magenta.
+//!
+//! [`Sensor::lift_clipped_samples`] finds the real saturation point of each colour from the samples
+//! (a pile-up of identical values near the top of the range) and raises the samples at or above it to
+//! the stated white level. Unclipped samples keep their values, and a file whose data reaches its white
+//! level, or has no pile-up, is left alone. Same detector as storytold/lightcraft#586.
+
+use crate::sensor::Sensor;
+
+/// A saturation plateau must hold at least this share of its colour's samples (and 100 of them), as
+/// many must lie below it (a scene, not a flat field)...
+const MIN_SHARE: f64 = 1e-4;
+/// ...be at least this many times as populated as the average value just below it...
+const MIN_SPIKE: f64 = 16.0;
+/// ...and have next to nothing above it (a real clip point is the top of the data; a popular value in
+/// the middle of sparse or curve-coded data has plenty of samples above): at most this share of the
+/// plateau lies more than `ABOVE_MARGIN` of the range over it (noise spilling past the plateau).
+const MAX_ABOVE: f64 = 0.02;
+const ABOVE_MARGIN: f32 = 0.01;
+/// Plateaus within this share of the range from the white level are the white level (no lift needed).
+const NEAR_WHITE: f32 = 0.03;
+/// How far below the plateau the "average value just below it" reaches.
+const NEIGHBOURHOOD: usize = 64;
+
+impl Sensor {
+    /// The value each colour's samples saturate at, when that is clearly below the stated white level
+    /// (see the module docs). Only CFA data without a linearization table is examined: with a table the
+    /// stored values are not on the white level's scale.
+    pub(crate) fn saturation_points(&self) -> [Option<u16>; 3] {
+        let none = [None; 3];
+        let Some(cfa) = &self.cfa else { return none };
+        if self.samples != 1 || self.linearization.is_some() || self.width.checked_mul(self.height) != Some(self.data.len()) {
+            return none;
+        }
+        let white = self.white[0];
+        let black = if self.black.values.is_empty() { 0.0 } else { self.black.values.iter().sum::<f32>() / self.black.values.len() as f32 };
+        // a hostile file can state any levels: NaN, negative or inverted ones are left alone
+        if !(black.is_finite() && white.is_finite() && black >= 0.0 && white > black && white <= 65535.0) {
+            return none;
+        }
+        let a = self.active;
+        let fits = |start: usize, len: usize, max: usize| start.checked_add(len).is_some_and(|end| end <= max);
+        if !fits(a.x, a.width, self.width) || !fits(a.y, a.height, self.height) {
+            return none;
+        }
+        let lo = (black + 0.5 * (white - black)).ceil() as usize;
+        let hi = white as usize;
+        if lo + NEIGHBOURHOOD >= hi {
+            return none;
+        }
+        let mut hist = vec![[0u32; 3]; 65536];
+        let mut total = [0u64; 3];
+        for y in a.y..a.y + a.height {
+            let row = &self.data[y * self.width + a.x..][..a.width];
+            for (x, &v) in (a.x..).zip(row) {
+                let c = usize::from(cfa.color(x, y)).min(2);
+                total[c] += 1;
+                hist[usize::from(v)][c] += 1;
+            }
+        }
+        let mut out = none;
+        for c in 0..3 {
+            // the most populated value of the upper half of the range
+            let Some((v, n)) = (lo..hi).map(|v| (v, hist[v][c])).max_by_key(|&(v, n)| (n, v)) else { continue };
+            let min_n = (total[c] as f64 * MIN_SHARE).max(100.0);
+            if f64::from(n) < min_n || v as f32 >= white - NEAR_WHITE * (white - black) {
+                continue;
+            }
+            // a colour whose samples all sit on one value is a flat field, not a scene that clipped
+            let darker: u64 = hist[..v].iter().map(|h| u64::from(h[c])).sum();
+            if (darker as f64) < min_n {
+                continue;
+            }
+            let below: u64 = (v.saturating_sub(NEIGHBOURHOOD)..v).map(|u| u64::from(hist[u][c])).sum();
+            let from = (v + ((ABOVE_MARGIN * (white - black)) as usize).max(1) + 1).min(hist.len());
+            let above: u64 = hist[from..].iter().map(|h| u64::from(h[c])).sum();
+            if f64::from(n) >= MIN_SPIKE * (below as f64 / NEIGHBOURHOOD as f64).max(1.0) && above as f64 <= MAX_ABOVE * f64::from(n) {
+                out[c] = u16::try_from(v).ok();
+            }
+        }
+        out
+    }
+
+    /// Raises samples at or above their colour's real saturation point ([`Self::saturation_points`]) to
+    /// the stated white level, so development clips them together. Returns how many samples changed
+    /// (0: the data is untouched).
+    pub(crate) fn lift_clipped_samples(&mut self) -> usize {
+        let points = self.saturation_points();
+        if points.iter().all(Option::is_none) {
+            return 0;
+        }
+        let Some(cfa) = self.cfa.clone() else { return 0 };
+        let (a, w) = (self.active, self.width);
+        // the white level itself, rounded up: (white - black) / (white - black) is exactly 1
+        let white = self.white[0].ceil() as u16;
+        let mut changed = 0;
+        for y in a.y..a.y + a.height {
+            let row = &mut self.data[y * w + a.x..][..a.width];
+            for (x, v) in (a.x..).zip(row.iter_mut()) {
+                if let Some(p) = points[usize::from(cfa.color(x, y)).min(2)]
+                    && *v >= p
+                    && *v < white
+                {
+                    *v = white;
+                    changed += 1;
+                }
+            }
+        }
+        changed
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+
+    /// A 64 x 64 RGGB mosaic with a gradient, black 528, white `white`, whose samples above `clip` (when
+    /// given) are stuck at `clip` like a sensor that saturates early.
+    fn sensor_with(clip: Option<u16>, white: f32) -> Sensor {
+        let data = (0..64 * 64)
+            .map(|i| {
+                let v = 528 + ((i % 64) * 60 + (i / 64) * 7) as u16 % 4000;
+                clip.map_or(v, |c| v.min(c))
+            })
+            .collect();
+        Sensor {
+            format: RawFormat::Dng,
+            make: None,
+            model: None,
+            width: 64,
+            height: 64,
+            samples: 1,
+            data,
+            cfa: Cfa::bayer("RGGB"),
+            linearization: None,
+            black: BlackLevels::uniform(528.0),
+            white: [white; 3],
+            active: Rect::new(0, 0, 64, 64),
+            crop: Rect::new(0, 0, 64, 64),
+            color: ColorInfo::default(),
+            camera_wb: None,
+            orientation: 1,
+            baseline_exposure: 0.0,
+            gain_maps: Vec::new(),
+            tone_curve: Vec::new(),
+            black_point: 0.0,
+            warnings: Vec::new(),
+        }
+    }
+
+    /// The gradient of `sensor_with`, wrapped so it never gets near the top of the range.
+    fn without_top(s: &mut Sensor) {
+        for v in s.data.iter_mut() {
+            *v = 528 + (*v - 528) % 3000;
+        }
+    }
+
+    #[test]
+    fn a_pile_up_below_the_white_level_is_found_and_lifted() {
+        let mut s = sensor_with(Some(3567), 4095.0);
+        assert_eq!(s.saturation_points(), [Some(3567); 3]);
+        let before = s.data.clone();
+        assert!(s.lift_clipped_samples() > 100);
+        for (x, y) in before.iter().zip(&s.data) {
+            // plateau samples go to the white level, everything else is untouched
+            assert_eq!(*y, if *x >= 3567 { 4095 } else { *x });
+        }
+        assert_eq!(s.lift_clipped_samples(), 0, "idempotent");
+    }
+
+    #[test]
+    fn data_that_reaches_its_white_level_is_left_alone() {
+        let mut s = sensor_with(Some(4095), 4095.0);
+        let before = s.data.clone();
+        assert_eq!(s.saturation_points(), [None; 3]);
+        assert_eq!(s.lift_clipped_samples(), 0);
+        assert_eq!(s.data, before);
+    }
+
+    #[test]
+    fn data_without_a_pile_up_is_left_alone() {
+        let mut s = sensor_with(None, 4095.0);
+        without_top(&mut s);
+        let before = s.data.clone();
+        assert_eq!(s.saturation_points(), [None; 3]);
+        assert_eq!(s.lift_clipped_samples(), 0);
+        assert_eq!(s.data, before);
+    }
+
+    /// Sparse or curve-coded data has popular values with plenty of samples above them: not a clip point.
+    #[test]
+    fn a_popular_value_with_data_above_it_is_not_a_clip_point() {
+        let mut s = sensor_with(None, 4095.0);
+        without_top(&mut s);
+        for (i, v) in s.data.iter_mut().enumerate() {
+            // a third of the samples sit on one code in the upper half, a few hundred are brighter
+            if i % 3 == 0 {
+                *v = 3000;
+            } else if i % 11 == 0 {
+                *v = 3000 + (i % 700) as u16 + 1;
+            }
+        }
+        assert_eq!(s.saturation_points(), [None; 3]);
+        assert_eq!(s.lift_clipped_samples(), 0);
+    }
+
+    /// A uniform patch (a flat-field test frame) has nothing darker: not a scene that clipped.
+    #[test]
+    fn a_flat_field_is_not_a_clip_point() {
+        let mut s = sensor_with(None, 4095.0);
+        s.data.fill(3000);
+        assert_eq!(s.saturation_points(), [None; 3]);
+        assert_eq!(s.lift_clipped_samples(), 0);
+    }
+
+    #[test]
+    fn a_few_stuck_samples_are_not_a_plateau() {
+        let mut s = sensor_with(None, 4095.0);
+        without_top(&mut s);
+        for v in s.data.iter_mut().take(20) {
+            *v = 3800;
+        }
+        assert_eq!(s.saturation_points(), [None; 3]);
+    }
+
+    /// With a linearization table the stored codes are not on the white level's scale.
+    #[test]
+    fn linearized_data_is_left_alone() {
+        let mut s = sensor_with(Some(3567), 4095.0);
+        s.linearization = Some((0..4096).collect());
+        assert_eq!(s.saturation_points(), [None; 3]);
+        assert_eq!(s.lift_clipped_samples(), 0);
+    }
+
+    #[test]
+    fn hostile_levels_are_left_alone() {
+        for black in [-5000.0, f32::NAN] {
+            let mut s = sensor_with(Some(40), 4095.0);
+            s.black = BlackLevels::uniform(black);
+            assert_eq!(s.saturation_points(), [None; 3]);
+            assert_eq!(s.lift_clipped_samples(), 0);
+        }
+        for white in [f32::NAN, f32::INFINITY, 1e9, 100.0] {
+            let mut s = sensor_with(Some(3567), 4095.0);
+            s.white = [white; 3];
+            assert_eq!(s.saturation_points(), [None; 3], "{white}");
+        }
+        // an active area that runs past the data (or overflows when added up) is refused
+        let mut s = sensor_with(Some(3567), 4095.0);
+        s.active = Rect::new(usize::MAX, 0, 2, 64);
+        assert_eq!(s.saturation_points(), [None; 3]);
+        s.active = Rect::new(0, 0, 64, 65);
+        assert_eq!(s.lift_clipped_samples(), 0);
+        let mut s = sensor_with(Some(3567), 4095.0);
+        s.data.pop();
+        assert_eq!(s.lift_clipped_samples(), 0);
+    }
+}
diff --git a/crates/raw/src/sensor.rs b/crates/raw/src/sensor.rs
index a775586dec..585191b799 100644
--- a/crates/raw/src/sensor.rs
+++ b/crates/raw/src/sensor.rs
@@ -63,14 +63,22 @@ impl Cfa {
     /// Colour at data coordinates.
     #[inline]
     pub fn color(&self, x: usize, y: usize) -> u8 {
-        let cx = (x + self.width - self.origin_x % self.width) % self.width;
-        let cy = (y + self.height - self.origin_y % self.height) % self.height;
-        self.colors.get(cy * self.width + cx).copied().unwrap_or(1)
+        fn relative(v: usize, origin: usize, period: usize) -> Option<usize> {
+            if period == 0 {
+                return None;
+            }
+            let (v, origin) = (v % period, origin % period);
+            Some(if v >= origin { v - origin } else { period - (origin - v) })
+        }
+        let Some((cx, cy)) = relative(x, self.origin_x, self.width).zip(relative(y, self.origin_y, self.height)) else {
+            return 1;
+        };
+        cy.checked_mul(self.width).and_then(|i| i.checked_add(cx)).and_then(|i| self.colors.get(i)).copied().unwrap_or(1)
     }
 
     /// The 2×2 colours seen from data coordinates (`x0`, `y0`), row-major.
     pub fn phase(&self, x0: usize, y0: usize) -> [u8; 4] {
-        [self.color(x0, y0), self.color(x0 + 1, y0), self.color(x0, y0 + 1), self.color(x0 + 1, y0 + 1)]
+        [self.color(x0, y0), self.color(x0.saturating_add(1), y0), self.color(x0, y0.saturating_add(1)), self.color(x0.saturating_add(1), y0.saturating_add(1))]
     }
 
     /// `true` for a Bayer pattern: a 2×2 period holding one red, one blue and two
@@ -79,10 +87,11 @@ impl Cfa {
         if self.width == 0 || self.height == 0 || self.width > 16 || self.height > 16 {
             return false;
         }
-        let p = self.phase(self.origin_x, self.origin_y);
-        let periodic = (0..self.height).all(|y| (0..self.width).all(|x| self.color(self.origin_x + x, self.origin_y + y) == p[(y % 2) * 2 + x % 2]));
-        let greens_on_diagonal =
-            (p[0] == 1 && p[3] == 1 && p[1] != 1 && p[2] != 1 && p[1] + p[2] == 2) || (p[1] == 1 && p[2] == 1 && p[0] != 1 && p[3] != 1 && p[0] + p[3] == 2);
+        let (ox, oy) = (self.origin_x % self.width, self.origin_y % self.height);
+        let p = self.phase(ox, oy);
+        let periodic = (0..self.height).all(|y| (0..self.width).all(|x| self.color(ox + x, oy + y) == p[(y % 2) * 2 + x % 2]));
+        let greens_on_diagonal = (p[0] == 1 && p[3] == 1 && p[1] != 1 && p[2] != 1 && u16::from(p[1]) + u16::from(p[2]) == 2)
+            || (p[1] == 1 && p[2] == 1 && p[0] != 1 && p[3] != 1 && u16::from(p[0]) + u16::from(p[3]) == 2);
         periodic && greens_on_diagonal
     }
 }
@@ -110,7 +119,8 @@ impl BlackLevels {
     pub fn at(&self, ax: usize, ay: usize, s: usize, spp: usize) -> f32 {
         let r = ay % self.rows.max(1);
         let c = ax % self.cols.max(1);
-        let base = self.values.get((r * self.cols.max(1) + c) * spp + s).or_else(|| self.values.first()).copied().unwrap_or(0.0);
+        let index = r.checked_mul(self.cols.max(1)).and_then(|i| i.checked_add(c)).and_then(|i| i.checked_mul(spp)).and_then(|i| i.checked_add(s));
+        let base = index.and_then(|i| self.values.get(i)).or_else(|| self.values.first()).copied().unwrap_or(0.0);
         base + self.delta_h.get(ax).copied().unwrap_or(0.0) + self.delta_v.get(ay).copied().unwrap_or(0.0)
     }
 
@@ -157,6 +167,10 @@ pub struct Sensor {
     /// output]` pairs in linear ProPhoto, applied per channel after the colour conversion and
     /// exposure. Below the first point the curve is a line through 0; empty: no curve.
     pub tone_curve: Vec<[f32; 2]>,
+    /// Camera Raw's adaptive black point, for profiles that copy its default rendering: this
+    /// factor times the 0.1th percentile of the image's linear luminance is subtracted before the
+    /// tone curve (see `tone.rs`). 0: no black point.
+    pub black_point: f32,
     pub warnings: Vec<String>,
 }
 
diff --git a/crates/raw/src/testgen.rs b/crates/raw/src/testgen.rs
index fdacc19828..2de64ae4bb 100644
--- a/crates/raw/src/testgen.rs
+++ b/crates/raw/src/testgen.rs
@@ -7,6 +7,41 @@
 
 // ---------------------------------------------------------------- lossless JPEG
 
+/// A CR3 container holding one JPEG track and CMT1 orientation. It deliberately
+/// contains no CRX data: used to test explicit preview fallback and BMFF bounds.
+pub fn cr3_preview(jpeg: &[u8], orientation: u16) -> Vec<u8> {
+    fn bx(kind: &[u8; 4], data: &[u8]) -> Vec<u8> {
+        let mut b = ((data.len() + 8) as u32).to_be_bytes().to_vec();
+        b.extend_from_slice(kind);
+        b.extend_from_slice(data);
+        b
+    }
+    fn moov(jpeg_len: usize, offset: u64, orientation: u16) -> Vec<u8> {
+        let mut tiff = TiffBuilder::default();
+        let ifd = tiff.ifd(vec![(274, Val::Short(vec![orientation]))]);
+        tiff.chain = vec![ifd];
+        let mut meta = vec![0x85, 0xc0, 0xb6, 0x87, 0x82, 0x0f, 0x11, 0xe0, 0x81, 0x11, 0xf4, 0xce, 0x46, 0x2b, 0x6a, 0x48];
+        meta.extend(bx(b"CMT1", &tiff.build()));
+        let mut entry = vec![0; 82];
+        entry.extend(bx(b"JPEG", &[0; 4]));
+        let mut description = vec![0, 0, 0, 0, 0, 0, 0, 1];
+        description.extend(bx(b"CRAW", &entry));
+        let mut sizes = vec![0; 4];
+        sizes.extend_from_slice(&(jpeg_len as u32).to_be_bytes());
+        sizes.extend_from_slice(&1u32.to_be_bytes());
+        let mut offsets = vec![0, 0, 0, 0, 0, 0, 0, 1];
+        offsets.extend_from_slice(&offset.to_be_bytes());
+        let mapping: Vec<u8> = [0u32, 1, 1, 1, 1].iter().flat_map(|n| n.to_be_bytes()).collect();
+        let table = [bx(b"stsd", &description), bx(b"stsz", &sizes), bx(b"co64", &offsets), bx(b"stsc", &mapping)].concat();
+        let track = bx(b"trak", &bx(b"mdia", &bx(b"minf", &bx(b"stbl", &table))));
+        bx(b"moov", &[bx(b"uuid", &meta), track].concat())
+    }
+    let ftyp = bx(b"ftyp", b"crx \0\0\0\x01crx isom");
+    let header = moov(jpeg.len(), 0, orientation);
+    let offset = ftyp.len() + header.len() + 8;
+    [ftyp, moov(jpeg.len(), offset as u64, orientation), bx(b"mdat", jpeg)].concat()
+}
+
 /// Huffman code lengths assigned to categories in decreasing frequency
 /// order. Kraft sum < 1 and no code is all ones.
 const LENGTHS: [u8; 17] = [2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 9, 10, 11, 12, 13];
@@ -1078,6 +1113,136 @@ pub fn rw2(width: usize, height: usize, data: &[u16], bits: u32) -> Vec<u8> {
     b
 }
 
+/// Byte split of the vendor-compressed (RawFormat 3/4) stream (see `rw2.rs`).
+const RW2_COMPRESSED_SPLIT: usize = 0x2008;
+
+/// Writer for the vendor-compressed RW2 stream: mirrors the decoder's cursor
+/// (page addressing, downward field order) and deposits every field where the
+/// reader will pick it up.
+struct V4Writer<'a> {
+    buf: &'a mut [u8],
+    base: usize,
+    pos: usize,
+    nbits: u32,
+}
+
+impl V4Writer<'_> {
+    /// Consumes one byte of the row seek (the decoder reads 8-bit fields).
+    fn skip_byte(&mut self) {
+        if 8 > self.nbits {
+            self.nbits += (RW2_PAGE as u32) * 8;
+            self.pos += RW2_PAGE;
+        }
+        self.nbits -= 8;
+    }
+
+    fn put(&mut self, v: u32, num: u32) {
+        if num > self.nbits {
+            self.nbits += (RW2_PAGE as u32) * 8;
+            self.pos += RW2_PAGE;
+        }
+        let mut at = ((self.nbits - num) >> 3) as usize ^ 0x3FF0;
+        at = (at + RW2_PAGE - RW2_COMPRESSED_SPLIT) % RW2_PAGE;
+        let at = self.base + at + self.pos - RW2_PAGE;
+        self.nbits -= num;
+        let cur = u32::from(self.buf[at]) | (u32::from(self.buf[at + 1]) << 8);
+        let cur = cur | ((v & ((1 << num) - 1)) << (self.nbits & 7));
+        self.buf[at] = cur as u8;
+        self.buf[at + 1] = (cur >> 8) as u8;
+    }
+
+    /// Encodes one row as 14-pixel groups: the scale selector is always 0 and
+    /// the two first pixels of each group are absolute (8 + 4 bits); later
+    /// pixels use the 8-bit delta path. Callers keep values inside 16..4096
+    /// and stepping by at most ±127 between pixels of the same parity.
+    fn row(&mut self, pixels: &[u16]) {
+        for group in pixels.as_chunks::<14>().0 {
+            let mut pred = [0i32; 2];
+            let mut nonz = [0i32; 2];
+            for (i, &px) in group.iter().enumerate() {
+                if i % 3 == 2 {
+                    self.put(0, 2); // sh = 0
+                }
+                let p = i & 1;
+                let t = i32::from(px);
+                if nonz[p] == 0 {
+                    let nz = (t >> 4) & 0xFF;
+                    self.put(nz as u32, 8);
+                    if nz != 0 || i > 11 {
+                        self.put((t & 0xF) as u32, 4);
+                        pred[p] = t;
+                    } else {
+                        pred[p] = 0;
+                    }
+                    nonz[p] = nz;
+                } else {
+                    let q = (pred[p] - 0x80).max(0);
+                    let j = t - q;
+                    assert!((1..=0xFF).contains(&j), "{t} is not encodable from {}", pred[p]);
+                    self.put(j as u32, 8);
+                    pred[p] = q + j;
+                }
+                assert_eq!(pred[p], t);
+            }
+        }
+    }
+}
+
+/// The vendor-compressed (RawFormat 3/4) stream of a whole image; see
+/// [`V4Writer::row`] for the value constraints.
+pub fn rw2_v4_pack(data: &[u16], width: usize) -> Vec<u8> {
+    assert_eq!(width % 14, 0);
+    let height = data.len() / width;
+    assert_eq!(data.len(), width * height);
+    let row_bytes = width / 14 * 16;
+    let mut buf = vec![0u8; row_bytes * height + 2 * RW2_PAGE];
+    for (row, pixels) in data.chunks_exact(width).enumerate() {
+        let skip = row_bytes * row;
+        let mut w = V4Writer { buf: &mut buf, base: skip / RW2_PAGE * RW2_PAGE, pos: 0, nbits: 0 };
+        for _ in 0..(skip % RW2_PAGE) {
+            w.skip_byte();
+        }
+        w.row(pixels);
+    }
+    buf
+}
+
+/// A synthetic Panasonic RW2 (RawFormat 4, vendor-compressed) with an RGGB
+/// sensor, a 2-pixel border on every side, black levels 128 / 129 / 130 and
+/// WB levels 512 / 256 / 384; see [`V4Writer::row`] for the pixel constraints.
+pub fn rw2_format4(width: usize, height: usize, data: &[u16]) -> Vec<u8> {
+    let mut t = TiffBuilder::default();
+    let raw = t.blob(rw2_v4_pack(data, width));
+    let ifd0 = t.ifd(vec![
+        (0x0002, Val::Short(vec![width as u16])),
+        (0x0003, Val::Short(vec![height as u16])),
+        (0x0004, Val::Short(vec![2])),
+        (0x0005, Val::Short(vec![2])),
+        (0x0006, Val::Short(vec![height as u16 - 2])),
+        (0x0007, Val::Short(vec![width as u16 - 2])),
+        (0x0009, Val::Short(vec![1])),
+        (0x000A, Val::Short(vec![12])),
+        (0x000E, Val::Short(vec![4095])),
+        (0x000F, Val::Short(vec![4095])),
+        (0x0010, Val::Short(vec![4095])),
+        (0x001C, Val::Short(vec![128])),
+        (0x001D, Val::Short(vec![129])),
+        (0x001E, Val::Short(vec![130])),
+        (0x0024, Val::Short(vec![512])),
+        (0x0025, Val::Short(vec![256])),
+        (0x0026, Val::Short(vec![384])),
+        (0x002D, Val::Short(vec![4])),
+        (0x010F, Val::Ascii("Panasonic".into())),
+        (0x0110, Val::Ascii("DC-Synthetic".into())),
+        (0x0112, Val::Short(vec![1])),
+        (0x0118, Val::Blobs(vec![raw])),
+    ]);
+    t.chain = vec![ifd0];
+    let mut b = t.build();
+    b[2..4].copy_from_slice(b"U\0");
+    b
+}
+
 // ---------------------------------------------------------------- Olympus ORF
 
 /// A little-endian IFD whose value offsets are relative to `base` (the IFD
diff --git a/crates/raw/src/tiff.rs b/crates/raw/src/tiff.rs
index 17b9b8af76..671ab11fbe 100644
--- a/crates/raw/src/tiff.rs
+++ b/crates/raw/src/tiff.rs
@@ -36,6 +36,10 @@ pub(crate) mod tag {
     pub const EXIF_IFD: u16 = 34665;
     pub const EXIF_CFA_PATTERN: u16 = 41730;
     pub const MAKER_NOTE: u16 = 37500;
+    pub const COLOR_SPACE: u16 = 40961;
+    pub const INTEROP_IFD: u16 = 40965;
+    /// In the Interoperability IFD.
+    pub const INTEROP_INDEX: u16 = 1;
     pub const DNG_VERSION: u16 = 50706;
     pub const UNIQUE_CAMERA_MODEL: u16 = 50708;
     pub const CFA_PLANE_COLOR: u16 = 50710;
diff --git a/crates/raw/src/tiffep.rs b/crates/raw/src/tiffep.rs
index b940d6bc3a..4a75491f5f 100644
--- a/crates/raw/src/tiffep.rs
+++ b/crates/raw/src/tiffep.rs
@@ -223,6 +223,7 @@ pub(crate) fn decode(t: &Tiff, format: RawFormat, limits: &Limits) -> Result<Sen
         baseline_exposure: 0.0,
         gain_maps: Vec::new(),
         tone_curve: Vec::new(),
+        black_point: 0.0,
         warnings,
     };
     crate::cameras::apply(&mut sensor);
diff --git a/crates/raw/src/tone.rs b/crates/raw/src/tone.rs
new file mode 100644
index 0000000000..80a80bfdd6
--- /dev/null
+++ b/crates/raw/src/tone.rs
@@ -0,0 +1,730 @@
+//! Camera Raw's Shadows, Highlights, Clarity, Texture and Dehaze on raw files, applied while
+//! developing (in linear light, before the tone curve), and its adaptive black point.
+//!
+//! Measured black-box from Photoshop 25.4 opening 29 Nikon D4 NEFs through Camera Raw (each slider
+//! at ±100 and +50, exposure ±1), against PhotoCraft's own linear development of the same files:
+//!
+//! * The change is a gain in linear light: exposure −1 gives the same gains, so Camera Raw applies
+//!   it before its tone curve.
+//! * log₂ of the gain is `slider / 100 · C(B − anchor)`. `B` is an edge-preserving base of the log₂
+//!   luminance (K. He's guided filter, radius 32 and ε 1 stop² on a copy 1232 px on its long
+//!   side): whole areas move together and edges stay sharp. The change is linear in the slider;
+//!   each direction has its own curve `C`.
+//! * The anchor follows the image, so exposure changes nothing: for Shadows the log₂ power mean
+//!   (p = 1.5) of the linear luminance, for Highlights the mean of the log₂ luminance.
+//!
+//! On frames left out of the fit the curves explain 80–90 % of the per-pixel change (a fixed,
+//! absolute anchor: 60–75 %).
+//!
+//! The black point: Camera Raw's default rendering follows the frame's darkest tones. A third of
+//! the 0.1th percentile of the linear luminance is subtracted; that halves the deep-shadow
+//! error of a fixed curve. It comes before the Shadows / Highlights gain, as in Camera Raw:
+//! the other order left lifted shadows 0.2 stop lighter and flatter than Photoshop's.
+//!
+//! Clarity, Texture and Dehaze were measured the same way (each at ±100 and +50, and +100 at
+//! exposure −1): all three act before the tone curve (the scene-domain change at exposure −1
+//! correlates 0.98–0.99 with the one at exposure 0) and follow the image, not absolute levels.
+//!
+//! * **Clarity** changes detail at every scale above a few pixels: log₂ luminance is split into
+//!   bands between edge-preserving bases (guided filter, radii 2, 8, 32 and 128 on the work copy,
+//!   ε 1 stop²), each band scaled by a gain that depends on its base's tone relative to the
+//!   frame's mean, plus a tone term. +100 roughly doubles midtone detail and darkens darker areas;
+//!   −100 flattens the detail of midtones and highlights and leaves the shadows' alone. On frames
+//!   left out of the fit the change correlates 0.81 (+100) and 0.92 (−100) with Photoshop's;
+//!   +50 is half of +100.
+//! * **Texture** works on fine detail only: bands between Gaussians of σ 1…32 px (full size), each
+//!   through its own measured response, so small detail is raised more than strong edges
+//!   (computed at half size and carried to full size by guided upsampling).
+//! * **Dehaze** follows K. He, J. Sun and X. Tang's dark channel prior (*Single Image Haze Removal
+//!   Using Dark Channel Prior*, 2009): the airlight `A` is the mean colour of the 0.1 % of pixels
+//!   with the brightest dark channel, the transmission `t = 1 − w · dark` from the dark channel
+//!   (minimum over RGB of `I / A` and over a 17 px window on the work copy) smoothed by a guided
+//!   filter, and each channel becomes `(I − A) / t + A`, with `w` 0.8 at +100 (0.7 fits the
+//!   per-pixel change best, 0.85 the overall darkening). −100 adds a uniform veil,
+//!   `I (1 − w) + A w`, `w` 0.22. The black point stays the default rendering's.
+
+use crate::par;
+
+mod tables;
+
+/// Camera Raw's Basic-panel sliders that act on raw data before the tone curve, −100…100.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Tone {
+    pub shadows: f32,
+    pub highlights: f32,
+    pub clarity: f32,
+    pub texture: f32,
+    pub dehaze: f32,
+}
+
+impl Tone {
+    /// Every slider at 0.
+    pub const NEUTRAL: Tone = Tone { shadows: 0.0, highlights: 0.0, clarity: 0.0, texture: 0.0, dehaze: 0.0 };
+
+    pub fn is_neutral(&self) -> bool {
+        self.gain_neutral() && self.dehaze == 0.0
+    }
+
+    /// No luminance gain: Shadows, Highlights, Clarity and Texture at 0.
+    fn gain_neutral(&self) -> bool {
+        self.work_neutral() && self.texture == 0.0
+    }
+
+    /// Nothing to compute on the work copy: Shadows, Highlights and Clarity at 0.
+    fn work_neutral(&self) -> bool {
+        self.shadows == 0.0 && self.highlights == 0.0 && self.clarity == 0.0
+    }
+}
+
+/// Long side of the copy the base is computed on, and the guided filter's radius and ε there.
+const WORK_SIDE: usize = 1232;
+const BASE_RADIUS: f32 = 32.0;
+const BASE_EPS: f32 = 1.0;
+/// ε (stops²) of the guided upsampling that carries the change to full size.
+const UPSAMPLE_EPS: f32 = 1.0;
+/// The curves' first knot (stops from the anchor) and knot spacing.
+const LO: f32 = -12.0;
+const STEP: f32 = 0.25;
+
+// log₂ gain at +100 / −100 against B − anchor, knots LO, LO + STEP, … (measured; flat or
+// extended linearly beyond the measured range, never steeper than 0.8 stop per stop so tones
+// keep their order).
+const SHADOWS_UP: [f32; 73] = [
+    2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142, 2.142,
+    2.142, 2.142, 2.142, 2.142, 2.138, 2.117, 2.074, 2.010, 1.918, 1.797, 1.668, 1.546, 1.429, 1.315, 1.204, 1.093, 0.979, 0.860, 0.734, 0.604, 0.482, 0.378,
+    0.288, 0.211, 0.157, 0.127, 0.104, 0.078, 0.056, 0.046, 0.044, 0.044, 0.044, 0.044, 0.044, 0.041, 0.030, 0.014, 0.003, 0.000, 0.000, 0.000, 0.000, 0.000,
+    0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000,
+];
+const SHADOWS_DOWN: [f32; 73] = [
+    -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365, -2.365,
+    -2.365, -2.365, -2.365, -2.365, -2.346, -2.270, -2.155, -2.078, -2.054, -2.031, -1.973, -1.872, -1.739, -1.604, -1.483, -1.372, -1.266, -1.161, -1.053,
+    -0.940, -0.821, -0.696, -0.570, -0.455, -0.356, -0.270, -0.197, -0.146, -0.117, -0.098, -0.076, -0.057, -0.048, -0.046, -0.046, -0.046, -0.046, -0.046,
+    -0.043, -0.032, -0.014, -0.003, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000,
+];
+const HIGHLIGHTS_UP: [f32; 73] = [
+    0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000,
+    0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.001, 0.002, 0.003, 0.004, 0.008, 0.017, 0.030, 0.043, 0.055, 0.070, 0.085, 0.097, 0.106,
+    0.114, 0.120, 0.127, 0.142, 0.167, 0.199, 0.239, 0.301, 0.381, 0.470, 0.569, 0.677, 0.796, 0.925, 1.056, 1.176, 1.268, 1.319, 1.339, 1.347, 1.351, 1.357,
+    1.364, 1.372, 1.380, 1.388, 1.396, 1.404, 1.412,
+];
+#[allow(clippy::approx_constant)] // measured values, one of them happens to be close to e
+const HIGHLIGHTS_DOWN: [f32; 73] = [
+    0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000,
+    0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, -0.004, -0.020, -0.046, -0.068, -0.086, -0.104, -0.116, -0.118, -0.118, -0.118, -0.118, -0.118,
+    -0.119, -0.120, -0.123, -0.127, -0.131, -0.144, -0.169, -0.204, -0.245, -0.301, -0.375, -0.452, -0.537, -0.639, -0.753, -0.872, -0.997, -1.132, -1.294,
+    -1.475, -1.637, -1.751, -1.836, -1.936, -2.059, -2.191, -2.323, -2.454, -2.586, -2.718, -2.850,
+];
+
+/// Clarity: the work-copy radii of the bases between its bands, and their guided-filter ε.
+const CLARITY_RADII: [f32; 4] = [2.0, 8.0, 32.0, 128.0];
+const CLARITY_EPS: f32 = 1.0;
+/// Texture: long side of its copy, the Gaussians' σ there, and the guided upsampling's ε (small:
+/// the change must follow fine detail into the full-size pixels).
+const TEXTURE_SIDE: usize = 2464;
+const TEXTURE_SIGMAS: [f32; 6] = [0.5, 1.0, 2.0, 4.0, 8.0, 16.0];
+const TEXTURE_UPSAMPLE_EPS: f32 = 1e-4;
+/// Dehaze: dark-channel window radius and guided smoothing radius (work copy), its ε, the
+/// smallest transmission, and the haze weight at +100 and −100.
+const HAZE_RADIUS: f32 = 8.0;
+const HAZE_SMOOTH: f32 = 64.0;
+const HAZE_EPS: f32 = 1e-3;
+const HAZE_T0: f32 = 0.1;
+const HAZE_UP: f32 = 0.8;
+const HAZE_DOWN: f32 = 0.22;
+/// Linear ProPhoto → linear Display P3 (both D50): the dark channel was measured in Photoshop's
+/// Display P3 output.
+const PRO_TO_P3: [[f32; 3]; 3] = [[1.632638, -0.379816, -0.252821], [-0.153846, 1.166859, -0.013013], [0.010511, -0.062886, 1.052375]];
+
+/// A change of log₂ luminance computed on a reduced copy, carried to full size along the image's
+/// own edges (guided upsampling): a local linear model `change = a · log₂ Y + b` per reduced pixel.
+struct Upsampled {
+    sw: usize,
+    sh: usize,
+    a: Vec<f32>,
+    b: Vec<f32>,
+    /// log₂ luminance floor (the reduced copy's 0.1th percentile).
+    floor: f32,
+}
+
+impl Upsampled {
+    /// The change at full-size pixel (`x`, `y`) of a `w × h` image, of linear luminance `lum`.
+    fn change(&self, w: usize, h: usize, x: usize, y: usize, lum: f32) -> f32 {
+        let l = if lum > 0.0 { lum.log2().max(self.floor) } else { self.floor };
+        bilinear(&self.a, self.sw, self.sh, w, h, x, y) * l + bilinear(&self.b, self.sw, self.sh, w, h, x, y)
+    }
+}
+
+/// `v` (`sw × sh`) at full-size pixel (`x`, `y`) of a `w × h` image, bilinearly.
+fn bilinear(v: &[f32], sw: usize, sh: usize, w: usize, h: usize, x: usize, y: usize) -> f32 {
+    let sx = ((x as f32 + 0.5) * sw as f32 / w as f32 - 0.5).clamp(0.0, (sw - 1) as f32);
+    let sy = ((y as f32 + 0.5) * sh as f32 / h as f32 - 0.5).clamp(0.0, (sh - 1) as f32);
+    let (x0, y0) = (sx as usize, sy as usize);
+    let (x1, y1) = ((x0 + 1).min(sw - 1), (y0 + 1).min(sh - 1));
+    let (fx, fy) = (sx - x0 as f32, sy - y0 as f32);
+    let top = v[y0 * sw + x0] * (1.0 - fx) + v[y0 * sw + x1] * fx;
+    let bottom = v[y1 * sw + x0] * (1.0 - fx) + v[y1 * sw + x1] * fx;
+    top * (1.0 - fy) + bottom * fy
+}
+
+/// Box means of `f` over `k × k` cells, `k` the smallest factor that brings the long side to
+/// `side` or less: (`sw`, `sh`, the means).
+fn reduce<const N: usize>(w: usize, h: usize, side: usize, f: impl Fn(usize) -> [f32; N] + Sync) -> (usize, usize, Vec<[f32; N]>) {
+    let k = w.max(h).div_ceil(side).max(1);
+    let (sw, sh) = (w.div_ceil(k), h.div_ceil(k));
+    let rows = par::map(sh, |sy| {
+        let (y0, y1) = (sy * k, ((sy + 1) * k).min(h));
+        (0..sw)
+            .map(|sx| {
+                let (x0, x1) = (sx * k, ((sx + 1) * k).min(w));
+                let mut s = [0.0f64; N];
+                for y in y0..y1 {
+                    for x in x0..x1 {
+                        let v = f(y * w + x);
+                        for c in 0..N {
+                            s[c] += f64::from(v[c].max(0.0));
+                        }
+                    }
+                }
+                let n = ((x1 - x0) * (y1 - y0)) as f64;
+                s.map(|v| (v / n) as f32)
+            })
+            .collect::<Vec<_>>()
+    });
+    (sw, sh, rows.concat())
+}
+
+/// The luminance change of one image (Shadows, Highlights, Clarity on the work copy; Texture on
+/// a half-size copy) and the black point.
+pub(crate) struct ToneMap {
+    w: usize,
+    h: usize,
+    work: Option<Upsampled>,
+    texture: Option<Upsampled>,
+    /// Linear black point to subtract (0: none).
+    pub(crate) black: f32,
+}
+
+impl ToneMap {
+    /// `lum(i)`: linear luminance of full-size pixel `i` (row-major, `w × h`). `black_point`: the
+    /// camera profile's black-point factor (see [`crate::Sensor::black_point`]). `None` when
+    /// nothing changes. Dehaze is not part of it (see [`Haze`]).
+    pub(crate) fn new(w: usize, h: usize, lum: impl Fn(usize) -> f32 + Sync, tone: Tone, black_point: f32) -> Option<Self> {
+        if w == 0 || h == 0 || (tone.gain_neutral() && black_point <= 0.0) {
+            return None;
+        }
+        let (sw, sh, y) = reduce(w, h, WORK_SIDE, |i| [lum(i)]);
+        let y: Vec<f32> = y.into_iter().map(|[v]| v).collect();
+        let p01 = quantile(&y, 0.001).max(2f32.powi(-20));
+        let black = if black_point > 0.0 { black_point * p01 } else { 0.0 };
+        let work = (!tone.work_neutral()).then(|| {
+            let l: Vec<f32> = y.iter().map(|v| v.max(p01).log2()).collect();
+            let n = l.len() as f64;
+            let geo = (l.iter().map(|v| f64::from(*v)).sum::<f64>() / n) as f32;
+            let scale = sw.max(sh) as f32 / WORK_SIDE as f32;
+            let mut change = vec![0.0f32; l.len()];
+            if tone.shadows != 0.0 || tone.highlights != 0.0 {
+                let pm = ((l.iter().map(|v| f64::from(v.exp2()).powf(1.5)).sum::<f64>() / n).log2() / 1.5) as f32;
+                let r = ((BASE_RADIUS * scale).round() as usize).max(1);
+                let base = guided(&l, &l, sw, sh, r, BASE_EPS);
+                for (c, b) in change.iter_mut().zip(&base) {
+                    *c += shadows(tone.shadows, b - pm) + highlights(tone.highlights, b - geo);
+                }
+            }
+            if tone.clarity != 0.0 {
+                clarity(&mut change, &l, sw, sh, geo, scale, tone.clarity);
+            }
+            // Fit change ≈ a · l + b locally, averaged; evaluated at full size. The large ε lets the
+            // change follow strong edges only: inside texture it stays smooth, so fine detail keeps
+            // its contrast as in Camera Raw (with ε 0.01 shadow detail lost a fifth of it; with ε 4 the change bled ~16 px over 3-stop edges).
+            let (a, b) = linear_fit(&l, &change, sw, sh, 2, UPSAMPLE_EPS);
+            Upsampled { sw, sh, a, b, floor: p01.log2() }
+        });
+        let texture = (tone.texture != 0.0).then(|| texture(w, h, &lum, tone.texture));
+        Some(ToneMap { w, h, work, texture, black })
+    }
+
+    /// The gain at full-size pixel (`x`, `y`) of linear luminance `lum`.
+    pub(crate) fn gain(&self, x: usize, y: usize, lum: f32) -> f32 {
+        if self.work.is_none() && self.texture.is_none() {
+            return 1.0;
+        }
+        let c = [&self.work, &self.texture].iter().filter_map(|u| u.as_ref()).map(|u| u.change(self.w, self.h, x, y, lum)).sum::<f32>();
+        c.clamp(-6.0, 6.0).exp2()
+    }
+
+    /// Black-point subtraction of one linear value.
+    #[inline]
+    pub(crate) fn unblack(&self, v: f32) -> f32 {
+        if self.black > 0.0 { ((v - self.black) / (1.0 - self.black)).max(0.0) } else { v }
+    }
+}
+
+/// The black point of an image of luminance `lum` for the profile's factor (0: none): `factor`
+/// times the 0.1th percentile of the work copy's linear luminance.
+pub(crate) fn black_level(w: usize, h: usize, lum: impl Fn(usize) -> f32 + Sync, factor: f32) -> f32 {
+    if w == 0 || h == 0 || factor <= 0.0 {
+        return 0.0;
+    }
+    let (_, _, y) = reduce(w, h, WORK_SIDE, |i| [lum(i)]);
+    let y: Vec<f32> = y.into_iter().map(|[v]| v).collect();
+    factor * quantile(&y, 0.001).max(2f32.powi(-20))
+}
+
+/// The slider's table for its direction and its weight 0…1.
+fn direction<T>(s: f32, up: &'static T, down: &'static T) -> (f32, &'static T) {
+    let s = s.clamp(-100.0, 100.0) / 100.0;
+    if s >= 0.0 { (s, up) } else { (-s, down) }
+}
+
+/// A table on evenly spaced knots `lo`, `lo + step`, …, read linearly, flat beyond its ends.
+fn even<const N: usize>(c: &[f32; N], lo: f32, step: f32, x: f32) -> f32 {
+    let t = ((x - lo) / step).clamp(0.0, (N - 1) as f32);
+    let i = (t as usize).min(N - 2);
+    c[i] + (c[i + 1] - c[i]) * (t - i as f32)
+}
+
+/// Adds Clarity `s` to `change`: bands of `l` between guided bases, each scaled by a gain that
+/// follows its base's tone (relative to `geo`), and a tone term of the coarsest base.
+fn clarity(change: &mut [f32], l: &[f32], sw: usize, sh: usize, geo: f32, scale: f32, s: f32) {
+    let (k, t) = direction(s, &tables::CLARITY_UP, &tables::CLARITY_DOWN);
+    let mut prev = l.to_vec();
+    for (band, r) in CLARITY_RADII.iter().enumerate() {
+        let base = guided(l, l, sw, sh, ((r * scale).round() as usize).max(1), CLARITY_EPS);
+        for ((c, p), b) in change.iter_mut().zip(&prev).zip(&base) {
+            *c += k * (p - b) * even(&t.bands[band], tables::CLARITY_TONE_LO, tables::CLARITY_TONE_STEP, b - geo);
+        }
+        prev = base;
+    }
+    for (c, b) in change.iter_mut().zip(&prev) {
+        *c += k * (even(&t.base, tables::CLARITY_BASE_LO, tables::CLARITY_BASE_STEP, b - geo) + t.offset);
+    }
+}
+
+/// Texture `s` on a half-size copy: each Gaussian band of log₂ luminance through its measured
+/// response (zero for flat areas), carried to full size.
+fn texture(w: usize, h: usize, lum: &(impl Fn(usize) -> f32 + Sync), s: f32) -> Upsampled {
+    let (sw, sh, y) = reduce(w, h, TEXTURE_SIDE, |i| [lum(i)]);
+    let y: Vec<f32> = y.into_iter().map(|[v]| v).collect();
+    let p01 = quantile(&y, 0.001).max(2f32.powi(-20));
+    let l: Vec<f32> = y.iter().map(|v| v.max(p01).log2()).collect();
+    let scale = sw.max(sh) as f32 / TEXTURE_SIDE as f32;
+    let (k, t) = direction(s, &tables::TEXTURE_UP, &tables::TEXTURE_DOWN);
+    let mut change = vec![0.0f32; l.len()];
+    let mut prev = l.clone();
+    for (band, sigma) in TEXTURE_SIGMAS.iter().enumerate() {
+        let base = gauss(&l, sw, sh, sigma * scale);
+        let zero = knots(&t[band], 0.0);
+        for ((c, p), b) in change.iter_mut().zip(&prev).zip(&base) {
+            *c += k * (knots(&t[band], p - b) - zero);
+        }
+        prev = base;
+    }
+    let (a, b) = linear_fit(&l, &change, sw, sh, 2, TEXTURE_UPSAMPLE_EPS);
+    Upsampled { sw, sh, a, b, floor: p01.log2() }
+}
+
+/// Texture's band response on the knots [`tables::TEXTURE_KNOTS`], read linearly, flat beyond.
+fn knots(c: &[f32; 11], d: f32) -> f32 {
+    let k = &tables::TEXTURE_KNOTS;
+    let d = d.clamp(k[0], k[10]);
+    let i = k.partition_point(|v| *v <= d).clamp(1, 10);
+    let f = (d - k[i - 1]) / (k[i] - k[i - 1]);
+    c[i - 1] + (c[i] - c[i - 1]) * f
+}
+
+/// Gaussian blur of `v` (`w × h`), σ `sigma`, radius ⌈3σ⌉, mirrored edges.
+fn gauss(v: &[f32], w: usize, h: usize, sigma: f32) -> Vec<f32> {
+    if sigma <= 0.05 {
+        return v.to_vec();
+    }
+    let r = (3.0 * sigma).ceil() as isize;
+    let mut k: Vec<f32> = (-r..=r).map(|x| (-(x * x) as f32 / (2.0 * sigma * sigma)).exp()).collect();
+    let sum: f32 = k.iter().sum();
+    k.iter_mut().for_each(|v| *v /= sum);
+    let rows = par::map(h, |y| {
+        let src = &v[y * w..(y + 1) * w];
+        (0..w as isize).map(|x| k.iter().enumerate().map(|(j, kv)| kv * src[mirror(x + j as isize - r, w)]).sum::<f32>()).collect::<Vec<f32>>()
+    });
+    let tmp = rows.concat();
+    let cols = par::map(w, |x| {
+        (0..h as isize).map(|y| k.iter().enumerate().map(|(j, kv)| kv * tmp[mirror(y + j as isize - r, h) * w + x]).sum::<f32>()).collect::<Vec<f32>>()
+    });
+    let mut out = vec![0.0f32; w * h];
+    for (x, col) in cols.iter().enumerate() {
+        for (y, v) in col.iter().enumerate() {
+            out[y * w + x] = *v;
+        }
+    }
+    out
+}
+
+/// Minimum over a `(2r + 1)²` window, edges clamped.
+fn min_filter(v: &[f32], w: usize, h: usize, r: usize) -> Vec<f32> {
+    let rows = par::map(h, |y| {
+        let src = &v[y * w..(y + 1) * w];
+        (0..w).map(|x| src[x.saturating_sub(r)..=(x + r).min(w - 1)].iter().fold(f32::MAX, |a, b| a.min(*b))).collect::<Vec<f32>>()
+    });
+    let tmp = rows.concat();
+    let cols =
+        par::map(w, |x| (0..h).map(|y| (y.saturating_sub(r)..=(y + r).min(h - 1)).map(|yy| tmp[yy * w + x]).fold(f32::MAX, f32::min)).collect::<Vec<f32>>());
+    let mut out = vec![0.0f32; w * h];
+    for (x, col) in cols.iter().enumerate() {
+        for (y, v) in col.iter().enumerate() {
+            out[y * w + x] = *v;
+        }
+    }
+    out
+}
+
+/// Camera Raw's Dehaze on linear ProPhoto RGB (see the module docs).
+pub(crate) struct Haze {
+    w: usize,
+    h: usize,
+    sw: usize,
+    sh: usize,
+    /// Transmission per work-copy pixel (Dehaze > 0); empty for the veil of Dehaze < 0.
+    t: Vec<f32>,
+    /// Airlight, linear ProPhoto.
+    air: [f32; 3],
+    /// Weight of the uniform veil (Dehaze < 0).
+    veil: f32,
+}
+
+impl Haze {
+    /// `px(i)`: linear ProPhoto RGB of full-size pixel `i`. `None` at 0.
+    pub(crate) fn new(w: usize, h: usize, px: impl Fn(usize) -> [f32; 3] + Sync, amount: f32) -> Option<Self> {
+        let amount = amount.clamp(-100.0, 100.0) / 100.0;
+        if w == 0 || h == 0 || amount == 0.0 {
+            return None;
+        }
+        let (sw, sh, small) = reduce(w, h, WORK_SIDE, px);
+        let p3 = |v: &[f32; 3]| PRO_TO_P3.map(|row| (row[0] * v[0] + row[1] * v[1] + row[2] * v[2]).max(0.0));
+        let small_p3: Vec<[f32; 3]> = small.iter().map(p3).collect();
+        // Airlight: mean colour of the 0.1 % of pixels with the brightest dark channel.
+        let dc: Vec<f32> = small_p3.iter().map(|c| c[0].min(c[1]).min(c[2])).collect();
+        let top = (dc.len() / 1000).max(1);
+        let mut idx: Vec<usize> = (0..dc.len()).collect();
+        idx.select_nth_unstable_by(top - 1, |a, b| dc[*b].total_cmp(&dc[*a]));
+        let mut air = [0.0f32; 3];
+        for i in &idx[..top] {
+            for c in 0..3 {
+                air[c] += small[*i][c] / top as f32;
+            }
+        }
+        let air = air.map(|v| v.max(1e-6));
+        if amount < 0.0 {
+            return Some(Haze { w, h, sw, sh, t: Vec::new(), air, veil: HAZE_DOWN * -amount });
+        }
+        let air_p3 = p3(&air).map(|v| v.max(1e-6));
+        let scale = sw.max(sh) as f32 / WORK_SIDE as f32;
+        let dark0: Vec<f32> = small_p3.iter().map(|c| (0..3).map(|k| c[k] / air_p3[k]).fold(f32::MAX, f32::min)).collect();
+        let dark = min_filter(&dark0, sw, sh, ((HAZE_RADIUS * scale).round() as usize).max(1));
+        let y = crate::color::rgb_to_xyz(crate::color::ROMM, crate::color::D50_XY)[1].map(|v| v as f32);
+        let lum = |c: &[f32; 3]| y[0] * c[0] + y[1] * c[1] + y[2] * c[2];
+        let air_y = lum(&air).max(1e-6);
+        let guide: Vec<f32> = small.iter().map(|c| lum(c) / air_y).collect();
+        let smooth = guided(&guide, &dark, sw, sh, ((HAZE_SMOOTH * scale).round() as usize).max(1), HAZE_EPS);
+        let wgt = HAZE_UP * amount;
+        let t = smooth.iter().map(|d| (1.0 - wgt * d).max(HAZE_T0)).collect();
+        Some(Haze { w, h, sw, sh, t, air, veil: 0.0 })
+    }
+
+    /// Dehaze at full-size pixel (`x`, `y`) of linear ProPhoto `v`.
+    pub(crate) fn apply(&self, x: usize, y: usize, v: [f32; 3]) -> [f32; 3] {
+        if self.t.is_empty() {
+            return [0, 1, 2].map(|c| v[c] * (1.0 - self.veil) + self.air[c] * self.veil);
+        }
+        let t = bilinear(&self.t, self.sw, self.sh, self.w, self.h, x, y).max(HAZE_T0);
+        [0, 1, 2].map(|c| ((v[c] - self.air[c]) / t + self.air[c]).max(0.0))
+    }
+}
+
+fn curve(c: &[f32; 73], d: f32) -> f32 {
+    let t = ((d - LO) / STEP).clamp(0.0, (c.len() - 1) as f32);
+    let i = (t as usize).min(c.len() - 2);
+    let f = t - i as f32;
+    c[i] + (c[i + 1] - c[i]) * f
+}
+
+/// log₂ gain of Shadows `s` (−100…100) at `d` stops from its anchor.
+fn shadows(s: f32, d: f32) -> f32 {
+    let s = s.clamp(-100.0, 100.0) / 100.0;
+    if s > 0.0 {
+        s * curve(&SHADOWS_UP, d)
+    } else if s < 0.0 {
+        -s * curve(&SHADOWS_DOWN, d)
+    } else {
+        0.0
+    }
+}
+
+/// log₂ gain of Highlights `h` (−100…100) at `d` stops from its anchor.
+fn highlights(h: f32, d: f32) -> f32 {
+    let h = h.clamp(-100.0, 100.0) / 100.0;
+    if h > 0.0 {
+        h * curve(&HIGHLIGHTS_UP, d)
+    } else if h < 0.0 {
+        -h * curve(&HIGHLIGHTS_DOWN, d)
+    } else {
+        0.0
+    }
+}
+
+/// The `q` quantile (0…1) of `v`.
+fn quantile(v: &[f32], q: f32) -> f32 {
+    let mut s = v.to_vec();
+    let k = ((s.len() - 1) as f32 * q).round() as usize;
+    let (_, m, _) = s.select_nth_unstable_by(k, |a, b| a.total_cmp(b));
+    *m
+}
+
+/// Index `i` mirrored into `0..n` (half-sample symmetric: … 1 0 | 0 1 … n−1 | n−1 n−2 …).
+fn mirror(i: isize, n: usize) -> usize {
+    let n = n as isize;
+    let p = i.rem_euclid(2 * n);
+    (if p < n { p } else { 2 * n - 1 - p }) as usize
+}
+
+/// Box mean of radius `r` with mirrored edges.
+fn box_mean(v: &[f32], w: usize, h: usize, r: usize) -> Vec<f32> {
+    let k = (2 * r + 1) as f64;
+    let ri = r as isize;
+    let rows = par::map(h, |y| {
+        let src = &v[y * w..(y + 1) * w];
+        let mut acc: f64 = (-ri..=ri).map(|i| f64::from(src[mirror(i, w)])).sum();
+        let mut out = vec![0.0f32; w];
+        for (x, o) in out.iter_mut().enumerate() {
+            *o = (acc / k) as f32;
+            let x = x as isize;
+            acc += f64::from(src[mirror(x + ri + 1, w)]) - f64::from(src[mirror(x - ri, w)]);
+        }
+        out
+    });
+    let tmp = rows.concat();
+    let cols = par::map(w, |x| {
+        let at = |y: isize| f64::from(tmp[mirror(y, h) * w + x]);
+        let mut acc: f64 = (-ri..=ri).map(at).sum();
+        let mut out = vec![0.0f32; h];
+        for (y, o) in out.iter_mut().enumerate() {
+            *o = (acc / k) as f32;
+            let y = y as isize;
+            acc += at(y + ri + 1) - at(y - ri);
+        }
+        out
+    });
+    let mut out = vec![0.0f32; w * h];
+    for (x, col) in cols.iter().enumerate() {
+        for (y, v) in col.iter().enumerate() {
+            out[y * w + x] = *v;
+        }
+    }
+    out
+}
+
+/// Local linear fit `p ≈ a · i + b` over boxes of radius `r` (regularized by `eps`), with `a`
+/// and `b` box-averaged (K. He, J. Sun, X. Tang, *Guided Image Filtering*, 2010).
+fn linear_fit(i: &[f32], p: &[f32], w: usize, h: usize, r: usize, eps: f32) -> (Vec<f32>, Vec<f32>) {
+    let ip: Vec<f32> = i.iter().zip(p).map(|(a, b)| a * b).collect();
+    let ii: Vec<f32> = i.iter().map(|a| a * a).collect();
+    let (mi, mp, mip, mii) = (box_mean(i, w, h, r), box_mean(p, w, h, r), box_mean(&ip, w, h, r), box_mean(&ii, w, h, r));
+    let a: Vec<f32> = (0..w * h).map(|k| (mip[k] - mi[k] * mp[k]) / ((mii[k] - mi[k] * mi[k]).max(0.0) + eps)).collect();
+    let b: Vec<f32> = (0..w * h).map(|k| mp[k] - a[k] * mi[k]).collect();
+    (box_mean(&a, w, h, r), box_mean(&b, w, h, r))
+}
+
+/// Guided filter of `p` with guide `i`.
+fn guided(i: &[f32], p: &[f32], w: usize, h: usize, r: usize, eps: f32) -> Vec<f32> {
+    let (a, b) = linear_fit(i, p, w, h, r, eps);
+    a.iter().zip(&b).zip(i).map(|((a, b), i)| a * i + b).collect()
+}
+
+/// The raw-stage sliders ([`Tone`]) on an image [`develop`](crate::develop) already made (gamma-1.8 ProPhoto
+/// RGBA, 0…1) with the profile tone `curve`, for a preview of the open-time setting: the curve is
+/// undone, the change applied in linear light and the curve redone. The developed pixels already
+/// carry the black point, so the change's map is computed from the luminance after it rather
+/// than before; that only differs in the deepest shadows.
+pub fn retone(px: &mut [[f32; 4]], w: usize, h: usize, curve: &[[f32; 2]], tone: Tone) {
+    if tone.is_neutral() || w == 0 || h == 0 || px.len() < w * h {
+        return;
+    }
+    let forward = |v: f32| crate::develop::tone(curve, v.clamp(0.0, 1.0)).clamp(0.0, 1.0).powf(1.0 / 1.8);
+    // The inverse from a table over s = √v (the encoding is steep near 0).
+    const N: usize = 4096;
+    let table: Vec<f32> = (0..=N).map(|i| forward((i as f32 / N as f32).powi(2))).collect();
+    let inverse = |e: f32| {
+        let i = table.partition_point(|t| *t < e).clamp(1, N);
+        let (a, b) = (table[i - 1], table[i]);
+        let f = if b > a { ((e - a) / (b - a)).clamp(0.0, 1.0) } else { 0.0 };
+        ((i - 1) as f32 + f) / N as f32
+    };
+    let mut lin: Vec<[f32; 3]> = px.iter().map(|p| [0, 1, 2].map(|k| inverse(p[k]).powi(2))).collect();
+    if let Some(haze) = Haze::new(w, h, |i| lin[i], tone.dehaze) {
+        for (i, l) in lin.iter_mut().enumerate() {
+            *l = haze.apply(i % w, i / w, *l);
+        }
+    }
+    let y = crate::color::rgb_to_xyz(crate::color::ROMM, crate::color::D50_XY)[1].map(|v| v as f32);
+    let lum = |c: &[f32; 3]| y[0] * c[0] + y[1] * c[1] + y[2] * c[2];
+    let map = ToneMap::new(w, h, |i| lum(&lin[i]), tone, 0.0);
+    for (i, (p, l)) in px.iter_mut().zip(&lin).enumerate() {
+        let g = map.as_ref().map_or(1.0, |m| m.gain(i % w, i / w, lum(l)));
+        for k in 0..3 {
+            p[k] = forward(l[k] * g);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SHADOWS: Tone = Tone { shadows: 100.0, ..Tone::NEUTRAL };
+    const HIGHLIGHTS: Tone = Tone { highlights: -100.0, ..Tone::NEUTRAL };
+
+    /// Three vertical bands of linear luminance 2⁻⁷ | 2⁻⁴ | 2⁻¹, times `scale`.
+    fn bands(w: usize, h: usize, scale: f32) -> Vec<f32> {
+        (0..w * h).map(|i| scale * [2f32.powi(-7), 2f32.powi(-4), 0.5][(i % w) * 3 / w]).collect()
+    }
+
+    fn gains(y: &[f32], w: usize, h: usize, tone: Tone) -> Vec<f32> {
+        let Some(m) = ToneMap::new(w, h, |i| y[i], tone, 0.0) else { return vec![1.0; w * h] };
+        (0..w * h).map(|i| m.gain(i % w, i / w, y[i])).collect()
+    }
+
+    #[test]
+    fn shadows_lift_the_dark_area_and_keep_the_bright_one() {
+        let (w, h) = (300, 120);
+        let g = gains(&bands(w, h, 1.0), w, h, SHADOWS);
+        let (dark, mid, bright) = (g[60 * w + 50], g[60 * w + 150], g[60 * w + 250]);
+        // 5 stops below the anchor: about +2 stops, as Camera Raw lifts such areas; 1 stop above it: almost nothing.
+        assert!(dark.log2() > 1.8 && dark.log2() < 2.3, "{dark}");
+        assert!(mid > 1.0 && mid < dark, "{mid}");
+        assert!(bright.log2() < 0.06, "{bright}");
+    }
+
+    #[test]
+    fn highlights_lower_the_bright_area_and_keep_the_dark_one() {
+        let (w, h) = (300, 120);
+        let g = gains(&bands(w, h, 1.0), w, h, HIGHLIGHTS);
+        let (dark, bright) = (g[60 * w + 50], g[60 * w + 250]);
+        // 3 stops above the anchor about −1 stop; 3 below a slight darkening (Camera Raw lowers a
+        // high-contrast frame as a whole a little too).
+        assert!(dark.log2() < 0.0 && dark.log2() > -0.15, "{dark}");
+        assert!(bright.log2() < -0.8 && bright.log2() > -1.3, "{bright}");
+    }
+
+    #[test]
+    fn exposure_changes_nothing() {
+        let (w, h) = (300, 120);
+        for tone in [SHADOWS, HIGHLIGHTS, Tone { shadows: -60.0, highlights: 40.0, clarity: 50.0, texture: -40.0, ..Tone::NEUTRAL }] {
+            let (a, b) = (gains(&bands(w, h, 1.0), w, h, tone), gains(&bands(w, h, 0.25), w, h, tone));
+            assert!(a.iter().zip(&b).all(|(a, b)| (a - b).abs() < 1e-3 * a), "{tone:?}");
+        }
+    }
+
+    #[test]
+    fn areas_move_as_a_whole_without_a_halo() {
+        // Next to an edge the change stays between the two areas' changes (no over- or undershoot)
+        // and close to the change inside the area.
+        let (w, h) = (600, 120);
+        let g: Vec<f32> = gains(&bands(w, h, 1.0), w, h, SHADOWS).iter().map(|g| g.log2()).collect();
+        let row = &g[60 * w..61 * w];
+        let (dark, mid) = (row[w / 6], row[w / 2]);
+        for (x, v) in row.iter().enumerate().take(w / 2).skip(w / 6) {
+            assert!(*v <= dark + 1e-3 && *v >= mid - 1e-3, "{x}: {v} outside {mid}…{dark}");
+        }
+        // Within 0.3 stop: near strong edges the change matches Photoshop as well as elsewhere.
+        assert!(dark - row[w / 3 - 2] < 0.3 && row[w / 3 + 2] - mid < 0.3, "{} {} | {} {}", dark, row[w / 3 - 2], row[w / 3 + 2], mid);
+    }
+
+    #[test]
+    fn the_result_does_not_depend_on_the_image_size() {
+        let probe = |w: usize, h: usize| {
+            let g = gains(&bands(w, h, 1.0), w, h, SHADOWS);
+            [w / 6, w / 2, 5 * w / 6].map(|x| g[(h / 2) * w + x].log2())
+        };
+        let (a, b) = (probe(4928, 1640), probe(1232, 410));
+        assert!(a.iter().zip(&b).all(|(a, b)| (a - b).abs() < 0.02), "{a:?} vs {b:?}");
+    }
+
+    #[test]
+    fn the_black_point_follows_the_darkest_tones() {
+        let (w, h) = (300, 120);
+        let y = bands(w, h, 1.0);
+        let m = ToneMap::new(w, h, |i| y[i], Tone::default(), 0.33).unwrap();
+        assert!((m.black - 0.33 * 2f32.powi(-7)).abs() < 1e-7, "{}", m.black);
+        assert!(m.unblack(m.black * 0.5) == 0.0 && (m.unblack(1.0) - 1.0).abs() < 1e-6);
+        assert!(ToneMap::new(w, h, |i| y[i], Tone::default(), 0.0).is_none());
+    }
+
+    /// log₂ luminance of a `w × h` image: `base` plus a vertical sine of `amp` stops and period `period` px.
+    fn stripes(w: usize, h: usize, base: f32, amp: f32, period: f32) -> Vec<f32> {
+        (0..w * h).map(|i| (base + amp * ((i % w) as f32 * std::f32::consts::TAU / period).sin()).exp2()).collect()
+    }
+
+    /// Peak-to-peak log₂ luminance over the middle row's central half, after the gains.
+    fn swing(y: &[f32], g: &[f32], w: usize, h: usize) -> f32 {
+        let row = (h / 2) * w;
+        let v: Vec<f32> = (w / 4..3 * w / 4).map(|x| (y[row + x] * g[row + x]).log2()).collect();
+        v.iter().cloned().fold(f32::MIN, f32::max) - v.iter().cloned().fold(f32::MAX, f32::min)
+    }
+
+    #[test]
+    fn clarity_raises_midtone_detail_and_minus_flattens_it() {
+        let (w, h) = (1232, 200);
+        let y = stripes(w, h, -2.5, 0.25, 40.0);
+        let before = swing(&y, &vec![1.0; w * h], w, h);
+        let up = swing(&y, &gains(&y, w, h, Tone { clarity: 100.0, ..Tone::NEUTRAL }), w, h);
+        let down = swing(&y, &gains(&y, w, h, Tone { clarity: -100.0, ..Tone::NEUTRAL }), w, h);
+        // Measured: +100 roughly doubles midtone detail, −100 flattens it by more than a third.
+        assert!(up > 1.5 * before && up < 3.5 * before, "{before} → {up}");
+        assert!(down < 0.8 * before && down > 0.1 * before, "{before} → {down}");
+    }
+
+    #[test]
+    fn texture_raises_fine_detail_more_than_coarse_and_leaves_flat_areas() {
+        let (w, h) = (2464, 160);
+        let fine = stripes(w, h, -2.5, 0.1, 6.0);
+        let coarse = stripes(w, h, -2.5, 0.1, 600.0);
+        let gain = |y: &[f32]| swing(y, &gains(y, w, h, Tone { texture: 100.0, ..Tone::NEUTRAL }), w, h) / swing(y, &vec![1.0; w * h], w, h);
+        let (f, c) = (gain(&fine), gain(&coarse));
+        assert!(f > 1.15, "fine detail ×{f}");
+        assert!(c < 1.05 && f > c + 0.1, "coarse ×{c}, fine ×{f}");
+        let flat = vec![0.2f32; 400 * 300];
+        assert!(gains(&flat, 400, 300, Tone { texture: 100.0, ..Tone::NEUTRAL }).iter().all(|g| (g - 1.0).abs() < 1e-4));
+    }
+
+    #[test]
+    fn dehaze_lowers_the_haze_and_minus_adds_a_veil() {
+        // A pale, hazy sky (top) over a darker, colourful ground.
+        let (w, h) = (400, 300);
+        let px: Vec<[f32; 3]> = (0..w * h).map(|i| if i / w < h / 2 { [0.55, 0.6, 0.7] } else { [0.12, 0.08, 0.03] }).collect();
+        let up = Haze::new(w, h, |i| px[i], 100.0).unwrap();
+        let (sky, ground) = (up.apply(200, 40, px[40 * w + 200]), up.apply(200, 260, px[260 * w + 200]));
+        // The airlight itself stays; what is darker than it moves away from it.
+        assert!(sky.iter().zip(&px[40 * w + 200]).all(|(a, b)| (a - b).abs() < 0.02), "{sky:?}");
+        assert!(ground[2] < 0.03 && ground[0] <= 0.12, "{ground:?}");
+        let down = Haze::new(w, h, |i| px[i], -100.0).unwrap();
+        let veiled = down.apply(200, 260, px[260 * w + 200]);
+        assert!((0..3).all(|c| veiled[c] > px[260 * w + 200][c]), "{veiled:?}");
+        assert!(Haze::new(w, h, |i| px[i], 0.0).is_none());
+    }
+
+    #[test]
+    fn retone_changes_nothing_at_zero_and_matches_the_develop_stage() {
+        let (w, h) = (300, 120);
+        let y = bands(w, h, 1.0);
+        let curve = [[0.01, 0.02], [0.1, 0.25], [1.0, 1.0]];
+        let enc = |v: f32| crate::develop::tone(&curve, v).powf(1.0 / 1.8);
+        let px: Vec<[f32; 4]> = y.iter().map(|v| [enc(*v), enc(*v), enc(*v), 1.0]).collect();
+        let mut same = px.clone();
+        retone(&mut same, w, h, &curve, Tone::default());
+        assert_eq!(same, px);
+        let mut out = px.clone();
+        retone(&mut out, w, h, &curve, SHADOWS);
+        let g = gains(&y, w, h, SHADOWS);
+        for i in [60 * w + 50, 60 * w + 150, 60 * w + 250] {
+            assert!((out[i][0] - enc(y[i] * g[i])).abs() < 0.003, "{i}: {} vs {}", out[i][0], enc(y[i] * g[i]));
+        }
+    }
+}
diff --git a/crates/raw/src/tone/tables.rs b/crates/raw/src/tone/tables.rs
new file mode 100644
index 0000000000..eb4892360b
--- /dev/null
+++ b/crates/raw/src/tone/tables.rs
@@ -0,0 +1,66 @@
+//! Measured tables for Clarity and Texture (see the parent module's docs). Generated by
+//! photoshop-acr-re `tools/export_presence.py` from the fits in `tools/presfinal.py`.
+
+/// Clarity's tone knots for the band gains (relative to the frame's mean log₂ luminance)
+/// and for the tone term.
+pub(super) const CLARITY_TONE_LO: f32 = -8.0;
+pub(super) const CLARITY_TONE_STEP: f32 = 2.0;
+pub(super) const CLARITY_BASE_LO: f32 = -8.0;
+pub(super) const CLARITY_BASE_STEP: f32 = 1.0;
+
+/// One direction of Clarity at full strength: per band (finest first) the gain of the band
+/// against its base's tone, the tone term of the coarsest base, and a constant (log₂).
+pub(super) struct Clarity {
+    pub(super) bands: [[f32; 7]; 4],
+    pub(super) base: [f32; 13],
+    pub(super) offset: f32,
+}
+
+/// Clarity +100 (cross-validated effect correlation 0.81).
+pub(super) const CLARITY_UP: Clarity = Clarity {
+    bands: [
+        [0.9573, 0.9573, 0.9573, 1.5534, 1.3206, 1.0011, 1.1671],
+        [1.0920, 1.0920, 1.0920, 1.1946, 0.9268, 0.5702, 1.1336],
+        [0.7149, 0.7149, 0.7149, 0.9739, 0.8363, 0.5026, 0.6025],
+        [0.9620, 0.9620, 0.9620, 0.5886, 0.4937, 0.2263, 0.7602],
+    ],
+    base: [0.2924, 0.2924, 0.2924, 0.2924, 0.2924, 0.2924, 0.1063, 0.0520, 0.2993, 0.2779, -0.0507, -0.0348, -0.2987],
+    offset: -0.2342,
+};
+
+/// Clarity -100 (cross-validated effect correlation 0.92).
+pub(super) const CLARITY_DOWN: Clarity = Clarity {
+    bands: [
+        [-0.0449, -0.0449, -0.0449, 0.0021, -0.5728, -1.0000, -0.8334],
+        [-0.0734, -0.0734, -0.0734, -0.0653, -0.7011, -1.0000, -0.8558],
+        [-0.0462, -0.0462, -0.0462, -0.0394, -0.4121, -0.6502, -0.5797],
+        [0.0527, 0.0527, 0.0527, -0.0505, 0.0206, 0.0066, 0.0594],
+    ],
+    base: [-0.0179, -0.0179, -0.0179, -0.0179, -0.0179, -0.0179, -0.0079, -0.0138, 0.0165, 0.0167, 0.0509, 0.0485, 0.0390],
+    offset: 0.0107,
+};
+
+/// Texture's band-response knots (stops of band detail).
+pub(super) const TEXTURE_KNOTS: [f32; 11] = [-2.0000, -1.0000, -0.5000, -0.2500, -0.1000, 0.0000, 0.1000, 0.2500, 0.5000, 1.0000, 2.0000];
+
+/// Texture +100: per band (σ 0.5 … 16 on the half-size copy) its change against
+/// the band's detail on [`TEXTURE_KNOTS`] (cross-validated correlation 0.89).
+pub(super) const TEXTURE_UP: [[f32; 11]; 6] = [
+    [-0.1951, -0.1951, -0.1951, -0.1951, -0.0637, -0.0122, 0.0595, 0.2096, 0.2096, 0.2096, 0.2096],
+    [-0.0598, -0.0598, -0.0598, -0.1444, -0.0747, -0.0089, 0.0477, 0.0790, 0.0494, 0.0494, 0.0494],
+    [-0.0648, -0.0648, -0.0648, -0.1096, -0.0822, -0.0196, 0.0420, 0.0509, 0.0331, 0.0331, 0.0331],
+    [-0.0886, -0.0886, -0.0886, -0.0958, -0.0526, 0.0136, 0.0836, 0.0817, 0.0851, 0.0851, 0.0851],
+    [-0.0728, -0.0728, -0.0728, -0.0525, -0.0203, 0.0305, 0.0752, 0.0759, 0.0762, 0.0408, 0.0408],
+    [-0.0140, -0.0140, 0.0051, 0.0180, 0.0141, 0.0207, 0.0181, 0.0092, 0.0050, -0.0051, -0.0051],
+];
+
+/// Texture -100: per band (σ 0.5 … 16 on the half-size copy) its change against
+/// the band's detail on [`TEXTURE_KNOTS`] (cross-validated correlation 0.91).
+pub(super) const TEXTURE_DOWN: [[f32; 11]; 6] = [
+    [0.0194, 0.0194, 0.0194, 0.0194, -0.1470, -0.2059, -0.2565, -0.3623, -0.3623, -0.3623, -0.3623],
+    [0.1957, 0.1957, 0.1957, 0.2306, 0.1984, 0.1493, 0.0965, 0.0527, 0.0333, 0.0333, 0.0333],
+    [0.0426, 0.0426, 0.0426, 0.0942, 0.0664, 0.0104, -0.0384, -0.0452, -0.0167, -0.0167, -0.0167],
+    [0.0725, 0.0725, 0.0725, 0.0795, 0.0659, 0.0050, -0.0538, -0.0603, -0.0689, -0.0689, -0.0689],
+    [0.0771, 0.0771, 0.0771, 0.0492, 0.0319, -0.0107, -0.0507, -0.0533, -0.0512, -0.0225, -0.0225],
+    [0.0137, 0.0137, 0.0027, -0.0062, -0.0018, -0.0046, -0.0051, 0.0038, 0.0086, 0.0170, 0.0170],
+];
diff --git a/crates/raw/tests/cr3.rs b/crates/raw/tests/cr3.rs
new file mode 100644
index 0000000000..6907172460
--- /dev/null
+++ b/crates/raw/tests/cr3.rs
@@ -0,0 +1,119 @@
+//! CR3 preview extraction never mistakes encoded sensor data for a JPEG.
+use photocraft_raw::testgen::cr3_preview;
+use photocraft_raw::{RawFormat, embedded_preview, embedded_previews, identify, orientation};
+
+fn jpeg() -> Vec<u8> {
+    vec![0xff, 0xd8, 0xff, 0xc0, 0, 11, 8, 0, 20, 0, 32, 1, 1, 0x11, 0, 0xff, 0xd9]
+}
+
+fn position(b: &[u8], marker: &[u8]) -> usize {
+    b.windows(marker.len()).position(|w| w == marker).unwrap()
+}
+
+#[test]
+fn full_size_jpeg_and_orientation_are_read_from_their_boxes() {
+    let j = jpeg();
+    let b = cr3_preview(&j, 6);
+    assert_eq!(identify(&b), Some(RawFormat::Cr3));
+    let p = embedded_preview(&b).unwrap();
+    assert_eq!((p.width, p.height), (32, 20));
+    assert_eq!(p.jpeg, j);
+    assert_eq!(embedded_previews(&b).len(), 1);
+    assert_eq!(orientation(&b), Some(6));
+}
+
+#[test]
+fn variable_sizes_and_32_bit_chunk_offsets_work() {
+    let mut b = cr3_preview(&jpeg(), 1);
+    let at = position(&b, b"stsz") + 8;
+    // Add a single variable-size entry and repair ancestor lengths/offset.
+    let len = u32::from_be_bytes(b[at..at + 4].try_into().unwrap());
+    b[at..at + 4].fill(0);
+    b.splice(at + 8..at + 8, len.to_be_bytes());
+    for marker in [b"moov", b"trak", b"mdia", b"minf", b"stbl", b"stsz"] {
+        let at = position(&b, marker) - 4;
+        let n = u32::from_be_bytes(b[at..at + 4].try_into().unwrap());
+        b[at..at + 4].copy_from_slice(&(n + 4).to_be_bytes());
+    }
+    let at = position(&b, b"co64");
+    let off = u64::from_be_bytes(b[at + 12..at + 20].try_into().unwrap()) + 4;
+    b[at..at + 4].copy_from_slice(b"stco");
+    b[at + 12..at + 16].copy_from_slice(&(off as u32).to_be_bytes());
+    assert_eq!(embedded_preview(&b).unwrap().jpeg, jpeg());
+}
+
+#[test]
+fn broken_tables_and_raw_codec_tracks_are_not_used() {
+    let good = cr3_preview(&jpeg(), 1);
+    for marker in [b"stsz", b"co64", b"stsc", b"JPEG"] {
+        let mut b = good.clone();
+        let at = position(&b, marker);
+        b[at..at + 4].copy_from_slice(b"xxxx");
+        assert!(embedded_preview(&b).is_none());
+    }
+    let mut b = good.clone();
+    let at = position(&b, b"co64") + 12;
+    b[at..at + 8].copy_from_slice(&u64::MAX.to_be_bytes());
+    assert!(embedded_preview(&b).is_none());
+    let mut b = good;
+    let at = position(&b, b"stsz") + 12;
+    b[at..at + 4].copy_from_slice(&u32::MAX.to_be_bytes());
+    assert!(embedded_preview(&b).is_none());
+}
+
+#[test]
+fn truncations_and_corrupted_box_lengths_never_panic() {
+    let b = cr3_preview(&jpeg(), 8);
+    for n in 0..b.len() {
+        let _ = embedded_previews(&b[..n]);
+        let _ = orientation(&b[..n]);
+    }
+    for marker in [b"ftyp", b"moov", b"trak", b"mdat"] {
+        for len in [0u32, 1, 2, 7, u32::MAX] {
+            let mut corrupt = b.clone();
+            let at = position(&b, marker) - 4;
+            corrupt[at..at + 4].copy_from_slice(&len.to_be_bytes());
+            let _ = embedded_previews(&corrupt);
+        }
+    }
+}
+
+#[test]
+fn extended_mdat_length_is_supported() {
+    let mut b = cr3_preview(&jpeg(), 1);
+    let at = position(&b, b"mdat") - 4;
+    let size = u32::from_be_bytes(b[at..at + 4].try_into().unwrap()) as u64 + 8;
+    b[at..at + 4].copy_from_slice(&1u32.to_be_bytes());
+    b.splice(at + 8..at + 8, size.to_be_bytes());
+    let off = position(&b, b"co64") + 12;
+    let n = u64::from_be_bytes(b[off..off + 8].try_into().unwrap()) + 8;
+    b[off..off + 8].copy_from_slice(&n.to_be_bytes());
+    assert_eq!(embedded_preview(&b).unwrap().jpeg, jpeg());
+}
+
+#[test]
+fn prvw_is_used_when_no_jpeg_track_exists() {
+    fn bx(kind: &[u8; 4], body: &[u8]) -> Vec<u8> {
+        [(body.len() as u32 + 8).to_be_bytes().as_slice(), kind, body].concat()
+    }
+    let ftyp = bx(b"ftyp", b"crx \0\0\0\x01crx isom");
+    let mut body = vec![0; 12];
+    body.extend_from_slice(&(jpeg().len() as u32).to_be_bytes());
+    body.extend(jpeg());
+    let mut uuid = vec![0xea, 0xf4, 0x2b, 0x5e, 0x1c, 0x98, 0x4b, 0x88, 0xb9, 0xfb, 0xb7, 0xdc, 0x40, 0x6e, 0x4d, 0x16];
+    uuid.extend([0; 8]);
+    uuid.extend(bx(b"PRVW", &body));
+    let b = [ftyp, bx(b"uuid", &uuid)].concat();
+    assert_eq!(embedded_preview(&b).unwrap().jpeg, jpeg());
+    assert_eq!(orientation(&b), None);
+}
+
+#[test]
+fn deeply_nested_containers_are_bounded() {
+    let mut b = vec![0; 8];
+    for _ in 0..1000 {
+        b = [((b.len() + 8) as u32).to_be_bytes().as_slice(), b"moov", &b].concat();
+    }
+    let ftyp = [24u32.to_be_bytes().as_slice(), b"ftypcrx \0\0\0\x01crx isom"].concat();
+    assert!(embedded_previews(&[ftyp, b].concat()).is_empty());
+}
diff --git a/crates/raw/tests/development_limits.rs b/crates/raw/tests/development_limits.rs
new file mode 100644
index 0000000000..4e5e1636d3
--- /dev/null
+++ b/crates/raw/tests/development_limits.rs
@@ -0,0 +1,91 @@
+//! Development limits and hostile public sensor metadata.
+use photocraft_raw::testgen::DngSpec;
+use photocraft_raw::*;
+
+fn small_sensor() -> Sensor {
+    decode(&DngSpec::cfa(64, 48, vec![1000; 64 * 48]).build(), &Limits::default()).unwrap()
+}
+
+#[test]
+fn checks_peak_live_buffers_instead_of_summing_disjoint_phases() {
+    let sensor = decode(&DngSpec::cfa(128, 96, vec![1000; 128 * 96]).build(), &Limits::default()).unwrap();
+    let mut opts = DevelopOptions { demosaic: Demosaic::Mhc, ..Default::default() };
+    opts.limits.max_alloc = 128 * 96 * 18 + (4096 + 2) * 4;
+    let expected = develop_sensor(&sensor, &DevelopOptions { demosaic: Demosaic::Mhc, ..Default::default() }).unwrap();
+    assert_eq!(develop_sensor(&sensor, &opts).unwrap().rgb, expected.rgb);
+    opts.limits.max_alloc -= 1;
+    assert!(matches!(develop_sensor(&sensor, &opts), Err(RawError::LimitExceeded(_))));
+}
+
+#[test]
+fn monochrome_and_rgb_linear_raw_preserve_output_and_memory_limits() {
+    let (w, h) = (32, 24);
+    for samples in [1, 3] {
+        let data = (0..w * h).flat_map(|i| (0..samples).map(move |c| (i % w * 1000 + c * 5000) as u16)).collect();
+        let spec = DngSpec { samples, monochrome: samples == 1, ..DngSpec::cfa(w, h, data) };
+        let sensor = decode(&spec.build(), &Limits::default()).unwrap();
+        assert!(sensor.cfa.is_none());
+        assert_eq!(sensor.samples, samples);
+        let expected = develop_sensor(&sensor, &DevelopOptions::default()).unwrap();
+        let mut opts = DevelopOptions::default();
+        opts.limits.max_alloc = 32 * 1024;
+        let got = develop_sensor(&sensor, &opts).unwrap();
+        assert_eq!(got.rgb, expected.rgb);
+        assert_eq!((got.width, got.height), (w as u32, h as u32));
+        if samples == 1 {
+            assert!(got.rgb.as_chunks::<3>().0.iter().all(|p| p[0] == p[1] && p[1] == p[2]));
+        }
+        // Even the encoded RGB output alone cannot fit this budget.
+        opts.limits.max_alloc = (expected.rgb.len() * 2 - 1) as u64;
+        assert!(matches!(develop_sensor(&sensor, &opts), Err(RawError::LimitExceeded(_))));
+    }
+}
+
+#[test]
+fn invalid_public_sensor_metadata_returns_errors() {
+    let sensor = small_sensor();
+    let mut cases = Vec::new();
+    let mut s = sensor.clone();
+    s.crop.x = usize::MAX;
+    cases.push(s);
+    let mut s = sensor.clone();
+    s.width = usize::MAX;
+    cases.push(s);
+    let mut s = sensor.clone();
+    s.samples = usize::MAX;
+    cases.push(s);
+    let mut s = sensor.clone();
+    s.cfa.as_mut().unwrap().width = 0;
+    cases.push(s);
+    let mut s = sensor.clone();
+    s.cfa.as_mut().unwrap().colors.clear();
+    cases.push(s);
+    let mut s = sensor.clone();
+    s.cfa.as_mut().unwrap().colors[0] = 255;
+    cases.push(s);
+    let mut s = sensor.clone();
+    s.cfa = None;
+    s.samples = 2;
+    s.data.resize(64 * 48 * 2, 1000);
+    cases.push(s);
+    let mut s = sensor.clone();
+    s.samples = 3;
+    s.data.resize(64 * 48 * 3, 1000);
+    cases.push(s);
+    for s in cases {
+        assert!(develop_sensor(&s, &DevelopOptions::default()).is_err());
+    }
+}
+
+#[test]
+fn extreme_cfa_and_black_origins_do_not_overflow() {
+    let mut sensor = small_sensor();
+    let cfa = sensor.cfa.as_mut().unwrap();
+    cfa.origin_x = usize::MAX;
+    cfa.origin_y = usize::MAX;
+    assert!(cfa.is_bayer());
+    sensor.black.rows = usize::MAX;
+    sensor.black.cols = usize::MAX;
+    assert!(develop_sensor(&sensor, &DevelopOptions::default()).is_ok());
+    assert_eq!(Cfa { width: 0, height: 0, colors: vec![], origin_x: 0, origin_y: 0 }.color(1, 2), 1);
+}
diff --git a/crates/raw/tests/dng.rs b/crates/raw/tests/dng.rs
index 9dfab5dfd7..e13fb920dd 100644
--- a/crates/raw/tests/dng.rs
+++ b/crates/raw/tests/dng.rs
@@ -425,6 +425,31 @@ fn highlights_clip_to_white_and_exposure_applies() {
     assert!((lin(up) / lin(base) - 2.0).abs() < 0.02, "{} vs {}", lin(up), lin(base));
 }
 
+/// storytold/photocraft#4348 (as storytold/lightcraft#548): a 12-bit DNG that states WhiteLevel 4095
+/// but whose sensor saturates at 3567 in every colour. Under the camera's white balance (red x2.46,
+/// blue x1.59) the stuck red and blue samples clip at 1 while green stays at 0.85, so a blown wall
+/// rendered magenta. The wall must come out neutral, and the unclipped ramp beside it unchanged.
+#[test]
+fn highlights_that_clip_below_the_stated_white_level_stay_neutral() {
+    let (w, h) = (64, 32);
+    let data: Vec<u16> = (0..w * h).map(|i| if i % w < w / 2 { 528 + ((i % w) * 90 + (i / w) * 3) as u16 } else { 3567 }).collect();
+    let mut spec = DngSpec::cfa(w, h, data.clone());
+    spec.bits = 12;
+    spec.black = vec![528];
+    spec.white = 4095;
+    spec.as_shot_neutral = Some([1.0 / 2.46, 1.0, 1.0 / 1.59]);
+    let b = spec.build();
+    let d = develop(&b, &DevelopOptions::default()).unwrap();
+    let px = &d.rgb[(16 * w + 48) * 3..(16 * w + 48) * 3 + 3];
+    let lin = |v: u16| (f64::from(v) / 65535.0).powf(1.8);
+    let tint = (lin(px[0]) / lin(px[1]) - 1.0).abs().max((lin(px[2]) / lin(px[1]) - 1.0).abs());
+    assert!(tint < 0.01, "the clipped wall is tinted: {px:?}");
+    let s = sensor(&b);
+    for (i, (&got, &was)) in s.data.iter().zip(&data).enumerate() {
+        assert_eq!(got, if was == 3567 { 4095 } else { was }, "sample {i}");
+    }
+}
+
 #[test]
 fn gain_map_opcode_is_applied() {
     // Uniform 0.25 grey; a gain map that doubles everything over the whole image.
diff --git a/crates/raw/tests/hostile.rs b/crates/raw/tests/hostile.rs
index dabe9ffe9e..4b91f2f103 100644
--- a/crates/raw/tests/hostile.rs
+++ b/crates/raw/tests/hostile.rs
@@ -88,6 +88,7 @@ fn exercise(b: &[u8]) {
     let _ = identify(b);
     let _ = embedded_preview(b);
     let _ = embedded_previews(b);
+    let _ = embedded_preview_color_space(b);
     let opts = DevelopOptions { limits: Limits { max_alloc: 64 << 20, ..Limits::default() }, ..Default::default() };
     if let Ok(s) = decode(b, &opts.limits) {
         for m in [Demosaic::Bilinear, Demosaic::Ahd] {
diff --git a/crates/raw/tests/vendor_codecs.rs b/crates/raw/tests/vendor_codecs.rs
index e210c6f31b..2d91a322a5 100644
--- a/crates/raw/tests/vendor_codecs.rs
+++ b/crates/raw/tests/vendor_codecs.rs
@@ -2,7 +2,7 @@
 //! Sony compressed ARW (cRAW), Panasonic RW2 (RawFormat 5) and uncompressed
 //! Olympus ORF (with its maker-note preview).
 
-use photocraft_raw::testgen::{craw_block, mosaic, orf, rw2, scene, sony_craw};
+use photocraft_raw::testgen::{craw_block, mosaic, orf, rw2, rw2_format4, scene, sony_craw};
 use photocraft_raw::*;
 
 const CURVE: [u16; 4] = [8000, 10400, 12900, 14100];
@@ -176,13 +176,63 @@ fn patch_ifd0_short(b: &mut [u8], tag: u16, v: u16) {
 }
 
 #[test]
-fn rw2_compressed_formats_fall_back() {
+fn rw2_format4_round_trip_is_exact() {
+    let (w, h) = (42, 6);
+    let mut data = Vec::with_capacity(w * h);
+    for y in 0..h {
+        for x in 0..w {
+            data.push(200 + 4 * (y as u16) + 3 * (x as u16));
+        }
+    }
+    let b = rw2_format4(w, h, &data);
+    assert_eq!(identify(&b), Some(RawFormat::Rw2));
+    let s = decode(&b, &Limits::default()).unwrap();
+    assert_eq!((s.width, s.height), (w, h));
+    assert_eq!(s.data, data);
+    assert_eq!(s.cfa.as_ref().unwrap().phase(0, 0), [0, 1, 1, 2]);
+    // The compressed variants record a black level 15 counts below the black
+    // of the decoded samples.
+    assert_eq!(s.black.values, vec![143.0, 144.0, 144.0, 145.0]);
+    assert_eq!(s.white, [4095.0; 3]);
+    assert_eq!(s.camera_wb, Some([2.0, 1.0, 1.5]));
+    assert_eq!(s.crop, Rect::new(2, 2, w - 4, h - 4));
+    assert!(s.warnings.is_empty(), "{:?}", s.warnings);
+    let d = develop_sensor(&s, &DevelopOptions::default()).unwrap();
+    assert_eq!((d.width as usize, d.height as usize), (w - 4, h - 4));
+}
+
+#[test]
+fn rw2_format4_crosses_pages() {
+    // 16 bytes a row: 1100 rows walk past several 0x4000-byte page boundaries.
+    let (w, h) = (14, 1100);
+    let mut data = Vec::with_capacity(w * h);
+    for y in 0..h {
+        for x in 0..w {
+            data.push(300 + 16 * ((y % 8) as u16) + 3 * (x as u16));
+        }
+    }
+    let b = rw2_format4(w, h, &data);
+    let s = decode(&b, &Limits::default()).unwrap();
+    assert_eq!(s.data, data);
+}
+
+#[test]
+fn rw2_format4_rejects_other_block_widths() {
+    let (w, h) = (42, 2);
+    let data: Vec<u16> = (0..w * h).map(|i| 200 + (i % 14) as u16 * 3).collect();
+    let mut b = rw2_format4(w, h, &data);
+    patch_ifd0_short(&mut b, 0x0002, 41);
+    assert!(matches!(decode(&b, &Limits::default()), Err(RawError::Unsupported(_))));
+}
+
+#[test]
+fn rw2_undecoded_formats_fall_back() {
     let data = vec![200u16; 20 * 4];
     let mut b = rw2(20, 4, &data, 12);
     assert!(decode(&b, &Limits::default()).is_ok());
-    patch_ifd0_short(&mut b, 0x002D, 4);
+    patch_ifd0_short(&mut b, 0x002D, 6);
     match decode(&b, &Limits::default()) {
-        Err(RawError::Unsupported(m)) => assert!(m.contains("raw format 4"), "{m}"),
+        Err(RawError::Unsupported(m)) => assert!(m.contains("raw format 6"), "{m}"),
         other => panic!("expected unsupported, got {other:?}"),
     }
     // Width not made of whole blocks.
diff --git a/crates/text/src/fonts.rs b/crates/text/src/fonts.rs
index 1d728f14d4..5ce71e59ac 100644
--- a/crates/text/src/fonts.rs
+++ b/crates/text/src/fonts.rs
@@ -59,7 +59,7 @@ fn inflate_font(deflated: &[u8]) -> Vec<u8> {
 
 /// Families tried (if installed) after the requested one, for missing glyphs. The Southeast Asian
 /// and CJK families ([`THAI_FAMILIES`], [`KHMER_FAMILIES`], [`LAO_FAMILIES`], [`MYANMAR_FAMILIES`],
-/// [`crate::cjk::families`]) go between these two lists, in the UI locale's script order.
+/// [`INDIC_FAMILIES`], [`crate::cjk::families`]) go between these two lists, in the UI locale's script order.
 const FALLBACK_CANDIDATES: &[&str] = &["Noto Sans", "Segoe UI", "DejaVu Sans", "Geeza Pro", "Arial Hebrew", "Noto Sans Arabic", "Noto Sans Hebrew"];
 /// Thai-capable families: Windows (Leelawadee UI since Windows 8; Tahoma and Leelawadee on
 /// older systems), macOS (Thonburi, Sukhumvit Set) and Linux (Noto). Text in a font without Thai
@@ -76,6 +76,38 @@ pub const LAO_FAMILIES: &[&str] = &["Lao Sangam MN", "Lao MN", "Lao UI", "Noto S
 /// Myanmar/Burmese-capable families: macOS (Myanmar Sangam MN, Myanmar MN), Windows (Myanmar Text)
 /// and Linux (Noto).
 pub const MYANMAR_FAMILIES: &[&str] = &["Myanmar Sangam MN", "Myanmar MN", "Myanmar Text", "Noto Sans Myanmar"];
+/// Indic-script families for document text. Windows has `Nirmala UI` for all nine scripts (from
+/// Windows 8); macOS has the Kohinoor and Sangam MN families; Linux has Noto Sans. Indic text in a
+/// font without these glyphs had no candidate to fall back to and drew .notdef boxes (#218).
+pub const DEVANAGARI_FAMILIES: &[&str] = &["Nirmala UI", "Kohinoor Devanagari", "Devanagari Sangam MN", "Noto Sans Devanagari", "Noto Sans Devanagari UI"];
+/// Bengali-capable families (see [`DEVANAGARI_FAMILIES`]).
+pub const BENGALI_FAMILIES: &[&str] = &["Nirmala UI", "Kohinoor Bangla", "Bangla Sangam MN", "Noto Sans Bengali", "Noto Sans Bengali UI"];
+/// Gurmukhi-capable families (see [`DEVANAGARI_FAMILIES`]).
+pub const GURMUKHI_FAMILIES: &[&str] = &["Nirmala UI", "Gurmukhi Sangam MN", "Noto Sans Gurmukhi", "Noto Sans Gurmukhi UI"];
+/// Gujarati-capable families (see [`DEVANAGARI_FAMILIES`]).
+pub const GUJARATI_FAMILIES: &[&str] = &["Nirmala UI", "Kohinoor Gujarati", "Gujarati Sangam MN", "Noto Sans Gujarati", "Noto Sans Gujarati UI"];
+/// Tamil-capable families (see [`DEVANAGARI_FAMILIES`]).
+pub const TAMIL_FAMILIES: &[&str] = &["Nirmala UI", "Tamil Sangam MN", "Noto Sans Tamil", "Noto Sans Tamil UI"];
+/// Telugu-capable families (see [`DEVANAGARI_FAMILIES`]).
+pub const TELUGU_FAMILIES: &[&str] = &["Nirmala UI", "Kohinoor Telugu", "Telugu Sangam MN", "Noto Sans Telugu", "Noto Sans Telugu UI"];
+/// Kannada-capable families (see [`DEVANAGARI_FAMILIES`]).
+pub const KANNADA_FAMILIES: &[&str] = &["Nirmala UI", "Kannada Sangam MN", "Noto Sans Kannada", "Noto Sans Kannada UI"];
+/// Malayalam-capable families (see [`DEVANAGARI_FAMILIES`]).
+pub const MALAYALAM_FAMILIES: &[&str] = &["Nirmala UI", "Malayalam Sangam MN", "Noto Sans Malayalam", "Noto Sans Malayalam UI"];
+/// Sinhala-capable families (see [`DEVANAGARI_FAMILIES`]).
+pub const SINHALA_FAMILIES: &[&str] = &["Nirmala UI", "Sinhala Sangam MN", "Noto Sans Sinhala", "Noto Sans Sinhala UI"];
+/// All Indic-script families, in the order they join the fallback candidates.
+pub const INDIC_FAMILIES: &[&[&str]] = &[
+    DEVANAGARI_FAMILIES,
+    BENGALI_FAMILIES,
+    GURMUKHI_FAMILIES,
+    GUJARATI_FAMILIES,
+    TAMIL_FAMILIES,
+    TELUGU_FAMILIES,
+    KANNADA_FAMILIES,
+    MALAYALAM_FAMILIES,
+    SINHALA_FAMILIES,
+];
 /// Broad-coverage and emoji fonts, tried after the CJK script fonts so shared Han characters get
 /// the locale's forms instead of Arial Unicode's.
 const FALLBACK_LAST: &[&str] = &["Arial Unicode MS", "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji"];
@@ -87,6 +119,14 @@ pub fn fallback_candidates(order: &[crate::cjk::CjkScript; 4]) -> Vec<&'static s
     v.extend_from_slice(KHMER_FAMILIES);
     v.extend_from_slice(LAO_FAMILIES);
     v.extend_from_slice(MYANMAR_FAMILIES);
+    for fams in INDIC_FAMILIES {
+        for f in *fams {
+            // Nirmala UI covers all nine scripts and is listed by each; probe it once.
+            if !v.contains(f) {
+                v.push(f);
+            }
+        }
+    }
     for s in order {
         // craft-fonts' Japanese fonts (if built in) go ahead of the installed Japanese fonts, in
         // the Japanese slot of the locale order, so shared Han keeps the locale's forms.
@@ -109,6 +149,16 @@ pub fn generation() -> u64 {
     GENERATION.load(Ordering::Relaxed)
 }
 
+/// Bumped only by the [`FontDb`] of [`crate::shared`], so caches of the shared engine's fonts
+/// aren't invalidated by unrelated databases (a document's own engine, a test's throwaway one).
+static SHARED_GENERATION: AtomicU64 = AtomicU64::new(0);
+
+/// Changes whenever font data is registered in the shared engine's [`FontDb`] ([`crate::shared`]).
+/// Font menus key their caches on this, not [`generation`].
+pub fn shared_generation() -> u64 {
+    SHARED_GENERATION.load(Ordering::Relaxed)
+}
+
 /// One face in the database (for font menus).
 #[derive(Clone, Debug, PartialEq)]
 pub struct FaceInfo {
@@ -140,8 +190,13 @@ pub struct FontDb {
     /// PostScript name → (family, weight, italic), filled lazily.
     ps_cache: HashMap<String, Option<ResolvedFont>>,
     fallbacks: Vec<String>,
+    /// Preferences ▸ Type ▸ Missing Glyph Protection: route glyphs the chosen face lacks through
+    /// [`Self::fallback_stack`] (#1909). Off, only the default family shapes the text.
+    missing_glyph_protection: bool,
     face_cache: HashMap<String, Vec<FaceInfo>>,
     face_aliases: HashMap<(String, usize), String>,
+    /// This is the shared engine's database: registrations also move [`shared_generation`].
+    shared: bool,
 }
 
 impl Default for FontDb {
@@ -159,8 +214,10 @@ impl FontDb {
             system_loaded: false,
             ps_cache: HashMap::new(),
             fallbacks: Vec::new(),
+            missing_glyph_protection: true,
             face_cache: HashMap::new(),
             face_aliases: HashMap::new(),
+            shared: false,
         };
         for (_, bytes) in BUNDLED {
             db.register_static_font(bytes.as_slice());
@@ -242,9 +299,19 @@ impl FontDb {
         self.face_cache.clear();
         self.refresh_generics();
         GENERATION.fetch_add(1, Ordering::Relaxed);
+        if self.shared {
+            SHARED_GENERATION.fetch_add(1, Ordering::Relaxed);
+        }
         names
     }
 
+    /// Marks this as the shared engine's database ([`crate::shared`]) and moves
+    /// [`shared_generation`], since its fonts replace whatever caches saw before.
+    pub(crate) fn mark_shared(&mut self) {
+        self.shared = true;
+        SHARED_GENERATION.fetch_add(1, Ordering::Relaxed);
+    }
+
     fn refresh_generics(&mut self) {
         let c = &mut self.fcx.collection;
         if let Some(inter) = c.family_id(DEFAULT_FAMILY) {
@@ -272,8 +339,20 @@ impl FontDb {
     }
 
     /// Families available after the requested one (bundled default + installed coverage fonts).
+    /// With missing glyph protection off (Preferences ▸ Type), only the default family shapes.
     pub(crate) fn fallback_stack(&self) -> impl Iterator<Item = &str> {
-        std::iter::once(DEFAULT_FAMILY).chain(self.fallbacks.iter().map(String::as_str))
+        let fallbacks = self.missing_glyph_protection.then_some(self.fallbacks.iter().map(String::as_str));
+        std::iter::once(DEFAULT_FAMILY).chain(fallbacks.into_iter().flatten())
+    }
+
+    /// Preferences ▸ Type ▸ Missing Glyph Protection, applied by the engine's `apply_prefs`.
+    pub fn set_missing_glyph_protection(&mut self, on: bool) {
+        self.missing_glyph_protection = on;
+    }
+
+    /// Is missing glyph protection on?
+    pub fn missing_glyph_protection(&self) -> bool {
+        self.missing_glyph_protection
     }
 
     /// All family names, sorted.
@@ -505,11 +584,77 @@ pub fn face_count(bytes: &[u8]) -> usize {
     }
 }
 
+// CamelCase style suffix of a name without a hyphen (`GmarketSansBold`). Only a capitalised word
+// counts ("Daylight" keeps its "light"), and one after a vendor tag stays in a legacy family name
+// (`ArialRoundedMTBold` is the family "Arial Rounded MT Bold").
+fn split_trailing_style(ps: &str) -> (&str, &str) {
+    let base = ps.trim_end_matches("MT").trim_end_matches("PS");
+    let mut family = base;
+    for suffix in ["Italic", "Oblique"] {
+        if let Some(rest) = family.strip_suffix(suffix).filter(|s| !s.is_empty()) {
+            family = rest;
+            break;
+        }
+    }
+    for suffix in [
+        "ExtraLight",
+        "UltraLight",
+        "ExtraBold",
+        "UltraBold",
+        "SemiBold",
+        "DemiBold",
+        "Hairline",
+        "Regular",
+        "Medium",
+        "Normal",
+        "Heavy",
+        "Black",
+        "Light",
+        "Thin",
+        "Bold",
+        "Demi",
+    ] {
+        if let Some(rest) = family.strip_suffix(suffix).filter(|s| !s.is_empty()) {
+            family = rest;
+            break;
+        }
+    }
+    if family.len() < base.len() && !family.ends_with("MT") { (family, ps.get(family.len()..).unwrap_or("")) } else { (ps, "") }
+}
+
 /// Heuristic PostScript-name split: `MyriadPro-BoldIt` → ("Myriad Pro", 700, italic).
 pub fn guess_from_postscript(ps: &str) -> ResolvedFont {
-    let (fam, style) = ps.split_once('-').unwrap_or((ps, ""));
-    let fam = fam.trim_end_matches("MT").trim_end_matches("PS").trim_end_matches("Std").trim_end_matches("Pro");
-    let pro = ps.split_once('-').map_or(ps, |p| p.0);
+    // A vendor or family name may contain hyphens; start with the final face suffix.
+    let (mut pro, mut style) = ps.rsplit_once('-').unwrap_or_else(|| split_trailing_style(ps));
+    // Keep compound style suffixes the old heuristic understood, such as Bold-It.
+    // Regular alone must not consume a family component named Bold or Black.
+    if matches!(style.to_ascii_lowercase().as_str(), "it" | "italic" | "oblique")
+        && let Some((family, weight)) = pro.rsplit_once('-')
+        && matches!(
+            weight.to_ascii_lowercase().as_str(),
+            "thin"
+                | "hairline"
+                | "extralight"
+                | "ultralight"
+                | "light"
+                | "regular"
+                | "roman"
+                | "book"
+                | "medium"
+                | "semibold"
+                | "demibold"
+                | "demi"
+                | "bold"
+                | "extrabold"
+                | "ultrabold"
+                | "heavy"
+                | "black"
+        )
+    {
+        pro = family;
+        style = ps.strip_prefix(family).and_then(|s| s.strip_prefix('-')).unwrap_or(style);
+    }
+    let fam = pro.trim_end_matches("MT").trim_end_matches("PS").trim_end_matches("Std").trim_end_matches("Pro");
     let suffix = if pro.ends_with("Pro") {
         " Pro"
     } else if pro.ends_with("Std") {
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index f7494bd992..55f9e0a539 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -43,6 +43,25 @@ enum SmallCapsMode {
     Synthetic,
 }
 
+/// Index of the run containing byte offset `off`, given each run's start offset (non-decreasing):
+/// the last run starting at or before `off`, or 0 when none does. Binary search, so a layer with
+/// many runs doesn't make per-character lookups quadratic.
+fn run_index_at(run_starts: &[usize], off: usize) -> usize {
+    run_starts.partition_point(|&s| s <= off).saturating_sub(1)
+}
+
+/// Whether the style's selected face has an `smcp` feature (a font load and GSUB parse).
+fn probe_smcp(fonts: &mut FontDb, style: &CharStyle) -> bool {
+    #[cfg(test)]
+    SMCP_PROBES.with(|c| c.set(c.get() + 1));
+    fonts.selected_face_has_feature(&style.font_family, style.weight, style.italic, Tag::new(b"smcp"))
+}
+
+#[cfg(test)]
+thread_local! {
+    static SMCP_PROBES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
 fn small_caps_mode(caps: Caps, face_has_smcp: bool) -> SmallCapsMode {
     match caps {
         Caps::SmallCaps if face_has_smcp => SmallCapsMode::OpenType,
@@ -469,7 +488,7 @@ impl Layouter {
                 Some(s)
             })
             .collect();
-        let style_at = |off: usize| run_starts.iter().rposition(|&s| s <= off).unwrap_or(0);
+        let style_at = |off: usize| run_index_at(&run_starts, off);
         let para_starts: Vec<usize> = paras
             .iter()
             .scan(0, |a, r| {
@@ -483,11 +502,23 @@ impl Layouter {
         let text = &t.text;
         let (box_rect, is_box) = match t.shape {
             TextShape::Box { x, y, width, height } => ((x, y, width, height), true),
-            TextShape::Point => ((0.0, 0.0, 0.0, 0.0), false),
+            // Path text is laid out as one point-text line, then bent onto the path.
+            TextShape::Point | TextShape::Path { .. } => ((0.0, 0.0, 0.0, 0.0), false),
         };
         let mut prev_baseline: Option<f32> = None;
         let mut pending_space = 0.0f32;
         let mut stop = false;
+        // Fixed for the whole layout, and the font probe only matters for styles that use small
+        // caps. A real `smcp` substitution must receive lowercase source text; only the fallback
+        // path uppercases it and scales it down.
+        let small_caps: Vec<SmallCapsMode> = out
+            .styles
+            .iter()
+            .map(|style| match style.caps {
+                Caps::SmallCaps => small_caps_mode(style.caps, probe_smcp(fonts, style)),
+                _ => SmallCapsMode::None,
+            })
+            .collect();
         for (pi, prange) in split_paragraphs(text).into_iter().enumerate() {
             if stop {
                 break;
@@ -502,13 +533,6 @@ impl Layouter {
             };
             let mut ptext = String::with_capacity(prefix.len() + content.len());
             ptext.push_str(prefix);
-            // A real `smcp` substitution must receive lowercase source text; only the fallback
-            // path uppercases it and scales it down.
-            let small_caps: Vec<SmallCapsMode> = out
-                .styles
-                .iter()
-                .map(|style| small_caps_mode(style.caps, fonts.selected_face_has_feature(&style.font_family, style.weight, style.italic, Tag::new(b"smcp"))))
-                .collect();
             // Ranges in `ptext` for lowercase characters rendered as synthetic small caps.
             // They have the same UTF-8 length as their uppercase form, so the layer's byte-based
             // run and caret offsets remain unchanged.
@@ -702,7 +726,11 @@ impl Layouter {
                     Some(b) => b + leading + pending_space,
                 };
                 pending_space = 0.0;
-                let overflow = if vertical { baseline + descent > -box_rect.0 + 0.5 } else { baseline + descent > box_rect.1 + box_rect.3 + 0.5 };
+                // Photoshop keeps a horizontal line whose baseline is inside the box and lets
+                // its descenders hang below the bottom edge (#1317: three 35 pt lines in a
+                // 91.3 pt box, the last baseline at 88). Requiring the descent to fit dropped
+                // that line.
+                let overflow = if vertical { baseline + descent > -box_rect.0 + 0.5 } else { baseline > box_rect.1 + box_rect.3 + 0.5 };
                 if is_box && overflow {
                     stop = true;
                     break;
@@ -1350,7 +1378,63 @@ fn first_ascent(line: &parley::Line<'_, RunBrush>) -> Option<f32> {
 #[cfg(test)]
 mod tests {
     use super::{SmallCapsMode, feature_list, small_caps_mode, variation_list};
-    use photocraft_doc::text::{Caps, CharStyle, FontVariation};
+    use photocraft_doc::TextLayer;
+    use photocraft_doc::text::{Caps, CharStyle, FontVariation, TextRun};
+
+    /// Reference: the lookup the layout used before it became a binary search.
+    fn run_index_reference(starts: &[usize], off: usize) -> usize {
+        starts.iter().rposition(|&s| s <= off).unwrap_or(0)
+    }
+
+    #[test]
+    fn run_lookup_matches_the_linear_reference() {
+        // Deterministic pseudo-random run layouts with empty runs, equal adjacent styles and
+        // offsets past the end.
+        let mut seed = 0x2545_f491_4f6c_dd1d_u64;
+        let mut next = move |m: u64| {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            (seed % m) as usize
+        };
+        for _ in 0..300 {
+            let n = next(12);
+            let mut acc = 0;
+            let starts: Vec<usize> = (0..n)
+                .map(|_| {
+                    let s = acc;
+                    acc += next(4); // 0 = empty run
+                    s
+                })
+                .collect();
+            for off in 0..acc + 4 {
+                assert_eq!(super::run_index_at(&starts, off), run_index_reference(&starts, off), "{starts:?} @ {off}");
+            }
+        }
+        assert_eq!(super::run_index_at(&[], 5), 0);
+    }
+
+    /// Many runs and paragraphs: the font is probed once per small-caps style per layout, not
+    /// once per style per paragraph, and styles that don't use small caps are never probed.
+    #[test]
+    fn small_caps_probe_runs_once_per_small_caps_style() {
+        let plain = CharStyle { font_family: "Inter".into(), ..Default::default() };
+        let small = CharStyle { caps: Caps::SmallCaps, ..plain.clone() };
+        let text: String = "a\n".repeat(300);
+        let runs = |small_every: usize| -> Vec<TextRun> {
+            (0..text.len()).map(|i| TextRun { len: 1, style: if small_every > 0 && i % small_every == 0 { small.clone() } else { plain.clone() } }).collect()
+        };
+        let mut engine = crate::TextEngine::new();
+        let mut probes = |small_every: usize| {
+            super::SMCP_PROBES.with(|c| c.set(0));
+            let layer = TextLayer { text: text.clone(), runs: runs(small_every), ..Default::default() };
+            let _ = engine.layout(&layer, 72.0);
+            super::SMCP_PROBES.with(|c| c.get())
+        };
+        assert_eq!(probes(0), 0);
+        let styles = text.len().div_ceil(2); // every other index is a small-caps run
+        assert_eq!(probes(2), styles);
+    }
 
     /// A variable font's optical size follows the type size unless the style sets `opsz` (#2985).
     #[test]
diff --git a/crates/text/src/lib.rs b/crates/text/src/lib.rs
index da323b5a22..7909199a6f 100644
--- a/crates/text/src/lib.rs
+++ b/crates/text/src/lib.rs
@@ -125,7 +125,7 @@ impl TextEngine {
     /// Lays out and rasterizes a text layer into document space.
     pub fn render(&mut self, layer: &TextLayer, dpi: f32, format: PixelFormat) -> (TextLayout, Rendered) {
         let l = self.layout(layer, dpi);
-        let warp = render::layout_warp(&l, layer.warp.as_ref());
+        let warp = render::layout_deform(&l, layer);
         let r = render::rasterize_warped(&l, &layer.transform, format, layer.antialias, warp.as_ref());
         (l, r)
     }
@@ -147,7 +147,9 @@ fn uses_system_fonts() -> bool {
 }
 
 fn new_shared() -> std::sync::Mutex<TextEngine> {
-    std::sync::Mutex::new(if uses_system_fonts() { TextEngine::with_system_fonts() } else { TextEngine::new() })
+    let mut engine = if uses_system_fonts() { TextEngine::with_system_fonts() } else { TextEngine::new() };
+    engine.fonts.mark_shared();
+    std::sync::Mutex::new(engine)
 }
 
 /// A process-wide engine for callers without their own (bundled fonts only on the web; bundled
@@ -165,6 +167,43 @@ pub fn try_shared() -> Option<&'static std::sync::Mutex<TextEngine>> {
     SHARED.try_get(new_shared, uses_system_fonts())
 }
 
+/// Preferences › Type › Enable Missing Glyph Protection for [`shared`]: 0 = not set yet,
+/// 1 = off, 2 = on. Read under the engine's lock, so the newest setting always wins.
+static WANT_GLYPH_PROTECTION: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
+/// A thread is already waiting for the font scan to apply [`WANT_GLYPH_PROTECTION`].
+static GLYPH_PROTECTION_WAITING: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+
+fn apply_glyph_protection(engine: &std::sync::Mutex<TextEngine>) {
+    let mut e = engine.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    match WANT_GLYPH_PROTECTION.load(std::sync::atomic::Ordering::SeqCst) {
+        1 => e.fonts.set_missing_glyph_protection(false),
+        2 => e.fonts.set_missing_glyph_protection(true),
+        _ => {}
+    }
+}
+
+/// Sets [`shared`]'s missing-glyph protection without waiting for the system font scan (#4519):
+/// applied now when the engine is built, otherwise by a helper thread once the scan finishes.
+/// Called from the UI thread at launch and on every preferences change, where [`shared`] would
+/// block until the scan is done.
+pub fn set_shared_missing_glyph_protection(on: bool) {
+    WANT_GLYPH_PROTECTION.store(if on { 2 } else { 1 }, std::sync::atomic::Ordering::SeqCst);
+    if let Some(engine) = try_shared() {
+        apply_glyph_protection(engine);
+        return;
+    }
+    if GLYPH_PROTECTION_WAITING.swap(true, std::sync::atomic::Ordering::SeqCst) {
+        // The waiting thread reads the newest setting when it applies it.
+        return;
+    }
+    let spawned = std::thread::Builder::new().name("photocraft-glyph-protection".into()).spawn(|| apply_glyph_protection(shared()));
+    if spawned.is_err() {
+        // No thread: apply it here, as before.
+        GLYPH_PROTECTION_WAITING.store(false, std::sync::atomic::Ordering::SeqCst);
+        apply_glyph_protection(shared());
+    }
+}
+
 /// Starts building [`shared`] (the system font scan) on a background thread, so the Type tool's
 /// font menus don't stall the UI when they first draw. Call once at startup; calling again does
 /// nothing.
diff --git a/crates/text/src/psd.rs b/crates/text/src/psd.rs
index c6724bf2cc..3f8ce72902 100644
--- a/crates/text/src/psd.rs
+++ b/crates/text/src/psd.rs
@@ -12,7 +12,7 @@
 use photocraft_color::{Color, ColorMode};
 use photocraft_doc::TextLayer;
 use photocraft_doc::text::{AntiAlias, Caps, CharStyle, Kerning, Orientation, ParagraphRun, ParagraphStyle, TextAlign, TextRun, TextShape, TextWarp};
-use photocraft_geom::Affine;
+use photocraft_geom::{Affine, Point};
 use photocraft_psd::descriptor::{Descriptor, Id, UnicodeString, Value as D, VersionedDescriptor};
 
 use crate::engine_data::{self as ed, Value as E};
@@ -24,8 +24,10 @@ pub struct TySh {
     pub transform: Affine,
     pub text: Descriptor,
     pub warp: Option<Descriptor>,
-    /// The four trailing i32 values (left, top, right, bottom).
-    pub bounds: [i32; 4],
+    /// The four trailing big-endian f32 values (left, top, right, bottom) after the warp
+    /// descriptor. Photoshop writes zeros for unwarped type and the text-space bounds (the
+    /// `bounds` descriptor's rectangle) for warped type.
+    pub bounds: [f32; 4],
 }
 
 /// Parses a `TySh` block.
@@ -42,10 +44,10 @@ pub fn parse_tysh(data: &[u8]) -> Option<TySh> {
         None => (None, 0),
     };
     let tail = rest.get(wused..).unwrap_or(&[]);
-    let mut bounds = [0i32; 4];
+    let mut bounds = [0f32; 4];
     for (i, b) in bounds.iter_mut().enumerate() {
         if let Some(x) = tail.get(i * 4..i * 4 + 4) {
-            *b = i32::from_be_bytes(x.try_into().unwrap_or([0; 4]));
+            *b = f32::from_be_bytes(x.try_into().unwrap_or([0; 4]));
         }
     }
     Some(TySh { transform: Affine { m }, text: text.descriptor, warp, bounds })
@@ -138,9 +140,11 @@ pub fn parse_txt2(data: &[u8]) -> Option<E> {
     ed::parse(&wrapped).ok().filter(|v| matches!(v, E::Dict(_)))
 }
 
-/// Applies the automatic kerning modes that Photoshop keeps only in `Txt2` (EngineData writes
-/// Optical and "0" alike as `AutoKerning true`) to `layer`, read from `tysh`. Only when the
-/// layer's `TextIndex` entry still holds the layer's text (an edit elsewhere leaves `Txt2`
+/// Applies what Photoshop keeps only in `Txt2` to `layer`, read from `tysh`: the automatic
+/// kerning modes (EngineData writes Optical and "0" alike as `AutoKerning true`) and the
+/// OpenType settings besides (discretionary) ligatures: stylistic sets, contextual alternates,
+/// swashes and the rest ([`TXT2_FEATURES`]), which Photoshop leaves out of EngineData. Only when
+/// the layer's `TextIndex` entry still holds the layer's text (an edit elsewhere leaves `Txt2`
 /// stale).
 ///
 /// Observed layout: `Txt2 /1` is the list of text objects; an object's `/0` is its text model
@@ -166,11 +170,10 @@ pub fn apply_txt2(layer: &mut TextLayer, tysh: &[u8], txt2: &E) {
     let Some(style_runs) = model.path(&["6", "0"]).and_then(E::as_array) else {
         return;
     };
-    let modes: Vec<(f64, Option<i64>)> =
-        style_runs.iter().map(|r| (r.get("1").and_then(E::as_f64).unwrap_or(0.0), r.path(&["0", "0", "6", "11"]).and_then(E::as_i64))).collect();
-    let lens = utf16_to_byte_lengths(text, &modes.iter().map(|m| m.0).collect::<Vec<_>>());
-    // Auto-kern mode per byte segment, then split the model runs at segment boundaries.
-    let mut segs: Vec<(usize, Option<i64>)> = lens.into_iter().zip(modes.iter().map(|m| m.1)).collect();
+    let styles: Vec<(f64, Option<&E>)> = style_runs.iter().map(|r| (r.get("1").and_then(E::as_f64).unwrap_or(0.0), r.path(&["0", "0", "6"]))).collect();
+    let lens = utf16_to_byte_lengths(text, &styles.iter().map(|m| m.0).collect::<Vec<_>>());
+    // Txt2 style per byte segment, then split the model runs at segment boundaries.
+    let mut segs: Vec<(usize, Option<&E>)> = lens.into_iter().zip(styles.iter().map(|m| m.1)).collect();
     segs.retain(|s| s.0 > 0);
     let runs = layer.char_runs();
     let mut out: Vec<TextRun> = Vec::new();
@@ -185,14 +188,18 @@ pub fn apply_txt2(layer: &mut TextLayer, tysh: &[u8], txt2: &E) {
             }
             let piece_end = if at < seg_end { end.min(seg_end) } else { end };
             let mut style = r.style.clone();
+            let txt2_style = segs.get(si).and_then(|s| s.1).filter(|_| at < seg_end);
             // Txt2 has the exact mode (EngineData's reading also marks neighbours of manual
             // kerns manual, like Photoshop's legacy reader).
-            match segs.get(si).and_then(|s| s.1).filter(|_| at < seg_end) {
+            match txt2_style.and_then(|st| st.get("11")).and_then(E::as_i64) {
                 Some(0) => style.kerning = Kerning::Off,
                 Some(1) => style.kerning = Kerning::Metrics,
                 Some(2) => style.kerning = Kerning::Optical,
                 _ => {}
             }
+            if let Some(st) = txt2_style {
+                add_txt2_features(&mut style, st);
+            }
             let len = piece_end - at;
             match out.last_mut() {
                 Some(last) if last.style == style => last.len += len,
@@ -205,6 +212,120 @@ pub fn apply_txt2(layer: &mut TextLayer, tysh: &[u8], txt2: &E) {
     layer.sync_summary();
 }
 
+/// The frame (`Txt2 /0 /8 /0` entry) of text object `index`: its rendered frame's `/10` names it.
+fn txt2_frame(txt2: &E, index: usize) -> Option<&E> {
+    let object = txt2.path(&["1", "1"]).and_then(E::as_array)?.get(index)?;
+    let frame =
+        object.path(&["1", "2"]).and_then(E::as_array)?.first()?.get("6").and_then(E::as_array)?.iter().find_map(|f| f.get("10").and_then(E::as_i64))?;
+    txt2.path(&["0", "8", "0"]).and_then(E::as_array)?.get(usize::try_from(frame).ok()?)?.get("0")
+}
+
+/// Places `layer` where Photoshop draws it when the text object's frame in `Txt2` is moved
+/// (#1317). Recent Photoshop keeps a type layer's position partly in its `Txt2` frame: a matrix
+/// (`/2 /2`) from the frame's space to the `TySh` text space and, for point text, the anchor
+/// (`/0`), while EngineData's `PointBase` stays at the origin and `BoxBounds` stays in the
+/// frame's space. Ignoring them put the text far from Photoshop's pixels (off the canvas, so
+/// it "disappeared" as soon as an edit started), and point text a line too high and off its
+/// alignment anchor. Only when the layer's `TextIndex` entry still holds the layer's text, as
+/// for [`apply_txt2`], and the frame agrees with the `TySh` `bounds`.
+pub fn apply_txt2_frame(layer: &mut TextLayer, tysh: &[u8], txt2: &E) {
+    let Some(t) = parse_tysh(tysh) else { return };
+    let Some(index) = (match t.text.get("TextIndex") {
+        Some(D::Integer(i)) => usize::try_from(*i).ok(),
+        _ => None,
+    }) else {
+        return;
+    };
+    let text = txt2.path(&["1", "1"]).and_then(E::as_array).and_then(|a| a.get(index)).and_then(|o| o.path(&["0", "0"])).and_then(E::as_str);
+    if text.is_none_or(|t| t.strip_suffix('\r').unwrap_or(t).replace('\r', "\n") != layer.text) {
+        return;
+    }
+    let Some(frame) = txt2_frame(txt2, index) else { return };
+    let m = arr_f(frame.path(&["2", "2"]));
+    let matrix = if m.len() == 6 && m.iter().all(|v| v.is_finite()) { Affine { m: [m[0], m[1], m[2], m[3], m[4], m[5]] } } else { Affine::IDENTITY };
+    let at = match layer.shape {
+        TextShape::Point | TextShape::Path { .. } => {
+            let p = arr_f(frame.get("0"));
+            if p.len() == 2 && p.iter().all(|v| v.is_finite()) { Affine::translate(p[0], p[1]) } else { Affine::IDENTITY }
+        }
+        TextShape::Box { .. } => Affine::IDENTITY,
+    };
+    let to_text = matrix.mul(&at);
+    if to_text == Affine::IDENTITY || to_text.determinant().abs() <= 1e-9 {
+        return;
+    }
+    // The frame's origin (point text: the anchor; box text: the box's top left) must land in
+    // the text-space `bounds` Photoshop wrote beside it, and not already be there without it. A `TySh` PhotoCraft rewrote (an edited
+    // or moved layer whose text is unchanged keeps its old `Txt2` object and frame) already has
+    // the frame folded into its transform and its `bounds` near the origin: applying the frame
+    // again would move it twice.
+    let origin = match layer.shape {
+        TextShape::Point | TextShape::Path { .. } => Point::new(0.0, 0.0),
+        TextShape::Box { .. } => {
+            let b = engine_data(&t.text)
+                .map(|e| {
+                    arr_f(
+                        e.path(&["EngineDict", "Rendered", "Shapes", "Children"])
+                            .and_then(E::as_array)
+                            .and_then(|c| c.first())
+                            .and_then(|s| s.path(&["Cookie", "Photoshop", "BoxBounds"])),
+                    )
+                })
+                .unwrap_or_default();
+            let [x, y, ..] = b[..] else { return };
+            Point::new(x, y)
+        }
+    };
+    let Some([l, top, r, bottom]) = descriptor_rect(&t.text, "bounds") else { return };
+    let inside = |p: Point| p.x >= l - 1.0 && p.x <= r + 1.0 && p.y >= top - 1.0 && p.y <= bottom + 1.0;
+    if inside(origin) || !inside(to_text.apply(origin)) {
+        return;
+    }
+    {
+        // From the file's own transform: the frame's anchor is exact, so it replaces the
+        // ink-box estimate `legacy_point_origin` made for such point text (#1469), which put
+        // the baseline at the ink's top and the anchor at the ink's left whatever the alignment.
+        layer.transform = t.transform.mul(&to_text);
+    }
+}
+
+/// OpenType settings of a `Txt2` style that are on/off flags, by style key, as Photoshop
+/// writes them (each turned on alone in the Character panel's OpenType settings and read back):
+/// `/20` Contextual Alternates, `/23` Fractions, `/24` Ordinals, `/25` Swash, `/26` Titling
+/// Alternates, `/28` Stylistic Alternates, `/29` Ornaments. (`/18` and `/19` are the standard and
+/// discretionary ligatures, which EngineData carries too; `/27` is Arabic connection forms.)
+pub const TXT2_FEATURES: [(&str, &str); 7] = [("20", "calt"), ("23", "frac"), ("24", "ordn"), ("25", "swsh"), ("26", "titl"), ("28", "salt"), ("29", "ornm")];
+
+/// The `Txt2` style key holding the Stylistic Sets as a bit mask: bit n is set n + 1
+/// (`ss01`..`ss20`).
+pub const TXT2_STYLISTIC_SETS: &str = "85";
+
+/// Sets in `style` the OpenType features a `Txt2` style dictionary turns on ([`TXT2_FEATURES`]
+/// and the Stylistic Sets mask). A feature the style already sets keeps its value. A flag that is
+/// off changes nothing, except Contextual Alternates: shapers apply `calt` by default, Photoshop
+/// only when it is on (its default is off), so off is written as `calt` 0.
+fn add_txt2_features(style: &mut CharStyle, txt2_style: &E) {
+    let mut set = |tag: String, value: u16| {
+        if !style.features.iter().any(|f| f.tag == tag) {
+            style.features.push(photocraft_doc::text::FontFeature { tag, value });
+        }
+    };
+    for (key, tag) in TXT2_FEATURES {
+        match txt2_style.get(key).and_then(E::as_bool) {
+            Some(true) => set(tag.to_string(), 1),
+            Some(false) if tag == "calt" => set(tag.to_string(), 0),
+            _ => {}
+        }
+    }
+    // A mask beyond the 20 sets is not Photoshop's: ignore it.
+    let sets = txt2_style.get(TXT2_STYLISTIC_SETS).and_then(E::as_i64).filter(|m| (0..1 << 20).contains(m)).unwrap_or(0);
+    for n in 0..20 {
+        if sets & (1 << n) != 0 {
+            set(format!("ss{:02}", n + 1), 1);
+        }
+    }
+}
+
 /// Builds a [`TextLayer`] (model, text and transform; no cache, no `psd_raw`) from `TySh` data.
 pub fn text_layer_from_tysh(data: &[u8], dpi: f32) -> Option<TextLayer> {
     let t = parse_tysh(data)?;
@@ -221,7 +342,11 @@ pub fn text_layer_from_tysh(data: &[u8], dpi: f32) -> Option<TextLayer> {
         Some("AnSt" | "antiAliasStrong") => AntiAlias::Strong,
         Some("antiAliasPlatformGray") => AntiAlias::Windows,
         Some("antiAliasPlatformLCD") => AntiAlias::WindowsLcd,
-        _ => AntiAlias::Smooth,
+        Some(_) => AntiAlias::Smooth,
+        // No `AntA`: the engine data's mode says it.
+        None => {
+            engine_data(&t.text).and_then(|e| e.path(&["EngineDict", "AntiAlias"]).and_then(E::as_f64)).and_then(engine_antialias).unwrap_or(AntiAlias::Smooth)
+        }
     };
     if let Some(w) = &t.warp {
         let style = enum_value(w, "warpStyle").unwrap_or_else(|| "warpNone".into());
@@ -332,46 +457,97 @@ fn apply_engine_data(layer: &mut TextLayer, e: &E, txt: Option<&str>, k: f32) {
         .and_then(E::as_array)
         .map(|a| a.iter().map(|f| f.get("Name").and_then(E::as_str).unwrap_or("").to_string()).collect())
         .unwrap_or_default();
-    let default_sheet = res.and_then(|r| r.get("TheNormalStyleSheet")).and_then(E::as_i64).unwrap_or(0) as usize;
-    let base_style =
-        res.and_then(|r| r.get("StyleSheetSet")).and_then(E::as_array).and_then(|a| a.get(default_sheet).or(a.first())).and_then(|s| s.get("StyleSheetData"));
-    let default_para_sheet = res.and_then(|r| r.get("TheNormalParagraphSheet")).and_then(E::as_i64).unwrap_or(0) as usize;
-    let base_para = res
-        .and_then(|r| r.get("ParagraphSheetSet"))
-        .and_then(E::as_array)
-        .and_then(|a| a.get(default_para_sheet).or(a.first()))
-        .and_then(|s| s.get("Properties"));
+    // Style resolution (#3795). A run's own `StyleSheetData` / `Properties` hold only what it
+    // overrides; the rest comes from its sheets, as in Photoshop:
+    // - a paragraph run: its `Properties` → the `ParagraphSheetSet` entry its `Name` names (a
+    //   paragraph style; or its `Parent` index) → `TheNormalParagraphSheet`;
+    // - a character run: its `StyleSheetData` → the `StyleSheetSet` entry its `Parent` or `Name`
+    //   names (a character style) → the default character style of its paragraph (the paragraph run's
+    //   `DefaultStyleSheet`, else its paragraph style's) → `TheNormalStyleSheet`.
+    // Missing or out-of-range indices fall through to the next level, then to the defaults.
+    let style_set: &[E] = res.and_then(|r| r.get("StyleSheetSet")).and_then(E::as_array).unwrap_or(&[]);
+    let para_set: &[E] = res.and_then(|r| r.get("ParagraphSheetSet")).and_then(E::as_array).unwrap_or(&[]);
+    let index = |key: &str| res.and_then(|r| r.get(key)).and_then(E::as_i64).and_then(|i| usize::try_from(i).ok());
+    let normal_style = index("TheNormalStyleSheet").and_then(|i| style_set.get(i)).or(style_set.first());
+    let normal_para = index("TheNormalParagraphSheet").and_then(|i| para_set.get(i)).or(para_set.first());
+    // A run names its sheet by a `Parent` index or by `Name` (see `psd_styles::reference`).
+    let named = |set: &'_ [E], sheet: &E| -> Option<usize> {
+        if let Some(i) = sheet.get("Parent").and_then(E::as_i64).and_then(|i| usize::try_from(i).ok()).filter(|i| *i < set.len()) {
+            return Some(i);
+        }
+        let name = sheet.get("Name").and_then(E::as_str)?;
+        set.iter().position(|s| s.get("Name").and_then(E::as_str) == Some(name))
+    };
+
+    // Paragraph runs first: a character run's defaults depend on its paragraph.
+    let prun = e.path(&["EngineDict", "ParagraphRun"]);
+    let psheets: Vec<&E> =
+        prun.and_then(|r| r.get("RunArray")).and_then(E::as_array).map(|a| a.iter().filter_map(|x| x.get("ParagraphSheet")).collect()).unwrap_or_default();
+    let plens16 = arr_f(prun.and_then(|r| r.get("RunLengthArray")));
+    let plens = utf16_to_byte_lengths(&ed_text, &plens16);
+    let empty = E::Dict(Vec::new());
+    // Per paragraph run: its merged base properties and its default character style.
+    let para_bases: Vec<(E, Option<&E>)> = psheets
+        .iter()
+        .map(|sheet| {
+            let style = named(para_set, sheet).and_then(|i| para_set.get(i));
+            let base = merged(&[style.and_then(|s| s.get("Properties")), normal_para.and_then(|s| s.get("Properties"))]);
+            let char_default = [Some(*sheet), style]
+                .into_iter()
+                .flatten()
+                .find_map(|s| s.get("DefaultStyleSheet").and_then(E::as_i64).and_then(|i| usize::try_from(i).ok()).and_then(|i| style_set.get(i)));
+            (base, char_default)
+        })
+        .collect();
+    layer.paragraphs = psheets
+        .iter()
+        .zip(&para_bases)
+        .zip(plens)
+        .map(|((sheet, (base, _)), len)| ParagraphRun { len, style: para_style(Some(base), sheet.get("Properties").unwrap_or(&empty), k) })
+        .collect();
 
     // Character runs.
     let srun = e.path(&["EngineDict", "StyleRun"]);
-    let sdata: Vec<&E> = srun
-        .and_then(|r| r.get("RunArray"))
-        .and_then(E::as_array)
-        .map(|a| a.iter().filter_map(|x| x.path(&["StyleSheet", "StyleSheetData"])).collect())
-        .unwrap_or_default();
-    let slens = utf16_to_byte_lengths(&ed_text, &arr_f(srun.and_then(|r| r.get("RunLengthArray"))));
+    let ssheets: Vec<&E> =
+        srun.and_then(|r| r.get("RunArray")).and_then(E::as_array).map(|a| a.iter().filter_map(|x| x.get("StyleSheet")).collect()).unwrap_or_default();
+    let slens16 = arr_f(srun.and_then(|r| r.get("RunLengthArray")));
+    let slens = utf16_to_byte_lengths(&ed_text, &slens16);
+    // The paragraph run each character run starts in (UTF-16 offsets).
+    let para_of = |at: f64| -> Option<usize> {
+        let mut end = 0.0;
+        for (i, n) in plens16.iter().enumerate() {
+            end += n;
+            if at < end {
+                return Some(i);
+            }
+        }
+        plens16.len().checked_sub(1)
+    };
+    let mut at16 = 0.0;
+    let bases: Vec<E> = ssheets
+        .iter()
+        .enumerate()
+        .map(|(i, sheet)| {
+            let own = named(style_set, sheet).and_then(|i| style_set.get(i));
+            let para_default = para_of(at16).and_then(|p| para_bases.get(p)).and_then(|(_, c)| *c);
+            at16 += slens16.get(i).copied().unwrap_or(0.0);
+            merged(&[own, para_default, normal_style].map(|s| s.and_then(|s| s.get("StyleSheetData"))))
+        })
+        .collect();
+    let sdata: Vec<&E> = ssheets.iter().map(|s| s.get("StyleSheetData").unwrap_or(&empty)).collect();
     let incoming: Vec<(usize, bool, f32)> = sdata
         .iter()
+        .zip(&bases)
         .zip(&slens)
-        .map(|(d, len)| {
-            let auto = lookup(d, base_style, "AutoKerning").and_then(E::as_bool) != Some(false);
-            let kern = lookup(d, base_style, "Kerning").and_then(E::as_f64).filter(|v| v.is_finite()).unwrap_or(0.0) as f32;
+        .map(|((d, base), len)| {
+            let auto = lookup(d, Some(base), "AutoKerning").and_then(E::as_bool) != Some(false);
+            let kern = lookup(d, Some(base), "Kerning").and_then(E::as_f64).filter(|v| v.is_finite()).unwrap_or(0.0) as f32;
             (*len, auto, kern)
         })
         .collect();
-    layer.runs = sdata.iter().zip(slens).map(|(d, len)| TextRun { len, style: char_style(base_style, d, &fonts, k) }).collect();
+    layer.runs = sdata.iter().zip(&bases).zip(slens).map(|((d, base), len)| TextRun { len, style: char_style(Some(base), d, &fonts, k) }).collect();
     layer.runs = kerning_from_pairs(&layer.text, layer.char_runs(), &incoming);
 
-    // Paragraph runs.
-    let prun = e.path(&["EngineDict", "ParagraphRun"]);
-    let pdata: Vec<&E> = prun
-        .and_then(|r| r.get("RunArray"))
-        .and_then(E::as_array)
-        .map(|a| a.iter().filter_map(|x| x.path(&["ParagraphSheet", "Properties"])).collect())
-        .unwrap_or_default();
-    let plens = utf16_to_byte_lengths(&ed_text, &arr_f(prun.and_then(|r| r.get("RunLengthArray"))));
-    layer.paragraphs = pdata.iter().zip(plens).map(|(d, len)| ParagraphRun { len, style: para_style(base_para, d, k) }).collect();
-
     // Shape.
     let shape = e.path(&["EngineDict", "Rendered", "Shapes", "Children"]).and_then(E::as_array).and_then(|a| a.first());
     if let Some(sh) = shape
@@ -384,6 +560,21 @@ fn apply_engine_data(layer: &mut TextLayer, e: &E, txt: Option<&str>, k: f32) {
     }
 }
 
+/// The dictionaries in `levels` as one: a key comes from the first level that has it.
+fn merged(levels: &[Option<&E>]) -> E {
+    let mut out: Vec<(String, E)> = Vec::new();
+    for level in levels.iter().flatten() {
+        if let E::Dict(kv) = level {
+            for (k, v) in kv {
+                if !out.iter().any(|(o, _)| o == k) {
+                    out.push((k.clone(), v.clone()));
+                }
+            }
+        }
+    }
+    E::Dict(out)
+}
+
 fn lookup<'a>(run: &'a E, base: Option<&'a E>, key: &str) -> Option<&'a E> {
     run.get(key).or_else(|| base.and_then(|b| b.get(key)))
 }
@@ -393,7 +584,7 @@ pub(crate) fn char_style(base: Option<&E>, d: &E, fonts: &[String], k: f32) -> C
     let num = |key: &str| g(key).and_then(E::as_f64);
     let flag = |key: &str| g(key).and_then(E::as_bool);
     let mut s = CharStyle::default();
-    if let Some(ps) = g("Font").and_then(E::as_i64).and_then(|i| fonts.get(i as usize)) {
+    if let Some(ps) = g("Font").and_then(E::as_i64).and_then(|i| usize::try_from(i).ok()).and_then(|i| fonts.get(i)) {
         let r = guess_from_postscript(ps);
         s.font_family = r.family;
         s.weight = r.weight;
@@ -979,19 +1170,21 @@ pub fn build_engine_data(layer: &TextLayer, template: Option<E>, dpi: f32) -> E
         "AntiAlias",
         E::Int(match layer.antialias {
             AntiAlias::None => 0,
-            AntiAlias::Sharp => 1,
-            AntiAlias::Crisp => 2,
-            AntiAlias::Strong => 3,
-            AntiAlias::Smooth => 4,
-            // EngineData has no platform modes; the `AntA` descriptor carries the exact value.
-            AntiAlias::Windows | AntiAlias::WindowsLcd => 1,
+            AntiAlias::Crisp => 1,
+            AntiAlias::Strong => 2,
+            AntiAlias::Smooth => 3,
+            AntiAlias::Sharp => 4,
+            // No Photoshop file confirms the platform modes' numbers here; the `AntA` descriptor
+            // carries the exact mode, and Smooth is the closest.
+            AntiAlias::Windows | AntiAlias::WindowsLcd => 3,
         }),
     );
     if dict.get("UseFractionalGlyphWidths").is_none() {
         dict.set("UseFractionalGlyphWidths", E::Bool(true));
     }
     let (shape_type, box_bounds) = match layer.shape {
-        TextShape::Point => (0, None),
+        // PSD path type is not written yet: the layer saves as point text.
+        TextShape::Point | TextShape::Path { .. } => (0, None),
         TextShape::Box { x, y, width, height } => (1, Some([x, y, x + width, y + height])),
     };
     let mut photoshop = E::Dict(vec![("ShapeType".into(), E::Int(shape_type))]);
@@ -1059,6 +1252,19 @@ pub fn build_engine_data(layer: &TextLayer, template: Option<E>, dpi: f32) -> E
     e
 }
 
+/// The anti-aliasing mode for EngineData's `AntiAlias` number, as Photoshop writes it: 0 None,
+/// 1 Crisp, 2 Strong, 3 Smooth, 4 Sharp. Other numbers (platform modes) are left to `AntA`.
+fn engine_antialias(n: f64) -> Option<AntiAlias> {
+    Some(match n as i64 {
+        0 => AntiAlias::None,
+        1 => AntiAlias::Crisp,
+        2 => AntiAlias::Strong,
+        3 => AntiAlias::Smooth,
+        4 => AntiAlias::Sharp,
+        _ => return None,
+    })
+}
+
 /// Builds the `TySh` block for `layer`, patching its current `psd_raw` when present.
 /// `ink` is the layer's rendered bounds in text space (for `bounds`/`boundingBox`).
 pub fn build_tysh(layer: &TextLayer, dpi: f32, ink: Option<[f32; 4]>) -> Vec<u8> {
@@ -1091,8 +1297,8 @@ pub fn build_tysh(layer: &TextLayer, dpi: f32, ink: Option<[f32; 4]>) -> Vec<u8>
             },
         ),
     );
-    let [l, t, r, b] = match (layer.shape, ink) {
-        (TextShape::Box { x, y, width, height }, _) => [x, y, x + width, y + height],
+    let [l, t, r, b] = match (&layer.shape, ink) {
+        (&TextShape::Box { x, y, width, height }, _) => [x, y, x + width, y + height],
         (_, Some(i)) => i,
         _ => [0.0; 4],
     };
@@ -1123,6 +1329,8 @@ pub fn build_tysh(layer: &TextLayer, dpi: f32, ink: Option<[f32; 4]>) -> Vec<u8>
         (None, Some(old)) if enum_value(&old, "warpStyle").as_deref() == Some("warpNone") => Some(old),
         _ => None,
     };
-    let bounds = [l.floor() as i32, t.floor() as i32, r.ceil() as i32, b.ceil() as i32];
+    // Photoshop's trailing bounds: zeros for unwarped type, the text-space bounds when warped.
+    let warped = warp.as_ref().is_some_and(|w| enum_value(w, "warpStyle").is_some_and(|s| s != "warpNone"));
+    let bounds = if warped { [l, t, r, b] } else { [0.0; 4] };
     write_tysh(&TySh { transform: layer.transform, text, warp, bounds })
 }
diff --git a/crates/text/src/psd_styles.rs b/crates/text/src/psd_styles.rs
index fb3b297fdc..7c4f69cd8a 100644
--- a/crates/text/src/psd_styles.rs
+++ b/crates/text/src/psd_styles.rs
@@ -38,7 +38,12 @@ pub struct PsdStyleSheets {
 }
 
 fn k_of(dpi: f32) -> f32 {
-    72.0 / if dpi > 0.0 { dpi } else { 72.0 }
+    72.0 / if dpi.is_finite() && dpi > 0.0 { dpi } else { 72.0 }
+}
+
+/// A sheet index from EngineData. A negative or overflowing index is not a slot (#4429).
+fn sheet_index(v: i64) -> Option<usize> {
+    usize::try_from(v).ok()
 }
 
 fn names(set: Option<&E>) -> Vec<String> {
@@ -48,13 +53,27 @@ fn names(set: Option<&E>) -> Vec<String> {
 /// Index a run's sheet dictionary refers to (`Parent` index, else `Name`), skipping `normal`.
 fn reference(sheet: Option<&E>, set_names: &[String], normal: usize) -> Option<usize> {
     let s = sheet?;
-    let i = s.get("Parent").and_then(E::as_i64).map(|i| i as usize).or_else(|| {
+    let i = s.get("Parent").and_then(E::as_i64).and_then(sheet_index).or_else(|| {
         let n = s.get("Name").and_then(E::as_str)?;
         set_names.iter().position(|x| x == n)
     })?;
     (i != normal && i < set_names.len()).then_some(i)
 }
 
+/// Adds to `sheet[key]` (a dictionary) every entry of `resolved` it lacks; existing entries win.
+fn fill_missing(sheet: &mut E, key: &str, resolved: E) {
+    let E::Dict(all) = resolved else { return };
+    if sheet.get(key).is_none() {
+        sheet.set(key, E::dict());
+    }
+    let Some(E::Dict(have)) = sheet.get_mut(key) else { return };
+    for (k, v) in all {
+        if !have.iter().any(|(h, _)| *h == k) {
+            have.push((k, v));
+        }
+    }
+}
+
 /// Reads the style sheets of a `TySh` block. None when it has no engine data.
 pub fn read_style_sheets(tysh: &[u8], dpi: f32) -> Option<PsdStyleSheets> {
     let t = parse_tysh(tysh)?;
@@ -64,8 +83,8 @@ pub fn read_style_sheets(tysh: &[u8], dpi: f32) -> Option<PsdStyleSheets> {
     let fonts: Vec<String> = names(res.get("FontSet"));
     let sset = res.get("StyleSheetSet").and_then(E::as_array).unwrap_or(&[]);
     let pset = res.get("ParagraphSheetSet").and_then(E::as_array).unwrap_or(&[]);
-    let normal_c = res.get("TheNormalStyleSheet").and_then(E::as_i64).unwrap_or(0) as usize;
-    let normal_p = res.get("TheNormalParagraphSheet").and_then(E::as_i64).unwrap_or(0) as usize;
+    let normal_c = res.get("TheNormalStyleSheet").and_then(E::as_i64).and_then(sheet_index).unwrap_or(0);
+    let normal_p = res.get("TheNormalParagraphSheet").and_then(E::as_i64).and_then(sheet_index).unwrap_or(0);
     let empty = E::dict();
     let base_data = sset.get(normal_c).and_then(|s| s.get("StyleSheetData"));
     let normal_char = char_style(None, base_data.unwrap_or(&empty), &fonts, k);
@@ -86,7 +105,7 @@ pub fn read_style_sheets(tysh: &[u8], dpi: f32) -> Option<PsdStyleSheets> {
         }
         let name = s.get("Name").and_then(E::as_str).unwrap_or("").to_string();
         let props = s.get("Properties").unwrap_or(&empty);
-        let dss = s.get("DefaultStyleSheet").and_then(E::as_i64).map(|i| i as usize).filter(|i| *i != normal_c);
+        let dss = s.get("DefaultStyleSheet").and_then(E::as_i64).and_then(sheet_index).filter(|i| *i != normal_c);
         let cs = dss.and_then(|d| sset.get(d)).map(|d| char_style(base_data, d.get("StyleSheetData").unwrap_or(&empty), &fonts, k));
         out.para_sheets.push((i, name, para_style(base_props, props, k), cs));
     }
@@ -130,8 +149,8 @@ pub fn write_style_sheets(tysh: &[u8], layer: &TextLayer, styles: &TextStyles, d
     for key in ["ResourceDict", "DocumentResources"] {
         let Some(rd) = e.get_mut(key) else { continue };
         let mut fonts = names(rd.get("FontSet"));
-        let normal_c = rd.get("TheNormalStyleSheet").and_then(E::as_i64).unwrap_or(0) as usize;
-        let normal_p = rd.get("TheNormalParagraphSheet").and_then(E::as_i64).unwrap_or(0) as usize;
+        let normal_c = rd.get("TheNormalStyleSheet").and_then(E::as_i64).and_then(sheet_index).unwrap_or(0);
+        let normal_p = rd.get("TheNormalParagraphSheet").and_then(E::as_i64).and_then(sheet_index).unwrap_or(0);
         let keep_c = rd.get("StyleSheetSet").and_then(E::as_array).and_then(|a| a.get(normal_c).or(a.first())).cloned();
         let keep_p = rd.get("ParagraphSheetSet").and_then(E::as_array).and_then(|a| a.get(normal_p).or(a.first())).cloned();
         let mut font_index = |s: &CharStyle| {
@@ -170,6 +189,7 @@ pub fn write_style_sheets(tysh: &[u8], layer: &TextLayer, styles: &TextStyles, d
         rd.set("TheNormalParagraphSheet", E::Int(0));
         rd.set("FontSet", E::Array(fonts.iter().map(|f| crate::psd::font_entry(f)).collect()));
     }
+    let char_fonts = e.path(&["ResourceDict", "FontSet"]).or_else(|| e.path(&["DocumentResources", "FontSet"])).map(|f| names(Some(f))).unwrap_or_default();
     let char_ix = |id: Option<u32>| id.and_then(|id| styles.character.iter().position(|d| d.id == id)).map(|i| i as i64 + 1);
     let para_ix = |id: Option<u32>| id.and_then(|id| styles.paragraph.iter().position(|d| d.id == id)).map(|i| i as i64 + 1);
     let runs = layer.char_runs();
@@ -193,9 +213,16 @@ pub fn write_style_sheets(tysh: &[u8], layer: &TextLayer, styles: &TextStyles, d
             if let Some(sheet) = r.get_mut("StyleSheet") {
                 remove_key(sheet, "Parent");
                 remove_key(sheet, "Name");
-                if let Some(ix) = char_ix(run_at(start).and_then(|r| r.style.style_sheet)) {
+                let run = run_at(start);
+                if let Some(ix) = char_ix(run.and_then(|r| r.style.style_sheet)) {
                     sheet.set("Parent", E::Int(ix));
                 }
+                // The run's reference may be dropped or renumbered: write what it inherited
+                // too, so it keeps its look whatever sheet it now points to (#3795).
+                if let Some(run) = run {
+                    let fi = char_fonts.iter().position(|f| *f == postscript_for(&run.style)).unwrap_or(0);
+                    fill_missing(sheet, "StyleSheetData", style_sheet_data(&run.style, fi, k));
+                }
             }
         }
     }
@@ -208,6 +235,9 @@ pub fn write_style_sheets(tysh: &[u8], layer: &TextLayer, styles: &TextStyles, d
                 if let Some(ix) = para_ix(paras.get(i).and_then(|p| p.style.style_sheet)) {
                     sheet.set("Parent", E::Int(ix));
                 }
+                if let Some(p) = paras.get(i) {
+                    fill_missing(sheet, "Properties", paragraph_properties(&p.style, k));
+                }
             }
         }
     }
@@ -225,6 +255,14 @@ mod tests {
     use photocraft_doc::text::{TextAlign, TextRun};
     use photocraft_doc::text_styles::{CharacterStyleDef, ParagraphStyleDef, diff_attrs};
 
+    #[test]
+    fn a_negative_sheet_index_is_not_a_slot_and_infinite_dpi_uses_72() {
+        assert_eq!(sheet_index(-1), None);
+        assert_eq!(sheet_index(2), Some(2));
+        assert_eq!(k_of(f32::INFINITY), 1.0);
+        assert_eq!(k_of(144.0), 0.5);
+    }
+
     #[test]
     fn named_sheets_round_trip() {
         let mut styles = TextStyles::default();
diff --git a/crates/text/src/render.rs b/crates/text/src/render.rs
index 6068ae4a69..af29dd10d6 100644
--- a/crates/text/src/render.rs
+++ b/crates/text/src/render.rs
@@ -1,6 +1,6 @@
 //! Rasterizes a [`TextLayout`] into a document-space [`Surface`] of any pixel format.
 
-use photocraft_color::{Color, PixelFormat};
+use photocraft_color::{Color, PixelFormat, SampleType};
 use photocraft_doc::text::AntiAlias;
 use photocraft_geom::{Affine, Rect};
 use photocraft_raster::Surface;
@@ -10,12 +10,12 @@ use skrifa::{GlyphId, MetadataProvider};
 
 use crate::layout::{GlyphOrient, PlacedGlyph, TextLayout};
 use crate::raster::{Bounds, Coverage, LineSink, Pen, Xform, rect_to};
-use crate::warp::Warp;
+use crate::warp::{Placement, Warp};
 
 /// Faux-italic slant in degrees (Photoshop-like).
 pub const FAUX_ITALIC_DEG: f32 = 12.0;
-/// Faux-bold dilation radius as a fraction of the font size.
-pub const FAUX_BOLD_RADIUS: f32 = 0.018;
+/// Faux-bold ring radius as a fraction of the font size (tuned so stem weight stays close to the old summed-coverage look).
+pub const FAUX_BOLD_RADIUS: f32 = 0.036;
 /// Largest raster we produce (pixels), as a guard against absurd sizes.
 const MAX_PIXELS: u64 = 256 * 1024 * 1024;
 
@@ -53,6 +53,30 @@ impl<S: LineSink> LineSink for WarpSink<'_, S> {
 /// when `color` is `None`) into `sink`, through `transform` (text space → sink space), bending
 /// the outlines with `warp` first (in text space).
 fn draw(layout: &TextLayout, transform: &Xform, sink: &mut impl LineSink, only_color: Option<&Color>, warp: Option<&Warp>) {
+    draw_pass(layout, transform, sink, only_color, warp, Pass::All);
+}
+
+/// Which part of the layout [`draw_pass`] emits. Faux bold draws each glyph at several offsets;
+/// summing those into one coverage buffer saturates the antialiased edge pixels (hard, pixelated
+/// stems), so the rasteriser draws every offset into its own buffer and merges them with `max`.
+#[derive(Clone, Copy, PartialEq)]
+enum Pass {
+    /// Everything, all offsets (bounds, outlines).
+    All,
+    /// Non-bold glyphs and decorations.
+    Plain,
+    /// Bold glyphs at one offset (index into [`BOLD_OFFSETS`]).
+    Bold(usize),
+}
+
+const BOLD_OFFSETS: [(f64, f64); 8] = [(-1.0, 0.0), (1.0, 0.0), (0.0, -1.0), (0.0, 1.0), (0.7, 0.7), (-0.7, -0.7), (0.7, -0.7), (-0.7, 0.7)];
+
+fn is_bold(layout: &TextLayout, g: &PlacedGlyph) -> bool {
+    let face_bold = layout.faces.get(g.face as usize).is_some_and(|f| f.embolden);
+    layout.styles.get(g.style as usize).is_some_and(|s| s.faux_bold) || face_bold
+}
+
+fn draw_pass(layout: &TextLayout, transform: &Xform, sink: &mut impl LineSink, only_color: Option<&Color>, warp: Option<&Warp>, pass: Pass) {
     for g in &layout.glyphs {
         let st = &layout.styles[g.style as usize];
         if only_color.is_some_and(|c| c != &st.color) {
@@ -66,15 +90,36 @@ fn draw(layout: &TextLayout, transform: &Xform, sink: &mut impl LineSink, only_c
             continue;
         };
         let coords: Vec<NormalizedCoord> = face.coords.iter().map(|&c| NormalizedCoord::from_bits(c)).collect();
-        let glyph = glyph_xform(layout, g, face.skew_deg);
+        let mut glyph = glyph_xform(layout, g, face.skew_deg);
+        // Type on a path moves each glyph rigidly: turned to the curve at its centre.
+        let mut bend = warp;
+        if let Some(w) = warp {
+            match w.place_glyph(glyph_center(layout, g, &font, face.size_px, &coords)) {
+                Placement::Bend => {}
+                Placement::Hidden => continue,
+                Placement::Frame(m) => {
+                    glyph = Xform(m).mul(&glyph);
+                    bend = None;
+                }
+            }
+        }
         let bold = st.faux_bold || face.embolden;
         let r = (face.size_px * FAUX_BOLD_RADIUS) as f64;
-        let offsets: &[(f64, f64)] =
-            if bold { &[(-1.0, 0.0), (1.0, 0.0), (0.0, -1.0), (0.0, 1.0), (0.7, 0.7), (-0.7, -0.7), (0.7, -0.7), (-0.7, 0.7)] } else { &[(0.0, 0.0)] };
+        let single = [(0.0, 0.0)];
+        let offsets: &[(f64, f64)] = match (pass, bold) {
+            (Pass::Plain, true) => continue,
+            (Pass::Bold(_), false) => continue,
+            (Pass::Bold(k), true) => match BOLD_OFFSETS.get(k..=k) {
+                Some(o) => o,
+                None => continue,
+            },
+            (Pass::All, true) => &BOLD_OFFSETS,
+            (_, false) => &single,
+        };
         for &(ox, oy) in offsets {
-            let local = Xform([1.0, 0.0, 0.0, 1.0, ox * r, oy * r]).mul(&glyph);
+            let local = glyph.mul(&Xform([1.0, 0.0, 0.0, 1.0, ox * r, oy * r]));
             let settings = DrawSettings::unhinted(Size::new(face.size_px), LocationRef::new(&coords));
-            match warp {
+            match bend {
                 Some(w) => {
                     let mut ws = WarpSink { inner: &mut *sink, warp: w, post: *transform };
                     let mut pen = Pen::new(&mut ws, local);
@@ -91,6 +136,9 @@ fn draw(layout: &TextLayout, transform: &Xform, sink: &mut impl LineSink, only_c
             }
         }
     }
+    if matches!(pass, Pass::Bold(_)) {
+        return;
+    }
     for d in &layout.decorations {
         let st = &layout.styles[d.style as usize];
         if only_color.is_some_and(|c| c != &st.color) {
@@ -125,6 +173,22 @@ fn glyph_xform(layout: &TextLayout, g: &PlacedGlyph, face_skew_deg: f32) -> Xfor
     }
 }
 
+/// The horizontal centre (text space) of a placed glyph: the pen position plus half its advance.
+fn glyph_center(layout: &TextLayout, g: &PlacedGlyph, font: &skrifa::FontRef, size_px: f32, coords: &[NormalizedCoord]) -> f64 {
+    let hs = layout.styles.get(g.style as usize).map_or(1.0, |st| if st.horizontal_scale > 0.0 { st.horizontal_scale } else { 1.0 });
+    let advance = match g.orient {
+        GlyphOrient::Horizontal => font.glyph_metrics(Size::new(size_px), LocationRef::new(coords)).advance_width(GlyphId::new(g.id)).unwrap_or(0.0),
+        _ => 0.0,
+    };
+    f64::from(g.x) + f64::from(advance * hs) / 2.0
+}
+
+/// The deformation of a type layer: the path it runs along, or its Warp Text settings (None
+/// when neither applies).
+pub fn layout_deform(layout: &TextLayout, layer: &photocraft_doc::TextLayer) -> Option<Warp> {
+    Warp::on_path(&layer.shape).or_else(|| layout_warp(layout, layer.warp.as_ref()))
+}
+
 /// The warp to apply to `layout` (None when `warp` is absent, `warpNone` or flat).
 pub fn layout_warp(layout: &TextLayout, warp: Option<&photocraft_doc::text::TextWarp>) -> Option<Warp> {
     Warp::new(warp?, layout.bounds()?)
@@ -199,8 +263,17 @@ pub fn rasterize_warped(layout: &TextLayout, transform: &Affine, format: PixelFo
     }
     for c in &colors {
         let mut cov = Coverage::new(w, h);
-        draw(layout, &xf, &mut cov, Some(c), warp);
-        let cov = cov.finish();
+        draw_pass(layout, &xf, &mut cov, Some(c), warp, Pass::Plain);
+        let mut cov = cov.finish();
+        if layout.glyphs.iter().any(|g| is_bold(layout, g)) {
+            for k in 0..BOLD_OFFSETS.len() {
+                let mut bc = Coverage::new(w, h);
+                draw_pass(layout, &xf, &mut bc, Some(c), warp, Pass::Bold(k));
+                for (a, b) in cov.iter_mut().zip(bc.finish()) {
+                    *a = a.max(b);
+                }
+            }
+        }
         let comps = color_in(&format, c);
         let a = c.alpha.clamp(0.0, 1.0);
         for (i, &cv) in cov.iter().enumerate() {
@@ -222,7 +295,10 @@ pub fn rasterize_warped(layout: &TextLayout, transform: &Affine, format: PixelFo
         let a = px[n];
         if a > 0.0 {
             for v in &mut px[..n] {
-                *v = (*v / a).clamp(0.0, 1.0);
+                let straight = *v / a;
+                // Float text can carry HDR and signed colours. Keep integer output bounded
+                // and retain the old handling of non-finite intermediate values.
+                *v = if format.sample == SampleType::F32 && straight.is_finite() { straight } else { straight.clamp(0.0, 1.0) };
             }
         }
     }
@@ -299,8 +375,19 @@ pub fn outlines(layout: &TextLayout, transform: &Affine, warp: Option<&Warp>) ->
             continue;
         };
         let coords: Vec<NormalizedCoord> = face.coords.iter().map(|&c| NormalizedCoord::from_bits(c)).collect();
-        let glyph = glyph_xform(layout, g, face.skew_deg);
-        let mut rec = Recorder { glyph, post: Xform(transform.m), warp, out: Vec::new() };
+        let mut glyph = glyph_xform(layout, g, face.skew_deg);
+        let mut bend = warp;
+        if let Some(w) = warp {
+            match w.place_glyph(glyph_center(layout, g, &font, face.size_px, &coords)) {
+                Placement::Bend => {}
+                Placement::Hidden => continue,
+                Placement::Frame(m) => {
+                    glyph = Xform(m).mul(&glyph);
+                    bend = None;
+                }
+            }
+        }
+        let mut rec = Recorder { glyph, post: Xform(transform.m), warp: bend, out: Vec::new() };
         let settings = DrawSettings::unhinted(Size::new(face.size_px), LocationRef::new(&coords));
         if outline.draw(settings, &mut rec).is_ok() && !rec.out.is_empty() {
             glyphs.push(rec.out);
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index fa0a626fe7..13de665ccd 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -13,6 +13,44 @@ fn styled(text: &str, style: CharStyle) -> TextLayer {
     TextLayer { text: text.into(), runs: vec![TextRun { len: text.len(), style }], ..Default::default() }
 }
 
+#[test]
+fn raster_preserves_hdr_and_signed_float_text_colors() {
+    let mut e = TextEngine::new();
+    for alpha in [1.0, 0.4] {
+        let color = Color::rgba(2.5, -0.25, 0.5, alpha);
+        let style = CharStyle { size_pt: 48.0, color, ..Default::default() };
+        let (_, rendered) = e.render(&styled("HDR", style), 72.0, PixelFormat::RGBA32F);
+        let pixels = rendered.surface.read_region(rendered.rect);
+        let mut covered = 0;
+        for pixel in pixels.as_chunks::<4>().0.iter().filter(|p| p[3] > 0.01) {
+            covered += 1;
+            for channel in 0..3 {
+                assert!((pixel[channel] - color.c[channel]).abs() < 1e-5, "alpha={alpha}, pixel={pixel:?}");
+            }
+            assert!(pixel[3] <= alpha + 1e-6);
+        }
+        assert!(covered > 100);
+    }
+}
+
+#[test]
+fn raster_integer_text_colors_stay_bounded() {
+    let mut e = TextEngine::new();
+    for format in [PixelFormat::RGBA8, PixelFormat::RGBA16] {
+        let style = CharStyle { size_pt: 48.0, color: Color::rgba(2.5, -0.25, 0.5, 0.4), ..Default::default() };
+        let (_, rendered) = e.render(&styled("HDR", style), 72.0, format);
+        let pixels = rendered.surface.read_region(rendered.rect);
+        let mut covered = 0;
+        for pixel in pixels.as_chunks::<4>().0.iter().filter(|p| p[3] > 0.01) {
+            covered += 1;
+            assert_eq!(&pixel[..2], &[1.0, 0.0]);
+            assert!((pixel[2] - 0.5).abs() < 1.0 / 255.0);
+            assert!(pixel[3] <= 0.4 + 1.0 / 255.0);
+        }
+        assert!(covered > 100);
+    }
+}
+
 fn with_para(mut t: TextLayer, p: ParagraphStyle) -> TextLayer {
     t.paragraphs = vec![ParagraphRun { len: t.text.len(), style: p }];
     t
@@ -47,6 +85,21 @@ fn registering_fonts_moves_the_generation() {
     assert!(fonts::generation() > g);
 }
 
+/// Font menus cache on the shared engine's generation: other engines registering fonts (a test's
+/// throwaway one, in parallel) must not invalidate them, or the menus re-render every frame.
+#[test]
+fn only_the_shared_database_moves_the_shared_generation() {
+    let _ = crate::shared();
+    let g = fonts::shared_generation();
+    TextEngine::new().fonts.register_font_data(fonts::INTER_REGULAR.to_vec());
+    assert_eq!(fonts::shared_generation(), g, "an unrelated engine leaves it alone");
+    let mut e = TextEngine::new();
+    e.fonts.mark_shared();
+    let g = fonts::shared_generation();
+    e.fonts.register_font_data(fonts::INTER_REGULAR.to_vec());
+    assert!(fonts::shared_generation() > g);
+}
+
 #[test]
 fn literal_psd_tabs_shape_as_whitespace_without_shifting_text_offsets() {
     let mut e = TextEngine::new();
@@ -99,7 +152,7 @@ fn tabs_advance_to_the_next_default_tab_stop() {
 #[test]
 fn psd_round_trips_tabs() {
     for shape in [TextShape::Point, TextShape::Box { x: 0.0, y: 0.0, width: 300.0, height: 100.0 }] {
-        let t = TextLayer { shape, ..point("Name\tValue\n\tIndented", 20.0) };
+        let t = TextLayer { shape: shape.clone(), ..point("Name\tValue\n\tIndented", 20.0) };
         let back = crate::psd::text_layer_from_tysh(&crate::psd::build_tysh(&t, 72.0, None), 72.0).unwrap();
         assert_eq!(back.text, t.text, "{shape:?}");
     }
@@ -381,6 +434,76 @@ fn styles_change_pixels() {
     assert!(hrect.width() as f32 > prect.width() as f32 * 1.7);
 }
 
+/// #4130: Faux bold at 72 dpi looked pixelated because the offset copies were summed into one
+/// coverage buffer, saturating every antialiased edge pixel. Edges must stay antialiased and the
+/// ink must grow only by the dilation (about perimeter x radius), not by edge saturation.
+#[test]
+fn faux_bold_keeps_antialiased_edges_at_small_sizes() {
+    let mut e = TextEngine::new();
+    let base = CharStyle { size_pt: 12.0, ..Default::default() };
+    let stats = |e: &mut TextEngine, s: CharStyle| {
+        let (_, r) = e.render(&TextLayer { transform: Affine::translate(5.0, 20.0), ..styled("Bold Test", s) }, 72.0, PixelFormat::RGBA8);
+        let (w, h) = (r.rect.width() as usize, r.rect.height() as usize);
+        let mut partial = 0usize;
+        for y in 0..h {
+            for x in 0..w {
+                let a = alpha_sum(
+                    &r.surface,
+                    photocraft_geom::Rect::new(r.rect.x0 + x as i32, r.rect.y0 + y as i32, r.rect.x0 + x as i32 + 1, r.rect.y0 + y as i32 + 1),
+                );
+                if a > 0.05 && a < 0.95 {
+                    partial += 1;
+                }
+            }
+        }
+        (alpha_sum(&r.surface, r.rect), partial)
+    };
+    let (plain_ink, plain_partial) = stats(&mut e, base.clone());
+    let (bold_ink, bold_partial) = stats(&mut e, CharStyle { faux_bold: true, ..base });
+    assert!(bold_ink > plain_ink, "bold must add ink");
+    // Weight: the old summed-coverage faux bold (before #4130) measured 282.7 total ink for this
+    // text at 12 px (plain 138.0). The antialiased version must stay close to that weight.
+    const MAIN_BOLD_INK: f64 = 282.7;
+    assert!(bold_ink >= MAIN_BOLD_INK * 0.85, "stems too thin: {bold_ink} vs old {MAIN_BOLD_INK}");
+    assert!(bold_ink <= MAIN_BOLD_INK * 1.15, "stems too heavy: {bold_ink} vs old {MAIN_BOLD_INK}");
+    assert!(bold_partial * 10 >= plain_partial * 8, "edges stay antialiased: {plain_partial} -> {bold_partial}");
+}
+
+/// #3705: Faux bold dilation must scale with horizontal and vertical glyph scaling.
+#[test]
+fn faux_bold_scales_with_glyph_scaling() {
+    let mut e = TextEngine::new();
+    let base = CharStyle { size_pt: 40.0, ..Default::default() };
+    let ink = |e: &mut TextEngine, s: CharStyle| {
+        let (_, r) = e.render(&TextLayer { transform: Affine::translate(5.0, 50.0), ..styled("Hi", s) }, 72.0, PixelFormat::RGBA8);
+        (alpha_sum(&r.surface, r.rect), r.rect)
+    };
+    let (_plain, prect) = ink(&mut e, base.clone());
+    let (_bold, brect) = ink(&mut e, CharStyle { faux_bold: true, ..base.clone() });
+    let unscaled_extra_w = brect.width() - prect.width();
+    let unscaled_extra_h = brect.height() - prect.height();
+
+    // With 2x horizontal scale, the horizontal dilation scales with the glyph:
+    let hscaled = CharStyle { size_pt: 40.0, horizontal_scale: 2.0, ..Default::default() };
+    let (_, phrect) = ink(&mut e, hscaled.clone());
+    let (_, bhrect) = ink(&mut e, CharStyle { faux_bold: true, ..hscaled });
+    let hscaled_extra_w = bhrect.width() - phrect.width();
+    assert!(
+        hscaled_extra_w >= unscaled_extra_w * 2 - 1 && hscaled_extra_w <= unscaled_extra_w * 2 + 1,
+        "hscaled extra width {hscaled_extra_w} vs unscaled {unscaled_extra_w}"
+    );
+
+    // With 2x vertical scale, the vertical dilation scales with the glyph:
+    let vscaled = CharStyle { size_pt: 40.0, vertical_scale: 2.0, ..Default::default() };
+    let (_, pvrect) = ink(&mut e, vscaled.clone());
+    let (_, bvrect) = ink(&mut e, CharStyle { faux_bold: true, ..vscaled });
+    let vscaled_extra_h = bvrect.height() - pvrect.height();
+    assert!(
+        vscaled_extra_h >= unscaled_extra_h * 2 - 1 && vscaled_extra_h <= unscaled_extra_h * 2 + 1,
+        "vscaled extra height {vscaled_extra_h} vs unscaled {unscaled_extra_h}"
+    );
+}
+
 #[test]
 fn multicolor_runs() {
     let mut e = TextEngine::new();
@@ -505,6 +628,28 @@ fn forced_line_break_starts_a_line_in_the_same_paragraph() {
     }
 }
 
+#[test]
+fn hyphenated_postscript_names_preserve_family_prefixes() {
+    for (ps, family, weight, italic) in
+        [("FOT-NewRodinPro-Regular", "FOT-New Rodin Pro", 400, false), ("Vendor-FamilyPro-BoldIt", "Vendor-Family Pro", 700, true)]
+    {
+        let guessed = fonts::guess_from_postscript(ps);
+        assert_eq!((guessed.family.as_str(), guessed.weight, guessed.italic), (family, weight, italic));
+    }
+}
+
+#[test]
+fn hyphenated_postscript_style_suffix_keeps_weight_and_slant() {
+    for (ps, family, weight, italic) in [
+        ("MyriadPro-Bold-It", "Myriad Pro", 700, true),
+        ("FOT-NewRodinPro-Bold-It", "FOT-New Rodin Pro", 700, true),
+        ("Vendor-Bold-Regular", "Vendor-Bold", 400, false),
+    ] {
+        let guessed = fonts::guess_from_postscript(ps);
+        assert_eq!((guessed.family.as_str(), guessed.weight, guessed.italic), (family, weight, italic));
+    }
+}
+
 #[test]
 fn postscript_names() {
     let g = fonts::guess_from_postscript("MyriadPro-BoldIt");
@@ -647,6 +792,11 @@ fn warp_bends_rendered_text_and_outlines() {
 /// `Txt2` as Photoshop writes it (a bare `/key value` sequence; text objects at `/1 /1`, style
 /// runs at `/0 /6 /0`, auto-kern mode at `/11`), for the layer text `text`.
 fn txt2_with_modes(text: &str, modes: &[(usize, i64)]) -> Vec<u8> {
+    txt2_with_styles(text, &modes.iter().map(|(len, m)| (*len, format!("/11 {m}"))).collect::<Vec<_>>())
+}
+
+/// [`txt2_with_modes`] with each style run's keys given as EngineData text (`"/11 1 /85 2"`).
+fn txt2_with_styles(text: &str, styles: &[(usize, String)]) -> Vec<u8> {
     let mut v = b"\n\n/98 << /0 14 >> /0 << >> /1 << /1 [ << /0 << /0 (\xfe\xff".to_vec();
     for u in format!("{text}\r").encode_utf16() {
         let b = u.to_be_bytes();
@@ -658,8 +808,8 @@ fn txt2_with_modes(text: &str, modes: &[(usize, i64)]) -> Vec<u8> {
         }
     }
     v.extend_from_slice(b") /6 << /0 [ ");
-    for (len, m) in modes {
-        v.extend_from_slice(format!("<< /0 << /0 << /0 (\u{fe}\u{ff}) /6 << /0 0 /11 {m} >> >> >> /1 {len} >> ").as_bytes());
+    for (len, keys) in styles {
+        v.extend_from_slice(format!("<< /0 << /0 << /0 (\u{fe}\u{ff}) /6 << /0 0 {keys} >> >> >> /1 {len} >> ").as_bytes());
     }
     v.extend_from_slice(b"] >> >> >> ] >>");
     v
@@ -706,6 +856,55 @@ fn txt2_carries_optical_kerning() {
     assert!(l.char_runs().iter().all(|r| r.style.kerning == Kerning::Optical));
 }
 
+/// #3617: Photoshop keeps Stylistic Sets, Contextual Alternates, Swash and the other OpenType
+/// settings besides (discretionary) ligatures only in `Txt2`. Import reads them, so the layout
+/// our engine draws when the type is edited keeps Photoshop's glyphs instead of falling back to
+/// the default ones.
+#[test]
+fn txt2_carries_opentype_features() {
+    let feats = |l: &TextLayer| l.char_runs().iter().map(|r| r.style.features.iter().map(|f| (f.tag.clone(), f.value)).collect::<Vec<_>>()).collect::<Vec<_>>();
+    let f = |tag: &str, value: u16| (tag.to_string(), value);
+    // "Il->36" plus the engine's closing break: Stylistic Set 2 (mask 2), Contextual Alternates
+    // and Swash on "Il"; Contextual Alternates off (Photoshop's default), Stylistic Set 1 and
+    // Fractions on the rest.
+    let text = "Il->36";
+    let plain = styled(text, CharStyle { font_family: "Inter".into(), ..Default::default() });
+    let tysh = with_text_index(&crate::psd::build_tysh(&plain, 72.0, None), 0);
+    let styles = [(2, "/11 1 /18 true /19 false /20 true /25 true /85 2".to_string()), (5, "/11 1 /20 false /23 true /85 1".to_string())];
+    let txt2 = crate::psd::parse_txt2(&txt2_with_styles(text, &styles)).unwrap();
+    let mut back = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
+    assert_eq!(feats(&back), vec![Vec::<(String, u16)>::new()], "EngineData alone doesn't have them");
+    crate::psd::apply_txt2(&mut back, &tysh, &txt2);
+    assert_eq!(feats(&back), vec![vec![f("calt", 1), f("swsh", 1), f("ss02", 1)], vec![f("calt", 0), f("frac", 1), f("ss01", 1)]]);
+    assert_eq!(back.char_runs().iter().map(|r| r.len).collect::<Vec<_>>(), vec![2, 4]);
+    // What editing shows (our layout) has Photoshop's glyphs: Inter's `ss02` draws another I and
+    // l, `ss01` another 3 and 6, and `->` stays two glyphs without `calt` (with it, an arrow).
+    let mut e = TextEngine::new();
+    let ids = |e: &mut TextEngine, t: &TextLayer| e.layout(t, 72.0).glyphs.iter().map(|g| g.id).collect::<Vec<_>>();
+    let with = |len: usize, tags: &[(&str, u16)]| TextRun {
+        len,
+        style: CharStyle {
+            features: tags.iter().map(|(tag, value)| FontFeature { tag: (*tag).into(), value: *value }).collect(),
+            ..back.char_runs()[0].style.clone()
+        },
+    };
+    let mut expected = back.clone();
+    expected.runs = vec![with(2, &[("ss02", 1)]), with(4, &[("calt", 0), ("ss01", 1)])];
+    let shown = ids(&mut e, &back);
+    assert_eq!(shown, ids(&mut e, &expected));
+    let defaults = ids(&mut e, &crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap());
+    assert_eq!((shown.len(), defaults.len()), (6, 5), "`->` is two glyphs, as in Photoshop, not an arrow");
+    assert!(shown.first() != defaults.first() && shown.last() != defaults.last(), "{shown:?} vs {defaults:?}");
+    // A feature the style already sets (from EngineData, read first) keeps its value; masks and
+    // flags of the wrong type, masks beyond the 20 sets and unknown keys change nothing.
+    let mut t = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
+    t.runs = vec![TextRun { len: text.len(), style: CharStyle { features: vec![FontFeature { tag: "ss01".into(), value: 0 }], ..Default::default() } }];
+    let odd =
+        [(1, "/85 1".to_string()), (1, "/85 (x) /20 (x) /25 (true)".to_string()), (1, "/85 -1".to_string()), (4, "/85 99999999999 /999 true".to_string())];
+    crate::psd::apply_txt2(&mut t, &tysh, &crate::psd::parse_txt2(&txt2_with_styles(text, &odd)).unwrap());
+    assert_eq!(feats(&t), vec![vec![f("ss01", 0)]]);
+}
+
 /// A `Txt2` written by [`crate::psd::build_txt2`] (what PSD export writes for the type layers)
 /// restores every auto-kern mode on import (#1348: a new Optical layer used to reopen as
 /// Metrics, because EngineData's `AutoKerning true` covers both).
@@ -1478,6 +1677,59 @@ fn southeast_asian_fallback_candidates_cover_every_platform() {
     }
 }
 
+/// The Indic scripts of document text, with conjuncts, matras and viramas (#218).
+const INDIC: &[(&str, &str, &[&str])] = &[
+    ("Devanagari", "हिन्दी भाषा क्षत्रिय श्री", fonts::DEVANAGARI_FAMILIES),
+    ("Bengali", "বাংলা ভাষা ক্ষত্রিয় শ্রী", fonts::BENGALI_FAMILIES),
+    ("Gurmukhi", "ਪੰਜਾਬੀ ਭਾਸ਼ਾ ਸਤਿ ਸ੍ਰੀ", fonts::GURMUKHI_FAMILIES),
+    ("Gujarati", "ગુજરાતી ભાષા ક્ષત્રિય શ્રી", fonts::GUJARATI_FAMILIES),
+    ("Tamil", "தமிழ் மொழி ஸ்ரீ கொடை", fonts::TAMIL_FAMILIES),
+    ("Telugu", "తెలుగు భాష క్షత్రియ శ్రీ", fonts::TELUGU_FAMILIES),
+    ("Kannada", "ಕನ್ನಡ ಭಾಷೆ ಕ್ಷತ್ರಿಯ ಶ್ರೀ", fonts::KANNADA_FAMILIES),
+    ("Malayalam", "മലയാളം ഭാഷ ക്ഷത്രിയ ശ്രീ", fonts::MALAYALAM_FAMILIES),
+    ("Sinhala", "සිංහල භාෂාව ක්‍ෂත්‍රිය ශ්‍රී", fonts::SINHALA_FAMILIES),
+];
+
+#[test]
+fn indic_scripts_fall_back_to_installed_fonts() {
+    for (name, sample, families) in INDIC {
+        let mut e = TextEngine::with_system_fonts();
+        let Some(hit) = families.iter().find(|f| e.fonts.has_family(f)) else {
+            eprintln!("skipped: no {name}-capable font installed");
+            continue;
+        };
+        let direct = TextLayer { text: (*sample).into(), font_family: hit.to_string(), size_pt: 24.0, ..Default::default() };
+        let l = e.layout(&direct, 72.0);
+        assert!(!l.glyphs.is_empty() && l.glyphs.iter().all(|g| g.id != 0), "{hit} is installed but shapes .notdef for {name}");
+        let mixed = format!("Latin {sample}");
+        let l = e.layout(&point(&mixed, 24.0), 72.0);
+        assert!(l.glyphs.iter().all(|g| g.id != 0), "{name} in a Latin font drawn with .notdef although {hit} is installed");
+        let latin = l.glyphs.first().map(|g| g.face);
+        assert!(l.glyphs.iter().any(|g| Some(g.face) != latin), "Latin and {name} drawn with the same face");
+    }
+}
+
+#[test]
+fn indic_fallback_candidates_cover_every_platform() {
+    // Logic-level half (runs without these fonts): every script has a Windows, macOS and Linux
+    // family in the candidates, ahead of the broad last-resort fonts; the shared Nirmala UI is
+    // probed once.
+    for order in [crate::cjk::script_order(None), crate::cjk::script_order(Some("ja"))] {
+        let fb = fonts::fallback_candidates(&order);
+        let last = fb.iter().position(|f| *f == "Arial Unicode MS").unwrap();
+        assert_eq!(fb.iter().filter(|f| **f == "Nirmala UI").count(), 1, "{fb:?}");
+        for (name, _, families) in INDIC {
+            assert!(families.contains(&"Nirmala UI"), "{name}");
+            assert!(families.iter().any(|f| f.ends_with("Sangam MN") || f.starts_with("Kohinoor")), "{name}: no macOS family");
+            assert!(families.iter().any(|f| f.starts_with("Noto Sans ")), "{name}: no Linux family");
+            for fam in *families {
+                let i = fb.iter().position(|f| f == fam).unwrap_or_else(|| panic!("{fam} missing from {fb:?}"));
+                assert!(i < last, "{fam} after the last-resort fonts");
+            }
+        }
+    }
+}
+
 #[test]
 fn a_served_script_fallback_joins_the_fallback_stack_once_it_arrives() {
     let Some(cairo) = crate::CRAFT_FONTS.iter().find(|f| f.family == "Cairo") else {
@@ -1491,6 +1743,138 @@ fn a_served_script_fallback_joins_the_fallback_stack_once_it_arrives() {
     assert!(db.fallback_stack().any(|f| f == "Cairo"), "{:?}", db.fallback_stack().collect::<Vec<_>>());
 }
 
+/// #1317: Photoshop keeps the last line of a text box whose baseline is inside the box even
+/// when its descenders hang below the bottom edge (three 35 pt lines of 25 pt type in a
+/// 91.3 pt box). A line whose baseline falls outside the box is still dropped.
+#[test]
+fn box_lines_whose_descent_hangs_below_the_box_are_kept() {
+    let mut e = TextEngine::new();
+    let mut t = styled("one\ntwo\nthree", CharStyle { size_pt: 25.0, leading_pt: Some(35.0), ..Default::default() });
+    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: 300.0, height: 91.27 };
+    let l = e.layout(&t, 72.0);
+    assert_eq!(l.lines.len(), 3, "{:?}", l.lines.iter().map(|l| l.baseline).collect::<Vec<_>>());
+    assert!(l.lines[2].baseline <= 91.27 + 0.5);
+    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: 300.0, height: 80.0 };
+    assert_eq!(e.layout(&t, 72.0).lines.len(), 2, "the third baseline (about 88) is below an 80 pt box");
+}
+
+/// `Txt2` with one text object for `text` whose rendered frame is frame 0, and that frame:
+/// for point text an anchor `point`, and a frame-to-text matrix `matrix` (recent Photoshop,
+/// #1317).
+fn txt2_with_frame(text: &str, point: Option<[f64; 2]>, matrix: [f64; 6]) -> Vec<u8> {
+    let mut v = txt2_with_modes(text, &[(text.encode_utf16().count() + 1, 1)]);
+    // Close the object's model early: `… >> >> ] >>` → `… >> /1 << /2 [ frame ] >> >> ] >>`.
+    let tail = b"] >> >> >> ] >>";
+    assert!(v.ends_with(tail));
+    v.truncate(v.len() - tail.len());
+    v.extend_from_slice(b"] >> >> /1 << /2 [ << /6 [ << /10 0 >> ] >> ] >> >> ] >>");
+    let pt = point.map(|[x, y]| format!("/0 [ {x:.5} {y:.5} ] ")).unwrap_or_default();
+    let m = matrix.map(|x| format!("{x:.5}")).join(" ");
+    let frames = format!("/0 << /8 << /0 [ << /0 << {pt}/2 << /2 [ {m} ] >> >> >> ] >> >>");
+    let at = v.windows(9).position(|w| w == b"/0 << >> ").unwrap();
+    v.splice(at..at + 9, frames.into_bytes().into_iter().chain(*b" "));
+    v
+}
+
+/// #1317: point text whose anchor Photoshop keeps only in its `Txt2` frame (EngineData's
+/// `PointBase` at the origin, the transform far away) is placed at that anchor, not at the
+/// ink's top left. A rewritten `TySh` (bounds near the origin) is left alone.
+#[test]
+fn txt2_frame_places_point_text_at_its_anchor() {
+    let mut t = point("2", 100.0);
+    t.transform = Affine::translate(-1000.0, -2000.0);
+    // Photoshop's text space: anchor at (1100, 2050), ink above its baseline.
+    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, Some([1100.0, 1980.0, 1160.0, 2050.0])), 0);
+    let txt2 = crate::psd::parse_txt2(&txt2_with_frame("2", Some([1000.0, 2100.0]), [1.0, 0.0, 0.0, 1.0, 100.0, -50.0])).unwrap();
+    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
+    crate::psd::apply_txt2_frame(&mut l, &tysh, &txt2);
+    let o = l.transform.apply(photocraft_geom::Point::new(0.0, 0.0));
+    assert!((o.x - 100.0).abs() < 1e-3 && (o.y - 50.0).abs() < 1e-3, "anchor at {o:?}");
+    // Already folded in (bounds near the origin): unchanged; another text: unchanged.
+    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, Some([0.0, -70.0, 60.0, 0.0])), 0);
+    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
+    let before = l.transform;
+    crate::psd::apply_txt2_frame(&mut l, &tysh, &txt2);
+    assert_eq!(l.transform, before);
+    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, Some([1100.0, 1980.0, 1160.0, 2050.0])), 0);
+    let other = crate::psd::parse_txt2(&txt2_with_frame("3", Some([1000.0, 2100.0]), [1.0, 0.0, 0.0, 1.0, 100.0, -50.0])).unwrap();
+    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
+    let before = l.transform;
+    crate::psd::apply_txt2_frame(&mut l, &tysh, &other);
+    assert_eq!(l.transform, before);
+}
+
+/// `tysh` with its text-space `bounds` set to `r` (Photoshop's, where it drew the text).
+fn with_bounds(tysh: &[u8], r: [f64; 4]) -> Vec<u8> {
+    use photocraft_psd::descriptor::{Descriptor, Id, Value};
+    let mut t = crate::psd::parse_tysh(tysh).unwrap();
+    let mut d = Descriptor::default();
+    for (k, v) in ["Left", "Top ", "Rght", "Btom"].iter().zip(r) {
+        d.items.push((Id::new(k), Value::Double(v)));
+    }
+    t.text.items.retain(|(k, _)| !k.is("bounds"));
+    t.text.items.push((Id::new("bounds"), Value::Descriptor(d)));
+    crate::psd::write_tysh(&t)
+}
+
+/// #1317: a text box whose `BoxBounds` are in its `Txt2` frame's space is moved by the frame's
+/// matrix onto the `bounds` Photoshop drew it at (it used to land off the canvas, so its text
+/// "disappeared" when an edit started).
+#[test]
+fn txt2_frame_moves_box_text_onto_its_bounds() {
+    let mut t = styled("Casemiro 45", CharStyle { size_pt: 25.0, ..Default::default() });
+    t.shape = TextShape::Box { x: 500.0, y: 600.0, width: 300.0, height: 90.0 };
+    t.transform = Affine::translate(-700.0, -300.0);
+    let built = with_text_index(&crate::psd::build_tysh(&t, 72.0, None), 0);
+    let tysh = with_bounds(&built, [960.0, 300.0, 1260.0, 390.0]);
+    let txt2 = crate::psd::parse_txt2(&txt2_with_frame("Casemiro 45", None, [1.0, 0.0, 0.0, 1.0, 460.0, -300.0])).unwrap();
+    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
+    assert!(matches!(l.shape, TextShape::Box { .. }));
+    crate::psd::apply_txt2_frame(&mut l, &tysh, &txt2);
+    let TextShape::Box { x, y, .. } = l.shape else { panic!("not a box") };
+    let o = l.transform.apply(photocraft_geom::Point::new(f64::from(x), f64::from(y)));
+    assert!((o.x - 260.0).abs() < 1e-3 && (o.y - 0.0).abs() < 1e-3, "box top left at {o:?}");
+    // PhotoCraft's own `TySh` (bounds = the box, frame already folded in): unchanged.
+    let mut l = crate::psd::text_layer_from_tysh(&built, 72.0).unwrap();
+    let before = l.transform;
+    crate::psd::apply_txt2_frame(&mut l, &built, &txt2);
+    assert_eq!(l.transform, before);
+}
+
+/// Preferences ▸ Type ▸ Missing Glyph Protection: off, only the default family is in the
+/// fallback stack, so a face without the glyph shows the missing-glyph box instead of a
+/// fallback's glyph (#1909).
+#[test]
+fn missing_glyph_protection_can_turn_the_fallback_stack_off() {
+    let Some(cairo) = crate::CRAFT_FONTS.iter().find(|f| f.family == "Cairo") else {
+        eprintln!("skipping: built without craft-fonts (set CRAFT_FONTS_DIR to a craft-fonts checkout)");
+        return;
+    };
+    let mut db = fonts::FontDb::new();
+    db.register_font_data(cairo.bytes.to_vec());
+    assert!(db.missing_glyph_protection(), "on by default, as in Photoshop");
+    assert!(db.fallback_stack().any(|f| f == "Cairo"));
+    db.set_missing_glyph_protection(false);
+    assert_eq!(db.fallback_stack().collect::<Vec<_>>(), [fonts::DEFAULT_FAMILY], "only the default family remains");
+    db.set_missing_glyph_protection(true);
+    assert!(db.fallback_stack().any(|f| f == "Cairo"), "turning it back on restores the coverage fonts");
+}
+
+/// The shared engine's missing-glyph protection follows the setting without waiting for the
+/// system font scan (#4519). Under test the shared engine has no scan, so it applies at once;
+/// the newest setting wins.
+#[test]
+fn shared_missing_glyph_protection_follows_the_setting() {
+    let read = || crate::shared().lock().unwrap_or_else(std::sync::PoisonError::into_inner).fonts.missing_glyph_protection();
+    crate::set_shared_missing_glyph_protection(false);
+    assert!(!read());
+    crate::set_shared_missing_glyph_protection(true);
+    crate::set_shared_missing_glyph_protection(false);
+    assert!(!read(), "the newest setting wins");
+    crate::set_shared_missing_glyph_protection(true);
+    assert!(read());
+}
+
 #[test]
 fn translate_tysh_moves_only_the_translation() {
     let mut t = point("Hello!", 26.0);
@@ -1505,3 +1889,122 @@ fn translate_tysh_moves_only_the_translation() {
     assert_eq!(crate::psd::parse_tysh(&tysh).unwrap().bounds, back.bounds, "bounds are in text space");
     assert!(crate::psd::translate_tysh(&tysh[..40], 1.0, 1.0).is_none(), "a truncated block is refused");
 }
+
+/// The four values after the `TySh` warp descriptor are big-endian f32, as Photoshop writes them:
+/// zeros for unwarped type, the text-space bounds for warped type.
+#[test]
+fn tysh_trailing_bounds_are_f32() {
+    use photocraft_doc::text::TextWarp;
+    let tail = |b: &[u8]| -> [f32; 4] {
+        let t = b.get(b.len() - 16..).unwrap();
+        std::array::from_fn(|i| f32::from_be_bytes(t[i * 4..i * 4 + 4].try_into().unwrap()))
+    };
+    let ink = [0.0, -34.316406, 288.90625, 15.058594];
+    let plain = crate::psd::build_tysh(&point("Type", 20.0), 72.0, Some(ink));
+    assert_eq!(tail(&plain), [0.0; 4]);
+    let warped = TextLayer {
+        warp: Some(TextWarp { style: "warpArc".into(), value: 50.0, horizontal_distortion: 0.0, vertical_distortion: 0.0, horizontal: true }),
+        ..point("Type", 20.0)
+    };
+    let bytes = crate::psd::build_tysh(&warped, 72.0, Some(ink));
+    assert_eq!(tail(&bytes), ink);
+    let parsed = crate::psd::parse_tysh(&bytes).unwrap();
+    assert_eq!(parsed.bounds, ink);
+    assert_eq!(crate::psd::write_tysh(&parsed), bytes);
+}
+
+/// EngineData's `AntiAlias` numbers as Photoshop writes them, beside the `AntA` descriptor:
+/// 0 None, 1 Crisp, 2 Strong, 3 Smooth, 4 Sharp. Read back from EngineData alone (no `AntA`),
+/// every mode survives.
+#[test]
+fn engine_data_antialias_numbers_match_photoshop() {
+    use photocraft_doc::text::AntiAlias;
+    for (mode, n) in [(AntiAlias::None, 0), (AntiAlias::Crisp, 1), (AntiAlias::Strong, 2), (AntiAlias::Smooth, 3), (AntiAlias::Sharp, 4)] {
+        let t = TextLayer { antialias: mode, ..point("Type", 20.0) };
+        let mut tysh = crate::psd::parse_tysh(&crate::psd::build_tysh(&t, 72.0, None)).unwrap();
+        let e = crate::psd::engine_data(&tysh.text).unwrap();
+        assert_eq!(e.path(&["EngineDict", "AntiAlias"]).and_then(crate::engine_data::Value::as_f64), Some(f64::from(n)), "{mode:?}");
+        tysh.text.items.retain(|(k, _)| !k.is("AntA"));
+        let back = crate::psd::text_layer_from_tysh(&crate::psd::write_tysh(&tysh), 72.0).unwrap();
+        assert_eq!(back.antialias, mode, "{n}");
+    }
+}
+
+/// Type on a path (#218): along a vertical line the type runs top to bottom with its glyphs
+/// turned, along a curve it follows the curve, and glyphs beyond the end are not drawn.
+#[test]
+fn type_on_a_path_follows_the_curve() {
+    use photocraft_doc::vector::{Knot, Subpath};
+    let fmt = PixelFormat::RGBA8;
+    let mut eng = TextEngine::new();
+    let ink = |eng: &mut TextEngine, t: &TextLayer| {
+        let (_, r) = eng.render(t, 72.0, fmt);
+        r.rect
+    };
+    let straight = point("Path text", 24.0);
+    let flat = ink(&mut eng, &straight);
+    assert!(flat.width() > flat.height() * 3, "{flat:?}");
+
+    let mut down = straight.clone();
+    down.shape = TextShape::Path { path: Subpath::polyline(&[(0.0, 0.0), (0.0, 400.0)]), start: 0.0, flip: false };
+    let r = ink(&mut eng, &down);
+    assert!(r.height() > r.width() * 3, "vertical path gives tall ink: {r:?}");
+    assert!(r.height() >= flat.width() - 8, "arc length is preserved: {r:?} vs {flat:?}");
+
+    // A half circle bends the text through a larger area than the straight line.
+    let k = 0.5523 * 60.0;
+    let arc = Subpath {
+        closed: false,
+        knots: vec![
+            Knot {
+                anchor: photocraft_geom::Point::new(-60.0, 0.0),
+                in_ctrl: photocraft_geom::Point::new(-60.0, 0.0),
+                out_ctrl: photocraft_geom::Point::new(-60.0, -k),
+                smooth: true,
+            },
+            Knot {
+                anchor: photocraft_geom::Point::new(0.0, -60.0),
+                in_ctrl: photocraft_geom::Point::new(-k, -60.0),
+                out_ctrl: photocraft_geom::Point::new(k, -60.0),
+                smooth: true,
+            },
+            Knot {
+                anchor: photocraft_geom::Point::new(60.0, 0.0),
+                in_ctrl: photocraft_geom::Point::new(60.0, -k),
+                out_ctrl: photocraft_geom::Point::new(60.0, 0.0),
+                smooth: true,
+            },
+        ],
+        ..Default::default()
+    };
+    let mut curved = straight.clone();
+    curved.shape = TextShape::Path { path: arc.clone(), start: 0.0, flip: false };
+    let c = ink(&mut eng, &curved);
+    assert!(c.height() > flat.height() * 2, "curved ink is taller: {c:?} vs {flat:?}");
+
+    // A path too short for the text hides the glyphs past its end.
+    let mut short = straight.clone();
+    short.shape = TextShape::Path { path: Subpath::polyline(&[(0.0, 0.0), (30.0, 0.0)]), start: 0.0, flip: false };
+    assert!(ink(&mut eng, &short).width() < flat.width() / 2);
+    // A degenerate path falls back to straight point text instead of failing.
+    let mut dot = straight.clone();
+    dot.shape = TextShape::Path { path: Subpath::polyline(&[(5.0, 5.0), (5.0, 5.0)]), start: 0.0, flip: false };
+    assert_eq!(ink(&mut eng, &dot), flat);
+}
+
+#[test]
+fn hyphenless_postscript_names_split_trailing_styles() {
+    for (ps, family, weight, italic) in [
+        ("GmarketSansBold", "Gmarket Sans", 700, false),
+        ("NanumGothicBold", "Nanum Gothic", 700, false),
+        ("GmarketSansTTFBold", "Gmarket Sans TTF", 700, false),
+        ("ExampleSansSemiBoldItalic", "Example Sans", 600, true),
+        ("ExampleSansExtraLight", "Example Sans", 200, false),
+        // A style word after a vendor tag belongs to a legacy family name; lowercase is no style.
+        ("ArialRoundedMTBold", "Arial Rounded MT Bold", 400, false),
+        ("Daylight", "Daylight", 400, false),
+    ] {
+        let r = fonts::guess_from_postscript(ps);
+        assert_eq!((r.family.as_str(), r.weight, r.italic), (family, weight, italic), "{ps}");
+    }
+}
diff --git a/crates/text/src/warp.rs b/crates/text/src/warp.rs
index e056bdff33..f148a18e1b 100644
--- a/crates/text/src/warp.rs
+++ b/crates/text/src/warp.rs
@@ -6,7 +6,8 @@
 //! formulas), the identity at `bend = 0` and continuous in `bend`. The mapping is evaluated per
 //! point; the renderer subdivides long segments so straight edges bend.
 
-use photocraft_doc::text::TextWarp;
+use photocraft_doc::text::{TextShape, TextWarp};
+use photocraft_doc::vector::Subpath;
 use photocraft_geom::warp::{StyleWarp, WarpStyle};
 
 /// Warp styles in Photoshop's menu order: (PSD `warpStyle` value, short id used by commands).
@@ -45,10 +46,29 @@ pub fn short_style(psd: &str) -> Option<&'static str> {
     STYLES.iter().find(|(p, _)| *p == psd).map(|(_, short)| *short)
 }
 
+/// Where a glyph goes when the layout is bent: see [`Warp::place_glyph`].
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Placement {
+    /// Not path text: bend the outline point by point with [`Warp::apply`].
+    Bend,
+    /// Beyond either end of the path: the glyph is not drawn.
+    Hidden,
+    /// Path text: the glyph keeps its shape and is moved rigidly by this text-space map
+    /// (`[a, b, c, d, e, f]`, applied to text-space points).
+    Frame([f64; 6]),
+}
+
 /// A warp prepared for one layout: the shared style math of
-/// [`photocraft_geom::warp::StyleWarp`] (also used by Edit › Transform › Warp) over the text box.
-#[derive(Clone, Copy, Debug)]
-pub struct Warp(StyleWarp);
+/// [`photocraft_geom::warp::StyleWarp`] (also used by Edit › Transform › Warp) over the text box,
+/// or a path the type runs along.
+#[derive(Clone, Debug)]
+pub struct Warp(Kind);
+
+#[derive(Clone, Debug)]
+enum Kind {
+    Style(Box<StyleWarp>),
+    Path(PathFrame),
+}
 
 impl Warp {
     /// Prepares `w` for text whose bounds are `[x0, y0, x1, y1]` (text space). `None` for
@@ -56,17 +76,117 @@ impl Warp {
     pub fn new(w: &TextWarp, bounds: [f32; 4]) -> Option<Warp> {
         let style = WarpStyle::parse(&w.style).filter(|s| s.is_preset() && s.psd_name() == w.style)?;
         StyleWarp::new(style, f64::from(w.value), f64::from(w.horizontal_distortion), f64::from(w.vertical_distortion), !w.horizontal, bounds.map(f64::from))
-            .map(Warp)
+            .map(|s| Warp(Kind::Style(Box::new(s))))
+    }
+
+    /// The deformation of type on a path (`None` for any other shape, or a path without length).
+    pub fn on_path(shape: &TextShape) -> Option<Warp> {
+        let TextShape::Path { path, start, flip } = shape else { return None };
+        PathFrame::new(path, *start, *flip).map(|f| Warp(Kind::Path(f)))
     }
 
     /// Longest segment (text-space px) worth sending through [`Warp::apply`] unsplit.
     pub fn max_segment(&self) -> f64 {
-        self.0.max_segment()
+        match &self.0 {
+            Kind::Style(s) => s.max_segment(),
+            Kind::Path(_) => 2.0,
+        }
     }
 
     /// Maps a text-space point.
     pub fn apply(&self, x: f64, y: f64) -> (f64, f64) {
-        self.0.apply(x, y)
+        match &self.0 {
+            Kind::Style(s) => s.apply(x, y),
+            Kind::Path(p) => p.apply(x, y),
+        }
+    }
+
+    /// How to place a glyph whose horizontal centre is at text-space `cx`.
+    pub fn place_glyph(&self, cx: f64) -> Placement {
+        match &self.0 {
+            Kind::Style(_) => Placement::Bend,
+            Kind::Path(p) => p.frame(cx).map_or(Placement::Hidden, Placement::Frame),
+        }
+    }
+}
+
+/// Most cubic segments of a type path that are followed (a hostile file cannot make this large).
+const MAX_PATH_SEGMENTS: usize = 4096;
+
+/// A flattened path with arc lengths: text-space `x` is arc length from `start`, `y` the
+/// distance to the left of the direction of travel (the side the glyph tops point to).
+#[derive(Clone, Debug)]
+struct PathFrame {
+    pts: Vec<(f64, f64)>,
+    /// Arc length at each point.
+    cum: Vec<f64>,
+    start: f64,
+}
+
+impl PathFrame {
+    fn new(path: &Subpath, start: f32, flip: bool) -> Option<PathFrame> {
+        let mut pts: Vec<(f64, f64)> = Vec::new();
+        for seg in path.segments().iter().take(MAX_PATH_SEGMENTS) {
+            let p = seg.map(|q| (q.x, q.y));
+            if p.iter().any(|q| !q.0.is_finite() || !q.1.is_finite()) {
+                return None;
+            }
+            let poly = (p[1].0 - p[0].0).hypot(p[1].1 - p[0].1) + (p[2].0 - p[1].0).hypot(p[2].1 - p[1].1) + (p[3].0 - p[2].0).hypot(p[3].1 - p[2].1);
+            let n = ((poly / 2.0).ceil() as usize).clamp(4, 128);
+            if pts.is_empty() {
+                pts.push(p[0]);
+            }
+            for i in 1..=n {
+                let t = i as f64 / n as f64;
+                let u = 1.0 - t;
+                let (a, b, c, d) = (u * u * u, 3.0 * u * u * t, 3.0 * u * t * t, t * t * t);
+                pts.push((a * p[0].0 + b * p[1].0 + c * p[2].0 + d * p[3].0, a * p[0].1 + b * p[1].1 + c * p[2].1 + d * p[3].1));
+            }
+        }
+        // Drop repeated points so every piece has a direction.
+        pts.dedup_by(|b, a| (b.0 - a.0).abs() < 1e-9 && (b.1 - a.1).abs() < 1e-9);
+        if flip {
+            pts.reverse();
+        }
+        let mut cum = Vec::with_capacity(pts.len());
+        let mut acc = 0.0;
+        for (i, p) in pts.iter().enumerate() {
+            if let Some(q) = i.checked_sub(1).and_then(|j| pts.get(j)) {
+                acc += (p.0 - q.0).hypot(p.1 - q.1);
+            }
+            cum.push(acc);
+        }
+        (pts.len() >= 2 && acc.is_finite() && acc > 1e-6 && start.is_finite()).then(|| PathFrame { pts, cum, start: f64::from(start) })
+    }
+
+    fn length(&self) -> f64 {
+        self.cum.last().copied().unwrap_or(0.0)
+    }
+
+    /// Point and unit tangent at arc length `s`; past either end the end tangent continues straight.
+    fn at(&self, s: f64) -> ((f64, f64), (f64, f64)) {
+        let last = self.pts.len() - 1;
+        let i = self.cum.partition_point(|&c| c < s).clamp(1, last);
+        let (a, b) = (self.pts[i - 1], self.pts[i]);
+        let len = (b.0 - a.0).hypot(b.1 - a.1).max(1e-12);
+        let t = ((b.0 - a.0) / len, (b.1 - a.1) / len);
+        let along = s - self.cum[i - 1];
+        ((a.0 + t.0 * along, a.1 + t.1 * along), t)
+    }
+
+    fn apply(&self, x: f64, y: f64) -> (f64, f64) {
+        let (p, t) = self.at(self.start + x);
+        (p.0 - t.1 * y, p.1 + t.0 * y)
+    }
+
+    /// The rigid map for a glyph centred at text-space `cx`; `None` outside the path.
+    fn frame(&self, cx: f64) -> Option<[f64; 6]> {
+        let s = self.start + cx;
+        if !(0.0..=self.length()).contains(&s) {
+            return None;
+        }
+        let (p, t) = self.at(s);
+        Some([t.0, t.1, -t.1, t.0, p.0 - t.0 * cx, p.1 - t.1 * cx])
     }
 }
 
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index 568727163b..d6a49c0038 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -30,7 +30,7 @@ photocraft-format = { workspace = true }
 photocraft-codecs = { workspace = true }
 egui = { workspace = true }
 egui_extras = { version = "0.36", default-features = false, features = ["svg"] }
-eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit"] }
+eframe = { workspace = true, features = ["wgpu", "accesskit"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 log = { workspace = true }
@@ -49,6 +49,9 @@ sys-locale = "=0.3.2"
 winsafe = { version = "=0.0.29", default-features = false, features = ["kernel"] }
 
 [dev-dependencies]
+# egui's own default fonts in tests: the oracle for egui_fonts.rs, and contexts made with
+# `Context::default()` (no install_fonts) can lay out text.
+egui = { workspace = true, features = ["default_fonts"] }
 # Synthetic raw files for the open-time Camera Raw dialog tests.
 photocraft-raw = { workspace = true, features = ["testgen"] }
 egui_kittest = { workspace = true, features = ["wgpu", "snapshot", "eframe"] }
@@ -58,7 +61,9 @@ photocraft-testkit = { workspace = true }
 photocraft-psd = { workspace = true }
 
 [build-dependencies]
-# Deflates the translation catalogs (build.rs); already linked at run time to inflate them.
+# Deflates the translation catalogs and egui's default fonts (build.rs); already linked at run time to inflate them.
 flate2 = { workspace = true }
+# egui's default fonts, deflated by build.rs for egui_fonts.rs (the same version egui uses).
+epaint_default_fonts = "0.36"
 serde_json = { workspace = true }
 toml = "1"
diff --git a/crates/ui-egui/build.rs b/crates/ui-egui/build.rs
index fa0e19cc1f..900370eb69 100644
--- a/crates/ui-egui/build.rs
+++ b/crates/ui-egui/build.rs
@@ -8,10 +8,10 @@
 //!
 //! A missing or malformed file gives empty tables (or no names) and a warning.
 //!
-//! Also deflates the translation catalogs (`src/i18n/*.tsv`) into `OUT_DIR/i18n/<code>.tsv.deflate`
-//! for `i18n::LANGUAGES`: stored compressed they take ~0.65 MB of the binary instead of ~1.9 MB,
-//! which keeps the web build under its 24 MiB size gate (packaging/web/package.sh). A catalog is
-//! inflated the first time its language is used.
+//! Also packs the translation catalogs (`src/i18n/*.tsv`) into `OUT_DIR/i18n/` for
+//! `i18n::LANGUAGES` (see [`pack_catalogs`]): stored that way they take ~0.5 MB of the binary
+//! instead of ~2.2 MB, which keeps the web build under its 24 MiB size gate
+//! (packaging/web/package.sh). A catalog is unpacked the first time its language is used.
 
 use std::fmt::Write as _;
 
@@ -27,30 +27,123 @@ fn main() {
     if let Err(e) = std::fs::write(&out, generate(&json, &people)) {
         println!("cargo::warning=writing {}: {e}", out.display());
     }
-    deflate_catalogs();
+    pack_catalogs();
+    deflate_egui_fonts();
 }
 
-/// Deflate every `src/i18n/*.tsv` into `OUT_DIR/i18n/`. A catalog that can't be written is a
-/// build error (`include_bytes!` would fail on it anyway, with a less helpful message).
-fn deflate_catalogs() {
+/// Deflate egui's default fonts (the `epaint_default_fonts` crate) into `OUT_DIR/egui_fonts/` for
+/// `egui_fonts.rs`. The app builds egui without `default_fonts`, which would embed the same 1.4 MB
+/// uncompressed; deflated they take 0.78 MB (the web build's 24 MiB size gate).
+fn deflate_egui_fonts() {
     use std::io::Write as _;
-    let src = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/i18n");
-    let out = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap_or_default()).join("i18n");
-    println!("cargo::rerun-if-changed={}", src.display());
+    let out = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap_or_default()).join("egui_fonts");
+    let fonts = [
+        ("Hack-Regular", epaint_default_fonts::HACK_REGULAR),
+        ("NotoEmoji-Regular", epaint_default_fonts::NOTO_EMOJI_REGULAR),
+        ("Ubuntu-Light", epaint_default_fonts::UBUNTU_LIGHT),
+        ("emoji-icon-font", epaint_default_fonts::EMOJI_ICON),
+    ];
     let result = (|| -> std::io::Result<()> {
         std::fs::create_dir_all(&out)?;
-        for entry in std::fs::read_dir(&src)? {
-            let path = entry?.path();
-            let Some(name) = path.file_name().and_then(|n| n.to_str()).filter(|n| n.ends_with(".tsv")) else { continue };
-            println!("cargo::rerun-if-changed={}", path.display());
+        for (name, bytes) in fonts {
             let mut z = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::best());
-            z.write_all(&std::fs::read(&path)?)?;
-            std::fs::write(out.join(format!("{name}.deflate")), z.finish()?)?;
+            z.write_all(bytes)?;
+            std::fs::write(out.join(format!("{name}.ttf.deflate")), z.finish()?)?;
         }
         Ok(())
     })();
     if let Err(e) = result {
-        println!("cargo::error=deflating the translation catalogs in {}: {e}", src.display());
+        println!("cargo::error=deflating egui's default fonts into {}: {e}", out.display());
+    }
+}
+
+/// Whether a catalog line is an entry (`context<TAB>source<TAB>translation`, source and
+/// translation non-empty, as `i18n::catalog::parse_entries` reads it), and its key and translation.
+fn catalog_entry(line: &str) -> Option<(&str, &str)> {
+    if line.starts_with('#') {
+        return None;
+    }
+    let mut cols = line.splitn(3, '\t');
+    let (ctx, src, tr) = (cols.next()?, cols.next()?, cols.next()?);
+    let key = line.get(..ctx.len() + 1 + src.len())?;
+    (!src.is_empty() && !tr.is_empty() && !tr.contains('\t')).then_some((key, tr))
+}
+
+/// Pack every `src/i18n/*.tsv` into `OUT_DIR/i18n/`, losslessly (`i18n::unpack` restores each file
+/// byte for byte). Every catalog repeats the same English sources, so they are stored once:
+///
+/// - `keys.deflate`: every entry's `context<TAB>source`, one per line, in order of first
+///   appearance (the largest catalog first).
+/// - `<code>.tsv.deflate`: the catalog, each entry line replaced by `\x01<translation>` when its key
+///   follows the previous entry's in `keys`, else `\x02<offset><TAB><translation>` (the offset from
+///   there). Other lines are kept; one that starts with \x01, \x02 or \x03 gets a \x03 prefix.
+///
+/// Both are deflated. A catalog that can't be written is a build error (`include_bytes!` would
+/// fail on it anyway, with a less helpful message).
+fn pack_catalogs() {
+    use std::io::Write as _;
+    let src = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/i18n");
+    let out = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap_or_default()).join("i18n");
+    println!("cargo::rerun-if-changed={}", src.display());
+    let deflate = |bytes: &[u8]| -> std::io::Result<Vec<u8>> {
+        let mut z = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::best());
+        z.write_all(bytes)?;
+        z.finish()
+    };
+    let result = (|| -> std::io::Result<()> {
+        std::fs::create_dir_all(&out)?;
+        let mut catalogs = Vec::new();
+        for entry in std::fs::read_dir(&src)? {
+            let path = entry?.path();
+            let Some(name) = path.file_name().and_then(|n| n.to_str()).filter(|n| n.ends_with(".tsv")) else { continue };
+            println!("cargo::rerun-if-changed={}", path.display());
+            catalogs.push((name.to_owned(), std::fs::read_to_string(&path)?));
+        }
+        // Largest first, then by name: the key order (and so the output) is reproducible.
+        catalogs.sort_by(|a, b| b.1.len().cmp(&a.1.len()).then_with(|| a.0.cmp(&b.0)));
+        let mut keys: Vec<&str> = Vec::new();
+        let mut index = std::collections::HashMap::new();
+        for line in catalogs.iter().flat_map(|(_, text)| text.split('\n')) {
+            if let Some((key, _)) = catalog_entry(line) {
+                index.entry(key).or_insert_with(|| {
+                    keys.push(key);
+                    keys.len() - 1
+                });
+            }
+        }
+        std::fs::write(out.join("keys.deflate"), deflate(keys.join("\n").as_bytes())?)?;
+        for (name, text) in &catalogs {
+            let mut packed = String::with_capacity(text.len());
+            let mut next = 0usize;
+            for (n, line) in text.split('\n').enumerate() {
+                if n > 0 {
+                    packed.push('\n');
+                }
+                match catalog_entry(line) {
+                    Some((key, tr)) => {
+                        let i = index.get(key).copied().unwrap_or_default();
+                        if i == next {
+                            packed.push('\x01');
+                        } else {
+                            let _ = write!(packed, "\x02{}\t", i as i64 - next as i64);
+                        }
+                        packed.push_str(tr);
+                        next = i + 1;
+                    }
+                    None => {
+                        if line.starts_with(['\x01', '\x02', '\x03']) {
+                            packed.push('\x03');
+                        }
+                        packed.push_str(line);
+                    }
+                }
+            }
+            std::fs::write(out.join(format!("{name}.deflate")), deflate(packed.as_bytes())?)?;
+        }
+        Ok(())
+    })();
+    if let Err(e) = result {
+        println!("cargo::error=packing the translation catalogs in {}: {e}", src.display());
     }
 }
 
diff --git a/crates/ui-egui/examples/unsharp_preview_bench.rs b/crates/ui-egui/examples/unsharp_preview_bench.rs
new file mode 100644
index 0000000000..0f4518187a
--- /dev/null
+++ b/crates/ui-egui/examples/unsharp_preview_bench.rs
@@ -0,0 +1,67 @@
+//! Synthetic existing preview workload, including proxy creation, command/history and CPU
+//! flattening. Excludes scheduling, egui frames, display conversion, GPU upload/presentation.
+use photocraft_color::{Color, ColorMode, SampleType};
+use photocraft_doc::{Document, LayerContent};
+use photocraft_geom::{Rect, Size};
+use photocraft_ui_egui::{filter_dialog, proxy};
+use serde_json::json;
+use std::time::Instant;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let n = |key: &str, default| std::env::var(key).ok().and_then(|s| s.parse::<u32>().ok()).unwrap_or(default);
+    let (w, h, reps) = (n("PHOTOCRAFT_UNSHARP_WIDTH", 6000), n("PHOTOCRAFT_UNSHARP_HEIGHT", 4000), n("PHOTOCRAFT_UNSHARP_REPS", 5));
+    if w == 0 || h == 0 || w > 8192 || h > 8192 || !(1..=15).contains(&reps) {
+        return Err("invalid benchmark dimensions/reps".into());
+    }
+    let depth = match n("PHOTOCRAFT_UNSHARP_DEPTH", 8) {
+        8 => SampleType::U8,
+        16 => SampleType::U16,
+        32 => SampleType::F32,
+        _ => return Err("invalid depth".into()),
+    };
+    let mut doc = Document::with_background("Synthetic Unsharp Mask", Size::new(w, h), ColorMode::Rgb, depth, Color::WHITE);
+    let layer = doc.layers.first_mut().ok_or("missing layer")?;
+    let id = layer.id;
+    let LayerContent::Raster(s) = &mut layer.content else { return Err("raster required".into()) };
+    for y in 0..h as i32 {
+        let data: Vec<_> = (0..w as i32)
+            .flat_map(|x| [((x * 7 + y * 13) % 257) as f32 / 256.0, ((x ^ y) % 251) as f32 / 250.0, ((x + y * 11) % 127) as f32 / 126.0, 1.0])
+            .collect();
+        s.write_region(Rect::new(0, y, w as i32, y + 1), &data);
+    }
+    let cmd = "filter.sharpen.unsharpMask";
+    let cases = std::env::var("PHOTOCRAFT_UNSHARP_CASES").unwrap_or_else(|_| "0.6:150:0,3:150:8,10:300:16,30:150:0".into());
+    for case in cases.split(',') {
+        let v: Vec<f64> = case.split(':').map(str::parse).collect::<Result<_, _>>()?;
+        let (&radius, &amount, &threshold) = (v.first().ok_or("radius")?, v.get(1).ok_or("amount")?, v.get(2).ok_or("threshold")?);
+        for reduced in [true, false] {
+            let k = filter_dialog::preview_factor(cmd, &json!({"radius":radius}), proxy::preview_factor(&doc, reduced));
+            let mut times = Vec::new();
+            let mut checksum = 0u64;
+            for rep in 0..reps + 2 {
+                let start = Instant::now();
+                let result = filter_dialog::preview_document(&doc, Some(id), cmd, &json!({"radius":radius,"amount":amount,"threshold":threshold}), k)
+                    .ok_or("preview failed")?;
+                let pixels = photocraft_compose::flatten(&result);
+                let ms = start.elapsed().as_secs_f64() * 1000.0;
+                // Outside timing: stable hash over the full flattened result, no image file needed.
+                let hash = pixels.px.iter().flatten().fold(0u64, |h, v| h.wrapping_mul(1099511628211).wrapping_add(u64::from(v.to_bits())));
+                if rep == 0 {
+                    checksum = hash;
+                } else if checksum != hash {
+                    return Err("unstable preview output".into());
+                }
+                if rep >= 2 {
+                    times.push(ms);
+                }
+            }
+            let mut sorted = times.clone();
+            sorted.sort_by(f64::total_cmp);
+            println!(
+                "{}",
+                json!({"width":w,"height":h,"depth":n("PHOTOCRAFT_UNSHARP_DEPTH",8),"radius":radius,"amount":amount,"threshold":threshold,"proxy_factor":k,"runs_ms":times,"median_ms":sorted.get(sorted.len()/2),"checksum":checksum,"workers":rayon::current_num_threads(),"scope":"existing preview_document + CPU flatten; excludes GUI and GPU"})
+            );
+        }
+    }
+    Ok(())
+}
diff --git a/crates/ui-egui/src/actions.rs b/crates/ui-egui/src/actions.rs
index 504ecf2beb..e0f3713f2e 100644
--- a/crates/ui-egui/src/actions.rs
+++ b/crates/ui-egui/src/actions.rs
@@ -21,6 +21,8 @@ pub struct ActionsUi {
     pub selected: Option<usize>,
     pub selected_step: Option<usize>,
     pub expanded: Vec<bool>,
+    /// Set folders shown collapsed (Photoshop's set disclosure triangles).
+    pub collapsed_sets: Vec<String>,
     #[serde(skip)]
     reveal_recording: Option<(usize, usize)>,
     /// The action whose name is being edited in place (double-click on its name).
@@ -35,10 +37,12 @@ struct RenameAction {
     focused: bool,
 }
 
-fn label_of(id: &str) -> String {
+pub(crate) fn label_of(id: &str) -> String {
     photocraft_engine::commands::find(id)
         .map(|c| c.label)
         .or_else(|| crate::menus::UI_COMMANDS.iter().find(|c| c.0 == id).map(|c| c.1))
+        // Shell menu items recorded as steps, like Save a Copy (#4373).
+        .or_else(|| crate::menu_catalog::CATALOG.iter().find(|c| c.3 == id).map(|c| c.1))
         .map(|label| label.trim_end_matches('…').to_string())
         .unwrap_or_else(|| id.to_string())
 }
@@ -92,7 +96,22 @@ pub(crate) fn play(app: &mut PhotocraftApp, params: &Value) -> Result<Value, Str
     let recording = actions_cmds::begin_playback(&mut app.session, &action).map_err(|e| e.to_string())?;
     let mut ran = 0u64;
     let mut failed = None;
+    let mut paused = None;
     for (i, (id, p)) in action.enabled_steps().skip_while(|(i, _)| *i < from) {
+        // The dialog toggle: show the step's dialog with its recorded values and continue
+        // from the next step when it is confirmed (`resume`). Agents play headlessly.
+        if action.dialogs.contains(&i) && !app.automation_input && (crate::filter_dialog::has_dialog(id) || crate::adjust_dialog::has_dialog(id)) {
+            let label = label_of(id);
+            let dialog = crate::dialogs::open_command_dialog(app, id, &label);
+            if let Some(d) = app.ui.dialog_mut(dialog) {
+                if let Some(o) = p.as_object() {
+                    d.fields.extend(o.iter().map(|(k, v)| (k.clone(), v.clone())));
+                }
+                d.fields.insert(RESUME.into(), json!({"action": action.name, "from": i + 1}));
+            }
+            paused = Some(json!({"step": i, "id": id, "dialog": dialog}));
+            break;
+        }
         let result = (|| {
             if let Some(auth) = app.session.authorize {
                 auth(id, p).map_err(|e| e.to_string())?;
@@ -119,6 +138,11 @@ pub(crate) fn play(app: &mut PhotocraftApp, params: &Value) -> Result<Value, Str
                     failed = Some(json!({"step": i, "id": id, "error": error}));
                     break;
                 }
+                if let Some(inner) = value.get("paused").filter(|p| p.is_object()) {
+                    // A called action paused for a dialog; it resumes alone when confirmed.
+                    paused = Some(inner.clone());
+                    break;
+                }
                 ran += 1;
             }
             Err(error) => {
@@ -128,9 +152,10 @@ pub(crate) fn play(app: &mut PhotocraftApp, params: &Value) -> Result<Value, Str
         }
     }
     actions_cmds::finish_playback(&mut app.session, recording, &action, from);
-    Ok(match failed {
-        Some(f) => json!({"action": action.name, "ran": ran, "failed": f}),
-        None => json!({"action": action.name, "ran": ran}),
+    Ok(match (failed, paused) {
+        (Some(f), _) => json!({"action": action.name, "ran": ran, "failed": f}),
+        (None, Some(p)) => json!({"action": action.name, "ran": ran, "paused": p}),
+        (None, None) => json!({"action": action.name, "ran": ran}),
     })
 }
 
@@ -177,6 +202,13 @@ fn begin_recording(app: &mut PhotocraftApp, append: bool) {
 }
 
 pub(crate) fn report_play(app: &mut PhotocraftApp, v: &Value) {
+    if let Some(paused) = v.get("paused").filter(|p| p.is_object()) {
+        let step = paused.get("step").and_then(Value::as_u64).unwrap_or(0);
+        let template = "Step {step} is waiting for its dialog";
+        app.ui.status = crate::i18n::fmt(tl!(template), &[("step", &(step + 1).to_string())]);
+        app.ui.status_error = false;
+        return;
+    }
     let Some(failed) = v.get("failed").filter(|f| f.is_object()) else {
         let ran = v.get("ran").and_then(Value::as_u64).unwrap_or(0);
         app.ui.status = crate::i18n::trn(crate::i18n::current(), ran, "Played {n} step", "Played {n} steps");
@@ -218,11 +250,219 @@ fn step_label(id: &str, params: &Value) -> String {
     if id == "actions.play" {
         let target = params.get("action").map(|v| v.as_str().map(str::to_owned).unwrap_or_else(|| v.to_string())).unwrap_or_default();
         format!("{}: {target}", label_of(id))
+    } else if id == "actions.conditional" {
+        // "If hasLayers: FS8-Layers / FS8-No-Layers"
+        let cond = params.get("if").and_then(Value::as_str).unwrap_or("?");
+        let branch = |k: &str| params.get(k).and_then(Value::as_str).unwrap_or("–").to_string();
+        format!("{}: {cond} → {} / {}", label_of(id), branch("then"), branch("else"))
+    } else if id == photocraft_engine::atn_cmds::STOP_MESSAGE {
+        format!("{}: {}", label_of(id), params.get("message").and_then(Value::as_str).unwrap_or_default())
+    } else if id == photocraft_engine::atn_cmds::PHOTOSHOP_STEP {
+        // A step from a .atn file PhotoCraft can't play yet: its Photoshop name, marked.
+        let name = params.get("name").and_then(Value::as_str).filter(|n| !n.is_empty()).unwrap_or("?");
+        crate::i18n::fmt(tl!("{name} (Photoshop)"), &[("name", name)])
     } else {
         label_of(id)
     }
 }
 
+/// Command params for a picked file: a real path keeps the journal small; browser files arrive
+/// as bytes.
+fn source(name: &str, bytes: &[u8]) -> Value {
+    #[cfg(not(target_arch = "wasm32"))]
+    if std::path::Path::new(name).is_absolute() && std::path::Path::new(name).is_file() {
+        return json!({"path": name});
+    }
+    let _ = name;
+    json!({"data": photocraft_engine::paint::tile::b64_encode(bytes)})
+}
+
+/// Load a `.atn` file's bytes into the Actions panel (the panel menu's Load Actions…).
+pub fn load_bytes(app: &mut PhotocraftApp, name: &str, bytes: &[u8]) -> Result<Value, String> {
+    let r = app.run("actions.load", source(name, bytes))?;
+    let n = r["actions"].as_array().map_or(0, Vec::len) as u64;
+    let unsupported = r["unsupported"].as_array().map_or(0, Vec::len);
+    let shown = crate::file_open::display_name(name);
+    let loaded =
+        crate::i18n::fmt(&crate::i18n::trn(crate::i18n::current(), n, "Loaded {n} action from {file}", "Loaded {n} actions from {file}"), &[("file", &shown)]);
+    app.ui.status_error = false;
+    app.ui.status = if unsupported > 0 {
+        let note = crate::i18n::trn(
+            crate::i18n::current(),
+            unsupported as u64,
+            "{n} step has no PhotoCraft equivalent yet",
+            "{n} steps have no PhotoCraft equivalent yet",
+        );
+        let template = "{message} ({note})";
+        crate::i18n::fmt(tl!(template), &[("message", &loaded), ("note", &note)])
+    } else {
+        loaded
+    };
+    // Show what arrived: select the first loaded action, expanded.
+    let list = &app.session.actions.list;
+    if let Some(first) = r["actions"][0].as_str()
+        && let Some(i) = list.iter().position(|a| a.name == first)
+    {
+        app.ui.actions.selected = Some(i);
+        app.ui.actions.selected_step = None;
+        app.ui.actions.expanded.resize(list.len(), false);
+        if let Some(e) = app.ui.actions.expanded.get_mut(i) {
+            *e = true;
+        }
+    }
+    app.ui.panels.history = true;
+    Ok(r)
+}
+
+fn load_dialog(app: &mut PhotocraftApp) -> Result<Value, String> {
+    app.pick_file_bytes_filtered(&["atn"], |app, name, bytes| load_bytes(app, &name, &bytes))
+}
+
+/// Save Actions…: the selected action's set (every action of it), or every action when none
+/// came from a set, as a `.atn` file Photoshop loads.
+fn save_dialog(app: &mut PhotocraftApp, set: Option<String>) -> Result<Value, String> {
+    let set = set.or_else(|| selected_action(app).and_then(|a| a.set.clone()));
+    let params = match &set {
+        Some(set) => json!({"set": set, "skipUnsupported": true}),
+        None => json!({"skipUnsupported": true}),
+    };
+    let r = app.run("actions.save", params)?;
+    let bytes = r["data"].as_str().and_then(photocraft_engine::paint::tile::b64_decode).ok_or("the export returned no data")?;
+    let n = r["actions"].as_array().map_or(0, Vec::len) as u64;
+    let skipped = r["skipped"].as_array().map_or(0, Vec::len);
+    let file = format!("{}.atn", r["set"].as_str().unwrap_or("Actions"));
+    app.pick_save(&file, move |app, path| {
+        let write = app.services.write.as_mut().ok_or("no writer configured")?;
+        write(&path, &bytes)?;
+        let shown = crate::file_open::display_name(&path);
+        let saved =
+            crate::i18n::fmt(&crate::i18n::trn(crate::i18n::current(), n, "Saved {n} action to {file}", "Saved {n} actions to {file}"), &[("file", &shown)]);
+        app.ui.status_error = false;
+        app.ui.status = if skipped > 0 {
+            let note = crate::i18n::trn(
+                crate::i18n::current(),
+                skipped as u64,
+                "{n} step with no Photoshop equivalent left out",
+                "{n} steps with no Photoshop equivalent left out",
+            );
+            let template = "{message} ({note})";
+            crate::i18n::fmt(tl!(template), &[("message", &saved), ("note", &note)])
+        } else {
+            saved
+        };
+        Ok(json!({"path": path, "actions": n, "skipped": skipped}))
+    })
+}
+
+const INSERT_STOP: &str = "__insertStop";
+
+pub fn owns_insert_stop(fields: &serde_json::Map<String, Value>) -> bool {
+    fields.contains_key(INSERT_STOP)
+}
+
+/// Insert Stop…: a message step after the selected step (or at the end of the selected action).
+fn insert_stop_dialog(app: &mut PhotocraftApp) -> Result<Value, String> {
+    let action = app.ui.actions.selected.filter(|i| *i < app.session.actions.list.len()).ok_or_else(|| tl!("Select an action first").to_string())?;
+    let len = app.session.actions.list[action].steps.len() + actions_cmds::pending_steps(&app.session, action).count();
+    let at = app.ui.actions.selected_step.map_or(len, |s| (s + 1).min(len));
+    let fields =
+        json!({INSERT_STOP: true, "__command": "actions.insert", "__label": "Insert Stop", "action": action, "at": at, "message": "", "allowContinue": false});
+    let id = app.ui.open_dialog(crate::state::DialogKind::Command, fields.as_object().cloned().unwrap_or_default());
+    Ok(json!({"dialog": id}))
+}
+
+pub fn insert_stop_body(ui: &mut egui::Ui, fields: &mut serde_json::Map<String, Value>) {
+    ui.label(tl!("Message:"));
+    let mut message = fields.get("message").and_then(Value::as_str).unwrap_or_default().to_string();
+    ui.add(egui::TextEdit::multiline(&mut message).desired_rows(4).desired_width(320.0));
+    fields.insert("message".into(), json!(message));
+    ui.add_space(6.0);
+    let mut allow = fields.get("allowContinue").and_then(Value::as_bool).unwrap_or(false);
+    ui.checkbox(&mut allow, tl!("Allow Continue"));
+    fields.insert("allowContinue".into(), json!(allow));
+}
+
+pub fn insert_stop_confirm(app: &mut PhotocraftApp, fields: &serde_json::Map<String, Value>) -> Result<Value, String> {
+    let action = fields.get("action").and_then(Value::as_u64).ok_or("the dialog names no action")?;
+    let params = json!({
+        "action": action,
+        "at": fields.get("at").cloned().unwrap_or(Value::Null),
+        "id": photocraft_engine::atn_cmds::STOP_MESSAGE,
+        "params": {"message": fields.get("message").cloned().unwrap_or(json!("")), "allowContinue": fields.get("allowContinue").cloned().unwrap_or(json!(false))},
+    });
+    let r = app.run("actions.insert", params)?;
+    if let (Some(a), Some(step)) = (usize::try_from(action).ok(), r["step"].as_u64().and_then(|s| usize::try_from(s).ok())) {
+        app.ui.actions.selected = Some(a);
+        app.ui.actions.selected_step = Some(step);
+        app.ui.actions.expanded.resize(app.session.actions.list.len(), false);
+        if let Some(e) = app.ui.actions.expanded.get_mut(a) {
+            *e = true;
+        }
+    }
+    Ok(r)
+}
+
+/// The key a paused playback leaves in its dialog's fields: `{action, from}`.
+pub const RESUME: &str = "__resumeAction";
+
+/// A step dialog confirmed: continue the action after it (`dialogs::confirm` calls this).
+pub fn resume(app: &mut PhotocraftApp, fields: &serde_json::Map<String, Value>) {
+    let Some(r) = fields.get(RESUME) else { return };
+    // The dialog's command may run as a background job; the next step needs its result.
+    if let Some(doc) = app.session.active().map(|d| d.doc.id)
+        && let Some(job) = app.session.job_on(doc)
+    {
+        let _ = app.session.wait_job(job.id);
+    }
+    let params = json!({"action": r.get("action").cloned().unwrap_or(Value::Null), "from": r.get("from").cloned().unwrap_or(Value::Null)});
+    match play(app, &params) {
+        Ok(v) => report_play(app, &v),
+        Err(e) => {
+            let template = "Action playback failed: {error}";
+            app.ui.status = crate::i18n::fmt(tl!(template), &[("error", &e)]);
+            app.ui.status_error = true;
+        }
+    }
+}
+
+/// A step dialog cancelled: the action stops there, as in Photoshop.
+pub fn stopped(app: &mut PhotocraftApp, fields: &serde_json::Map<String, Value>) {
+    if fields.contains_key(RESUME) {
+        app.ui.status = tl!("Action playback stopped").to_string();
+        app.ui.status_error = false;
+    }
+}
+
+/// The Actions entries of the panel group's menu ("…").
+pub fn panel_menu(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
+    let mut act: Option<&str> = None;
+    if ui.button(tl!("Load Actions…")).clicked() {
+        act = Some("load");
+    }
+    let any = !app.session.actions.list.is_empty();
+    if ui.add_enabled(any, egui::Button::new(tl!("Save Actions…"))).clicked() {
+        act = Some("save");
+    }
+    ui.separator();
+    let selected = app.ui.actions.selected.is_some_and(|i| i < app.session.actions.list.len());
+    if ui.add_enabled(selected, egui::Button::new(tl!("Insert Stop…"))).clicked() {
+        act = Some("stop");
+    }
+    let Some(a) = act else { return };
+    ui.close();
+    let r = match a {
+        "load" => load_dialog(app),
+        "stop" => insert_stop_dialog(app),
+        _ => save_dialog(app, None),
+    };
+    if let Err(e) = r
+        && e != "cancelled"
+    {
+        app.ui.status = e;
+        app.ui.status_error = true;
+    }
+}
+
 #[derive(Clone, Copy)]
 struct DragRow {
     action: usize,
@@ -265,6 +505,12 @@ fn move_row(app: &mut PhotocraftApp, source: DragRow, to: usize) {
         }
         app.ui.actions.selected = Some(to);
         app.ui.actions.selected_step = None;
+        // Dropped among another set's actions: the action joins that set (the row above wins).
+        let list = &app.session.actions.list;
+        let neighbour = to.checked_sub(1).and_then(|j| list.get(j)).or_else(|| list.get(to + 1)).and_then(|a| a.set.clone());
+        if list.get(to).is_some_and(|a| a.set != neighbour) {
+            let _ = app.run("actions.assignSet", json!({"action": to, "set": neighbour}));
+        }
     }
 }
 
@@ -324,15 +570,49 @@ fn rename_action(app: &mut PhotocraftApp, index: usize, name: String) {
     }
 }
 
+/// One action's row data for a frame.
+struct Row {
+    name: String,
+    steps: Vec<(String, Value)>,
+    disabled: std::collections::BTreeSet<usize>,
+    dialogs: std::collections::BTreeSet<usize>,
+    set: Option<String>,
+}
+
+/// The panel's order: actions outside any set first, then each set folder (in order of first
+/// appearance) with its actions. Indices are into the engine's flat list.
+fn display_order(rows: &[Row]) -> Vec<usize> {
+    let mut order: Vec<usize> = rows.iter().enumerate().filter(|(_, r)| r.set.is_none()).map(|(i, _)| i).collect();
+    let mut sets: Vec<&str> = Vec::new();
+    for r in rows {
+        if let Some(set) = r.set.as_deref()
+            && !sets.contains(&set)
+        {
+            sets.push(set);
+        }
+    }
+    for set in sets {
+        order.extend(rows.iter().enumerate().filter(|(_, r)| r.set.as_deref() == Some(set)).map(|(i, _)| i));
+    }
+    order
+}
+
 pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let t = Tokens::get(ui.ctx());
     let recording = app.session.actions.recording;
-    let rows: Vec<_> = app.session.actions.list.iter().enumerate().map(|(i, a)| (a.name.clone(), visible_steps(app, i), a.disabled.clone())).collect();
+    let rows: Vec<Row> = app
+        .session
+        .actions
+        .list
+        .iter()
+        .enumerate()
+        .map(|(i, a)| Row { name: a.name.clone(), steps: visible_steps(app, i), disabled: a.disabled.clone(), dialogs: a.dialogs.clone(), set: a.set.clone() })
+        .collect();
     if app
         .ui
         .actions
         .selected
-        .is_some_and(|i| i >= rows.len() || app.ui.actions.selected_step.is_some_and(|step| rows.get(i).is_none_or(|row| step >= row.1.len())))
+        .is_some_and(|i| i >= rows.len() || app.ui.actions.selected_step.is_some_and(|step| rows.get(i).is_none_or(|row| step >= row.steps.len())))
     {
         app.ui.actions.selected = None;
         app.ui.actions.selected_step = None;
@@ -345,10 +625,13 @@ pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     }
     let mut renamed = None;
     let mut toggled = None;
+    let mut dialog_toggled = None;
+    let mut set_toggled: Option<String> = None;
+    let mut save_set: Option<String> = None;
     let max_h = (ui.available_height() - 38.0).max(0.0);
     let mut play_idx = None;
     let mut moved = None;
-    let recording_row = recording.and_then(|(_, i)| rows.get(i).map(|(_, steps, _)| (i, steps.len())));
+    let recording_row = recording.and_then(|(_, i)| rows.get(i).map(|r| (i, r.steps.len())));
     let reveal = recording_row.filter(|row| app.ui.actions.reveal_recording != Some(*row));
     app.ui.actions.reveal_recording = recording_row;
     if let Some((i, _)) = reveal {
@@ -377,8 +660,54 @@ pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                 }
             }
         }
-        for (i, (name, steps, disabled)) in rows.iter().enumerate() {
+        let mut shown_set: Option<&str> = None;
+        for i in display_order(&rows) {
+            let Row { name, steps, disabled, dialogs, set } = &rows[i];
+            // A set folder row before the first of its actions; collapsed folders hide them.
+            if let Some(set) = set.as_deref()
+                && shown_set != Some(set)
+            {
+                shown_set = Some(set);
+                let collapsed = app.ui.actions.collapsed_sets.iter().any(|c| c == set);
+                let (hr, hresp) = ui.allocate_exact_size(vec2(ui.available_width(), 24.0), Sense::click());
+                hresp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::SelectableLabel, true, !collapsed, set));
+                if hresp.hovered() {
+                    ui.painter().rect_filled(hr, 0.0, t.hover.gamma_multiply(0.5));
+                }
+                let tri = Rect::from_center_size(pos2(hr.left() + 12.0, hr.center().y), vec2(8.0, 8.0));
+                let pts = if collapsed {
+                    vec![tri.left_top(), tri.right_center(), tri.left_bottom()]
+                } else {
+                    vec![tri.left_top(), tri.right_top(), tri.center_bottom()]
+                };
+                ui.painter().add(egui::Shape::convex_polygon(pts, t.text_dim, Stroke::NONE));
+                crate::icons::paint(
+                    ui,
+                    Rect::from_center_size(pos2(hr.left() + 30.0, hr.center().y), vec2(16.0, 16.0)),
+                    if collapsed { "folder" } else { "folder-open" },
+                    12.0,
+                    t.icon,
+                );
+                ui.painter().text(pos2(hr.left() + 44.0, hr.center().y), Align2::LEFT_CENTER, set, egui::FontId::proportional(12.0), t.text);
+                let count = rows.iter().filter(|r| r.set.as_deref() == Some(set)).count() as u64;
+                let summary = crate::i18n::trn(crate::i18n::current(), count, "{n} action", "{n} actions");
+                ui.painter().text(pos2(hr.right() - 8.0, hr.center().y), Align2::RIGHT_CENTER, summary, egui::FontId::proportional(11.0), t.text_faint);
+                if hresp.clicked() {
+                    set_toggled = Some(set.to_string());
+                }
+                hresp.context_menu(|ui| {
+                    if ui.button(tl!("Save Set…")).clicked() {
+                        save_set = Some(set.to_string());
+                        ui.close();
+                    }
+                });
+            }
+            if set.as_deref().is_some_and(|set| app.ui.actions.collapsed_sets.iter().any(|c| c == set)) {
+                continue;
+            }
+            let indent = if set.is_some() { 14.0 } else { 0.0 };
             let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 26.0), Sense::click_and_drag());
+            let x0 = rect.left() + indent;
             if reveal == Some((i, 0)) {
                 ui.scroll_to_rect(rect, Some(egui::Align::BOTTOM));
             }
@@ -393,22 +722,21 @@ pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                 moved = Some(change);
             }
             let expanded = app.ui.actions.expanded.get(i).copied().unwrap_or(false);
-            let tri = Rect::from_center_size(pos2(rect.left() + 12.0, rect.center().y), vec2(8.0, 8.0));
+            let tri = Rect::from_center_size(pos2(x0 + 12.0, rect.center().y), vec2(8.0, 8.0));
             let pts =
                 if expanded { vec![tri.left_top(), tri.right_top(), tri.center_bottom()] } else { vec![tri.left_top(), tri.right_center(), tri.left_bottom()] };
             ui.painter().add(egui::Shape::convex_polygon(pts, t.text_dim, Stroke::NONE));
-            crate::icons::paint(ui, Rect::from_center_size(pos2(rect.left() + 30.0, rect.center().y), vec2(16.0, 16.0)), "play", 11.0, t.icon);
+            crate::icons::paint(ui, Rect::from_center_size(pos2(x0 + 30.0, rect.center().y), vec2(16.0, 16.0)), "play", 11.0, t.icon);
             let recording_this = recording.is_some_and(|(_, r)| r == i);
             let nsteps = steps.len();
             let name_rect = if app.ui.actions.renaming.as_ref().is_some_and(|r| r.index == i) {
-                let field =
-                    Rect::from_min_max(pos2(rect.left() + 40.0, rect.top() + 3.0), pos2((rect.right() - 80.0).max(rect.left() + 120.0), rect.bottom() - 3.0));
+                let field = Rect::from_min_max(pos2(x0 + 40.0, rect.top() + 3.0), pos2((rect.right() - 80.0).max(x0 + 120.0), rect.bottom() - 3.0));
                 if let Some(text) = rename_field(app, ui, i, field) {
                     renamed = Some((i, text));
                 }
                 field
             } else {
-                ui.painter().text(pos2(rect.left() + 44.0, rect.center().y), Align2::LEFT_CENTER, name, egui::FontId::proportional(12.0), t.text)
+                ui.painter().text(pos2(x0 + 44.0, rect.center().y), Align2::LEFT_CENTER, name, egui::FontId::proportional(12.0), t.text)
             };
             ui.painter().text(
                 pos2(rect.right() - 8.0, rect.center().y),
@@ -428,7 +756,7 @@ pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             if resp.clicked() {
                 app.ui.actions.selected = Some(i);
                 app.ui.actions.selected_step = None;
-                if resp.interact_pointer_pos().is_some_and(|p| p.x < rect.left() + 20.0) {
+                if resp.interact_pointer_pos().is_some_and(|p| p.x < x0 + 20.0) {
                     if app.ui.actions.expanded.len() <= i {
                         app.ui.actions.expanded.resize(i + 1, false);
                     }
@@ -473,17 +801,33 @@ pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                     }
                     let on = !disabled.contains(&step);
                     let color = if on { t.text_dim } else { t.text_faint };
-                    ui.painter().text(pos2(r.left() + 44.0, r.center().y), Align2::LEFT_CENTER, &label, egui::FontId::proportional(11.5), color);
+                    ui.painter().text(pos2(x0 + 62.0, r.center().y), Align2::LEFT_CENTER, &label, egui::FontId::proportional(11.5), color);
                     // Photoshop's check column: unchecked steps are skipped by playback, Batch and droplets.
                     let check = ui.interact(
-                        Rect::from_center_size(pos2(r.left() + 30.0, r.center().y), vec2(16.0, 16.0)),
+                        Rect::from_center_size(pos2(x0 + 30.0, r.center().y), vec2(16.0, 16.0)),
                         ui.id().with(("action-step-check", i, step)),
                         Sense::click(),
                     );
                     check.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Checkbox, true, on, format!("{}: {label}", tl!("Include in playback"))));
                     paint_check(ui, check.rect, on, &t);
+                    // Photoshop's dialog column: playback shows the step's dialog, seeded with its
+                    // recorded values, and continues when it is confirmed.
+                    let with_dialog = dialogs.contains(&step);
+                    let dialog = ui.interact(
+                        Rect::from_center_size(pos2(x0 + 46.0, r.center().y), vec2(16.0, 16.0)),
+                        ui.id().with(("action-step-dialog", i, step)),
+                        Sense::click(),
+                    );
+                    // A toggle button, not a check box, so the check column stays the only CheckBox role.
+                    dialog.widget_info(|| {
+                        egui::WidgetInfo::selected(egui::WidgetType::Button, true, with_dialog, format!("{}: {label}", tl!("Show dialog during playback")))
+                    });
+                    crate::icons::paint(ui, dialog.rect, "message-square", 11.0, if with_dialog { t.icon } else { t.text_faint.gamma_multiply(0.45) });
+                    let dialog = dialog.on_hover_text(tl!("Show dialog during playback"));
                     if check.on_hover_text(tl!("Include in playback")).clicked() {
                         toggled = Some((i, step));
+                    } else if dialog.clicked() {
+                        dialog_toggled = Some((i, step));
                     } else if response.clicked() {
                         app.ui.actions.selected = Some(i);
                         app.ui.actions.selected_step = Some(step);
@@ -495,6 +839,24 @@ pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     if let Some((action, step)) = toggled {
         let _ = app.run("actions.toggle", json!({"action": action, "step": step}));
     }
+    if let Some((action, step)) = dialog_toggled {
+        let _ = app.run("actions.dialog", json!({"action": action, "step": step}));
+    }
+    if let Some(set) = set_toggled {
+        match app.ui.actions.collapsed_sets.iter().position(|c| *c == set) {
+            Some(i) => {
+                app.ui.actions.collapsed_sets.remove(i);
+            }
+            None => app.ui.actions.collapsed_sets.push(set),
+        }
+    }
+    if let Some(set) = save_set
+        && let Err(e) = save_dialog(app, Some(set))
+        && e != "cancelled"
+    {
+        app.ui.status = e;
+        app.ui.status_error = true;
+    }
     if let Some((index, name)) = renamed {
         rename_action(app, index, name);
     }
@@ -555,7 +917,7 @@ mod tests {
         let bottom = |height: f32| {
             let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
             for i in 0..50 {
-                app.session.actions.list.push(Action { name: format!("Action {i}"), steps: vec![], disabled: Default::default() });
+                app.session.actions.list.push(Action { name: format!("Action {i}"), steps: vec![], disabled: Default::default(), ..Default::default() });
             }
             let mut h = Harness::builder().with_size(vec2(320.0, height)).build_ui_state(|ui, app| panel(app, ui), app);
             h.run_steps(3);
@@ -572,7 +934,12 @@ mod tests {
         use egui_kittest::{Harness, kittest::Queryable};
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
         app.run("file.new", json!({"width": 32, "height": 32})).unwrap();
-        app.session.actions.list.push(Action { name: "Action 1".into(), steps: vec![("layer.new.layer".into(), json!({}))], disabled: Default::default() });
+        app.session.actions.list.push(Action {
+            name: "Action 1".into(),
+            steps: vec![("layer.new.layer".into(), json!({}))],
+            disabled: Default::default(),
+            ..Default::default()
+        });
         let layers = app.session.active().unwrap().doc.layers.len();
         // 60 fps steps, so two clicks a frame apart count as a double-click.
         let mut h = Harness::builder().with_size(vec2(320.0, 260.0)).with_step_dt(1.0 / 60.0).build_ui_state(|ui, app| panel(app, ui), app);
@@ -606,8 +973,18 @@ mod tests {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
         app.run("file.new", json!({"width": 32, "height": 32})).unwrap();
         assert_eq!(playback_selection(&app), None);
-        app.session.actions.list.push(Action { name: "Make Layer".into(), steps: vec![("layer.new.layer".into(), json!({}))], disabled: Default::default() });
-        app.session.actions.list.push(Action { name: "Fit".into(), steps: vec![("view.fitOnScreen".into(), json!({}))], disabled: Default::default() });
+        app.session.actions.list.push(Action {
+            name: "Make Layer".into(),
+            steps: vec![("layer.new.layer".into(), json!({}))],
+            disabled: Default::default(),
+            ..Default::default()
+        });
+        app.session.actions.list.push(Action {
+            name: "Fit".into(),
+            steps: vec![("view.fitOnScreen".into(), json!({}))],
+            disabled: Default::default(),
+            ..Default::default()
+        });
         assert_eq!(playback_selection(&app), Some(0));
         app.ui.actions.selected = Some(1);
         assert_eq!(playback_selection(&app), Some(1));
@@ -654,7 +1031,12 @@ mod tests {
         use egui_kittest::{Harness, kittest::Queryable};
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
         app.run("file.new", json!({"width": 32, "height": 32})).unwrap();
-        app.session.actions.list.push(Action { name: "Bad action".into(), steps: vec![("not.a.command".into(), json!({}))], disabled: Default::default() });
+        app.session.actions.list.push(Action {
+            name: "Bad action".into(),
+            steps: vec![("not.a.command".into(), json!({}))],
+            disabled: Default::default(),
+            ..Default::default()
+        });
         let mut h = Harness::builder().with_size(vec2(400.0, 320.0)).build_ui_state(|ui, app| panel(app, ui), app);
         h.run_steps(3);
         h.get_by_label("Play selection").click();
@@ -669,7 +1051,7 @@ mod tests {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
         app.run("file.new", json!({"width":4,"height":4})).unwrap();
         for i in 0..30 {
-            app.session.actions.list.push(Action { name: format!("Existing {i}"), steps: vec![], disabled: Default::default() });
+            app.session.actions.list.push(Action { name: format!("Existing {i}"), steps: vec![], disabled: Default::default(), ..Default::default() });
         }
         let mut h = Harness::builder().with_size(vec2(320.0, 260.0)).build_ui_state(|ui, app| panel(app, ui), app);
         h.run_steps(4);
@@ -694,8 +1076,9 @@ mod tests {
             name: "First".into(),
             steps: vec![("view.zoomOut".into(), json!({})), ("view.fitOnScreen".into(), json!({})), ("view.actualPixels".into(), json!({}))],
             disabled: Default::default(),
+            ..Default::default()
         });
-        app.session.actions.list.push(Action { name: "Second".into(), steps: vec![], disabled: Default::default() });
+        app.session.actions.list.push(Action { name: "Second".into(), steps: vec![], disabled: Default::default(), ..Default::default() });
         app.ui.actions.expanded = vec![true, false];
         let mut h = Harness::builder().with_size(vec2(320.0, 400.0)).build_ui_state(|ui, app| panel(app, ui), app);
         h.run_steps(4);
@@ -735,6 +1118,7 @@ mod tests {
             name: "Child".into(),
             steps: vec![("layer.new.layer".into(), json!({})), ("view.fitOnScreen".into(), json!({}))],
             disabled: Default::default(),
+            ..Default::default()
         });
         app.run("actions.record", json!({"name":"Parent"})).unwrap();
         app.run("actions.play", json!({"action":"Child"})).unwrap();
@@ -827,6 +1211,7 @@ mod tests {
             name: "Fit".into(),
             steps: vec![("view.fitOnScreen".into(), json!({})), ("view.actualPixels".into(), json!({}))],
             disabled: Default::default(),
+            ..Default::default()
         });
         let result = app.run("actions.play", json!({"action": "Fit"})).unwrap();
         assert_eq!(result["ran"], 0);
@@ -904,4 +1289,134 @@ mod tests {
         assert_eq!(*written.borrow(), ["out/result.psd", "out/result.psd"]);
         assert_eq!(app.session.active().unwrap().path.as_deref(), Some("out/result.psd"));
     }
+
+    #[test]
+    fn set_folders_group_actions_and_collapse() {
+        use egui_kittest::{Harness, kittest::Queryable};
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let mut sharpen = Action::new("Sharpen", vec![("filter.sharpen.sharpen".into(), json!({}))]);
+        sharpen.set = Some("Retouch".into());
+        let mut soften = Action::new("Soften", vec![("filter.blur.blur".into(), json!({}))]);
+        soften.set = Some("Retouch".into());
+        app.session.actions.list.push(Action::new("Loose", vec![]));
+        app.session.actions.list.push(sharpen);
+        app.session.actions.list.push(Action::new("Also loose", vec![]));
+        app.session.actions.list.push(soften);
+        let mut h = Harness::builder().with_size(vec2(360.0, 400.0)).build_ui_state(|ui, app| panel(app, ui), app);
+        h.run_steps(3);
+        // The folder row shows the set with its count; its actions sit under it, loose ones first.
+        let folder = h.get_by_label("Retouch").rect();
+        assert!(h.get_by_label("Loose").rect().top() < folder.top());
+        assert!(h.get_by_label("Also loose").rect().top() < folder.top());
+        assert!(h.get_by_label("Sharpen").rect().top() > folder.top());
+        assert!(h.get_by_label("Soften").rect().top() > h.get_by_label("Sharpen").rect().top());
+        assert_eq!(display_order(&[]), Vec::<usize>::new());
+        // Clicking the folder collapses it; its actions disappear and the state is remembered.
+        h.get_by_label("Retouch").click();
+        h.run_steps(3);
+        assert_eq!(h.state().ui.actions.collapsed_sets, ["Retouch"]);
+        assert!(h.query_by_label("Sharpen").is_none());
+        assert!(h.query_by_label("Loose").is_some());
+        h.get_by_label("Retouch").click();
+        h.run_steps(3);
+        assert!(h.state().ui.actions.collapsed_sets.is_empty());
+        assert!(h.query_by_label("Sharpen").is_some());
+    }
+
+    #[test]
+    fn moving_an_action_next_to_another_set_joins_it() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let mut a = Action::new("A", vec![]);
+        a.set = Some("One".into());
+        let mut b = Action::new("B", vec![]);
+        b.set = Some("Two".into());
+        app.session.actions.list.push(a);
+        app.session.actions.list.push(b);
+        app.session.actions.list.push(Action::new("C", vec![]));
+        // C dropped below B: it joins B's set, "Two".
+        move_row(&mut app, DragRow { action: 2, step: None }, 2);
+        assert_eq!(app.session.actions.list[2].set.as_deref(), Some("Two"));
+        // B dropped to the top, above A: the row below decides when there is none above.
+        move_row(&mut app, DragRow { action: 1, step: None }, 0);
+        assert_eq!((app.session.actions.list[0].name.as_str(), app.session.actions.list[0].set.as_deref()), ("B", Some("One")));
+        // C dropped between A (One) and nothing: the row above wins.
+        move_row(&mut app, DragRow { action: 2, step: None }, 2);
+        assert_eq!((app.session.actions.list[2].name.as_str(), app.session.actions.list[2].set.as_deref()), ("C", Some("One")));
+    }
+
+    #[test]
+    fn insert_stop_dialog_adds_a_stop_after_the_selected_step() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 8, "height": 8})).unwrap();
+        app.session.actions.list.push(Action::new("A", vec![("select.all".into(), json!({})), ("select.inverse".into(), json!({}))]));
+        assert!(insert_stop_dialog(&mut app).is_err(), "needs a selected action");
+        app.ui.actions.selected = Some(0);
+        app.ui.actions.selected_step = Some(0);
+        let id = insert_stop_dialog(&mut app).unwrap()["dialog"].as_u64().unwrap();
+        let d = app.ui.dialog_mut(id).unwrap();
+        assert!(owns_insert_stop(&d.fields));
+        assert_eq!(d.fields["at"], 1);
+        d.fields.insert("message".into(), json!("Check the mask"));
+        d.fields.insert("allowContinue".into(), json!(true));
+        crate::dialogs::confirm(&mut app, id).unwrap();
+        let steps = &app.session.actions.list[0].steps;
+        assert_eq!(steps[1], (photocraft_engine::atn_cmds::STOP_MESSAGE.to_string(), json!({"message": "Check the mask", "allowContinue": true})));
+        assert_eq!((app.ui.actions.selected, app.ui.actions.selected_step), (Some(0), Some(1)));
+        assert_eq!(step_label(&steps[1].0, &steps[1].1), "Stop: Check the mask");
+        // Without a selected step the stop goes last; the panel's menu wiring is exercised by name.
+        app.ui.actions.selected_step = None;
+        let id = insert_stop_dialog(&mut app).unwrap()["dialog"].as_u64().unwrap();
+        assert_eq!(app.ui.dialog_mut(id).unwrap().fields["at"], 3);
+        crate::dialogs::cancel(&mut app, id).unwrap();
+        assert_eq!(app.session.actions.list[0].steps.len(), 3);
+    }
+
+    #[test]
+    fn a_dialog_toggled_step_pauses_playback_and_resumes_on_ok() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 16, "height": 16})).unwrap();
+        let mut a = Action::new(
+            "Blur",
+            vec![("layer.new.layer".into(), json!({})), ("filter.blur.gaussianBlur".into(), json!({"radius": 3})), ("select.all".into(), json!({}))],
+        );
+        a.dialogs.insert(1);
+        app.session.actions.list.push(a);
+        let v = play(&mut app, &json!({"action": "Blur"})).unwrap();
+        assert_eq!(v["ran"], 1, "{v}");
+        assert_eq!(v["paused"]["step"], 1);
+        let id = v["paused"]["dialog"].as_u64().unwrap();
+        let d = app.ui.dialog_mut(id).unwrap();
+        assert_eq!(d.fields["radius"], 3, "the dialog opens on the recorded values");
+        assert_eq!(d.fields[RESUME], json!({"action": "Blur", "from": 2}));
+        assert!(app.session.active().unwrap().doc.selection.is_none(), "nothing after the dialog ran yet");
+        report_play(&mut app, &v);
+        assert!(app.ui.status.contains("dialog"), "{}", app.ui.status);
+        // OK runs the blur with the dialog's values and plays the rest.
+        app.ui.dialog_mut(id).unwrap().fields.insert("radius".into(), json!(5));
+        crate::dialogs::confirm(&mut app, id).unwrap();
+        assert!(app.ui.dialogs.is_empty());
+        assert!(app.session.active().unwrap().doc.selection.is_some(), "the step after the dialog ran");
+        assert!(app.ui.status.starts_with("Played"), "{}", app.ui.status);
+        // Cancel stops the action there.
+        app.run("select.deselect", json!({})).unwrap();
+        let v = play(&mut app, &json!({"action": "Blur"})).unwrap();
+        let id = v["paused"]["dialog"].as_u64().unwrap();
+        crate::dialogs::cancel(&mut app, id).unwrap();
+        assert!(app.session.active().unwrap().doc.selection.is_none());
+        assert!(app.ui.status.contains("stopped"), "{}", app.ui.status);
+        // With background jobs (the desktop default) the resumed steps wait for the dialog's
+        // filter to land instead of meeting a locked document.
+        app.background_jobs = true;
+        let v = play(&mut app, &json!({"action": "Blur"})).unwrap();
+        let id = v["paused"]["dialog"].as_u64().unwrap();
+        crate::dialogs::confirm(&mut app, id).unwrap();
+        assert!(app.session.active().unwrap().doc.selection.is_some(), "the step after the background blur ran");
+        assert!(app.ui.status.starts_with("Played"), "{}", app.ui.status);
+        app.background_jobs = false;
+        // Agents play headlessly: no pause, the recorded values run.
+        app.automation_input = true;
+        let v = play(&mut app, &json!({"action": "Blur"})).unwrap();
+        assert_eq!(v["ran"], 3, "{v}");
+        assert!(v.get("paused").is_none());
+    }
 }
diff --git a/crates/ui-egui/src/adjust_dialog.rs b/crates/ui-egui/src/adjust_dialog.rs
index 71392662e9..5f43348507 100644
--- a/crates/ui-egui/src/adjust_dialog.rs
+++ b/crates/ui-egui/src/adjust_dialog.rs
@@ -134,19 +134,33 @@ fn dialog_mem(kind: &str) -> egui::Id {
     egui::Id::new(("adjust-dialog", kind))
 }
 
-/// Whether holding Alt turns the dialog's Cancel into Reset. Measured in Photoshop 25.4 for Color
-/// Balance; other kinds keep Cancel until checked against Photoshop.
+/// Whether holding Alt turns Cancel into Reset for this adjustment dialog (every kind).
 pub fn resets(fields: &Map<String, Value>) -> bool {
-    fields.get("__adjust").and_then(Value::as_str) == Some("colorBalance")
+    owns(fields)
 }
 
-/// Alt+Cancel (Reset): back to the defaults Photoshop's Reset restores, dialog stays open.
-pub fn reset(ctx: &egui::Context, fields: &mut Map<String, Value>) {
-    if !resets(fields) {
+/// Alt+Cancel (Reset): engine defaults for the kind; Color Balance keeps Preserve Luminosity and
+/// shows Midtones (Photoshop 25.4). Dialog stays open.
+pub fn reset(app: &PhotocraftApp, ctx: &egui::Context, fields: &mut Map<String, Value>) {
+    if !owns(fields) {
         return;
     }
+    let kind = fields.get("__adjust").and_then(Value::as_str).unwrap_or_default().to_string();
+    let mode = app.session.active().map_or(photocraft_doc::ColorMode::Rgb, |s| s.doc.mode);
+    // Color Balance: Photoshop keeps the user's Preserve Luminosity across Reset.
+    let preserve = if kind == "colorBalance" { fields.get("preserveLuminosity").cloned() } else { None };
+    let Ok(defaults) = photocraft_engine::adjust_params::default_for(&kind, mode) else { return };
+    let values = photocraft_engine::adjust_params::to_params(&defaults);
+    // Replace parameter keys; keep private `__` chrome (preview, command, …).
+    fields.retain(|k, _| k.starts_with("__"));
+    if let Value::Object(v) = values {
+        fields.extend(v);
+    }
+    if let Some(p) = preserve {
+        fields.insert("preserveLuminosity".into(), p);
+    }
     let mut values = crate::filter_dialog::params_of(fields);
-    adjust_editors::reset_color_balance(ctx, dialog_mem("colorBalance"), &mut values);
+    adjust_editors::reset_adjustment_editor(ctx, &kind, dialog_mem(&kind), &mut values);
     if let Value::Object(v) = values {
         fields.extend(v);
     }
@@ -195,6 +209,9 @@ pub fn body(app: &mut PhotocraftApp, ui: &mut egui::Ui, fields: &mut Map<String,
         dynamic_color_sliders: app.session.prefs().interface.dynamic_color_sliders,
     };
     let e = adjust_editors::editor(ui, &kind, &mut values, &cx);
+    if e.import_gradients {
+        crate::preset_files_ui::import_gradients_dialog(app);
+    }
     if e.changed
         && let Value::Object(v) = values
     {
@@ -390,16 +407,29 @@ mod tests {
         assert!(h.state().ui.dialogs.is_empty(), "Cancel closes");
     }
 
-    /// Alt+Cancel is Reset only where it was checked against Photoshop.
+    /// Every adjustment kind opts into Alt+Reset; Levels restores engine defaults and stays open.
     #[test]
-    fn other_adjustment_dialogs_keep_cancel_under_alt() {
+    fn levels_alt_reset_restores_defaults() {
         use egui_kittest::kittest::Queryable;
         let mut h = Harness::builder().with_size(egui::vec2(1200.0, 900.0)).build_ui_state(|ui, app| crate::dialogs::show(app, ui.ctx()), app_with_image());
         PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
-        open(h.state_mut(), "image.adjustments.levels").unwrap();
-        h.event(egui::Event::ModifiersChanged(egui::Modifiers::ALT));
-        h.run_steps(3);
+        let id = open(h.state_mut(), "image.adjustments.levels").unwrap();
+        h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("inBlack".into(), json!(30));
+        h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("gamma".into(), json!(1.3));
+        h.run_steps(2);
         assert!(h.query_by_label("Cancel").is_some() && h.query_by_label("Reset").is_none());
+        h.event(egui::Event::ModifiersChanged(egui::Modifiers::ALT));
+        h.run_steps(2);
+        let reset = h.get_by_label("Reset").rect();
+        assert!(h.query_by_label("Cancel").is_none());
+        let click =
+            |pressed| egui::Event::PointerButton { pos: reset.center(), button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::ALT };
+        input(&mut h, egui::Modifiers::ALT, &[egui::Event::PointerMoved(reset.center()), click(true), click(false)]);
+        assert!(h.state().ui.dialogs.iter().any(|d| d.id == id), "Reset keeps the dialog open");
+        let defaults =
+            photocraft_engine::adjust_params::to_params(&photocraft_engine::adjust_params::default_for("levels", photocraft_doc::ColorMode::Rgb).unwrap());
+        assert_eq!(field(&h, id, "inBlack"), defaults["inBlack"]);
+        assert_eq!(field(&h, id, "gamma"), defaults["gamma"]);
     }
 
     fn sample_params(kind: &str) -> Value {
@@ -437,6 +467,37 @@ mod tests {
         assert!(std::sync::Arc::ptr_eq(&before, &after));
         assert!(harness.state().ui.dialogs.is_empty());
     }
+
+    #[test]
+    fn gradient_map_dialog_handles_preview_without_committing_until_ok() {
+        use egui_kittest::kittest::Queryable;
+        let mut h = Harness::builder().with_size(egui::vec2(1200.0, 900.0)).build_ui_state(|ui, app| crate::dialogs::show(app, ui.ctx()), app_with_image());
+        PhotocraftApp::setup_context(&h.ctx, Default::default());
+        let id = open(h.state_mut(), "image.adjustments.gradientMap").unwrap();
+        h.run_steps(4);
+        let doc = h.state().session.active().unwrap().doc.clone();
+        let steps = h.state().session.active().unwrap().history.past_len();
+        let strip = h.get_by_label("Gradient stops").rect();
+        let start = egui::pos2(strip.left() + 8.0, strip.top() + 36.0);
+        let to = start + egui::vec2((strip.width() - 16.0) * 0.3, 0.0);
+        h.hover_at(start);
+        h.run_steps(1);
+        h.drag_at(start);
+        h.run_steps(1);
+        h.hover_at(to);
+        h.run_steps(1);
+        h.drop_at(to);
+        h.run_steps(3);
+        let stops = h.state().ui.dialogs[0].fields["stops"].as_array().unwrap();
+        assert!((stops[0][0].as_f64().unwrap() - 0.3).abs() < 0.001);
+        assert!(std::sync::Arc::ptr_eq(&doc, &h.state().session.active().unwrap().doc), "dialog edits are previews");
+        assert_eq!(h.state().session.active().unwrap().history.past_len(), steps);
+        crate::dialogs::confirm(h.state_mut(), id).unwrap();
+        h.run_steps(2);
+        assert_eq!(h.state().session.active().unwrap().history.past_len(), steps + 1);
+        h.state_mut().run("edit.undo", json!({})).unwrap();
+        assert_eq!(*h.state().session.active().unwrap().doc, *doc);
+    }
     #[test]
     fn curves_pencil_drag_draws_the_map_and_confirm_applies_it() {
         let mut h = Harness::builder().with_size(egui::vec2(1200.0, 900.0)).build_ui_state(|ui, app| crate::dialogs::show(app, ui.ctx()), app_with_image());
diff --git a/crates/ui-egui/src/adjust_editors.rs b/crates/ui-egui/src/adjust_editors.rs
index a939d20eca..2678cc65f2 100644
--- a/crates/ui-egui/src/adjust_editors.rs
+++ b/crates/ui-egui/src/adjust_editors.rs
@@ -56,18 +56,21 @@ pub struct Edit {
     pub changed: bool,
     /// A gesture ended or a discrete control changed (commit them).
     pub commit: bool,
+    /// Open the host's gradient-file dialog without changing adjustment parameters.
+    pub import_gradients: bool,
 }
 
 impl Edit {
     fn add(&mut self, o: Edit) {
         self.changed |= o.changed;
         self.commit |= o.commit;
+        self.import_gradients |= o.import_gradients;
     }
     fn discrete(changed: bool) -> Self {
-        Edit { changed, commit: changed }
+        Edit { changed, commit: changed, ..Default::default() }
     }
     fn of(r: &egui::Response) -> Self {
-        Edit { changed: r.changed(), commit: r.drag_stopped() || (r.changed() && !r.dragged()) }
+        Edit { changed: r.changed(), commit: r.drag_stopped() || (r.changed() && !r.dragged()), ..Default::default() }
     }
 }
 
@@ -115,18 +118,18 @@ pub fn editor(ui: &mut egui::Ui, kind: &str, v: &mut Value, cx: &EditorCx) -> Ed
             ui,
             v,
             &[
-                ("exposure", tl!("Exposure"), -20.0, 20.0, 0.0, ""),
-                ("offset", tl!("Offset"), -0.5, 0.5, 0.0, ""),
-                ("gamma", tl!("Gamma Correction"), 0.01, 9.99, 1.0, ""),
+                ("exposure", tl!("Exposure"), -20.0, 20.0, 0.0, "", Some(2)),
+                ("offset", tl!("Offset"), -0.5, 0.5, 0.0, "", Some(4)),
+                ("gamma", tl!("Gamma Correction"), 0.01, 9.99, 1.0, "", None),
             ],
         ),
-        "vibrance" => sliders(ui, v, &[("vibrance", "Vibrance", -100.0, 100.0, 0.0, "%"), ("saturation", "Saturation", -100.0, 100.0, 0.0, "%")]),
+        "vibrance" => sliders(ui, v, &[("vibrance", "Vibrance", -100.0, 100.0, 0.0, "%", None), ("saturation", "Saturation", -100.0, 100.0, 0.0, "%", None)]),
         "hueSaturation" => hue_saturation(ui, v, cx),
         "colorBalance" => color_balance(ui, v, cx),
         "blackWhite" => black_white(ui, v, cx),
         "photoFilter" => photo_filter(ui, v, cx),
         "channelMixer" => channel_mixer(ui, v, cx),
-        "posterize" => sliders(ui, v, &[("levels", "Levels", 2.0, 255.0, 4.0, "")]),
+        "posterize" => sliders(ui, v, &[("levels", "Levels", 2.0, 255.0, 4.0, "", None)]),
         "threshold" => threshold(ui, v, cx),
         "gradientMap" => gradient_map(ui, v, cx),
         _ => Edit::default(),
@@ -190,15 +193,31 @@ fn label(ui: &mut egui::Ui, text: &str) {
 }
 
 /// Labelled slider rows over top-level keys: (key, label, min, max, default, unit).
-fn sliders(ui: &mut egui::Ui, v: &mut Value, rows: &[(&str, &str, f32, f32, f32, &str)]) -> Edit {
+/// A row of [`sliders`]: params key, label, range, default, unit, and its decimal places (None:
+/// two for a range of 10 or less, else whole numbers).
+type SliderRow<'a> = (&'a str, &'a str, f32, f32, f32, &'a str, Option<u32>);
+
+/// The value a [`sliders`] row stores for `x`: rounded to `decimals` places, or by its range.
+pub(crate) fn row_value(x: f32, min: f32, max: f32, decimals: Option<u32>) -> f32 {
+    match decimals {
+        Some(d) => {
+            let scale = 10f32.powi(d.min(6) as i32);
+            (x * scale).round() / scale
+        }
+        None if max - min <= 10.0 => round(x, 0.01),
+        None => x.round(),
+    }
+}
+
+fn sliders(ui: &mut egui::Ui, v: &mut Value, rows: &[SliderRow]) -> Edit {
     let mut e = Edit::default();
-    for &(key, text, min, max, default, unit) in rows {
+    for &(key, text, min, max, default, unit, decimals) in rows {
         let mut x = num(v, key, default).clamp(min, max);
         // A double-click on the slider puts it back to its default (Photoshop).
         let gestures = widgets::RowGestures { reset: Some(default), wheel_step: None };
-        let r = widgets::slider_row_with(ui, text, &mut x, min..=max, unit, None, gestures);
+        let r = widgets::slider_row_prec(ui, text, &mut x, min..=max, unit, None, gestures, decimals);
         if r.changed() {
-            v[key] = json!(if max - min <= 10.0 { round(x, 0.01) } else { x.round() });
+            v[key] = json!(row_value(x, min, max, decimals));
         }
         e.add(Edit::of(&r));
     }
@@ -222,7 +241,7 @@ fn track_stops<'a>(cx: &EditorCx, stops: &'a [Color32]) -> Option<&'a [Color32]>
 fn brightness_contrast(ui: &mut egui::Ui, v: &mut Value) -> Edit {
     let legacy = flag(v, "legacy", false);
     let lo = if legacy { -100.0 } else { -50.0 };
-    let mut e = sliders(ui, v, &[("brightness", tl!("Brightness"), -150.0, 150.0, 0.0, ""), ("contrast", tl!("Contrast"), lo, 100.0, 0.0, "")]);
+    let mut e = sliders(ui, v, &[("brightness", tl!("Brightness"), -150.0, 150.0, 0.0, "", None), ("contrast", tl!("Contrast"), lo, 100.0, 0.0, "", None)]);
     let mut l = legacy;
     if widgets::checkbox(ui, &mut l, tl!("Use Legacy")).changed() {
         v["legacy"] = json!(l);
@@ -798,7 +817,7 @@ fn threshold(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
     p.line_segment([pos2(x, hr.top()), pos2(x, hr.bottom())], Stroke::new(1.0, t.accent));
     p.rect_stroke(hr, 0.0, Stroke::new(1.0, t.field_border), StrokeKind::Inside);
     ui.add_space(4.0);
-    sliders(ui, v, &[("level", tl!("Threshold Level"), 1.0, 255.0, 128.0, "")])
+    sliders(ui, v, &[("level", tl!("Threshold Level"), 1.0, 255.0, 128.0, "", None)])
 }
 
 // ---------------------------------------------------------------------------------------------
@@ -912,7 +931,11 @@ fn hue_saturation(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
             o["hue"] = json!(h.round());
         }
         sub.add(Edit::of(&r));
-        sub.add(sliders(ui, &mut o, &[("saturation", tl!("Saturation"), -100.0, 100.0, 0.0, "%"), ("lightness", tl!("Lightness"), -100.0, 100.0, 0.0, "%")]));
+        sub.add(sliders(
+            ui,
+            &mut o,
+            &[("saturation", tl!("Saturation"), -100.0, 100.0, 0.0, "%", None), ("lightness", tl!("Lightness"), -100.0, 100.0, 0.0, "%", None)],
+        ));
         if sub.changed {
             v[key] = o;
         }
@@ -1019,6 +1042,14 @@ pub fn reset_color_balance(ctx: &egui::Context, mem: egui::Id, v: &mut Value) {
     ctx.data_mut(|d| d.insert_temp(color_balance_tone_id(mem), 1usize));
 }
 
+/// Kind-specific editor memory after Alt+Reset (or Properties Reset to defaults). Color Balance
+/// shows Midtones; other kinds have no dialog-local temp to clear yet.
+pub fn reset_adjustment_editor(ctx: &egui::Context, kind: &str, mem: egui::Id, v: &mut Value) {
+    if kind == "colorBalance" {
+        reset_color_balance(ctx, mem, v);
+    }
+}
+
 fn color_balance(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
     let tone_id = color_balance_tone_id(cx.mem);
     let mut tone_ix: usize = ui.data(|d| d.get_temp(tone_id)).unwrap_or(1);
@@ -1135,7 +1166,7 @@ fn photo_filter(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
         e.add(r);
     });
     ui.data_mut(|d| d.insert_temp(mode_id, use_color));
-    e.add(sliders(ui, v, &[("density", tl!("Density"), 0.0, 100.0, 25.0, "%")]));
+    e.add(sliders(ui, v, &[("density", tl!("Density"), 0.0, 100.0, 25.0, "%", None)]));
     let mut pl = flag(v, "preserveLuminosity", true);
     if widgets::checkbox(ui, &mut pl, tl!("Preserve Luminosity")).changed() {
         v["preserveLuminosity"] = json!(pl);
@@ -1244,10 +1275,108 @@ fn sample_stops(s: &[Stop], t: f32) -> [f32; 3] {
     sorted.last().map_or([t; 3], |l| l.1)
 }
 
+#[derive(Clone, Copy)]
+struct MapStopDrag {
+    index: usize,
+    offset: f32,
+    changed: bool,
+}
+
+/// Keep selection on the same stop when it crosses another stop (including coincident stops).
+fn move_map_stop(stops: &mut [Stop], index: usize, location: f32) -> Option<usize> {
+    let stop = stops.get_mut(index)?;
+    stop.0 = round(location.clamp(0.0, 1.0), 0.001);
+    let location = stop.0;
+    let rank = stops.iter().enumerate().filter(|(i, s)| *i != index && (s.0 < location || (s.0 == location && *i < index))).count();
+    stops.sort_by(|a, b| a.0.total_cmp(&b.0));
+    Some(rank)
+}
+
+fn gradient_map_strip(ui: &mut egui::Ui, stops: &mut Vec<Stop>, cx: &EditorCx, selected: &mut usize) -> Edit {
+    let t = Tokens::get(ui.ctx());
+    let key = cx.mem.with("gm-stop-drag");
+    let mut edit = Edit::default();
+    let w = ui.available_width().min(300.0);
+    let (outer, resp) = ui.allocate_exact_size(vec2(w, 44.0), Sense::click_and_drag());
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), tl!("Gradient stops")));
+    let bar = Rect::from_min_max(outer.min + vec2(8.0, 2.0), pos2(outer.right() - 8.0, outer.top() + 26.0));
+    let x_of = |loc: f32| bar.left() + loc * bar.width();
+    let loc_of = |x: f32| ((x - bar.left()) / bar.width().max(1.0)).clamp(0.0, 1.0);
+    let hit =
+        |pos: Pos2, stops: &[Stop]| stops.iter().enumerate().rev().find(|(_, s)| pos.y >= bar.bottom() && (x_of(s.0) - pos.x).abs() <= 6.0).map(|(i, _)| i);
+    if resp.drag_started()
+        && let Some(pos) = ui.input(|i| i.pointer.press_origin())
+        && let Some(index) = hit(pos, stops)
+    {
+        *selected = index;
+        let offset = stops.get(index).map_or(0.0, |s| pos.x - x_of(s.0));
+        ui.data_mut(|d| d.insert_temp(key, MapStopDrag { index, offset, changed: false }));
+    }
+    if let Some(mut drag) = ui.data(|d| d.get_temp::<MapStopDrag>(key)) {
+        if (resp.dragged() || resp.drag_stopped())
+            && let Some(pos) = resp.interact_pointer_pos()
+        {
+            let location = round(loc_of(pos.x - drag.offset), 0.001);
+            let changed = stops.get(drag.index).is_some_and(|s| s.0 != location);
+            if let Some(index) = move_map_stop(stops, drag.index, location) {
+                drag.index = index;
+                drag.changed |= changed;
+                *selected = index;
+                edit.changed |= changed;
+            }
+        }
+        if resp.drag_stopped() {
+            edit.commit = drag.changed;
+            ui.data_mut(|d| d.remove::<MapStopDrag>(key));
+        } else if ui.input(|i| i.pointer.primary_down()) {
+            ui.data_mut(|d| d.insert_temp(key, drag));
+        } else {
+            ui.data_mut(|d| d.remove::<MapStopDrag>(key));
+        }
+    }
+    if resp.clicked()
+        && let Some(pos) = resp.interact_pointer_pos()
+    {
+        resp.request_focus();
+        if let Some(index) = hit(pos, stops) {
+            *selected = index;
+        } else if stops.len() < 64 {
+            let at = round(loc_of(pos.x), 0.001);
+            let color = sample_stops(stops, at);
+            stops.push((at, color));
+            let index = stops.len() - 1;
+            *selected = move_map_stop(stops, index, at).unwrap_or(0);
+            edit.add(Edit::discrete(true));
+        }
+    }
+    if resp.hovered() && ui.input(|i| i.pointer.hover_pos()).is_some_and(|pos| hit(pos, stops).is_some()) || resp.dragged() {
+        ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
+    }
+    // Markers address un-reversed locations, as in the Gradient Tool; Reverse changes the image.
+    let cols: Vec<Color32> = (0..=48).map(|i| color32(sample_stops(stops, i as f32 / 48.0))).collect();
+    spectrum_bar(ui.painter(), bar, &cols);
+    ui.painter().rect_stroke(bar, 0.0, Stroke::new(1.0, t.field_border), StrokeKind::Outside);
+    for (i, (at, color)) in stops.iter().enumerate() {
+        let x = x_of(*at);
+        let border = if i == *selected { t.accent } else { t.text_dim };
+        let body = Rect::from_center_size(pos2(x, bar.bottom() + 10.0), vec2(10.0, 10.0));
+        ui.painter().add(egui::Shape::convex_polygon(
+            vec![pos2(x, bar.bottom() + 1.0), pos2(x + 5.0, body.top()), pos2(x - 5.0, body.top())],
+            border,
+            Stroke::NONE,
+        ));
+        ui.painter().rect_filled(body, 1.0, color32(*color));
+        ui.painter().rect_stroke(body, 1.0, Stroke::new(1.0, border), StrokeKind::Outside);
+    }
+    edit
+}
+
 fn gradient_map(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
     let t = Tokens::get(ui.ctx());
     let mut e = Edit::default();
     let mut stops = read_stops(v);
+    let selection = cx.mem.with("gm-stop-selection");
+    let mut selected = ui.data(|d| d.get_temp::<usize>(selection)).unwrap_or(0).min(stops.len().saturating_sub(1));
     // Photoshop's gradient picker: the same library as the Gradient tool and Gradients panel
     // (built-in groups and the user's own), Foreground/Background resolved to the current colours.
     let [fg, bg] = cx.swatches.map(|c| [c[0], c[1], c[2], 1.0]);
@@ -1257,11 +1386,19 @@ fn gradient_map(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
         let (press, close) = crate::press_menu::PressCombo::before(ui, cx.mem.with("gm-preset"));
         let combo = egui::ComboBox::from_id_salt(cx.mem.with("gm-preset"))
             .selected_text(tl!("Custom"))
-            .width(190.0)
+            .width(ui.available_width().min(190.0))
             .height(420.0)
             .icon(widgets::chevron_icon)
             .close_behavior(close)
             .show_ui(ui, |ui| {
+                let gear = crate::icons::button(ui, "settings", 24.0, false, tl!("Gradient Preset Options"));
+                egui::containers::menu::SubMenu::new().show(ui, &gear, |ui| {
+                    if ui.button(tl!("Import .GRD")).clicked() {
+                        e.import_gradients = true;
+                        ui.close();
+                    }
+                });
+                ui.separator();
                 for g in &cx.gradients {
                     ui.label(RichText::new(&g.name).color(t.text_faint));
                     for p in &g.items {
@@ -1282,47 +1419,46 @@ fn gradient_map(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
         press.after(&combo.response);
         if let Some(p) = picked {
             stops = p;
+            selected = 0;
+            ui.data_mut(|d| d.remove::<MapStopDrag>(cx.mem.with("gm-stop-drag")));
             write_stops(v, &stops);
             e.add(Edit::discrete(true));
         }
     });
-    // The gradient.
-    let w = ui.available_width().min(300.0);
-    let (r, _) = ui.allocate_exact_size(vec2(w, 22.0), Sense::hover());
-    let reverse = flag(v, "reverse", false);
-    let cols: Vec<Color32> = (0..=48)
-        .map(|i| {
-            let x = i as f32 / 48.0;
-            color32(sample_stops(&stops, if reverse { 1.0 - x } else { x }))
-        })
-        .collect();
-    spectrum_bar(ui.painter(), r, &cols);
-    ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.field_border), StrokeKind::Outside);
-    ui.add_space(4.0);
-    // Stops: colour, location, remove.
-    let mut remove = None;
-    let mut changed = false;
-    for (i, s) in stops.iter_mut().enumerate() {
+    let strip = gradient_map_strip(ui, &mut stops, cx, &mut selected);
+    let mut changed = strip.changed;
+    e.add(strip);
+    // The selected stop's colour and location, like the Gradient Tool's compact stop editor.
+    let mut location = None;
+    let mut remove = false;
+    let can_remove = stops.len() > 2;
+    if let Some(s) = stops.get_mut(selected) {
         ui.horizontal(|ui| {
+            label(ui, tl!("Color:"));
             let r = color_button(ui, &mut s.1);
             changed |= r.changed;
             e.add(r);
+            ui.add_enabled_ui(can_remove, |ui| {
+                remove = crate::icons::button(ui, "x", 20.0, false, tl!("Remove stop")).clicked();
+            });
+        });
+        ui.horizontal(|ui| {
+            label(ui, tl!("Location:"));
             let mut loc = s.0 * 100.0;
             let rl = widgets::value_field(ui, &mut loc, 0.0..=100.0, "%", 70.0);
             if rl.changed() {
-                s.0 = (loc / 100.0).clamp(0.0, 1.0);
+                location = Some(loc / 100.0);
                 changed = true;
             }
             e.add(Edit::of(&rl));
-            if crate::icons::button(ui, "x", 20.0, false, tl!("Remove stop")).clicked() {
-                remove = Some(i);
-            }
         });
     }
-    if let Some(i) = remove
-        && stops.len() > 2
-    {
-        stops.remove(i);
+    if let Some(loc) = location {
+        selected = move_map_stop(&mut stops, selected, loc).unwrap_or(0);
+    }
+    if remove && can_remove {
+        stops.remove(selected);
+        selected = selected.min(stops.len() - 1);
         changed = true;
         e.add(Edit::discrete(true));
     }
@@ -1332,6 +1468,8 @@ fn gradient_map(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
         sorted.sort_by(|a, b| a.0.total_cmp(&b.0));
         let at = sorted.windows(2).max_by(|a, b| (a[1].0 - a[0].0).total_cmp(&(b[1].0 - b[0].0))).map_or(0.5, |w| (w[0].0 + w[1].0) / 2.0);
         stops.push((at, sample_stops(&stops, at)));
+        let index = stops.len() - 1;
+        selected = move_map_stop(&mut stops, index, at).unwrap_or(0);
         changed = true;
         e.add(Edit::discrete(true));
     }
@@ -1339,6 +1477,7 @@ fn gradient_map(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
         write_stops(v, &stops);
         e.changed = true;
     }
+    ui.data_mut(|d| d.insert_temp(selection, selected));
     ui.horizontal(|ui| {
         for (key, text) in [("reverse", tl!("Reverse")), ("dither", tl!("Dither"))] {
             let mut b = flag(v, key, false);
@@ -1489,6 +1628,9 @@ pub fn layer_editor(app: &mut PhotocraftApp, ui: &mut egui::Ui, id: LayerId, adj
         crate::layer_picker::controls(app, ui, id);
     }
     let e = editor(ui, kind, &mut values, &cx);
+    if e.import_gradients {
+        crate::preset_files_ui::import_gradients_dialog(app);
+    }
     if e.changed {
         app.live_adjust = Some((id, values.clone()));
     }
diff --git a/crates/ui-egui/src/adjust_editors_tests.rs b/crates/ui-egui/src/adjust_editors_tests.rs
index 3a591c4333..9c39088bef 100644
--- a/crates/ui-egui/src/adjust_editors_tests.rs
+++ b/crates/ui-egui/src/adjust_editors_tests.rs
@@ -449,6 +449,140 @@ fn map_stops(a: &Adjustment) -> Vec<(f32, [u8; 3])> {
     }
 }
 
+fn map_handle(h: &Harness<'_, PhotocraftApp>, at: f32) -> Pos2 {
+    let strip = h.get_by_label("Gradient stops").rect();
+    Pos2::new(strip.left() + 8.0 + at * (strip.width() - 16.0), strip.top() + 36.0)
+}
+
+#[test]
+fn gradient_map_handle_drag_previews_and_commits_once_after_crossing_stops() {
+    for depth in [8, 16, 32] {
+        let mut h = app_harness("gradientMap", "rgb", depth);
+        let (id, _) = layer(&h);
+        h.state_mut()
+            .run(
+                "layer.setAdjustment",
+                json!({
+                    "layer": id.0, "stops": [[0, "#000000"], [0.25, "#ff0000"], [0.5, "#00ff00"], [1, "#ffffff"]]
+                }),
+            )
+            .unwrap();
+        h.run_steps(3);
+        let before = layer(&h).1;
+        let steps = h.state().session.active().unwrap().history.past_len();
+        let start = map_handle(&h, 0.25);
+        h.hover_at(start);
+        h.run_steps(1);
+        h.drag_at(start);
+        h.run_steps(1);
+        for location in [0.4, 0.5, 0.6, 0.75] {
+            let to = map_handle(&h, location);
+            h.hover_at(to);
+            h.run_steps(1);
+            assert!(h.state().live_adjust.is_some(), "{depth}: live preview");
+            assert_eq!(h.state().session.active().unwrap().history.past_len(), steps, "{depth}: dragging records no history");
+        }
+        let end = map_handle(&h, 0.8);
+        h.drop_at(end);
+        h.run_steps(3);
+        assert_eq!(map_stops(&layer(&h).1), vec![(0.0, [0, 0, 0]), (0.5, [0, 255, 0]), (0.8, [255, 0, 0]), (1.0, [255, 255, 255])]);
+        assert_eq!(h.ctx.data(|d| d.get_temp::<usize>(crate::adjust_editors::layer_mem(id).with("gm-stop-selection"))), Some(2));
+        assert!(h.state().live_adjust.is_none());
+        assert_eq!(h.state().session.active().unwrap().history.past_len(), steps + 1);
+        let after = layer(&h).1;
+        h.state_mut().run("edit.undo", json!({})).unwrap();
+        h.run_steps(3);
+        assert_eq!(layer(&h).1, before);
+        h.state_mut().run("edit.redo", json!({})).unwrap();
+        h.run_steps(3);
+        assert_eq!(layer(&h).1, after);
+    }
+}
+
+#[test]
+fn gradient_map_strip_adds_selects_and_removes_stops_without_deleting_the_last_pair() {
+    let mut h = app_harness("gradientMap", "rgb", 8);
+    let (id, original) = layer(&h);
+    let steps = h.state().session.active().unwrap().history.past_len();
+    let middle = map_handle(&h, 0.5);
+    click(&mut h, middle);
+    let added = map_stops(&layer(&h).1);
+    assert_eq!(added.len(), 3);
+    assert!((added[1].0 - 0.5).abs() < 0.001);
+    assert_eq!(added[1].1, [128, 128, 128]);
+    assert_eq!(h.state().session.active().unwrap().history.past_len(), steps + 1);
+    let first = map_handle(&h, 0.0);
+    click(&mut h, first);
+    assert_eq!(h.ctx.data(|d| d.get_temp::<usize>(crate::adjust_editors::layer_mem(id).with("gm-stop-selection"))), Some(0));
+    assert_eq!(h.state().session.active().unwrap().history.past_len(), steps + 1, "selection is view state");
+    click(&mut h, middle);
+    let remove = h.get_by_label("Remove stop").rect().center();
+    click(&mut h, remove);
+    assert_eq!(layer(&h).1, original);
+    assert_eq!(h.state().session.active().unwrap().history.past_len(), steps + 2);
+    let first = map_handle(&h, 0.0);
+    click(&mut h, first);
+    let remove = h.get_by_label("Remove stop").rect().center();
+    click(&mut h, remove);
+    assert_eq!(layer(&h).1, original, "keep two stops");
+}
+
+#[test]
+fn gradient_map_drag_clamps_at_the_endpoints_and_reverse_keeps_stop_coordinates() {
+    let mut h = app_harness("gradientMap", "rgb", 8);
+    let reverse = label_rect(&h, "Reverse").unwrap().center();
+    click(&mut h, reverse);
+    let first = map_handle(&h, 0.0);
+    let target = map_handle(&h, 0.3);
+    drag(&mut h, first, target);
+    assert!((map_stops(&layer(&h).1)[0].0 - 0.3).abs() < 0.001);
+    let target = map_handle(&h, 0.3);
+    drag(&mut h, target, first - vec2(60.0, 0.0));
+    assert_eq!(map_stops(&layer(&h).1)[0].0, 0.0);
+    let last = map_handle(&h, 1.0);
+    let beyond = last + vec2(60.0, 0.0);
+    let before = layer(&h).1;
+    let steps = h.state().session.active().unwrap().history.past_len();
+    drag(&mut h, last, beyond);
+    assert_eq!(layer(&h).1, before);
+    assert_eq!(h.state().session.active().unwrap().history.past_len(), steps, "a clamped no-op makes no history");
+}
+
+#[test]
+fn gradient_map_stop_controls_fit_a_narrow_properties_panel_in_every_theme() {
+    use crate::adjust_editors::{EditorCx, editor};
+    for kind in crate::theme::ThemeKind::ALL {
+        for width in [240.0, 280.0] {
+            let mut h = Harness::builder().with_size(vec2(width, 360.0)).build_ui_state(
+                |ui, values: &mut serde_json::Value| {
+                    if !ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                        return;
+                    }
+                    let cx = EditorCx {
+                        mem: egui::Id::new("map-layout"),
+                        hist: None,
+                        gray: false,
+                        swatches: [[0.0; 3], [1.0; 3]],
+                        gradients: Vec::new(),
+                        dialog: false,
+                        dynamic_color_sliders: true,
+                    };
+                    editor(ui, "gradientMap", values, &cx);
+                },
+                json!({"stops": [[0, "#000000"], [1, "#ffffff"]]}),
+            );
+            PhotocraftApp::setup_context(&h.ctx, kind);
+            h.run_steps(4);
+            for role in [egui::accesskit::Role::Button, egui::accesskit::Role::ComboBox, egui::accesskit::Role::SpinButton] {
+                for control in h.query_all_by_role(role) {
+                    let r = control.rect();
+                    assert!(r.left() >= 0.0 && r.right() <= width && r.width() >= 8.0, "{kind:?} width {width}: {role:?} {r:?}");
+                }
+            }
+        }
+    }
+}
+
 /// Issue #1588: the Gradient Map preset picker offers the session's gradient library (built-in
 /// groups beyond Basics and the user's own saved gradients), and picking one writes its stops as
 /// one history step.
@@ -458,6 +592,7 @@ fn gradient_map_picker_offers_the_gradient_library() {
     let mut h = app_harness("gradientMap", "rgb", 8);
     // A short library so every row fits the popup: Basics, Blues and a user-saved group.
     let mut lib: Vec<_> = gradients::builtin().into_iter().take(2).collect();
+    lib[1].items.truncate(3);
     lib.push(Group::new("Mine", vec![gradients::GradientPreset::new("My Teal", &["#008080", "#ffee00"])]));
     h.state_mut().session.presets.gradients = lib;
     h.run_steps(2);
@@ -477,6 +612,101 @@ fn gradient_map_picker_offers_the_gradient_library() {
     }
 }
 
+fn import_gradients_from_picker(h: &mut Harness<'_, PhotocraftApp>) {
+    let preset = label_rect(h, "Preset:").unwrap();
+    click(h, Pos2::new(preset.right() + 60.0, preset.center().y));
+    h.get_by_label("Gradient Preset Options").click();
+    h.run_steps(2);
+    h.get_by_label("Import .GRD").click();
+    h.run_steps(3);
+}
+
+#[test]
+fn gradient_map_picker_imports_grd_without_editing_the_map() {
+    use photocraft_psd::grd::{GrdColor, GrdGradient, GrdStop};
+    let mut h = app_harness("gradientMap", "rgb", 16);
+    h.state_mut().session.presets.gradients.truncate(1);
+    let before = layer(&h);
+    let history = h.state().session.active().unwrap().history.past_len();
+    let tool = h.state().session.presets.gradient.clone();
+    let bytes = photocraft_psd::grd::write(&[GrdGradient {
+        name: "Imported Teal".into(),
+        stops: vec![
+            GrdStop { location: 0.0, midpoint: 0.5, color: GrdColor::Rgb([0.0, 0.5, 0.5]) },
+            GrdStop { location: 1.0, midpoint: 0.5, color: GrdColor::Rgb([1.0, 1.0, 0.0]) },
+        ],
+        ..Default::default()
+    }]);
+    h.state_mut().services.file_dialog = Some(Box::new(move |request, _, reply| {
+        assert!(matches!(request, crate::FileDialogRequest::Open { multiple: false, extensions: Some(ref exts), .. } if exts == &["grd"]));
+        reply.send(Some(crate::FileDialogAnswer::Contents("My Gradients.GRD".into(), bytes.clone())));
+    }));
+    import_gradients_from_picker(&mut h);
+    assert_eq!(layer(&h), before, "import does not edit the adjustment");
+    assert_eq!(h.state().session.active().unwrap().history.past_len(), history);
+    assert_eq!(h.state().session.presets.gradient, tool);
+    assert!(!h.state().ui.status_error);
+    assert!(h.state().ui.status.contains("Imported 1 gradient"));
+    let preset = label_rect(&h, "Preset:").unwrap();
+    click(&mut h, Pos2::new(preset.right() + 60.0, preset.center().y));
+    h.get_by_label("My Gradients");
+    h.get_by_label("Imported Teal").click();
+    h.run_steps(3);
+    assert_eq!(map_stops(&layer(&h).1), vec![(0.0, [0, 128, 128]), (1.0, [255, 255, 0])]);
+    assert_eq!(h.state().session.active().unwrap().history.past_len(), history + 1);
+    h.state_mut().run("edit.undo", json!({})).unwrap();
+    assert_eq!(layer(&h), before);
+}
+
+#[test]
+fn gradient_map_picker_import_cancel_and_errors_preserve_state() {
+    use crate::FileDialogAnswer;
+    for answer in [
+        None,
+        Some(FileDialogAnswer::Contents("broken.grd".into(), b"invalid".to_vec())),
+        Some(FileDialogAnswer::Contents("old.grd".into(), b"8BGR\0\x03".to_vec())),
+        Some(FileDialogAnswer::Contents(
+            "noise.grd".into(),
+            photocraft_psd::grd::write(&[photocraft_psd::grd::GrdGradient { noise: true, ..Default::default() }]),
+        )),
+        Some(FileDialogAnswer::Contents("wrong.abr".into(), Vec::new())),
+        Some(FileDialogAnswer::Paths(vec!["/nonexistent/photocraft-gradients.grd".into()])),
+        Some(FileDialogAnswer::Unavailable("dialog unavailable".into())),
+    ] {
+        let mut h = app_harness("gradientMap", "rgb", 8);
+        h.state_mut().session.presets.gradients.truncate(1);
+        let before = layer(&h);
+        let presets = h.state().session.presets.gradients.clone();
+        let history = h.state().session.active().unwrap().history.past_len();
+        let error = answer.is_some();
+        h.state_mut().services.file_dialog = Some(Box::new(move |_, _, reply| reply.send(answer.clone())));
+        import_gradients_from_picker(&mut h);
+        assert_eq!(layer(&h), before);
+        assert_eq!(h.state().session.presets.gradients, presets);
+        assert_eq!(h.state().session.active().unwrap().history.past_len(), history);
+        assert_eq!(h.state().ui.status_error, error);
+        if error {
+            assert!(!h.state().ui.status.is_empty());
+        }
+    }
+}
+
+#[test]
+fn gradient_map_dialog_import_preserves_pending_settings() {
+    let mut h = app_harness("gradientMap", "rgb", 8);
+    let id = crate::adjust_dialog::open(h.state_mut(), "image.adjustments.gradientMap").unwrap();
+    let fields = h.state_mut().ui.dialog_mut(id).unwrap().fields.clone();
+    h.state_mut().services.file_dialog = Some(Box::new(|request, _, reply| {
+        assert!(matches!(request, crate::FileDialogRequest::Open { extensions: Some(ref exts), .. } if exts == &["grd"]));
+        reply.send(None);
+    }));
+    h.run_steps(3);
+    import_gradients_from_picker(&mut h);
+    assert_eq!(h.state_mut().ui.dialog_mut(id).unwrap().fields, fields);
+    assert!(!h.state().file_dialog_open());
+    assert!(!h.state().ui.status_error);
+}
+
 /// Document point (x, y) on screen in the app's first view.
 fn doc_on_screen(h: &Harness<'_, PhotocraftApp>, x: f32, y: f32) -> Pos2 {
     let app = h.state();
@@ -530,3 +760,89 @@ fn properties_white_point_eyedropper_edits_the_layer(kind: &str) {
     h.state_mut().run("edit.undo", json!({})).unwrap();
     assert_eq!(layer(&h).1, before);
 }
+
+/// A bare `kind` editor over `params`, as the Properties panel and the dialog host it.
+fn editor_harness(kind: &'static str, params: serde_json::Value) -> Harness<'static, serde_json::Value> {
+    use crate::adjust_editors::{EditorCx, editor};
+    let mut h = Harness::builder().with_size(vec2(300.0, 400.0)).build_ui_state(
+        move |ui, values: &mut serde_json::Value| {
+            let cx = EditorCx {
+                mem: egui::Id::new("precision"),
+                hist: None,
+                gray: false,
+                swatches: [[0.0; 3], [1.0; 3]],
+                gradients: Vec::new(),
+                dialog: true,
+                dynamic_color_sliders: true,
+            };
+            editor(ui, kind, values, &cx);
+        },
+        params,
+    );
+    PhotocraftApp::setup_context(&h.ctx, Default::default());
+    h.run_steps(4);
+    h
+}
+
+/// Types `text` into the `index`th number field and commits it with Enter.
+fn type_into_field(h: &mut Harness<'static, serde_json::Value>, index: usize, text: &str) {
+    h.query_all_by_role(egui::accesskit::Role::SpinButton).nth(index).unwrap().click();
+    h.run_steps(2);
+    h.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::A);
+    h.run_steps(1);
+    h.event(egui::Event::Text(text.into()));
+    h.run_steps(1);
+    h.key_press(egui::Key::Enter);
+    h.run_steps(3);
+}
+
+/// The text the `index`th number field shows.
+fn field_text(h: &Harness<'static, serde_json::Value>, index: usize) -> String {
+    h.query_all_by_role(egui::accesskit::Role::SpinButton).nth(index).unwrap().value().unwrap_or_default()
+}
+
+/// #4164: Exposure keeps fractional stops (Photoshop: two decimals) and Offset four decimals,
+/// instead of rounding Exposure to whole stops because its range is wider than 10.
+#[test]
+fn exposure_keeps_fractional_stops_and_offset_four_decimals() {
+    let mut h = editor_harness("exposure", json!({}));
+    type_into_field(&mut h, 0, "0.5");
+    assert_eq!(h.state()["exposure"].as_f64(), Some(0.5), "{}", h.state());
+    type_into_field(&mut h, 0, "-1.37");
+    assert!((h.state()["exposure"].as_f64().unwrap() + 1.37).abs() < 1e-4, "{}", h.state());
+    type_into_field(&mut h, 1, "0.0123");
+    assert!((h.state()["offset"].as_f64().unwrap() - 0.0123).abs() < 1e-6, "{}", h.state());
+    type_into_field(&mut h, 2, "1.234");
+    assert!((h.state()["gamma"].as_f64().unwrap() - 1.23).abs() < 1e-4, "Gamma keeps two decimals: {}", h.state());
+    h.run_steps(2);
+    assert_eq!(field_text(&h, 0), "-1.37");
+    assert_eq!(field_text(&h, 1), "0.0123");
+    assert_eq!(field_text(&h, 2), "1.23");
+}
+
+/// #4164: the integer rows that share Exposure's slider code stay whole numbers.
+#[test]
+fn integer_adjustment_rows_stay_whole_numbers() {
+    for (kind, key, typed, want) in [
+        ("posterize", "levels", "4.6", 5.0),
+        ("threshold", "level", "100.4", 100.0),
+        ("brightnessContrast", "brightness", "12.7", 13.0),
+        ("vibrance", "vibrance", "-20.4", -20.0),
+    ] {
+        let mut h = editor_harness(kind, json!({}));
+        type_into_field(&mut h, 0, typed);
+        assert_eq!(h.state()[key].as_f64(), Some(want), "{kind}: {}", h.state());
+    }
+}
+
+/// #4164: a row's own decimals win over the range rule; rows without them keep it.
+#[test]
+fn row_values_round_to_their_own_decimals() {
+    use crate::adjust_editors::row_value;
+    assert_eq!(row_value(0.5, -20.0, 20.0, Some(2)), 0.5);
+    assert_eq!(row_value(-1.374, -20.0, 20.0, Some(2)), -1.37);
+    assert!((row_value(0.012_34, -0.5, 0.5, Some(4)) - 0.0123).abs() < 1e-7);
+    assert_eq!(row_value(4.6, 2.0, 255.0, None), 5.0, "wide ranges stay whole numbers");
+    assert!((row_value(1.234, 0.01, 9.99, None) - 1.23).abs() < 1e-6, "small ranges keep two decimals");
+    assert!(row_value(f32::NAN, -20.0, 20.0, Some(u32::MAX)).is_nan(), "no panic on odd input");
+}
diff --git a/crates/ui-egui/src/analysis_ui.rs b/crates/ui-egui/src/analysis_ui.rs
index b0ad27bdd3..09aaf17670 100644
--- a/crates/ui-egui/src/analysis_ui.rs
+++ b/crates/ui-egui/src/analysis_ui.rs
@@ -565,7 +565,7 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
                 ui.label(RichText::new(tl!("Label Size")).color(t.text_dim).size(11.0));
                 let b = crate::widgets::value_field(ui, &mut ls, 8.0..=72.0, "", 44.0).changed();
                 if a || b {
-                    let _ = app.run("count.setGroup", json!({"markerSize": ms.round(), "labelSize": ls.round()}));
+                    let _ = app.run("count.setGroup", count_size_params(ms, ls));
                 }
             }
             true
@@ -613,6 +613,13 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
 
 // ------------------------------------------------------------------ panels and dialogs
 
+/// `count.setGroup` params for the options bar's Marker Size and Label Size fields, sent as JSON
+/// integers (the fields edit `f32`s; `8.0` is a float on the wire).
+fn count_size_params(marker: f32, label: f32) -> Value {
+    let whole = |v: f32, lo: f32, hi: f32| if v.is_finite() { v.round().clamp(lo, hi) as u32 } else { lo as u32 };
+    json!({"markerSize": whole(marker, 1.0, 10.0), "labelSize": whole(label, 8.0, 72.0)})
+}
+
 fn float_frame(t: &Tokens) -> egui::Frame {
     egui::Frame::NONE
         .fill(t.card)
@@ -1223,4 +1230,17 @@ pub(crate) mod tests {
         assert!(empty.run("view.colorSamplers.add", json!({"x": 1, "y": 1})).is_err());
         assert!(empty.run("view.colorSamplers.list", json!({})).is_err());
     }
+
+    #[test]
+    fn count_size_fields_send_whole_numbers_the_engine_applies() {
+        let p = count_size_params(7.6, 20.0);
+        assert_eq!(p, json!({"markerSize": 8, "labelSize": 20}));
+        assert!(p["markerSize"].is_u64() && p["labelSize"].is_u64());
+        assert_eq!(count_size_params(f32::NAN, 500.0), json!({"markerSize": 1, "labelSize": 72}));
+        let (mut app, _ctx) = app();
+        app.run("count.add", json!({"x": 10, "y": 10})).unwrap();
+        app.run("count.setGroup", count_size_params(8.0, 20.0)).unwrap();
+        let g = &app.session.active().unwrap().doc.measurement.count_groups[0];
+        assert_eq!((g.marker_size, g.label_size), (8, 20));
+    }
 }
diff --git a/crates/ui-egui/src/anchor_tools.rs b/crates/ui-egui/src/anchor_tools.rs
index a314db5fc9..9dc8b6cfe5 100644
--- a/crates/ui-egui/src/anchor_tools.rs
+++ b/crates/ui-egui/src/anchor_tools.rs
@@ -7,6 +7,9 @@
 //! * Delete Anchor Point: hovering an anchor highlights it; a click removes it
 //!   (`path.deleteAnchor`), joining its neighbours.
 //! * ⌥ swaps the two tools and ⌘/Ctrl is Direct Selection (`direct_select`) while held.
+//! * The Pen does both with Auto Add/Delete on (its options bar, on by default, #4144), on the
+//!   active path only and while no path is being drawn: a click on a segment adds, a click on an
+//!   anchor deletes, except an open subpath's end points; ⇧ turns it off while held.
 //!
 //! Each click is one command and one history step; a click on nothing it can edit does nothing.
 
@@ -43,8 +46,42 @@ fn target(app: &PhotocraftApp, tool: Tool, p: [f64; 2]) -> Option<(PathRef, Path
     }
 }
 
-/// Canvas pointer events for the anchor tools; false when the current tool isn't one.
+/// The Pen's Auto Add/Delete (#4144): what a Pen click at `p` does to the active path instead of
+/// starting a new one, as the anchor tool that does it (Add Anchor Point on a segment, Delete
+/// Anchor Point on an anchor), the path and the hit. `None` when the option is off, ⇧, ⌥ or ⌘ is
+/// held, a path is being drawn, or the click hits nothing it edits. The end points of an open
+/// subpath are left to the Pen, as in Photoshop.
+pub fn pen_auto(app: &PhotocraftApp, tool: Tool, mods: Modifiers, p: [f64; 2]) -> Option<(Tool, PathRef, Path, Hit)> {
+    if tool != Tool::Pen || !app.ui.tool_options.pen_auto_add_delete || app.ui.pen.is_some() || mods.shift || mods.alt || mods.command {
+        return None;
+    }
+    let tol = 6.0 / f64::from(app.point_zoom().max(0.01));
+    let (r, path, hit) =
+        crate::direct_select::active_paths(app).into_iter().find_map(|(r, path)| edit::hit(&path, Point::new(p[0], p[1]), tol, &[]).map(|h| (r, path, h)))?;
+    let tool = match hit {
+        Hit::Segment(..) => Tool::AddAnchorPoint,
+        Hit::Anchor([s, k]) => {
+            let sp = path.subpaths.get(s)?;
+            if !sp.closed && (k == 0 || k + 1 == sp.knots.len()) {
+                return None;
+            }
+            Tool::DeleteAnchorPoint
+        }
+        Hit::Handle(..) => return None,
+    };
+    Some((tool, r, path, hit))
+}
+
+/// Canvas pointer events for the anchor tools, and a Pen press that Auto Add/Delete takes; false
+/// when they aren't theirs.
 pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: Modifiers) -> bool {
+    if let ToolEvent::Down { x, y, .. } = ev
+        && let Some((_, r, _, hit)) = pen_auto(app, app.ui.tool, mods, [x, y])
+    {
+        // The release finds no Pen path to finish, so the Pen draws nothing.
+        apply(app, r, hit);
+        return true;
+    }
     let Some(tool) = effective(app.ui.tool, mods) else { return false };
     if let ToolEvent::Down { x, y, .. } = ev {
         click(app, tool, [x, y]);
@@ -53,7 +90,25 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: Modifiers) -> bool
 }
 
 fn click(app: &mut PhotocraftApp, tool: Tool, p: [f64; 2]) {
-    let Some((r, _, hit)) = target(app, tool, p) else { return };
+    let Some((r, mut path, hit)) = target(app, tool, p) else { return };
+    if r == PathRef::Pen {
+        // The Pen path being drawn isn't in the document yet: it takes the edit directly.
+        let edited = match hit {
+            Hit::Segment(k, t) => edit::add_anchor(&mut path, k, t).is_ok(),
+            Hit::Anchor(k) => edit::delete_anchor(&mut path, k).is_ok(),
+            Hit::Handle(..) => false,
+        };
+        if edited {
+            app.ui.direct_selection = DirectSelection { target: Some(r), ..Default::default() };
+            crate::vector_ui::pen_replace(app, &path);
+        }
+        return;
+    }
+    apply(app, r, hit);
+}
+
+/// Add an anchor where `hit` is on a segment of `r`, or delete the anchor it is on: one command.
+fn apply(app: &mut PhotocraftApp, r: PathRef, hit: Hit) {
     let (id, mut params) = match hit {
         Hit::Segment([s, k], t) => ("path.addAnchor", serde_json::json!({"subpath": s, "knot": k, "t": t})),
         Hit::Anchor([s, k]) => ("path.deleteAnchor", serde_json::json!({"subpath": s, "knot": k})),
@@ -82,6 +137,18 @@ pub fn draw_hover(app: &PhotocraftApp, painter: &egui::Painter, to_scr: &dyn Fn(
         return;
     }
     let Some((_, path, hit)) = target(app, tool, p) else { return };
+    draw_hit(painter, to_scr, accent, &path, hit);
+}
+
+/// The same feedback for the Pen when Auto Add/Delete would act on a click.
+pub fn draw_pen_hover(app: &PhotocraftApp, painter: &egui::Painter, to_scr: &dyn Fn([f64; 2]) -> Pos2, accent: Color32, mods: Modifiers) {
+    let Some(p) = app.hover_doc else { return };
+    if let Some((_, _, path, hit)) = pen_auto(app, app.ui.tool, mods, p) {
+        draw_hit(painter, to_scr, accent, &path, hit);
+    }
+}
+
+fn draw_hit(painter: &egui::Painter, to_scr: &dyn Fn([f64; 2]) -> Pos2, accent: Color32, path: &Path, hit: Hit) {
     match hit {
         Hit::Segment([s, k], t) => {
             let Some(seg) = path.subpaths.get(s).and_then(|sp| sp.segments().get(k).copied()) else { return };
diff --git a/crates/ui-egui/src/anchor_tools_tests.rs b/crates/ui-egui/src/anchor_tools_tests.rs
index c88f1a2b19..87c045eba9 100644
--- a/crates/ui-egui/src/anchor_tools_tests.rs
+++ b/crates/ui-egui/src/anchor_tools_tests.rs
@@ -154,3 +154,79 @@ fn the_cursor_shows_plus_or_minus() {
     assert_eq!(badge(&app, Tool::DeleteAnchorPoint, Modifiers::NONE), Some(Badge::Subtract));
     assert_eq!(badge(&app, Tool::DeleteAnchorPoint, Modifiers::COMMAND), None, "⌘ is Direct Selection");
 }
+
+/// #4144: with Auto Add/Delete (on by default) a Pen click on a segment of the active path adds
+/// an anchor and a click on one of its anchors deletes it, one step each, and no Pen path starts.
+#[test]
+fn the_pen_adds_and_deletes_anchors_on_the_active_path() {
+    let mut app = app(Tool::Pen);
+    assert!(app.ui.tool_options.pen_auto_add_delete, "on by default, as in Photoshop");
+    with_path(&mut app);
+    let n = steps(&app);
+    click(&mut app, [80.0, 120.0], Modifiers::NONE);
+    assert_eq!(work(&app).subpaths[0].knots.len(), 5);
+    assert_eq!(app.session.active().unwrap().history.undo_label(), Some("Add Anchor Point"));
+    assert!(app.ui.pen.is_none(), "no Pen path was started");
+    click(&mut app, [40.0, 120.0], Modifiers::NONE);
+    let p = work(&app);
+    assert_eq!(p.subpaths[0].knots.len(), 4);
+    assert!(!p.subpaths[0].knots.iter().any(|k| k.anchor == Point::new(40.0, 120.0)));
+    assert_eq!(app.session.active().unwrap().history.undo_label(), Some("Delete Anchor Point"));
+    assert_eq!(steps(&app), n + 2);
+    assert!(app.ui.pen.is_none());
+    // Off the path the Pen draws.
+    click(&mut app, [170.0, 170.0], Modifiers::NONE);
+    assert_eq!(app.ui.pen.as_ref().map(|p| p.knots.len()), Some(1));
+}
+
+/// Auto Add/Delete off, or ⇧ held, or a path being drawn: the Pen click places an anchor.
+#[test]
+fn the_pen_draws_over_the_path_with_auto_add_delete_off_shift_or_while_drawing() {
+    let mut app = app(Tool::Pen);
+    with_path(&mut app);
+    let before = work(&app);
+    app.ui.tool_options.pen_auto_add_delete = false;
+    click(&mut app, [80.0, 120.0], Modifiers::NONE);
+    assert_eq!((work(&app), app.ui.pen.as_ref().map(|p| p.knots.len())), (before.clone(), Some(1)));
+    app.ui.pen = None;
+
+    app.ui.tool_options.pen_auto_add_delete = true;
+    click(&mut app, [80.0, 120.0], Modifiers::SHIFT);
+    assert_eq!((work(&app), app.ui.pen.as_ref().map(|p| p.knots.len())), (before.clone(), Some(1)), "⇧ turns it off");
+    app.ui.pen = None;
+
+    click(&mut app, [170.0, 170.0], Modifiers::NONE);
+    click(&mut app, [80.0, 120.0], Modifiers::NONE);
+    assert_eq!((work(&app), app.ui.pen.as_ref().map(|p| p.knots.len())), (before, Some(2)), "a path being drawn takes the click");
+}
+
+/// The end points of an open subpath stay the Pen's; its middle anchors are deleted.
+#[test]
+fn the_pen_leaves_open_end_points_alone() {
+    let mut app = app(Tool::Pen);
+    let path = json!({"subpaths": [{"closed": false, "knots": [[40, 40], [120, 40], [120, 120]]}]});
+    app.run("path.set", json!({"name": "work", "path": path})).unwrap();
+    let before = work(&app);
+    for end in [[40.0, 40.0], [120.0, 120.0]] {
+        click(&mut app, end, Modifiers::NONE);
+        assert_eq!(work(&app), before, "{end:?}");
+        app.ui.pen = None;
+    }
+    click(&mut app, [120.0, 40.0], Modifiers::NONE);
+    assert_eq!(work(&app).subpaths[0].knots.len(), 2);
+}
+
+#[test]
+fn the_pen_cursor_shows_what_auto_add_delete_would_do() {
+    use crate::tool_feedback::{Badge, badge};
+    let mut app = app(Tool::Pen);
+    with_path(&mut app);
+    for (at, want) in [([80.0, 120.0], Some(Badge::Add)), ([40.0, 120.0], Some(Badge::Subtract)), ([80.0, 80.0], None)] {
+        app.hover_doc = Some(at);
+        assert_eq!(badge(&app, Tool::Pen, Modifiers::NONE), want, "{at:?}");
+    }
+    app.hover_doc = Some([80.0, 120.0]);
+    assert_eq!(badge(&app, Tool::Pen, Modifiers::SHIFT), None);
+    app.ui.tool_options.pen_auto_add_delete = false;
+    assert_eq!(badge(&app, Tool::Pen, Modifiers::NONE), None);
+}
diff --git a/crates/ui-egui/src/artboard_tool.rs b/crates/ui-egui/src/artboard_tool.rs
index 79a7cd3b78..6b996c3f14 100644
--- a/crates/ui-egui/src/artboard_tool.rs
+++ b/crates/ui-egui/src/artboard_tool.rs
@@ -417,7 +417,11 @@ mod tests {
         let press = |app: &mut PhotocraftApp, modifiers| {
             let key = egui::Key::V;
             let raw = egui::RawInput {
-                events: vec![egui::Event::ModifiersChanged(modifiers), egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }],
+                events: vec![
+                    egui::Event::ModifiersChanged(modifiers),
+                    egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers },
+                    egui::Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers },
+                ],
                 ..Default::default()
             };
             ctx.begin_pass(raw);
diff --git a/crates/ui-egui/src/background_redraw.rs b/crates/ui-egui/src/background_redraw.rs
new file mode 100644
index 0000000000..e8196bc1c2
--- /dev/null
+++ b/crates/ui-egui/src/background_redraw.rs
@@ -0,0 +1,252 @@
+//! Full CPU redraws of the GPU canvas off the UI thread (#4024). When the wgpu compositor can't
+//! draw a full refresh (the layers exceed its memory budget, or the document uses something it
+//! doesn't cover), the CPU compositor redraws the whole document: minutes on a multi-gigabyte
+//! PSB. With background jobs (the desktop app) a worker composites it in blocks instead, the
+//! visible ones first, and each frame uploads the blocks that are done, so the window keeps
+//! drawing and answering while the rest of the canvas fills in. Until a block lands the texture
+//! keeps what it showed before.
+//!
+//! An edit while it runs restarts the worker on the new document with the blocks still to draw;
+//! the edit's own damage is drawn by the canvas as usual. A full change (a new preview, a new
+//! display transform) starts over. Without background jobs (web, tests) the canvas keeps the
+//! synchronous [`GpuCanvas::upload_composite`].
+
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::{Receiver, SyncSender, TryRecvError};
+
+use photocraft_doc::{DocId, Document};
+use photocraft_engine::display_color::CanvasDisplay;
+use photocraft_geom::Rect;
+#[cfg(not(target_arch = "wasm32"))]
+use rayon::prelude::*;
+
+use crate::PhotocraftApp;
+use crate::gpu_canvas::GpuCanvas;
+
+/// Side of a block in document pixels: whole render tiles, and a power of two so each block's
+/// mip levels don't depend on its neighbours.
+const BLOCK: i32 = 1024;
+
+/// Blocks composited at once (in parallel, on top of each block's own tiles), and how many
+/// finished blocks may wait for the UI thread: bounds the memory a redraw holds.
+const BATCH: usize = 4;
+
+/// One finished block, as texels of the canvas texture.
+struct Piece {
+    block: usize,
+    texels: Vec<u8>,
+}
+
+/// A redraw in progress for one document's GPU texture.
+pub(crate) struct Redraw {
+    blocks: Vec<Rect>,
+    pending: Vec<bool>,
+    left: usize,
+    /// Pixels uploaded so far.
+    drawn: u64,
+    rx: Receiver<Piece>,
+    stop: Arc<AtomicBool>,
+    started_ms: f64,
+    fallback: Option<String>,
+}
+
+impl Redraw {
+    /// Share of the document drawn, 0..=1.
+    pub fn fraction(&self) -> f32 {
+        if self.blocks.is_empty() { 1.0 } else { 1.0 - self.left as f32 / self.blocks.len() as f32 }
+    }
+}
+
+impl Drop for Redraw {
+    fn drop(&mut self) {
+        self.stop.store(true, Ordering::Relaxed);
+    }
+}
+
+/// Whether full CPU refreshes run in the background here.
+pub(crate) fn enabled(app: &PhotocraftApp) -> bool {
+    cfg!(not(target_arch = "wasm32")) && app.background_jobs
+}
+
+/// `bounds` cut into [`BLOCK`]-sized blocks, row by row.
+fn blocks(bounds: Rect) -> Vec<Rect> {
+    let mut out = Vec::new();
+    let mut y = bounds.y0;
+    while y < bounds.y1 {
+        let mut x = bounds.x0;
+        while x < bounds.x1 {
+            out.push(Rect::new(x, y, (x + BLOCK).min(bounds.x1), (y + BLOCK).min(bounds.y1)));
+            x += BLOCK;
+        }
+        y += BLOCK;
+    }
+    out
+}
+
+/// The order to draw `wanted` blocks in: those `visible` shows first, then the rest, each group
+/// nearest the view's centre first.
+fn order(blocks: &[Rect], wanted: impl Iterator<Item = usize>, visible: Rect) -> Vec<usize> {
+    let (cx, cy) = ((visible.x0 as i64 + visible.x1 as i64) / 2, (visible.y0 as i64 + visible.y1 as i64) / 2);
+    let mut out: Vec<usize> = wanted.collect();
+    out.sort_by_key(|&i| {
+        let b = blocks[i];
+        let (bx, by) = ((b.x0 as i64 + b.x1 as i64) / 2, (b.y0 as i64 + b.y1 as i64) / 2);
+        (b.intersect(&visible).is_empty(), (bx - cx).pow(2) + (by - cy).pow(2))
+    });
+    out
+}
+
+/// Redraw `region` of document `doc` (`doc.id`'s texture, prepared by
+/// [`GpuCanvas::refresh_with`]) in the background. A redraw already running for it continues on
+/// `doc` with `region`'s blocks added.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn start(
+    app: &mut PhotocraftApp,
+    ctx: &egui::Context,
+    gpu: &GpuCanvas,
+    doc: Arc<Document>,
+    display: Option<Arc<CanvasDisplay>>,
+    visible: Rect,
+    region: Rect,
+    fallback: Option<String>,
+) {
+    let all = blocks(doc.bounds());
+    let (mut pending, since, fallback) = match app.redraws.remove(&doc.id) {
+        Some(old) if old.blocks == all => (old.pending.clone(), (old.started_ms, old.drawn), fallback.or_else(|| old.fallback.clone())),
+        _ => (vec![false; all.len()], (crate::gpu_canvas::now_ms(), 0), fallback),
+    };
+    for (p, b) in pending.iter_mut().zip(&all) {
+        *p |= !b.intersect(&region).is_empty();
+    }
+    if pending.contains(&true) {
+        spawn(app, ctx, gpu, doc, display, visible, all, pending, since, fallback);
+    }
+}
+
+/// After an edit drew its own damage: continue document `doc.id`'s redraw, if one is running, on
+/// the edited document, so blocks still to come don't bring back what was there before it.
+pub(crate) fn restart(app: &mut PhotocraftApp, ctx: &egui::Context, gpu: &GpuCanvas, doc: Arc<Document>, display: Option<Arc<CanvasDisplay>>, visible: Rect) {
+    if app.redraws.contains_key(&doc.id) {
+        start(app, ctx, gpu, doc, display, visible, Rect::EMPTY, None);
+    }
+}
+
+/// Upload the blocks document `doc`'s redraw has finished since the last frame. When the last one
+/// lands, the redraw is recorded like the synchronous refresh it replaces (and explained once if
+/// it was slow).
+pub(crate) fn poll(app: &mut PhotocraftApp, gpu: &GpuCanvas, doc: DocId) {
+    let Some(r) = app.redraws.get_mut(&doc) else { return };
+    loop {
+        match r.rx.try_recv() {
+            Ok(p) => {
+                let b = r.blocks[p.block];
+                if r.pending[p.block] && gpu.upload_rect(doc.0, [b.x0 as u32, b.y0 as u32], [b.width(), b.height()], &p.texels) {
+                    r.pending[p.block] = false;
+                    r.left -= 1;
+                    r.drawn += b.width() as u64 * b.height() as u64;
+                }
+            }
+            Err(TryRecvError::Empty) => return,
+            Err(TryRecvError::Disconnected) => break,
+        }
+    }
+    let Some(r) = app.redraws.remove(&doc) else { return };
+    if r.left > 0 {
+        log::warn!("canvas redraw stopped with {} of {} blocks left", r.left, r.blocks.len());
+        return;
+    }
+    let ms = crate::gpu_canvas::now_ms() - r.started_ms;
+    app.perf.record("background", r.drawn, ms, 0.0);
+    crate::notices::slow_cpu_refresh(app, doc.0, ms, r.fallback.as_deref());
+}
+
+/// The active document's redraw in the status bar: "Redrawing" and how much is done.
+pub(crate) fn status(app: &PhotocraftApp, ui: &mut egui::Ui) {
+    let Some(r) = app.session.active().and_then(|st| app.redraws.get(&st.doc.id)) else { return };
+    let t = crate::theme::Tokens::get(ui.ctx());
+    ui.label(egui::RichText::new(format!("{:.0}%", r.fraction() * 100.0)).color(t.text_dim).size(11.5).monospace());
+    ui.label(egui::RichText::new(tl!("Redrawing")).color(t.text_dim).size(12.0));
+}
+
+/// Stop document `doc`'s redraw (its canvas was redrawn some other way, or is gone).
+pub(crate) fn cancel(app: &mut PhotocraftApp, doc: DocId) {
+    app.redraws.remove(&doc);
+}
+
+/// Stop redraws of documents that are no longer open.
+pub(crate) fn retain(app: &mut PhotocraftApp) {
+    let docs = app.session.documents();
+    app.redraws.retain(|id, _| docs.iter().any(|st| st.doc.id == *id));
+}
+
+#[allow(clippy::too_many_arguments)]
+fn spawn(
+    app: &mut PhotocraftApp,
+    ctx: &egui::Context,
+    gpu: &GpuCanvas,
+    doc: Arc<Document>,
+    display: Option<Arc<CanvasDisplay>>,
+    visible: Rect,
+    blocks: Vec<Rect>,
+    pending: Vec<bool>,
+    (started_ms, drawn): (f64, u64),
+    fallback: Option<String>,
+) {
+    let id = doc.id;
+    let Some(format) = gpu.prepare_texture(id.0, &doc) else { return };
+    let todo = order(&blocks, (0..blocks.len()).filter(|&i| pending[i]), visible);
+    let left = todo.len();
+    let (tx, rx) = std::sync::mpsc::sync_channel(BATCH);
+    let stop = Arc::new(AtomicBool::new(false));
+    let work = (blocks.clone(), stop.clone(), ctx.clone());
+    let spawned = std::thread::Builder::new().name("canvas-redraw".into()).spawn(move || {
+        let (blocks, stop, ctx) = work;
+        // A panic stops the redraw: the receiver sees the worker gone and drops it.
+        let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| draw(&doc, display.as_deref(), format, &blocks, &todo, &stop, &tx, &ctx)));
+        ctx.request_repaint();
+    });
+    if let Err(e) = spawned {
+        log::warn!("couldn't start the canvas redraw: {e}");
+        return;
+    }
+    app.redraws.insert(id, Redraw { blocks, pending, left, drawn, rx, stop, started_ms, fallback });
+}
+
+/// The worker: composite `todo`'s blocks of `doc` in batches and hand each over, until done or
+/// stopped.
+#[allow(clippy::too_many_arguments)]
+fn draw(
+    doc: &Document,
+    display: Option<&CanvasDisplay>,
+    format: eframe::wgpu::TextureFormat,
+    blocks: &[Rect],
+    todo: &[usize],
+    stop: &AtomicBool,
+    tx: &SyncSender<Piece>,
+    ctx: &egui::Context,
+) {
+    for batch in todo.chunks(BATCH) {
+        if stop.load(Ordering::Relaxed) {
+            return;
+        }
+        // Never reached in the browser ([`enabled`]); it only has to build there, without rayon.
+        #[cfg(not(target_arch = "wasm32"))]
+        let batch = batch.par_iter();
+        #[cfg(target_arch = "wasm32")]
+        let batch = batch.iter();
+        let pieces: Vec<Piece> = batch
+            .map(|&block| Piece { block, texels: crate::gpu_canvas::display_texels(format, display, &photocraft_compose::render(doc, blocks[block])) })
+            .collect();
+        for p in pieces {
+            if stop.load(Ordering::Relaxed) || tx.send(p).is_err() {
+                return;
+            }
+            ctx.request_repaint();
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "background_redraw_tests.rs"]
+mod tests;
diff --git a/crates/ui-egui/src/background_redraw_tests.rs b/crates/ui-egui/src/background_redraw_tests.rs
new file mode 100644
index 0000000000..e054ffe2a6
--- /dev/null
+++ b/crates/ui-egui/src/background_redraw_tests.rs
@@ -0,0 +1,165 @@
+//! Background full CPU redraws (#4024). The GPU tests skip when there is no adapter.
+
+use super::*;
+use serde_json::json;
+
+#[test]
+fn blocks_cover_the_document_once() {
+    let bounds = Rect::new(0, 0, 2500, 1100);
+    let b = blocks(bounds);
+    assert_eq!(b.len(), 3 * 2);
+    assert_eq!(b.iter().map(|r| r.width() as u64 * r.height() as u64).sum::<u64>(), 2500 * 1100);
+    for (i, r) in b.iter().enumerate() {
+        assert!(r.x0 % BLOCK == 0 && r.y0 % BLOCK == 0, "block {i} starts on the grid: {r:?}");
+        assert!(b[i + 1..].iter().all(|o| o.intersect(r).is_empty()), "block {i} overlaps another");
+    }
+}
+
+#[test]
+fn visible_blocks_come_first_nearest_the_view_centre() {
+    let b = blocks(Rect::new(0, 0, 4096, 4096));
+    // The view shows the right half of the second block row.
+    let visible = Rect::new(2100, 1100, 4000, 1900);
+    let o = order(&b, 0..b.len(), visible);
+    assert_eq!(o.len(), 16);
+    let shown: Vec<usize> = (0..b.len()).filter(|&i| !b[i].intersect(&visible).is_empty()).collect();
+    assert_eq!(shown.len(), 2);
+    assert!(o[..2].iter().all(|i| shown.contains(i)), "{o:?}");
+    // Then the block row's neighbours, the far corners last.
+    assert!(o[14..].contains(&12), "the bottom-left corner is among the last: {o:?}");
+    // Only the blocks asked for.
+    assert_eq!(order(&b, [3, 9].into_iter(), visible).len(), 2);
+}
+
+struct Gpu {
+    harness: egui_kittest::Harness<'static, PhotocraftApp>,
+    observer: GpuCanvas,
+}
+
+/// The app on a real device with background jobs, or `None` without a GPU adapter.
+fn gpu_app() -> Option<Gpu> {
+    let observer = Arc::new(std::sync::Mutex::new(None));
+    let observer_out = observer.clone();
+    let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || {
+        egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 700.0)).with_pixels_per_point(1.0).with_max_steps(64).wgpu().build_eframe(move |cc| {
+            PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+            if let Some(rs) = cc.wgpu_render_state.as_ref() {
+                *observer_out.lock().expect("observer") = Some(GpuCanvas::new(rs));
+                app.set_wgpu(rs.clone());
+            }
+            app.background_jobs = true;
+            app
+        })
+    }));
+    let Ok(harness) = built else {
+        eprintln!("skipping: no GPU adapter");
+        return None;
+    };
+    let observer = observer.lock().expect("observer").take()?;
+    Some(Gpu { harness, observer })
+}
+
+/// A document the wgpu compositor leaves to the CPU (knockout on its top layer, which also has
+/// Blend If).
+fn cpu_only_document(app: &mut PhotocraftApp, w: u32, h: u32) -> DocId {
+    app.run("file.new", json!({"width": w, "height": h, "background": "#336699"})).expect("new");
+    app.run("layer.new.layer", json!({})).expect("layer");
+    app.run("edit.fill", json!({"color": "#cc8844"})).expect("fill");
+    app.run("layer.layerStyle.blendingOptions", json!({"opacity": 60, "knockout": "shallow", "blendIf": {"channel": "gray", "underlying": [0, 10, 245, 255]}}))
+        .expect("blending options");
+    app.session.active().expect("document").doc.id
+}
+
+/// Frames until no redraw is running.
+fn settle(g: &mut Gpu) {
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    loop {
+        g.harness.step();
+        if g.harness.state().redraws.is_empty() {
+            return;
+        }
+        assert!(std::time::Instant::now() < deadline, "the redraw didn't finish");
+        std::thread::sleep(std::time::Duration::from_millis(2));
+    }
+}
+
+/// The canvas texture of `doc` against the synchronous CPU refresh of the current document.
+fn assert_matches_synchronous(g: &mut Gpu, doc: DocId) {
+    let app = g.harness.state_mut();
+    let d = app.session.active().expect("document").doc.clone();
+    let (display, _) = crate::canvas::canvas_display(app, &d, None);
+    let reference = doc.0 ^ (1u64 << 60);
+    g.observer.upload_composite(reference, &d, display.as_deref());
+    let (_, size, shown) = g.observer.read_texels(doc.0).expect("canvas texture");
+    let (_, _, want) = g.observer.read_texels(reference).expect("reference texture");
+    assert_eq!(size, [d.size.width, d.size.height]);
+    let differ = shown.iter().zip(&want).filter(|(a, b)| a != b).count();
+    assert_eq!(differ, 0, "{differ} texels differ from the synchronous refresh");
+}
+
+#[test]
+fn a_full_cpu_refresh_draws_in_the_background_with_the_synchronous_pixels() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let Some(mut g) = gpu_app() else { return };
+    let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
+    g.harness.step();
+    assert!(g.harness.state().redraws.contains_key(&doc), "the frame started a redraw instead of compositing inline");
+    settle(&mut g);
+    let app = g.harness.state();
+    assert_eq!(app.perf.last_refresh, "background");
+    assert!(app.perf.gpu_fallback.as_deref().is_some_and(|f| f.contains("Advanced Blending")), "{:?}", app.perf.gpu_fallback);
+    assert_matches_synchronous(&mut g, doc);
+}
+
+#[test]
+fn an_edit_during_a_redraw_is_not_overwritten_by_blocks_drawn_before_it() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let Some(mut g) = gpu_app() else { return };
+    // 4×3 blocks: the worker can't hand them all over before the next frame.
+    let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
+    g.harness.step();
+    assert!(g.harness.state().redraws.contains_key(&doc));
+    // A corner, drawn last (farthest from the view's centre), changes on a layer of its own while
+    // the redraw runs: a small edit, drawn at once.
+    g.harness.state_mut().run("layer.new.layer", json!({})).expect("layer");
+    g.harness.step();
+    g.harness.state_mut().run("select.rect", json!({"x": 3900, "y": 2900, "width": 150, "height": 150})).expect("select");
+    g.harness.step();
+    g.harness.state_mut().run("edit.fill", json!({"color": "#22ee22"})).expect("fill");
+    g.harness.step();
+    assert_eq!(g.harness.state().perf.last_refresh, "rect", "the fill's damage was drawn synchronously");
+    assert!(g.harness.state().redraws.contains_key(&doc), "the redraw goes on");
+    settle(&mut g);
+    assert_matches_synchronous(&mut g, doc);
+}
+
+#[test]
+fn an_edit_damaging_most_of_a_large_document_is_drawn_in_the_background_too() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let Some(mut g) = gpu_app() else { return };
+    let doc = cpu_only_document(g.harness.state_mut(), 2600, 1700);
+    settle(&mut g);
+    // Filling part of the Blend If layer can change the composite anywhere: the whole canvas.
+    g.harness.state_mut().run("select.rect", json!({"x": 100, "y": 100, "width": 300, "height": 300})).expect("select");
+    g.harness.step();
+    g.harness.state_mut().run("edit.fill", json!({"color": "#22ee22"})).expect("fill");
+    assert_eq!(g.harness.state().session.active().expect("document").last_damage, Some(Rect::new(0, 0, 2600, 1700)));
+    g.harness.step();
+    assert!(g.harness.state().redraws.contains_key(&doc), "not composited inline: {}", g.harness.state().perf.last_refresh);
+    settle(&mut g);
+    assert_eq!(g.harness.state().perf.last_refresh, "background");
+    assert_matches_synchronous(&mut g, doc);
+}
+
+#[test]
+fn closing_the_document_stops_its_redraw() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let Some(mut g) = gpu_app() else { return };
+    let doc = cpu_only_document(g.harness.state_mut(), 4096, 3072);
+    g.harness.step();
+    assert!(g.harness.state().redraws.contains_key(&doc));
+    g.harness.state_mut().run("file.close", json!({"save": false})).expect("close");
+    g.harness.step();
+    assert!(g.harness.state().redraws.is_empty());
+}
diff --git a/crates/ui-egui/src/blur_pins.rs b/crates/ui-egui/src/blur_pins.rs
new file mode 100644
index 0000000000..6a90d9910a
--- /dev/null
+++ b/crates/ui-egui/src/blur_pins.rs
@@ -0,0 +1,311 @@
+//! Filter › Blur Gallery › Field Blur… as Photoshop's workspace (#3373): pins on the image, each
+//! with its own blur, interpolated between them. While the dialog is open the image under it takes
+//! the pointer: a click on the image adds a pin (and selects it), a drag moves a pin, and a drag on
+//! the selected pin's ring turns its blur up or down (one turn = the full 0–500 px; the arc shows
+//! the amount). Delete or Backspace removes the selected pin. The dialog shows the selected pin's
+//! Blur and the Preview switch; OK runs `filter.blurGallery.fieldBlur` with the `pins`.
+//!
+//! Everything lives in the dialog's fields, so automation drives it with `ui.dialog.set`: `pins`
+//! (`[{x, y, blur}]`, x and y as fractions of the filter's bounds) and `__selected`. The bounds are
+//! the engine's: the selection's when there is one, else the canvas.
+
+use egui::{Color32, Pos2, Stroke, vec2};
+use serde_json::{Map, Value, json};
+
+use crate::PhotocraftApp;
+use crate::canvas::ViewXform;
+
+pub const COMMAND: &str = "filter.blurGallery.fieldBlur";
+/// Field Blur's range, in pixels.
+const MAX_BLUR: f64 = 500.0;
+/// Photoshop's first pin.
+const DEFAULT_BLUR: f64 = 15.0;
+/// More pins than anyone places by hand; keeps the params and the per-pixel loop bounded.
+pub const MAX_PINS: usize = 64;
+/// Screen radii (points): the pin's dot, how near a press must be to grab it, and its ring.
+const DOT: f32 = 5.0;
+const GRAB: f32 = 9.0;
+const RING: f32 = 24.0;
+const RING_BAND: f32 = 5.0;
+
+pub fn owns(fields: &Map<String, Value>) -> bool {
+    fields.get("__command").and_then(Value::as_str) == Some(COMMAND)
+}
+
+/// Turn a freshly opened Field Blur dialog into the workspace: one pin in the middle of the
+/// filter's bounds with the remembered blur, selected.
+pub fn init(app: &mut PhotocraftApp, fields: &mut Map<String, Value>) {
+    reset(fields);
+    let bounds = app.session.active().map(|st| (st.doc.id, st.doc.bounds(), st.doc.selection.clone()));
+    if let Some((doc, canvas, selection)) = bounds {
+        let b = selection.map(|s| app.cached_bounds(u64::MAX - doc.0, &s)).filter(|b| !b.is_empty()).unwrap_or(canvas);
+        fields.insert("__bounds".into(), json!([b.x0, b.y0, b.x1, b.y1]));
+    }
+}
+
+/// One pin in the middle with the dialog's blur, selected. Alt+Cancel (Reset) runs this alone, so
+/// the bounds captured on opening stay.
+pub fn reset(fields: &mut Map<String, Value>) {
+    let blur = fields.get("blur").and_then(Value::as_f64).filter(|b| b.is_finite()).unwrap_or(DEFAULT_BLUR).clamp(0.0, MAX_BLUR);
+    fields.remove("centerX");
+    fields.remove("centerY");
+    fields.insert("blur".into(), json!(blur));
+    fields.insert("pins".into(), json!([{"x": 0.5, "y": 0.5, "blur": blur}]));
+    fields.insert("__selected".into(), json!(0));
+}
+
+/// Where the dialog first opens (offset from the window's top-left): at the right edge, beside the
+/// image, as Photoshop docks its Blur Tools panel, so the pins under it stay in view. Moved, it
+/// reopens where it was left, like any dialog.
+pub fn first_place(fields: &Map<String, Value>, ctx: &egui::Context) -> Option<egui::Vec2> {
+    owns(fields).then(|| vec2((ctx.content_rect().width() - 480.0).max(0.0), 96.0))
+}
+
+/// One pin: position as fractions of the bounds, blur in pixels.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Pin {
+    pub x: f64,
+    pub y: f64,
+    pub blur: f64,
+}
+
+/// The pins in `fields`, cleaned (finite, in range, at most [`MAX_PINS`]).
+pub fn pins(fields: &Map<String, Value>) -> Vec<Pin> {
+    let Some(list) = fields.get("pins").and_then(Value::as_array) else { return Vec::new() };
+    let num = |v: &Value, k: &str, d: f64| v.get(k).and_then(Value::as_f64).filter(|x| x.is_finite()).unwrap_or(d);
+    list.iter()
+        .take(MAX_PINS)
+        .map(|v| Pin { x: num(v, "x", 0.5).clamp(0.0, 1.0), y: num(v, "y", 0.5).clamp(0.0, 1.0), blur: num(v, "blur", DEFAULT_BLUR).clamp(0.0, MAX_BLUR) })
+        .collect()
+}
+
+fn set_pins(fields: &mut Map<String, Value>, pins: &[Pin]) {
+    let list: Vec<Value> = pins.iter().map(|p| json!({"x": p.x, "y": p.y, "blur": p.blur})).collect();
+    fields.insert("pins".into(), Value::Array(list));
+}
+
+/// The selected pin's index, if it exists.
+pub fn selected(fields: &Map<String, Value>) -> Option<usize> {
+    let n = pins(fields).len();
+    fields.get("__selected").and_then(Value::as_u64).map(|i| i as usize).filter(|i| *i < n)
+}
+
+fn select(fields: &mut Map<String, Value>, i: Option<usize>) {
+    fields.insert("__selected".into(), i.map_or(Value::Null, |i| json!(i)));
+    // The dialog's Blur (remembered for the next Field Blur) follows the selected pin.
+    if let Some(p) = i.and_then(|i| pins(fields).get(i).copied()) {
+        fields.insert("blur".into(), json!(p.blur));
+    }
+}
+
+/// The filter's bounds in document pixels `[x0, y0, x1, y1]`.
+fn bounds(fields: &Map<String, Value>) -> Option<[f64; 4]> {
+    let b = fields.get("__bounds")?.as_array()?;
+    let v = |i: usize| b.get(i).and_then(Value::as_f64);
+    let r = [v(0)?, v(1)?, v(2)?, v(3)?];
+    (r[2] > r[0] && r[3] > r[1]).then_some(r)
+}
+
+fn to_doc(b: [f64; 4], p: Pin) -> [f64; 2] {
+    [b[0] + p.x * (b[2] - b[0]), b[1] + p.y * (b[3] - b[1])]
+}
+
+fn from_doc(b: [f64; 4], d: [f64; 2]) -> (f64, f64) {
+    (((d[0] - b[0]) / (b[2] - b[0])).clamp(0.0, 1.0), ((d[1] - b[1]) / (b[3] - b[1])).clamp(0.0, 1.0))
+}
+
+/// Remove the selected pin; the one before it (or the new first) is selected.
+pub fn remove_selected(fields: &mut Map<String, Value>) -> bool {
+    let Some(i) = selected(fields) else { return false };
+    let mut list = pins(fields);
+    list.remove(i);
+    set_pins(fields, &list);
+    select(fields, if list.is_empty() { None } else { Some(i.saturating_sub(1)) });
+    true
+}
+
+/// The dialog body: the selected pin's Blur, how to place pins, and Preview.
+pub fn body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
+    let t = crate::theme::Tokens::get(ui.ctx());
+    match selected(f) {
+        Some(i) => {
+            let mut list = pins(f);
+            if let Some(pin) = list.get_mut(i) {
+                let mut v = pin.blur as f32;
+                if crate::widgets::slider_row(ui, tl!("Blur"), &mut v, 0.0..=MAX_BLUR as f32, "px", None).changed() {
+                    pin.blur = f64::from(v.round()).clamp(0.0, MAX_BLUR);
+                    set_pins(f, &list);
+                    select(f, Some(i));
+                }
+            }
+        }
+        None => {
+            ui.label(egui::RichText::new(tl!("No pin selected")).color(t.text_dim));
+        }
+    }
+    ui.add_space(4.0);
+    ui.add(
+        egui::Label::new(
+            egui::RichText::new(tl!("Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin."))
+                .color(t.text_dim)
+                .size(11.5),
+        )
+        .wrap(),
+    );
+    // Delete removes the selected pin, unless a field is being typed in.
+    let typing = ui.ctx().memory(|m| m.focused().is_some());
+    if !typing && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Delete) || i.consume_key(egui::Modifiers::NONE, egui::Key::Backspace)) {
+        remove_selected(f);
+        ui.ctx().request_repaint();
+    }
+    if let Some(mut preview) = f.get("__preview").and_then(Value::as_bool) {
+        ui.add_space(4.0);
+        crate::widgets::checkbox(ui, &mut preview, tl!("Preview"));
+        f.insert("__preview".into(), json!(preview));
+    }
+}
+
+/// What a press at screen point `at` grabs: the selected pin's ring, a pin, or nothing (a new pin).
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Grab {
+    Ring(usize),
+    Pin(usize),
+    New,
+}
+
+fn grab(fields: &Map<String, Value>, xf: &ViewXform, at: Pos2) -> Grab {
+    let Some(b) = bounds(fields) else { return Grab::New };
+    let list = pins(fields);
+    let screen = |p: Pin| {
+        let d = to_doc(b, p);
+        xf.to_screen(d[0] as f32, d[1] as f32)
+    };
+    if let Some(i) = selected(fields)
+        && let Some(p) = list.get(i)
+        && (screen(*p).distance(at) - RING).abs() <= RING_BAND
+    {
+        return Grab::Ring(i);
+    }
+    list.iter()
+        .enumerate()
+        .map(|(i, p)| (i, screen(*p).distance(at)))
+        .filter(|(_, d)| *d <= GRAB)
+        .min_by(|a, b| a.1.total_cmp(&b.1))
+        .map_or(Grab::New, |(i, _)| Grab::Pin(i))
+}
+
+/// The pointer on the free image under the dialog: `over` is where it is, `press` where the
+/// primary button is held (`dialogs::free_press`), both in screen points. Returns whether the
+/// workspace took it.
+pub fn canvas(app: &mut PhotocraftApp, ctx: &egui::Context, xf: &ViewXform, over: Pos2, press: Option<Pos2>) -> bool {
+    let Some(d) = app.ui.dialogs.last_mut().filter(|d| owns(&d.fields)) else { return false };
+    let f = &mut d.fields;
+    let Some(b) = bounds(f) else { return false };
+    let (start, down) = ctx.input(|i| (i.pointer.primary_pressed(), i.pointer.primary_down()));
+    ctx.set_cursor_icon(match grab(f, xf, over) {
+        Grab::Ring(_) => egui::CursorIcon::Alias,
+        Grab::Pin(_) => egui::CursorIcon::Grab,
+        Grab::New => egui::CursorIcon::Crosshair,
+    });
+    if !down && press.is_none() {
+        f.remove("__drag");
+        return true;
+    }
+    let Some(at) = press else { return true };
+    let doc = xf.to_doc(at);
+    let mut list = pins(f);
+    if start {
+        let drag = match grab(f, xf, at) {
+            Grab::Ring(i) => {
+                let c = list.get(i).map(|p| to_doc(b, *p)).unwrap_or(doc);
+                json!({"ring": i, "angle": (doc[1] - c[1]).atan2(doc[0] - c[0])})
+            }
+            Grab::Pin(i) => {
+                select(f, Some(i));
+                let c = list.get(i).map(|p| to_doc(b, *p)).unwrap_or(doc);
+                json!({"pin": i, "dx": c[0] - doc[0], "dy": c[1] - doc[1]})
+            }
+            Grab::New if list.len() < MAX_PINS && (b[0]..=b[2]).contains(&doc[0]) && (b[1]..=b[3]).contains(&doc[1]) => {
+                // A new pin takes the selected pin's blur, as the dialog's Blur shows it.
+                let blur = f.get("blur").and_then(Value::as_f64).filter(|v| v.is_finite()).unwrap_or(DEFAULT_BLUR).clamp(0.0, MAX_BLUR);
+                let (x, y) = from_doc(b, doc);
+                list.push(Pin { x, y, blur });
+                set_pins(f, &list);
+                select(f, Some(list.len() - 1));
+                json!({"pin": list.len() - 1, "dx": 0.0, "dy": 0.0})
+            }
+            Grab::New => return true,
+        };
+        f.insert("__drag".into(), drag);
+        ctx.request_repaint();
+        return true;
+    }
+    let Some(drag) = f.get("__drag").cloned() else { return true };
+    if let Some(i) = drag.get("pin").and_then(Value::as_u64).map(|i| i as usize)
+        && let Some(p) = list.get_mut(i)
+    {
+        let num = |k: &str| drag.get(k).and_then(Value::as_f64).unwrap_or(0.0);
+        (p.x, p.y) = from_doc(b, [doc[0] + num("dx"), doc[1] + num("dy")]);
+        set_pins(f, &list);
+    } else if let Some(i) = drag.get("ring").and_then(Value::as_u64).map(|i| i as usize)
+        && let Some(p) = list.get_mut(i)
+    {
+        // The angle turned since the last frame, the short way round: clockwise raises the blur.
+        let c = to_doc(b, *p);
+        let a = (doc[1] - c[1]).atan2(doc[0] - c[0]);
+        let last = drag.get("angle").and_then(Value::as_f64).unwrap_or(a);
+        let turn = (a - last + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI;
+        p.blur = (p.blur + turn / std::f64::consts::TAU * MAX_BLUR).clamp(0.0, MAX_BLUR);
+        set_pins(f, &list);
+        select(f, Some(i));
+        f.insert("__drag".into(), json!({"ring": i, "angle": a}));
+    }
+    ctx.request_repaint();
+    true
+}
+
+/// Draw the pins over the image while the workspace is open: a dot per pin (filled when
+/// selected) and, round the selected one, its ring with the blur as an arc from the top.
+pub fn draw(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform) {
+    let Some(d) = app.ui.dialogs.last().filter(|d| owns(&d.fields)) else { return };
+    let Some(b) = bounds(&d.fields) else { return };
+    let sel = selected(&d.fields);
+    let (dark, light) = (Stroke::new(3.0, Color32::from_black_alpha(150)), Stroke::new(1.5, Color32::from_white_alpha(235)));
+    for (i, p) in pins(&d.fields).into_iter().enumerate() {
+        let c = to_doc(b, p);
+        let c = xf.to_screen(c[0] as f32, c[1] as f32);
+        if sel == Some(i) {
+            painter.circle_stroke(c, RING, dark);
+            painter.circle_stroke(c, RING, Stroke::new(1.0, Color32::from_white_alpha(140)));
+            let frac = (p.blur / MAX_BLUR) as f32;
+            let steps = (frac * 64.0).ceil().max(1.0) as usize;
+            let arc: Vec<Pos2> = (0..=steps)
+                .map(|k| {
+                    let a = -std::f32::consts::FRAC_PI_2 + std::f32::consts::TAU * frac * k as f32 / steps as f32;
+                    c + vec2(a.cos(), a.sin()) * RING
+                })
+                .collect();
+            if frac > 0.0 {
+                painter.add(egui::Shape::line(arc.clone(), Stroke::new(4.5, Color32::from_black_alpha(150))));
+                painter.add(egui::Shape::line(arc, Stroke::new(2.5, Color32::WHITE)));
+            }
+            painter.circle(c, DOT, Color32::WHITE, Stroke::new(1.0, Color32::from_black_alpha(180)));
+        } else {
+            painter.circle_stroke(c, DOT, dark);
+            painter.circle_stroke(c, DOT, light);
+        }
+    }
+}
+
+/// Preview proxies run at 1/`k` of the document: the pins' pixel blur scales with them.
+pub fn scale_for_proxy(params: &mut Value, k: u32) {
+    if k <= 1 {
+        return;
+    }
+    let Some(list) = params.get_mut("pins").and_then(Value::as_array_mut) else { return };
+    for pin in list {
+        if let Some(b) = pin.get("blur").and_then(Value::as_f64) {
+            pin["blur"] = json!(b / f64::from(k));
+        }
+    }
+}
diff --git a/crates/ui-egui/src/blur_pins_tests.rs b/crates/ui-egui/src/blur_pins_tests.rs
new file mode 100644
index 0000000000..33a691d3d8
--- /dev/null
+++ b/crates/ui-egui/src/blur_pins_tests.rs
@@ -0,0 +1,193 @@
+//! #3373: Field Blur's pins are placed, dragged and tuned on the image under the dialog, the
+//! preview follows them, and OK applies them.
+
+use egui::{Modifiers, PointerButton, Pos2, pos2, vec2};
+use egui_kittest::Harness;
+use serde_json::json;
+
+use crate::PhotocraftApp;
+use crate::blur_pins::{COMMAND, Pin, pins, selected};
+use crate::canvas::ViewXform;
+
+/// A 400×300 document at 400 %, so it fills the window round the dialog, with Field Blur open.
+fn harness(selection: bool) -> Harness<'static, PhotocraftApp> {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+    if selection {
+        app.run("select.rect", json!({"x": 100, "y": 50, "width": 200, "height": 100})).unwrap();
+    }
+    app.sync_views();
+    app.ui.extras.rulers = false;
+    let mut h = Harness::builder().with_size(vec2(1200.0, 800.0)).build_ui_state(
+        |ui, app: &mut PhotocraftApp| {
+            let ctx = ui.ctx().clone();
+            if !ctx.fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                return;
+            }
+            crate::shortcuts::handle(app, &ctx);
+            egui::CentralPanel::default().show(ui, |ui| crate::canvas::document_area(app, ui));
+            crate::dialogs::show(app, &ctx);
+        },
+        app,
+    );
+    PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+    h.run_steps(4);
+    let v = &mut h.state_mut().ui.views[0];
+    (v.zoom, v.center, v.fit_pending) = (4.0, [200.0, 150.0], false);
+    crate::filter_dialog::open(h.state_mut(), COMMAND).unwrap();
+    h.run_steps(4);
+    h
+}
+
+fn fields(h: &Harness<'static, PhotocraftApp>) -> serde_json::Map<String, serde_json::Value> {
+    h.state().ui.dialogs.last().unwrap().fields.clone()
+}
+
+fn xf(h: &Harness<'static, PhotocraftApp>) -> ViewXform {
+    let app = h.state();
+    let v = &app.ui.views[0];
+    ViewXform {
+        rect: crate::rulers::content_rect(app, app.last_canvas_rect),
+        zoom: v.zoom,
+        center: v.center,
+        flip: false,
+        rotation: v.rotation,
+        aspect: app.ui.view.display_aspect(),
+    }
+}
+
+fn button(h: &mut Harness<'static, PhotocraftApp>, p: Pos2, down: bool) {
+    h.event(egui::Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: down, modifiers: Modifiers::NONE });
+    h.run_steps(1);
+}
+
+fn move_to(h: &mut Harness<'static, PhotocraftApp>, p: Pos2) {
+    h.event(egui::Event::PointerMoved(p));
+    h.run_steps(1);
+}
+
+fn drag(h: &mut Harness<'static, PhotocraftApp>, path: &[Pos2]) {
+    move_to(h, path[0]);
+    button(h, path[0], true);
+    for p in &path[1..] {
+        move_to(h, *p);
+    }
+    button(h, *path.last().unwrap(), false);
+    h.run_steps(2);
+}
+
+/// Where pin `p` is on screen.
+fn on_screen(h: &Harness<'static, PhotocraftApp>, p: Pin, bounds: [f64; 4]) -> Pos2 {
+    let (x, y) = (bounds[0] + p.x * (bounds[2] - bounds[0]), bounds[1] + p.y * (bounds[3] - bounds[1]));
+    xf(h).to_screen(x as f32, y as f32)
+}
+
+#[test]
+fn it_opens_with_one_selected_pin_in_the_middle_of_the_bounds() {
+    let h = harness(false);
+    let f = fields(&h);
+    assert_eq!(pins(&f), vec![Pin { x: 0.5, y: 0.5, blur: 15.0 }]);
+    assert_eq!(selected(&f), Some(0));
+    assert_eq!(f["__bounds"], json!([0, 0, 400, 300]));
+    assert!(!f.contains_key("centerX") && !f.contains_key("centerY"), "the pins replace the single centre");
+    // With a selection the pins are fractions of its bounds, as the engine reads them.
+    let h = harness(true);
+    assert_eq!(fields(&h)["__bounds"], json!([100, 50, 300, 150]));
+}
+
+#[test]
+fn pins_are_added_moved_tuned_and_removed_on_the_image() {
+    let mut h = harness(false);
+    let r = h.state().last_canvas_rect;
+    // A click on the free image (left of the dialog) adds a pin there, selected.
+    let a = pos2(r.left() + 80.0, r.bottom() - 80.0);
+    move_to(&mut h, a);
+    button(&mut h, a, true);
+    button(&mut h, a, false);
+    h.run_steps(2);
+    let f = fields(&h);
+    let list = pins(&f);
+    assert_eq!(list.len(), 2, "{list:?}");
+    assert_eq!(selected(&f), Some(1));
+    let at = xf(&h).to_doc(a);
+    assert!((list[1].x - at[0] / 400.0).abs() < 1e-3 && (list[1].y - at[1] / 300.0).abs() < 1e-3, "{:?} vs {at:?}", list[1]);
+    assert_eq!(list[1].blur, 15.0, "a new pin takes the selected pin's blur");
+    // Dragging the pin moves it by the pointer's movement (4 screen points per pixel at 400 %).
+    let b = a + vec2(40.0, -20.0);
+    drag(&mut h, &[a, a + vec2(20.0, -10.0), b]);
+    let moved = pins(&fields(&h))[1];
+    assert!((moved.x - (list[1].x + 10.0 / 400.0)).abs() < 1e-3 && (moved.y - (list[1].y - 5.0 / 300.0)).abs() < 1e-3, "{moved:?}");
+    assert!(fields(&h).get("__drag").is_none(), "the drag ends on release");
+    // A quarter turn clockwise on its ring adds a quarter of the 0–500 px range.
+    let c = on_screen(&h, moved, [0.0, 0.0, 400.0, 300.0]);
+    let ring: Vec<Pos2> = (0..=6).map(|k| c + vec2(24.0 * (k as f32 * 0.2618).cos(), 24.0 * (k as f32 * 0.2618).sin())).collect();
+    drag(&mut h, &ring);
+    let tuned = pins(&fields(&h))[1];
+    assert!((tuned.blur - 140.0).abs() < 2.0, "15 + 125 px: {}", tuned.blur);
+    assert!((tuned.x - moved.x).abs() < 1e-9, "the ring doesn't move the pin");
+    assert_eq!(fields(&h)["blur"], json!(tuned.blur), "the dialog's Blur follows the selected pin");
+    // The preview runs the filter with the pins (computed by the canvas's GPU path in the app;
+    // asked for directly here, as the headless harness has no GPU).
+    assert!(crate::canvas::ensure_filter_preview(h.state_mut(), 0, &egui::Context::default()).is_some());
+    let preview = h.state().filter_preview.as_ref().expect("a live preview");
+    assert_eq!(preview.key.params["pins"].as_array().map(Vec::len), Some(2));
+    // Delete removes the selected pin; OK applies the rest in one step.
+    h.key_press(egui::Key::Delete);
+    h.run_steps(2);
+    assert_eq!(pins(&fields(&h)).len(), 1);
+    assert_eq!(selected(&fields(&h)), Some(0));
+    let id = h.state().ui.dialogs.last().unwrap().id;
+    let steps = h.state().session.active().unwrap().history.past_len();
+    crate::dialogs::confirm(h.state_mut(), id).unwrap();
+    let (cmd, p) = h.state().session.journal.last().cloned().unwrap();
+    assert_eq!(cmd, COMMAND);
+    assert_eq!(p["pins"], json!([{"x": 0.5, "y": 0.5, "blur": 15.0}]), "{p}");
+    assert_eq!(h.state().session.active().unwrap().history.past_len(), steps + 1);
+}
+
+/// A click outside the bounds (beside a selection) adds no pin; pins are capped.
+#[test]
+fn pins_stay_inside_the_bounds_and_are_capped() {
+    let mut h = harness(true);
+    let r = h.state().last_canvas_rect;
+    let outside = pos2(r.left() + 30.0, r.top() + 30.0);
+    assert!(xf(&h).to_doc(outside)[0] < 100.0, "left of the selection");
+    move_to(&mut h, outside);
+    button(&mut h, outside, true);
+    button(&mut h, outside, false);
+    h.run_steps(2);
+    assert_eq!(pins(&fields(&h)).len(), 1);
+    let many: Vec<_> = (0..200).map(|i| json!({"x": f64::from(i) / 200.0, "y": 0.5, "blur": 1e9})).collect();
+    h.state_mut().ui.dialogs.last_mut().unwrap().fields.insert("pins".into(), json!(many));
+    let list = pins(&fields(&h));
+    assert_eq!(list.len(), crate::blur_pins::MAX_PINS);
+    assert!(list.iter().all(|p| p.blur == 500.0));
+}
+
+#[test]
+fn proxy_previews_scale_the_pins_blur() {
+    let mut p = json!({"pins": [{"x": 0.2, "y": 0.3, "blur": 40.0}, {"x": 0.9, "y": 0.9, "blur": 0.0}]});
+    crate::blur_pins::scale_for_proxy(&mut p, 4);
+    assert_eq!(p, json!({"pins": [{"x": 0.2, "y": 0.3, "blur": 10.0}, {"x": 0.9, "y": 0.9, "blur": 0.0}]}));
+    crate::blur_pins::scale_for_proxy(&mut p, 1);
+    assert_eq!(p["pins"][0]["blur"], json!(10.0));
+}
+
+/// Alt+Cancel → Reset (#3871) starts the workspace again from one pin in the middle, as when it
+/// opened, instead of leaving it with no pins; the bounds captured on opening stay.
+#[test]
+fn alt_reset_starts_again_from_one_pin() {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+    let id = crate::filter_dialog::open(&mut app, COMMAND).unwrap();
+    let mut fields = app.ui.dialog_mut(id).unwrap().fields.clone();
+    let bounds = fields["__bounds"].clone();
+    fields.insert("pins".into(), json!([{"x": 0.1, "y": 0.2, "blur": 40.0}, {"x": 0.8, "y": 0.7, "blur": 90.0}]));
+    fields.insert("__selected".into(), json!(1));
+    assert!(crate::dialog_alt_reset::supported(&fields));
+    crate::dialog_alt_reset::apply(&mut app, &egui::Context::default(), &mut fields);
+    assert_eq!(pins(&fields), [Pin { x: 0.5, y: 0.5, blur: 15.0 }]);
+    assert_eq!(selected(&fields), Some(0));
+    assert_eq!(fields["__bounds"], bounds);
+    assert!(!fields.contains_key("centerX") && !fields.contains_key("centerY"), "{fields:?}");
+}
diff --git a/crates/ui-egui/src/brush_cursor.rs b/crates/ui-egui/src/brush_cursor.rs
index 2cb30806aa..49c444c154 100644
--- a/crates/ui-egui/src/brush_cursor.rs
+++ b/crates/ui-egui/src/brush_cursor.rs
@@ -42,11 +42,25 @@ impl Key {
     }
 }
 
-/// The brush cursor at `at`. `radius` is the tip's screen radius (size / 2 at the current zoom);
-/// `normal` is Preferences › Cursors "Normal Brush Tip" (the 50 % contour, not the full tip).
-pub(crate) fn cursor(painter: &Painter, at: Pos2, brush: &BrushSettings, radius: f32, normal: bool, centre: bool) -> CursorIcon {
+/// The screen vectors of one tip radius (`size / 2` document pixels) along the document's x and
+/// y axes: the view's zoom, rotation, flip and pixel aspect, which the outline follows as the
+/// stroke does.
+pub(crate) fn tip_axes(xf: &crate::canvas::ViewXform, size: f32) -> [Vec2; 2] {
+    let r = if size.is_finite() { size.max(0.0) / 2.0 } else { 0.0 };
+    [xf.map_vec(Vec2::new(r, 0.0)), xf.map_vec(Vec2::new(0.0, r))]
+}
+
+/// Rings in radius units (document orientation) on screen, through [`tip_axes`].
+fn on_screen(rings: &[Vec<[f32; 2]>], axes: [Vec2; 2]) -> Vec<Vec<Vec2>> {
+    rings.iter().map(|r| r.iter().map(|p| axes[0] * p[0] + axes[1] * p[1]).collect()).collect()
+}
+
+/// The brush cursor at `at`. `radius` is the tip's screen radius (size / 2 at the current zoom),
+/// for the plain circle; `axes` comes from [`tip_axes`], for a traced outline. `normal` is
+/// Preferences › Cursors "Normal Brush Tip" (the 50 % contour, not the full tip).
+pub(crate) fn cursor(painter: &Painter, at: Pos2, brush: &BrushSettings, radius: f32, axes: [Vec2; 2], normal: bool, centre: bool) -> CursorIcon {
     if let Some(rings) = rings(painter.ctx(), brush, !normal) {
-        let pts: Vec<Vec<Vec2>> = rings.iter().map(|r| r.iter().map(|p| Vec2::new(p[0], p[1]) * radius).collect()).collect();
+        let pts = on_screen(&rings, axes);
         let extent = pts.iter().flatten().fold(0.0f32, |m, p| m.max(p.length()));
         if extent < MIN_RADIUS {
             return crate::tool_cursor::crosshair(painter, at, 4.0, 0.0);
@@ -59,7 +73,7 @@ pub(crate) fn cursor(painter: &Painter, at: Pos2, brush: &BrushSettings, radius:
 
 /// The tip outline in radius units, cached across frames; `None` when the plain circle says it all
 /// (a plain round tip) or the tip has no traceable shape.
-fn rings(ctx: &egui::Context, brush: &BrushSettings, full: bool) -> Option<Arc<Vec<Vec<[f32; 2]>>>> {
+pub(crate) fn rings(ctx: &egui::Context, brush: &BrushSettings, full: bool) -> Option<Arc<Vec<Vec<[f32; 2]>>>> {
     if matches!(brush.tip, TipShape::Round) && brush.angle == 0.0 && brush.roundness >= 1.0 {
         return None;
     }
@@ -73,3 +87,111 @@ fn rings(ctx: &egui::Context, brush: &BrushSettings, full: bool) -> Option<Arc<V
     ctx.data_mut(|d| d.insert_temp(id, Cached { key: Key::of(brush, full), rings: traced.clone() }));
     traced
 }
+
+/// Which texels of the document-pixel `rect` (`x0, y0, x1, y1`, row-major) lie inside the tip
+/// `rings` (radius units, even-odd so holes stay clear) when the tip is centred on `at` with
+/// `radius` document pixels. The Clone Source overlay uses it to clip to a shaped tip.
+pub(crate) fn tip_mask(rings: &[Vec<[f32; 2]>], at: [f64; 2], radius: f64, rect: [i32; 4]) -> Vec<bool> {
+    let [x0, y0, x1, y1] = rect;
+    let (w, h) = (usize::try_from(x1 - x0).unwrap_or(0), usize::try_from(y1 - y0).unwrap_or(0));
+    let mut mask = vec![false; w.saturating_mul(h)];
+    let mut hits: Vec<f64> = Vec::new();
+    for row in 0..h {
+        let y = f64::from(y0) + row as f64 + 0.5;
+        hits.clear();
+        for ring in rings {
+            for (i, a) in ring.iter().enumerate() {
+                let Some(b) = ring.get((i + 1) % ring.len()) else { continue };
+                let (ax, ay) = (at[0] + f64::from(a[0]) * radius, at[1] + f64::from(a[1]) * radius);
+                let (bx, by) = (at[0] + f64::from(b[0]) * radius, at[1] + f64::from(b[1]) * radius);
+                if (ay <= y) != (by <= y) {
+                    hits.push(ax + (y - ay) / (by - ay) * (bx - ax));
+                }
+            }
+        }
+        hits.sort_by(f64::total_cmp);
+        for pair in hits.chunks(2) {
+            let [a, b] = pair else { continue };
+            let (from, to) = (a - f64::from(x0) - 0.5, b - f64::from(x0) - 0.5);
+            let start = from.ceil().max(0.0) as usize;
+            let end = ((to.floor() + 1.0).max(0.0) as usize).min(w);
+            for x in start..end {
+                if let Some(m) = mask.get_mut(row * w + x) {
+                    *m = true;
+                }
+            }
+        }
+    }
+    mask
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::canvas::ViewXform;
+    use egui::{Rect, pos2};
+
+    fn view(rotation: f32, flip: bool, aspect: f32) -> ViewXform {
+        ViewXform { rect: Rect::from_min_size(pos2(0.0, 0.0), egui::vec2(400.0, 300.0)), zoom: 2.0, center: [50.0, 40.0], flip, rotation, aspect }
+    }
+
+    fn close(a: Vec2, b: Vec2) -> bool {
+        (a - b).length() < 1e-4
+    }
+
+    /// The axes are the screen offsets of the document points one radius right of and below the
+    /// pointer, whatever the view does.
+    #[test]
+    fn tip_axes_follow_the_view_like_to_screen() {
+        for (rotation, flip, aspect) in [(0.0, false, 1.0), (30.0, false, 1.0), (-90.0, true, 1.0), (45.0, true, 2.0), (200.0, false, 0.5)] {
+            let xf = view(rotation, flip, aspect);
+            let [ex, ey] = tip_axes(&xf, 20.0);
+            let o = xf.to_screen(60.0, 30.0);
+            assert!(close(ex, xf.to_screen(70.0, 30.0) - o), "x axis at {rotation}°, flip {flip}, aspect {aspect}");
+            assert!(close(ey, xf.to_screen(60.0, 40.0) - o), "y axis at {rotation}°, flip {flip}, aspect {aspect}");
+        }
+    }
+
+    /// An unrotated, unflipped view gives what upstream's radius scaling gave.
+    #[test]
+    fn a_plain_view_scales_the_outline_by_the_screen_radius() {
+        let rings = vec![vec![[1.0, 0.0], [0.0, 0.5], [-1.0, 0.0]]];
+        let pts = on_screen(&rings, tip_axes(&view(0.0, false, 1.0), 20.0));
+        let want = [Vec2::new(20.0, 0.0), Vec2::new(0.0, 10.0), Vec2::new(-20.0, 0.0)];
+        assert!(pts[0].iter().zip(want).all(|(a, b)| close(*a, b)), "{pts:?}");
+    }
+
+    /// A tip pointing along the document's x axis points down the screen in a view turned 90°,
+    /// and left in a flipped one.
+    #[test]
+    fn the_outline_turns_and_flips_with_the_view() {
+        let rings = vec![vec![[1.0, 0.0]]];
+        let turned = on_screen(&rings, tip_axes(&view(90.0, false, 1.0), 20.0));
+        assert!(close(turned[0][0], Vec2::new(0.0, 20.0)), "{turned:?}");
+        let flipped = on_screen(&rings, tip_axes(&view(0.0, true, 1.0), 20.0));
+        assert!(close(flipped[0][0], Vec2::new(-20.0, 0.0)), "{flipped:?}");
+    }
+
+    #[test]
+    fn hostile_sizes_give_finite_axes() {
+        for size in [f32::NAN, f32::INFINITY, -5.0, 0.0] {
+            let [ex, ey] = tip_axes(&view(30.0, true, 1.0), size);
+            assert!(ex.x.is_finite() && ex.y.is_finite() && ey.x.is_finite() && ey.y.is_finite(), "size {size}");
+        }
+    }
+
+    /// The overlay clip follows the tip: a square ring covers its own texels, a hole stays clear,
+    /// and a rotated flat tip leaves the corners of the brush square outside.
+    #[test]
+    fn tip_mask_follows_the_ring_shape() {
+        let square = vec![[-0.5, -0.5], [0.5, -0.5], [0.5, 0.5], [-0.5, 0.5]];
+        let hole = vec![[-0.1, -0.1], [0.1, -0.1], [0.1, 0.1], [-0.1, 0.1]];
+        let mask = tip_mask(&[square.clone(), hole], [10.0, 10.0], 10.0, [0, 0, 20, 20]);
+        let at = |x: usize, y: usize| mask[y * 20 + x];
+        assert!(at(6, 10) && at(14, 10) && at(10, 6) && at(10, 14), "inside the square");
+        assert!(!at(3, 10) && !at(10, 16) && !at(0, 0), "outside the square");
+        assert!(!at(10, 10) && at(8, 10), "the hole is clear");
+        assert_eq!(mask.iter().filter(|m| **m).count(), 10 * 10 - 2 * 2, "10x10 square minus the 2x2 hole");
+        assert!(tip_mask(&[square], [10.0, 10.0], 10.0, [5, 5, 5, 9]).is_empty(), "an empty rect is harmless");
+    }
+}
diff --git a/crates/ui-egui/src/brush_panel.rs b/crates/ui-egui/src/brush_panel.rs
index c0e877ef6d..515e6e5a21 100644
--- a/crates/ui-egui/src/brush_panel.rs
+++ b/crates/ui-egui/src/brush_panel.rs
@@ -1,7 +1,7 @@
 //! Window › Brush Settings (F5) and Window › Brushes: Photoshop's floating brush panel.
 //!
-//! Brush Settings: the section list with enable boxes on the left (clicking a name shows and turns
-//! on that section), the selected section's controls on the right (see [`crate::brush_sections`]),
+//! Brush Settings: the section list with enable boxes on the left (clicking a controls section
+//! shows and enables it; the last five rows only toggle), the selected section's controls on the right (see [`crate::brush_sections`]),
 //! and a live stroke preview strip below, rendered with the real brush engine and cached on the
 //! settings (it re-renders only when they change). Brushes: the presets in collapsible groups with
 //! tip thumbnails and stroke previews, a size slider and a search field.
@@ -14,7 +14,7 @@
 //! The lock beside a section name keeps that section's settings when another preset is picked
 //! (`locks` in the brush, applied by the engine). The Brushes tab lives in [`crate::brushes_tab`].
 
-use egui::{Color32, CornerRadius, RichText, Sense, Stroke, vec2};
+use egui::{Color32, CornerRadius, Sense, Stroke, vec2};
 use photocraft_engine::BrushSettings;
 use photocraft_engine::paint;
 use serde::{Deserialize, Serialize};
@@ -41,10 +41,17 @@ pub const SECTIONS: [(&str, bool); 13] = [
     ("Noise", true),
     ("Wet Edges", true),
     ("Build-up", true),
-    ("Smoothing", false),
+    ("Smoothing", true),
     ("Protect Texture", true),
 ];
 
+/// The final five entries are switches, not sections with a properties pane.
+const CHECKBOX_ONLY_START: usize = 8;
+
+fn checkbox_only(section: usize) -> bool {
+    (CHECKBOX_ONLY_START..SECTIONS.len()).contains(&section)
+}
+
 /// Panel width and the stroke strip's size.
 pub(crate) const WIDTH: f32 = 540.0;
 const STRIP: (u32, u32) = (488, 76);
@@ -114,7 +121,7 @@ impl Default for BrushesPanelState {
     }
 }
 
-/// The enable flag behind section `i` (None for Brush Tip Shape and Smoothing).
+/// The enable flag behind section `i` (None for Brush Tip Shape).
 pub fn section_flag(b: &mut BrushSettings, i: usize) -> Option<&mut bool> {
     Some(match i {
         1 => &mut b.shape_dynamics.enabled,
@@ -127,6 +134,7 @@ pub fn section_flag(b: &mut BrushSettings, i: usize) -> Option<&mut bool> {
         8 => &mut b.noise,
         9 => &mut b.wet_edges,
         10 => &mut b.build_up,
+        11 => &mut b.smoothing.enabled,
         12 => &mut b.protect_texture,
         _ => return None,
     })
@@ -233,19 +241,43 @@ pub(crate) fn full_uv() -> egui::Rect {
     egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0))
 }
 
-/// The section list: enable boxes, names, locks, the selection. Clicking a name shows the section
-/// and turns it on (Photoshop); clicking a box only toggles it; the lock on the right keeps the
-/// section when another preset is picked.
+/// Clicking a controls section shows and enables it; the final five rows only toggle, keeping
+/// the current controls open. The lock on the right is a separate hit target.
 fn section_list(app: &mut PhotocraftApp, ui: &mut egui::Ui, b: &mut BrushSettings) {
     let t = Tokens::get(ui.ctx());
     ui.vertical(|ui| {
         ui.set_width(150.0);
         ui.spacing_mut().item_spacing.y = 1.0;
+        let (br_rect, br_resp) = ui.allocate_exact_size(vec2(150.0, 23.0), Sense::click());
+        br_resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, tl!("Brushes")));
+        if br_resp.hovered() {
+            ui.painter().rect_filled(br_rect, t.radius_sm, t.hover);
+        }
+        let icon_rect = egui::Rect::from_center_size(egui::pos2(br_rect.left() + 12.0, br_rect.center().y), vec2(13.0, 13.0));
+        icons::paint(ui, icon_rect, "brush", 12.0, if br_resp.hovered() { t.text } else { t.icon });
+        let galley = ui.painter().layout_no_wrap(tl!("Brushes").to_string(), theme::semibold(12.0), if br_resp.hovered() { t.text } else { t.text_dim });
+        ui.painter().galley(egui::pos2(br_rect.left() + 26.0, br_rect.center().y - galley.size().y / 2.0), galley, t.text);
+        if br_resp.clicked() {
+            let _ = crate::menus::invoke(app, ui.ctx(), "window.panel.brushes", json!({}));
+        }
+        ui.add_space(3.0);
+        widgets::hairline(ui);
+        ui.add_space(3.0);
         for (i, (name, has_box)) in SECTIONS.iter().enumerate() {
-            let sel = app.ui.brush_section == i;
+            let toggle_only = checkbox_only(i);
+            // Group the switches with whitespace, not separators between individual rows.
+            if i == CHECKBOX_ONLY_START {
+                ui.add_space(6.0);
+            }
+            let sel = !toggle_only && app.ui.brush_section == i;
             let (r, resp) = ui.allocate_exact_size(vec2(150.0, 23.0), Sense::click());
             // Named for accessibility and for tests and agents that look sections up by name.
-            resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::SelectableLabel, true, sel, tl!(*name)));
+            if toggle_only {
+                let checked = section_flag(b, i).is_some_and(|flag| *flag);
+                resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Checkbox, true, checked, tl!(*name)));
+            } else {
+                resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::SelectableLabel, true, sel, tl!(*name)));
+            }
             if sel {
                 ui.painter().rect_filled(r, t.radius_sm, t.accent_soft);
             } else if resp.hovered() {
@@ -254,27 +286,30 @@ fn section_list(app: &mut PhotocraftApp, ui: &mut egui::Ui, b: &mut BrushSetting
             let mut x = r.left() + 6.0;
             if *has_box && let Some(flag) = section_flag(b, i) {
                 let br = egui::Rect::from_center_size(egui::pos2(x + 6.0, r.center().y), vec2(13.0, 13.0));
-                let box_resp = ui.interact(br, ui.id().with(("brush-sec-box", i)), Sense::click());
-                let checked = *flag;
-                box_resp.widget_info(|| {
-                    egui::WidgetInfo::selected(egui::WidgetType::Checkbox, true, checked, crate::i18n::fmt(tl!("Enable {name}"), &[("name", tl!(*name))]))
+                // A checkbox-only row is one accessible checkbox across its whole width. A
+                // controls section keeps its separate enable box and selectable label.
+                let box_resp = (!toggle_only).then(|| {
+                    let resp = ui.interact(br, ui.id().with(("brush-sec-box", i)), Sense::click());
+                    resp.widget_info(|| {
+                        egui::WidgetInfo::selected(egui::WidgetType::Checkbox, true, *flag, crate::i18n::fmt(tl!("Enable {name}"), &[("name", tl!(*name))]))
+                    });
+                    resp
                 });
-                if *flag {
-                    ui.painter().rect_filled(br, 2.0, t.accent);
-                    let (a, m, c) = (br.left_center() + vec2(3.0, 0.5), br.center_bottom() + vec2(-1.0, -3.5), br.right_top() + vec2(-3.0, 3.5));
-                    ui.painter().line_segment([a, m], Stroke::new(1.6, Color32::WHITE));
-                    ui.painter().line_segment([m, c], Stroke::new(1.6, Color32::WHITE));
-                } else {
-                    ui.painter().rect_stroke(br, 2.0, Stroke::new(1.2, t.text_faint), egui::StrokeKind::Inside);
-                }
                 let on_lock = resp.interact_pointer_pos().is_some_and(|p| p.x > r.right() - 22.0);
-                if box_resp.clicked() {
+                // A press on the row (but not its lock) presses the box too: a release there
+                // turns the section on, or toggles a checkbox-only row (#4476).
+                let pressed = box_resp.as_ref().is_some_and(|b| b.is_pointer_button_down_on()) || (resp.is_pointer_button_down_on() && !on_lock);
+                let hovered = box_resp.as_ref().is_some_and(|b| b.hovered()) || (toggle_only && resp.hovered());
+                widgets::check_box(ui.painter(), br, *flag, hovered, pressed, &t);
+                if box_resp.is_some_and(|resp| resp.clicked()) || (toggle_only && resp.clicked() && !on_lock) {
                     *flag = !*flag;
-                } else if resp.clicked() && !on_lock {
+                } else if !toggle_only && resp.clicked() && !on_lock {
                     *flag = true;
                 }
                 x += 20.0;
-            } else if i > 0 {
+            } else {
+                // No box (Brush Tip Shape): the name still starts in the names' column,
+                // as in Photoshop (#4282).
                 x += 20.0;
             }
             let color = if sel { t.text } else { t.text_dim };
@@ -289,11 +324,9 @@ fn section_list(app: &mut PhotocraftApp, ui: &mut egui::Ui, b: &mut BrushSetting
             if let Some(lock) = section_lock(b, i) {
                 let lr = egui::Rect::from_center_size(egui::pos2(r.right() - 11.0, r.center().y), vec2(18.0, 18.0));
                 let lresp = ui.interact(lr, ui.id().with(("brush-sec-lock", i)), Sense::click());
-                // Like Photoshop: the lock shows only when set or hovered.
-                if *lock || resp.hovered() || lresp.hovered() {
-                    let tint = if *lock { t.text } else { t.text_faint };
-                    icons::paint(ui, lr, if *lock { "lock" } else { "lock-open" }, 12.0, tint);
-                }
+                // Like Photoshop: lock icons stay visible on every lockable section row.
+                let tint = if *lock { t.text } else { t.text_faint };
+                icons::paint(ui, lr, if *lock { "lock" } else { "lock-open" }, 12.0, tint);
                 let tip =
                     if *lock { tl!("Unlock: picking a preset replaces these settings") } else { tl!("Lock: keep these settings when picking another preset") };
                 if lresp.on_hover_text(tip).clicked() {
@@ -301,7 +334,7 @@ fn section_list(app: &mut PhotocraftApp, ui: &mut egui::Ui, b: &mut BrushSetting
                     lock_clicked = true;
                 }
             }
-            if resp.clicked() && !lock_clicked {
+            if !toggle_only && resp.clicked() && !lock_clicked {
                 app.ui.brush_section = i;
             }
             if i == 0 {
@@ -315,15 +348,19 @@ fn settings_tab(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let t = Tokens::get(ui.ctx());
     let before = app.session.tools.brush.clone();
     let mut b = before.clone();
-    let section = app.ui.brush_section.min(SECTIONS.len() - 1);
+    // Older UI state and control clients could select any of the 13 entries. Switch rows no
+    // longer have a properties pane, so those selections recover to Brush Tip Shape.
+    if app.ui.brush_section >= CHECKBOX_ONLY_START {
+        app.ui.brush_section = 0;
+    }
+    let section = app.ui.brush_section;
     ui.horizontal_top(|ui| {
         section_list(app, ui, &mut b);
         widgets::vline(ui, 482.0);
         ui.vertical(|ui| {
             ui.set_width(WIDTH - 190.0);
-            let name = SECTIONS.get(section).map_or("Brush Tip Shape", |entry| entry.0);
-            ui.label(RichText::new(tl!(name)).font(theme::semibold(12.5)).color(t.text));
-            ui.add_space(6.0);
+            // No title above the options (#3477): the selected row in the list names them, as
+            // in Photoshop, and the line is better spent on the options.
             let on = section_flag(&mut b, section).is_none_or(|f| *f);
             egui::ScrollArea::vertical().id_salt(("brush-section", section)).max_height(450.0).auto_shrink([false, false]).show(ui, |ui| {
                 ui.set_width(WIDTH - 204.0);
@@ -347,9 +384,9 @@ fn settings_tab(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         let tex = brush_preview::stroke_texture(ui.ctx(), "settings-strip", &b, STRIP.0, STRIP.1, t.text);
         ui.painter().image(tex.id(), r, full_uv(), Color32::WHITE);
         ui.vertical(|ui| {
-            if icons::button(ui, "square-plus", 24.0, false, tl!("Create new brush from these settings")).clicked() {
-                let name = new_preset_name(&app.session.tools.presets);
-                run_or_status(app, "brush.presets.save", json!({ "name": name, "brush": serde_json::to_value(&b).unwrap_or(Value::Null) }));
+            let new = icons::button(ui, "square-plus", 24.0, false, tl!("Create new brush from these settings"));
+            if crate::brush_picker::named(new, "Create new brush from these settings").clicked() {
+                crate::brush_preset_dialog::open(app, Some(&b));
             }
             if icons::button(ui, "undo-2", 24.0, false, tl!("Reset the brush to the defaults")).clicked() {
                 b = BrushSettings { color: b.color, background: b.background, smoothing: b.smoothing.clone(), locks: b.locks.clone(), ..Default::default() };
@@ -368,6 +405,92 @@ fn settings_tab(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     commit_gesture(app, ui.ctx(), &before, &b);
 }
 
+/// Clear brush controls: turns off every section except Smoothing and resets their options
+/// to the defaults (Photoshop), keeping locked sections intact.
+pub fn clear_brush_controls(current: &BrushSettings) -> BrushSettings {
+    let mut b = current.clone();
+    let d = BrushSettings::default();
+    let l = &current.locks;
+    if !l.shape_dynamics {
+        b.shape_dynamics = d.shape_dynamics;
+    }
+    if !l.scattering {
+        b.scattering = d.scattering;
+    }
+    if !l.texture {
+        b.texture = d.texture;
+    }
+    if !l.dual_brush {
+        b.dual_brush = d.dual_brush;
+    }
+    if !l.color_dynamics {
+        b.color_dynamics = d.color_dynamics;
+    }
+    if !l.transfer {
+        b.transfer = d.transfer;
+    }
+    if !l.pose {
+        b.pose = d.pose;
+    }
+    if !l.noise {
+        b.noise = d.noise;
+    }
+    if !l.wet_edges {
+        b.wet_edges = d.wet_edges;
+    }
+    if !l.build_up {
+        b.build_up = d.build_up;
+        b.build_up_rate = d.build_up_rate;
+    }
+    if !l.protect_texture {
+        b.protect_texture = d.protect_texture;
+    }
+    b
+}
+
+/// Copy the current brush's Texture settings to other painting tools that have Texture enabled.
+pub fn copy_texture_to_other_tools(app: &mut PhotocraftApp) {
+    let texture = app.session.tools.brush.texture.clone();
+    for (_, brush) in &mut app.ui.tool_brushes {
+        if brush.texture.enabled {
+            brush.texture = texture.clone();
+        }
+    }
+}
+
+/// The Brush Settings panel menu actions (hamburger menu).
+pub fn panel_menu(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
+    if ui.button(tl!("New Brush Preset…")).clicked() {
+        let name = new_preset_name(&app.session.tools.presets);
+        run_or_status(app, "brush.presets.save", json!({ "name": name }));
+        if app.session.tools.presets.iter().any(|p| p.name == name) {
+            app.ui.brushes_panel.renaming = Some(Renaming { group: false, name: name.clone(), folder: Vec::new(), text: String::new() });
+            app.ui.brush_picker_list.renaming = Some(Renaming { group: false, name, folder: Vec::new(), text: String::new() });
+        }
+        ui.close();
+    }
+    ui.separator();
+    if ui.button(tl!("Clear Brush Controls")).clicked() {
+        let before = app.session.tools.brush.clone();
+        let cleared = clear_brush_controls(&before);
+        commit(app, &before, &cleared);
+        ui.close();
+    }
+    let has_locks = app.session.tools.brush.locks != photocraft_paint::brush::SectionLocks::default();
+    if ui.add_enabled(has_locks, egui::Button::new(tl!("Reset All Locked Settings"))).clicked() {
+        let before = app.session.tools.brush.clone();
+        let mut after = before.clone();
+        after.locks = photocraft_paint::brush::SectionLocks::default();
+        commit(app, &before, &after);
+        ui.close();
+    }
+    let has_texture = app.session.tools.brush.texture.enabled;
+    if ui.add_enabled(has_texture, egui::Button::new(tl!("Copy Texture to Other Tools"))).clicked() {
+        copy_texture_to_other_tools(app);
+        ui.close();
+    }
+}
+
 pub fn window(app: &mut PhotocraftApp, ctx: &egui::Context) {
     if !app.ui.panels.brush_settings {
         return;
@@ -401,6 +524,21 @@ pub fn window(app: &mut PhotocraftApp, ctx: &egui::Context) {
                     if icons::button(ui, "x", 20.0, false, tl!("Close")).clicked() {
                         open = false;
                     }
+                    let menu_btn = widgets::panel_menu_button(ui);
+                    egui::Popup::menu(&menu_btn).show(|ui| {
+                        widgets::style_spectrum_popup_menu(ui);
+                        ui.set_min_width(180.0);
+                        panel_menu(app, ui);
+                        ui.separator();
+                        if ui.button(tl!("Close")).clicked() {
+                            open = false;
+                            ui.close();
+                        }
+                        if ui.button(tl!("Close Tab Group")).clicked() {
+                            open = false;
+                            ui.close();
+                        }
+                    });
                 });
             });
             ui.add_space(6.0);
diff --git a/crates/ui-egui/src/brush_panel_tests.rs b/crates/ui-egui/src/brush_panel_tests.rs
index c61b48c1be..750a9d5506 100644
--- a/crates/ui-egui/src/brush_panel_tests.rs
+++ b/crates/ui-egui/src/brush_panel_tests.rs
@@ -220,6 +220,61 @@ fn section_locks_round_trip_and_survive_preset_picks() {
     assert_eq!(b.tip, chalk.tip);
 }
 
+#[test]
+fn section_locks_are_always_visible_and_toggle_on_click() {
+    use egui_kittest::kittest::Queryable;
+
+    fn collect_icon_rects(shape: &egui::Shape, out: &mut Vec<egui::Rect>) {
+        match shape {
+            egui::Shape::Rect(r) if (r.rect.size() - vec2(12.0, 12.0)).length() < 0.5 => out.push(r.rect),
+            egui::Shape::Mesh(mesh) => out.push(mesh.calc_bounds()),
+            egui::Shape::Vec(shapes) => {
+                for s in shapes {
+                    collect_icon_rects(s, out);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    let mut h = harness(0, 0);
+    let mut icons = Vec::new();
+    for clipped in &h.output().shapes {
+        collect_icon_rects(&clipped.shape, &mut icons);
+    }
+
+    // Every lockable section (1..SECTIONS.len()) paints its lock icon even when unlocked and unhovered.
+    for (name, _) in SECTIONS.iter().skip(1) {
+        let row = h.get_by_label(name).rect();
+        let lock_center = egui::pos2(row.right() - 11.0, row.center().y);
+        assert!(icons.iter().any(|r| r.contains(lock_center)), "expected lock icon at {lock_center:?} for {name}");
+    }
+
+    // Clicking the lock toggles it on and off without changing the selected section.
+    let row = h.get_by_label("Scattering").rect();
+    let lock_pos = egui::pos2(row.right() - 11.0, row.center().y);
+    assert!(!h.state().session.tools.brush.locks.scattering);
+    assert_eq!(h.state().ui.brush_section, 0);
+
+    h.hover_at(lock_pos);
+    h.run_steps(1);
+    h.drag_at(lock_pos);
+    h.run_steps(1);
+    h.drop_at(lock_pos);
+    h.run_steps(2);
+    assert!(h.state().session.tools.brush.locks.scattering);
+    assert_eq!(h.state().ui.brush_section, 0);
+
+    h.hover_at(lock_pos);
+    h.run_steps(1);
+    h.drag_at(lock_pos);
+    h.run_steps(1);
+    h.drop_at(lock_pos);
+    h.run_steps(2);
+    assert!(!h.state().session.tools.brush.locks.scattering);
+    assert_eq!(h.state().ui.brush_section, 0);
+}
+
 /// A harness that shows the options bar with `tool` in the Studio (non-pro) theme.
 fn options_bar_harness(tool: crate::state::Tool) -> Harness<'static, PhotocraftApp> {
     let mut app = app();
@@ -324,6 +379,26 @@ fn options_bar_edits_are_one_set_brush_per_gesture() {
     assert_eq!(s.tools.brush, h.state().session.tools.brush);
 }
 
+#[test]
+fn brush_mode_dropdown_shows_outside_the_pro_themes() {
+    // #4512: only the Pro themes drew the Brush's Mode; the Pencil has it in every theme.
+    use egui_kittest::kittest::{NodeT, Queryable};
+    let mut h = options_bar_harness(crate::state::Tool::Brush);
+    let n = h.state().session.journal.len();
+    assert!(h.query_by_label("Mode").is_some(), "the Brush's Mode label");
+    h.get_all_by_role(egui::accesskit::Role::ComboBox)
+        .find(|c| c.accesskit_node().value().as_deref() == Some("Normal"))
+        .expect("the Brush's Mode dropdown")
+        .click();
+    h.run();
+    h.key_press(egui::Key::ArrowDown);
+    h.run_steps(3);
+    assert_eq!(h.state().session.tools.brush.mode, photocraft_doc::BlendMode::Dissolve);
+    let j = &h.state().session.journal;
+    assert_eq!(j.len(), n + 1, "{:?}", &j[n..]);
+    assert_eq!(j[n].0, "tools.setBrush");
+}
+
 #[test]
 fn airbrush_smoothing_options_and_symmetry_buttons_work() {
     // #1177: in the default (Photoshop) theme these options-bar buttons did nothing.
@@ -403,7 +478,14 @@ fn drop_targets_and_actions_reorder_presets() {
     use crate::brushes_tab::{Action, apply, drop_target, group_key};
     let mut app = app();
     for (n, g) in [("A1", "Alpha"), ("A2", "Alpha"), ("A3", "Alpha"), ("B1", "Beta")] {
-        app.session.tools.presets.push(paint::BrushPreset { name: n.into(), brush: Default::default(), builtin: false, group: g.into(), folder: Vec::new() });
+        app.session.tools.presets.push(paint::BrushPreset {
+            name: n.into(),
+            brush: Default::default(),
+            builtin: false,
+            group: g.into(),
+            folder: Vec::new(),
+            captures: Default::default(),
+        });
     }
     let p = &app.session.tools.presets;
     // Dropping A1 on A3's lower half lands after A3 (index 2 once A1 is out); on its upper half, before it.
@@ -465,6 +547,210 @@ fn harness(tab: usize, section: usize) -> Harness<'static, PhotocraftApp> {
     h
 }
 
+fn toggle_value(app: &PhotocraftApp, section: usize) -> bool {
+    let brush = serde_json::to_value(&app.session.tools.brush).unwrap();
+    let path = match section {
+        8 => "/noise",
+        9 => "/wetEdges",
+        10 => "/buildUp",
+        11 => "/smoothing/enabled",
+        12 => "/protectTexture",
+        _ => panic!("not a checkbox-only row"),
+    };
+    brush.pointer(path).and_then(Value::as_bool).expect("the checkbox has a boolean brush setting")
+}
+
+#[test]
+fn hue_jitter_amount_edits_keep_percentage_units_and_command_routing() {
+    use egui::accesskit::Role;
+    use egui_kittest::kittest::{NodeT, Queryable};
+
+    let mut h = harness(0, 5);
+    h.state_mut()
+        .session
+        .execute(
+            "tools.setBrush",
+            json!({"brush": {"colorDynamics": {
+                "enabled": true, "hueJitter": 0.37, "saturationJitter": 0.23, "brightnessJitter": 0.41, "purity": -0.16
+            }}}),
+        )
+        .unwrap();
+    let before = h.state().session.tools.brush.clone();
+    h.run_steps(2);
+    let field = h.query_all_by_role(Role::SpinButton).find(|n| n.accesskit_node().numeric_value() == Some(37.0)).unwrap();
+    let center = field.rect().center();
+    field.click();
+    h.key_press(egui::Key::ArrowUp);
+    h.run_steps(2);
+    assert_eq!(h.state().session.tools.brush.color_dynamics.hue_jitter, 0.38);
+    h.key_press(egui::Key::Enter);
+    // Click near the high end of the track, then beyond its right edge while dragging.
+    let from = egui::pos2(center.x, center.y + 24.0);
+    h.event(egui::Event::PointerMoved(from));
+    h.event(egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE });
+    h.run_steps(1);
+    let to = from + vec2(200.0, 0.0);
+    h.event(egui::Event::PointerMoved(to));
+    h.run_steps(1);
+    h.event(egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE });
+    h.run_steps(2);
+    let mut expected = before;
+    expected.color_dynamics.hue_jitter = 1.0;
+    assert_eq!(h.state().session.tools.brush, expected, "the amount clamps at 100% and preserves neighboring settings");
+    assert_eq!(last_journal(h.state()).unwrap().0, "tools.setBrush");
+    let mut replay = photocraft_engine::Session::new();
+    for (id, params) in h.state().session.journal.clone() {
+        replay.execute(&id, params).unwrap();
+    }
+    assert_eq!(replay.tools.brush, expected, "the edit remains replayable through the engine");
+}
+
+#[test]
+fn checkbox_only_rows_toggle_without_changing_the_selected_controls() {
+    use egui_kittest::kittest::Queryable;
+    for (section, &(name, _)) in SECTIONS.iter().enumerate().skip(8) {
+        let mut h = harness(0, 1);
+        let before = toggle_value(h.state(), section);
+        let n = h.state().session.journal.len();
+        h.get_by_label(name).click();
+        h.run_steps(3);
+        assert_eq!(h.state().ui.brush_section, 1, "{name} must leave Shape Dynamics open");
+        assert_eq!(toggle_value(h.state(), section), !before, "{name}");
+        assert_eq!(h.state().session.journal.len(), n + 1, "one command for {name}");
+        assert_eq!(last_journal(h.state()).unwrap().0, "tools.setBrush");
+        h.get_by_label(name).click();
+        h.run_steps(3);
+        assert_eq!(toggle_value(h.state(), section), before, "a second row click turns {name} back");
+        assert_eq!(h.state().ui.brush_section, 1);
+        assert_eq!(h.state().session.journal.len(), n + 2);
+    }
+}
+
+#[test]
+fn checkbox_only_box_and_lock_clicks_do_not_select_or_double_toggle() {
+    use egui_kittest::kittest::Queryable;
+    for (section, &(name, _)) in SECTIONS.iter().enumerate().skip(8) {
+        let mut h = harness(0, 1);
+        let rect = h.get_by_label(name).rect();
+        let before = toggle_value(h.state(), section);
+        let n = h.state().session.journal.len();
+        let at = egui::pos2(rect.left() + 12.0, rect.center().y);
+        h.hover_at(at);
+        h.run_steps(2);
+        h.drag_at(at);
+        h.run_steps(2);
+        h.drop_at(at);
+        h.run_steps(3);
+        assert_eq!(toggle_value(h.state(), section), !before, "checkbox click on {name}");
+        assert_eq!(h.state().ui.brush_section, 1);
+        assert_eq!(h.state().session.journal.len(), n + 1);
+        let at = egui::pos2(rect.right() - 11.0, rect.center().y);
+        h.hover_at(at);
+        h.run_steps(2);
+        h.drag_at(at);
+        h.run_steps(2);
+        h.drop_at(at);
+        h.run_steps(3);
+        assert_eq!(toggle_value(h.state(), section), !before, "lock click must not toggle {name}");
+        assert_eq!(h.state().ui.brush_section, 1);
+        assert_eq!(h.state().session.journal.len(), n + 2);
+        let mut brush = h.state().session.tools.brush.clone();
+        assert!(*section_lock(&mut brush, section).unwrap(), "{name} lock");
+    }
+}
+
+#[test]
+fn checkbox_only_rows_cannot_restore_an_empty_properties_pane() {
+    for (section, &(name, _)) in SECTIONS.iter().enumerate().skip(8) {
+        let h = harness(0, section);
+        assert_eq!(h.state().ui.brush_section, 0, "an old selection of {name} returns to Brush Tip Shape");
+    }
+}
+
+#[test]
+fn smoothing_row_preserves_its_amount_and_options_across_toggles() {
+    use egui_kittest::kittest::Queryable;
+    let mut h = harness(0, 1);
+    h.state_mut().run("tools.setBrush", json!({"brush": {"smoothing": {"amount": 0.65, "pulledString": true, "catchUpOnEnd": false}}})).unwrap();
+    let before = h.state().session.tools.brush.smoothing.clone();
+    h.run_steps(2);
+    for enabled in [false, true] {
+        h.get_by_label("Smoothing").click();
+        h.run_steps(3);
+        let mut expected = before.clone();
+        expected.enabled = enabled;
+        assert_eq!(h.state().session.tools.brush.smoothing, expected);
+        assert_eq!(h.state().ui.brush_section, 1);
+        assert_eq!(last_journal(h.state()).unwrap().1["brush"], json!({"smoothing": {"enabled": enabled}}));
+    }
+}
+
+#[test]
+fn checkbox_only_rows_are_accessible_checkboxes_and_accept_space() {
+    use egui::accesskit::Role;
+    use egui_kittest::kittest::{NodeT, Queryable};
+    let mut h = harness(0, 1);
+    for (section, &(name, _)) in SECTIONS.iter().enumerate().skip(8) {
+        let node = h.get_by_label(name);
+        assert_eq!(node.accesskit_node().role(), Role::CheckBox, "{name}");
+        node.focus();
+        h.run_steps(2);
+        let before = toggle_value(h.state(), section);
+        h.key_press(egui::Key::Space);
+        h.run_steps(3);
+        assert_eq!(toggle_value(h.state(), section), !before, "Space toggles {name}");
+        assert_eq!(h.state().ui.brush_section, 1);
+    }
+}
+
+#[test]
+fn editing_the_options_bar_amount_reenables_smoothing() {
+    use egui_kittest::kittest::Queryable;
+    let mut h = options_bar_harness(crate::state::Tool::Brush);
+    h.state_mut().run("tools.setBrush", json!({"brush": {"smoothing": {"enabled": false, "amount": 0.4}}})).unwrap();
+    h.run_steps(3);
+    let n = h.state().session.journal.len();
+    let label = h.get_by_label("Smoothing").rect();
+    let at = egui::pos2(label.right() + 25.0, label.center().y);
+    h.hover_at(at);
+    h.run_steps(2);
+    h.drag_at(at);
+    h.run_steps(2);
+    h.hover_at(at + vec2(20.0, 0.0));
+    h.run_steps(2);
+    h.drop_at(at + vec2(20.0, 0.0));
+    h.run_steps(3);
+    let smoothing = &h.state().session.tools.brush.smoothing;
+    assert!(smoothing.enabled && smoothing.amount != 0.4);
+    assert_eq!(h.state().session.journal.len(), n + 1, "one options-bar gesture");
+    assert_eq!(last_journal(h.state()).unwrap().1["brush"]["smoothing"]["enabled"], true);
+}
+
+/// #4282: every name in the section list starts in the same column, Brush Tip Shape included,
+/// whether or not its row has an enable box (Photoshop indents the rows without one).
+#[test]
+fn section_names_line_up_whether_or_not_they_have_a_box() {
+    fn text_x(shape: &egui::Shape, out: &mut Vec<(String, f32)>) {
+        match shape {
+            egui::Shape::Text(text) => out.push((text.galley.job.text.clone(), text.pos.x)),
+            egui::Shape::Vec(shapes) => shapes.iter().for_each(|s| text_x(s, out)),
+            _ => {}
+        }
+    }
+    // Shape Dynamics is shown, so its heading paints too; the list's copy is the leftmost.
+    let h = harness(0, 1);
+    let mut painted = Vec::new();
+    for shape in &h.output().shapes {
+        text_x(&shape.shape, &mut painted);
+    }
+    let left = |name: &str| painted.iter().filter(|(t, _)| t == name).map(|(_, x)| *x).reduce(f32::min);
+    let columns: Vec<(&str, f32)> = SECTIONS.iter().map(|(name, _)| (*name, left(name).unwrap_or_else(|| panic!("{name} painted")))).collect();
+    let (_, boxed) = columns[1];
+    for (name, x) in &columns {
+        assert!((x - boxed).abs() < 0.5, "{name} starts at {x}, the boxed names at {boxed}: {columns:?}");
+    }
+}
+
 #[test]
 fn preview_strip_re_renders_only_when_the_brush_changes() {
     let mut h = harness(0, 0);
@@ -538,6 +824,7 @@ fn kit(name: &str, folder: &[&str]) -> paint::BrushPreset {
         builtin: false,
         group: "Kit".into(),
         folder: folder.iter().map(|s| s.to_string()).collect(),
+        captures: Default::default(),
     }
 }
 
@@ -635,6 +922,90 @@ fn folder_actions_become_folder_commands() {
     assert_eq!(last_journal(&app).unwrap(), ("brush.presets.moveGroup".to_string(), json!({ "group": "Kit", "folder": ["Dry"], "before": "Inks" })));
 }
 
+/// Dragging a folder or group header onto another header (#2014): the upper edge places it
+/// before, the rest puts it inside; the action runs `brush.presets.moveGroup` with `into`.
+#[test]
+fn folder_drops_map_to_move_commands() {
+    use crate::brushes_tab::{Action, apply, folder_drop};
+    let v = |p: &[&str]| p.iter().map(|s| s.to_string()).collect::<Vec<String>>();
+    // Into: a folder onto another folder, a group onto a group.
+    assert_eq!(
+        folder_drop("Kit", &v(&["Dry"]), "Kit", &v(&["Inks"]), false),
+        Some(Action::MoveInto { group: "Kit".into(), folder: v(&["Dry"]), into: Some(("Kit".into(), v(&["Inks"]))), before: None })
+    );
+    assert_eq!(
+        folder_drop("Pack", &[], "Kit", &v(&["Inks"]), false),
+        Some(Action::MoveInto { group: "Pack".into(), folder: vec![], into: Some(("Kit".into(), v(&["Inks"]))), before: None })
+    );
+    // Onto itself, into its own folder, or into the folder it is already in: nothing.
+    assert_eq!(folder_drop("Kit", &v(&["Inks"]), "Kit", &v(&["Inks"]), false), None);
+    assert_eq!(folder_drop("Kit", &v(&["Inks"]), "Kit", &v(&["Inks", "Fine"]), true), None);
+    assert_eq!(folder_drop("Kit", &[], "Kit", &v(&["Inks"]), false), None);
+    assert_eq!(folder_drop("Kit", &v(&["Inks", "Fine"]), "Kit", &v(&["Inks"]), false), None);
+    // Upper edge: siblings reorder; a nested folder before a group goes to the top level; a
+    // folder before a folder elsewhere moves next to it.
+    assert_eq!(
+        folder_drop("Kit", &v(&["Dry"]), "Kit", &v(&["Inks"]), true),
+        Some(Action::MoveGroup { group: "Kit".into(), folder: v(&["Dry"]), before: Some("Inks".into()) })
+    );
+    assert_eq!(folder_drop("Pack", &[], "Kit", &[], true), Some(Action::MoveGroup { group: "Pack".into(), folder: vec![], before: Some("Kit".into()) }));
+    assert_eq!(
+        folder_drop("Kit", &v(&["Inks", "Fine"]), "Pack", &[], true),
+        Some(Action::MoveInto { group: "Kit".into(), folder: v(&["Inks", "Fine"]), into: None, before: Some("Pack".into()) })
+    );
+    assert_eq!(
+        folder_drop("Kit", &v(&["Inks", "Fine"]), "Pack", &v(&["Box"]), true),
+        Some(Action::MoveInto { group: "Kit".into(), folder: v(&["Inks", "Fine"]), into: Some(("Pack".into(), vec![])), before: Some("Box".into()) })
+    );
+
+    let mut app = app();
+    for p in [kit("Kit Pen", &["Inks"]), kit("Kit Nib", &["Inks", "Fine"]), kit("Kit Chalk", &["Dry"])] {
+        app.session.tools.presets.push(p);
+    }
+    let into = folder_drop("Kit", &v(&["Dry"]), "Kit", &v(&["Inks", "Fine"]), false).unwrap();
+    apply(&mut app, vec![into]);
+    assert_eq!(paint::presets::find(&app.session.tools.presets, "Kit Chalk").unwrap().folder, ["Inks", "Fine", "Dry"]);
+    assert_eq!(
+        last_journal(&app).unwrap(),
+        ("brush.presets.moveGroup".to_string(), json!({ "group": "Kit", "folder": ["Dry"], "into": {"group": "Kit", "folder": ["Inks", "Fine"]} }))
+    );
+    // Out to the top level, before a group.
+    let out = folder_drop("Kit", &v(&["Inks", "Fine"]), "Kit", &[], true).unwrap();
+    apply(&mut app, vec![out]);
+    let chalk = paint::presets::find(&app.session.tools.presets, "Kit Chalk").unwrap();
+    assert_eq!((chalk.group.as_str(), chalk.folder.clone()), ("Fine", v(&["Dry"])));
+    let order = photocraft_engine::brush_preset_cmds::group_order(&app.session.tools.presets);
+    assert!(order.iter().position(|g| g == "Fine") < order.iter().position(|g| g == "Kit"));
+}
+
+/// A folder header dragged onto another folder's header in the Brushes panel goes inside it.
+#[test]
+fn dragging_a_folder_header_onto_another_moves_it_inside() {
+    use egui_kittest::kittest::Queryable;
+    let mut h = harness(1, 0);
+    let builtin_groups: Vec<String> = grouped_presets(&h.state().session.tools.presets).into_iter().map(|(g, _)| g).collect();
+    h.state_mut().ui.brushes_panel.collapsed = builtin_groups;
+    for p in [kit("Kit Pen", &["Test Inks"]), kit("Kit Chalk", &["Test Dry"])] {
+        h.state_mut().session.tools.presets.push(p);
+    }
+    h.run_steps(3);
+    let from = h.get_by_label("Test Dry").rect().center();
+    let to = h.get_by_label("Test Inks").rect();
+    let to = egui::pos2(to.center().x, to.top() + to.height() * 0.7);
+    h.hover_at(from);
+    h.run();
+    h.drag_at(from);
+    h.run();
+    for k in 1..=6 {
+        h.hover_at(from + (to - from) * (k as f32 / 6.0));
+        h.run();
+    }
+    h.drop_at(to);
+    h.run_steps(3);
+    assert_eq!(paint::presets::find(&h.state().session.tools.presets, "Kit Chalk").unwrap().folder, ["Test Inks", "Test Dry"]);
+    assert_eq!(last_journal(h.state()).unwrap().0, "brush.presets.moveGroup");
+}
+
 /// A fresh session with the Brush tool: shortcuts, the options bar and the Brush Settings window,
 /// in the default theme (#258).
 fn app_harness() -> Harness<'static, PhotocraftApp> {
@@ -666,7 +1037,7 @@ fn app_harness_with_language(lang: crate::i18n::Lang) -> Harness<'static, Photoc
 }
 
 #[test]
-fn brush_sections_paint_simplified_chinese_labels_and_heading() {
+fn brush_sections_paint_simplified_chinese_labels() {
     fn collect_text(shape: &egui::Shape, out: &mut Vec<String>) {
         match shape {
             egui::Shape::Text(text) => out.push(text.galley.job.text.clone()),
@@ -691,8 +1062,27 @@ fn brush_sections_paint_simplified_chinese_labels_and_heading() {
         assert!(painted.iter().any(|s| s == translated), "{name} must paint as {translated}");
         assert!(!painted.iter().any(|s| s == name), "{name} must not paint in English");
     }
-    let heading = crate::i18n::tr(zh, "Brush Tip Shape");
-    assert_eq!(painted.iter().filter(|s| s.as_str() == heading).count(), 2, "both the section row and heading are translated");
+}
+
+/// #3477: the options pane has no title of its own. The selected row in the section list is the
+/// only place the section's name is painted.
+#[test]
+fn options_pane_does_not_repeat_the_selected_sections_name() {
+    fn collect_text(shape: &egui::Shape, out: &mut Vec<String>) {
+        match shape {
+            egui::Shape::Text(text) => out.push(text.galley.job.text.clone()),
+            egui::Shape::Vec(shapes) => shapes.iter().for_each(|s| collect_text(s, out)),
+            _ => {}
+        }
+    }
+    for (section, (name, _)) in SECTIONS.iter().enumerate().take(CHECKBOX_ONLY_START) {
+        let h = harness(0, section);
+        let mut painted = Vec::new();
+        for shape in &h.output().shapes {
+            collect_text(&shape.shape, &mut painted);
+        }
+        assert_eq!(painted.iter().filter(|s| s.as_str() == *name).count(), 1, "{name} is painted once, in the section list");
+    }
 }
 
 #[test]
@@ -877,3 +1267,203 @@ fn hand_tool_offers_scale_buttons_and_requests_the_right_view() {
     assert!(h.state().ui.views[0].fill_pending);
     assert!(!h.state().ui.views[0].fit_pending);
 }
+
+#[test]
+fn brush_settings_hamburger_menu_actions() {
+    use egui_kittest::kittest::Queryable;
+
+    // 1. Menu opens and offers Photoshop actions
+    let mut h = harness(0, 0);
+    h.get_by_label("Panel menu").click();
+    h.run_steps(2);
+
+    assert!(h.query_all_by_label("New Brush Preset…").count() > 0);
+    assert!(h.query_all_by_label("Clear Brush Controls").count() > 0);
+    assert!(h.query_all_by_label("Reset All Locked Settings").count() > 0);
+    assert!(h.query_all_by_label("Copy Texture to Other Tools").count() > 0);
+    assert!(h.query_all_by_label("Close").count() > 0);
+    assert!(h.query_all_by_label("Close Tab Group").count() > 0);
+
+    // 2. New Brush Preset… saves a preset
+    let count0 = h.state().session.tools.presets.len();
+    h.get_by_label("New Brush Preset…").click();
+    h.run_steps(2);
+    assert_eq!(h.state().session.tools.presets.len(), count0 + 1);
+    assert_eq!(last_journal(h.state()).unwrap().0, "brush.presets.save");
+
+    // 3. Clear Brush Controls resets dynamics, keeps locked sections and smoothing
+    let mut h = harness(0, 0);
+    h.state_mut().session.tools.brush.size = 45.0;
+    h.state_mut().session.tools.brush.scattering.enabled = true;
+    h.state_mut().session.tools.brush.texture.enabled = true;
+    h.state_mut().session.tools.brush.locks.texture = true;
+    h.state_mut().session.tools.brush.smoothing.amount = 0.5;
+    h.run_steps(1);
+
+    h.get_by_label("Panel menu").click();
+    h.run_steps(2);
+    h.get_by_label("Clear Brush Controls").click();
+    h.run_steps(2);
+
+    let b = &h.state().session.tools.brush;
+    assert!(!b.scattering.enabled, "unlocked scattering cleared");
+    assert!(b.texture.enabled, "locked texture preserved");
+    assert_eq!(b.smoothing.amount, 0.5, "smoothing preserved");
+    assert_eq!(b.size, 45.0, "tip size preserved");
+
+    // 4. Reset All Locked Settings clears all locks
+    assert!(b.locks.texture);
+    h.get_by_label("Panel menu").click();
+    h.run_steps(2);
+    h.get_by_label("Reset All Locked Settings").click();
+    h.run_steps(2);
+    assert_eq!(h.state().session.tools.brush.locks, photocraft_paint::brush::SectionLocks::default());
+
+    // 5. Copy Texture to Other Tools copies texture to other tools with texture enabled
+    let mut h = harness(0, 0);
+    h.state_mut().session.tools.brush.texture.enabled = true;
+    h.state_mut().session.tools.brush.texture.scale = 2.5;
+    let mut pencil_brush = BrushSettings::default();
+    pencil_brush.texture.enabled = true;
+    pencil_brush.texture.scale = 1.0;
+    h.state_mut().ui.tool_brushes = vec![(crate::state::Tool::Pencil, pencil_brush)];
+    h.run_steps(1);
+
+    h.get_by_label("Panel menu").click();
+    h.run_steps(2);
+    h.get_by_label("Copy Texture to Other Tools").click();
+    h.run_steps(2);
+
+    let pencil = h.state().ui.tool_brushes.iter().find(|(t, _)| *t == crate::state::Tool::Pencil).unwrap();
+    assert_eq!(pencil.1.texture.scale, 2.5);
+
+    // 6. Close closes the window
+    let mut h = harness(0, 0);
+    assert!(h.state().ui.panels.brush_settings);
+    h.get_by_label("Panel menu").click();
+    h.run_steps(2);
+    let close_buttons: Vec<_> = h.query_all_by_label("Close").collect();
+    assert!(close_buttons.len() >= 2);
+    close_buttons.last().unwrap().click();
+    h.run_steps(2);
+    assert!(!h.state().ui.panels.brush_settings);
+
+    // 7. Close Tab Group closes the window
+    let mut h = harness(0, 0);
+    assert!(h.state().ui.panels.brush_settings);
+    h.get_by_label("Panel menu").click();
+    h.run_steps(2);
+    h.get_by_label("Close Tab Group").click();
+    h.run_steps(2);
+    assert!(!h.state().ui.panels.brush_settings);
+}
+
+#[test]
+fn brushes_button_at_top_of_brush_settings_opens_brushes_panel() {
+    use egui_kittest::kittest::Queryable;
+
+    let mut h = harness(0, 0);
+    assert_eq!(h.state().ui.brush_tab, 0);
+    h.get_by_label("Brushes").click();
+    h.run_steps(3);
+    assert!(h.state().ui.panels.brush_settings);
+    assert_eq!(h.state().ui.brush_tab, 1);
+}
+
+/// The fill painted for the check box in `rect` in the last frame (the topmost filled rect there).
+fn box_fill(h: &Harness<'_, PhotocraftApp>, rect: egui::Rect) -> Option<Color32> {
+    h.output()
+        .shapes
+        .iter()
+        .filter_map(|c| match &c.shape {
+            egui::Shape::Rect(r) if (r.rect.min - rect.min).length() < 1.0 && (r.rect.max - rect.max).length() < 1.0 && r.fill != Color32::TRANSPARENT => {
+                Some(r.fill)
+            }
+            _ => None,
+        })
+        .next_back()
+}
+
+/// #4476: while the mouse is down on a section's row or its box, the box shows it's pressed, as
+/// in Photoshop: an unchecked box darkens, a checked one turns less opaque. The release then
+/// acts as before.
+#[test]
+fn section_boxes_show_a_pressed_state() {
+    use egui_kittest::kittest::Queryable;
+    let mut h = app_harness();
+    h.key_press(egui::Key::F5);
+    h.run_steps(3);
+    let t = Tokens::get(&h.ctx);
+    let boxr = h.get_by_label("Enable Shape Dynamics").rect();
+    let row = h.get_by_label("Shape Dynamics").rect();
+    assert!(!h.state().session.tools.brush.shape_dynamics.enabled);
+    assert_eq!(box_fill(&h, boxr), Some(widgets::check_box_fill(false, false, &t)));
+    // Held on the row's name: the unchecked box darkens; the release turns the section on.
+    let at = egui::pos2(row.center().x, row.center().y);
+    h.drag_at(at);
+    h.run_steps(2);
+    assert_eq!(box_fill(&h, boxr), Some(widgets::check_box_fill(false, true, &t)), "pressed, unchecked");
+    h.drop_at(at);
+    h.run_steps(3);
+    assert!(h.state().session.tools.brush.shape_dynamics.enabled);
+    assert_eq!(box_fill(&h, boxr), Some(widgets::check_box_fill(true, false, &t)));
+    // Held on the checked box itself: less opaque, then the release turns it off.
+    h.drag_at(boxr.center());
+    h.run_steps(2);
+    assert_eq!(box_fill(&h, boxr), Some(widgets::check_box_fill(true, true, &t)), "pressed, checked");
+    h.drop_at(boxr.center());
+    h.run_steps(3);
+    assert!(!h.state().session.tools.brush.shape_dynamics.enabled);
+    // A checkbox-only row (no settings of its own) is one checkbox across the row: a press
+    // anywhere on it presses its box, and the release toggles it.
+    let wet = h.get_by_label("Wet Edges").rect();
+    let wet_box = egui::Rect::from_center_size(egui::pos2(wet.left() + 12.0, wet.center().y), vec2(13.0, 13.0));
+    let was = h.state().session.tools.brush.wet_edges;
+    h.drag_at(wet.center());
+    h.run_steps(2);
+    assert_eq!(box_fill(&h, wet_box), Some(widgets::check_box_fill(was, true, &t)), "pressed checkbox-only row");
+    h.drop_at(wet.center());
+    h.run_steps(3);
+    assert_ne!(h.state().session.tools.brush.wet_edges, was);
+    // The four looks are distinct.
+    let looks = [(false, false), (false, true), (true, false), (true, true)].map(|(on, pressed)| widgets::check_box_fill(on, pressed, &t));
+    for (i, a) in looks.iter().enumerate() {
+        assert!(looks.iter().skip(i + 1).all(|b| b != a), "{looks:?}");
+    }
+}
+
+/// The shared check box (options bars, dialogs) does the same, and pressing its label counts.
+#[test]
+fn checkboxes_show_a_pressed_state_from_their_label() {
+    use egui_kittest::kittest::Queryable;
+    let mut h = Harness::builder().with_size(vec2(300.0, 100.0)).build_ui_state(
+        |ui, on: &mut bool| {
+            widgets::checkbox(ui, on, "Sample All Layers");
+        },
+        false,
+    );
+    h.run();
+    let t = Tokens::get(&h.ctx);
+    let label = h.get_by_label("Sample All Layers").rect();
+    let boxr = egui::Rect::from_min_size(egui::pos2(label.left() - 6.0 - 14.0, label.center().y - 7.0), vec2(14.0, 14.0));
+    let fill = |h: &Harness<'_, bool>| {
+        h.output()
+            .shapes
+            .iter()
+            .filter_map(|c| match &c.shape {
+                egui::Shape::Rect(r) if (r.rect.center() - boxr.center()).length() < 1.5 && r.rect.width() < 15.0 && r.fill != Color32::TRANSPARENT => {
+                    Some(r.fill)
+                }
+                _ => None,
+            })
+            .next_back()
+    };
+    assert_eq!(fill(&h), Some(widgets::check_box_fill(false, false, &t)));
+    h.drag_at(label.center());
+    h.run();
+    assert_eq!(fill(&h), Some(widgets::check_box_fill(false, true, &t)), "pressing the label presses the box");
+    h.drop_at(label.center());
+    h.run();
+    assert!(*h.state(), "the release checks it");
+    assert_eq!(fill(&h), Some(widgets::check_box_fill(true, false, &t)));
+}
diff --git a/crates/ui-egui/src/brush_picker.rs b/crates/ui-egui/src/brush_picker.rs
index 8a7ec9d475..8ac5bb8c2c 100644
--- a/crates/ui-egui/src/brush_picker.rs
+++ b/crates/ui-egui/src/brush_picker.rs
@@ -24,7 +24,7 @@ use photocraft_engine::BrushSettings;
 use photocraft_engine::paint::{BrushPreset, MAX_BRUSH_SIZE, TipShape};
 use serde_json::{Value, json};
 
-use crate::brush_panel::{BrushesPanelState, Renaming, new_preset_name, run_or_status};
+use crate::brush_panel::{BrushesPanelState, Renaming};
 use crate::brushes_tab::{self, Action, ListLayout};
 use crate::theme::Tokens;
 use crate::{PhotocraftApp, icons, widgets};
@@ -159,13 +159,11 @@ pub fn apply(app: &mut PhotocraftApp, ctx: &egui::Context, picks: Vec<Pick>) {
         match pick {
             Pick::List(a) => brushes_tab::apply(app, vec![a]),
             Pick::OpenSettings => open_settings(app, ctx),
+            // Photoshop asks for the new preset's name and what it captures first, in a dialog that
+            // takes the picker's place.
             Pick::NewPreset => {
-                let name = new_preset_name(&app.session.tools.presets);
-                run_or_status(app, "brush.presets.save", json!({ "name": name }));
-                // Photoshop asks for the new preset's name: the picker's rename bar does.
-                if app.session.tools.presets.iter().any(|p| p.name == name) {
-                    app.ui.brush_picker_list.renaming = Some(Renaming { group: false, name, folder: Vec::new(), text: String::new() });
-                }
+                close(&mut app.ui);
+                crate::brush_preset_dialog::open(app, None);
             }
             Pick::Import => {
                 let _ = app.open_dialog_file();
@@ -262,12 +260,7 @@ pub fn body(
     ui.horizontal(|ui| {
         icons::paint(ui, egui::Rect::from_min_size(ui.cursor().min + vec2(0.0, 3.0), vec2(16.0, 16.0)), "search", 14.0, t.text_faint);
         ui.add_space(20.0);
-        ui.add(
-            egui::TextEdit::singleline(&mut st.filter)
-                .hint_text(tl!("Search Brushes"))
-                .desired_width((size.x - 118.0).max(60.0))
-                .id_salt("brush-picker-search"),
-        );
+        widgets::text_field(ui, ui.id().with("brush-picker-search"), &mut st.filter, tl!("Search Brushes"), (size.x - 118.0).max(60.0), false);
         ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
             gear_menu(ui, current, presets, st, &mut picks);
             let new_tip = "Create new brush preset from the current settings";
diff --git a/crates/ui-egui/src/brush_preset_dialog.rs b/crates/ui-egui/src/brush_preset_dialog.rs
new file mode 100644
index 0000000000..129b9adf28
--- /dev/null
+++ b/crates/ui-egui/src/brush_preset_dialog.rs
@@ -0,0 +1,165 @@
+//! The New Brush Preset dialog (#4490), as in Photoshop: the brush's tip and size on the left, the
+//! name and what the preset captures in the middle, OK and Cancel on the right. Every way of making
+//! a preset opens it: the picker's [+] and its gear menu, the Brush Settings [+] and the Brushes
+//! tab's [+]. Nothing is saved until OK.
+use egui::{Color32, pos2, vec2};
+use photocraft_paint::{BrushPreset, BrushSettings};
+use serde_json::{Map, Value, json};
+
+use crate::{PhotocraftApp, state::DialogKind, theme::Tokens, widgets};
+
+const MARK: &str = "__newBrushPreset";
+const PREVIEW: f32 = 96.0;
+
+pub fn owns(fields: &Map<String, Value>) -> bool {
+    fields.contains_key(MARK)
+}
+
+/// The name the dialog suggests: the current preset's name and the first free number after it
+/// ("Soft Round 1"), so OK never overwrites a preset; "Brush N" when the brush isn't a preset's.
+pub fn suggested_name(presets: &[BrushPreset], current: Option<&str>) -> String {
+    match current.filter(|n| presets.iter().any(|p| p.name.eq_ignore_ascii_case(n))) {
+        Some(base) => (1..).map(|n| format!("{base} {n}")).find(|n| !taken(presets, n)).unwrap_or_else(|| base.to_string()),
+        None => crate::brush_panel::new_preset_name(presets),
+    }
+}
+
+fn taken(presets: &[BrushPreset], name: &str) -> bool {
+    presets.iter().any(|p| p.name.eq_ignore_ascii_case(name.trim()))
+}
+
+/// Open the dialog for the tool's brush, or for `brush` (the Brush Settings panel's copy, which
+/// may be ahead of the tool's by a frame). Returns the dialog's id.
+pub fn open(app: &mut PhotocraftApp, brush: Option<&BrushSettings>) -> u64 {
+    let tools = &app.session.tools;
+    let mut fields = Map::new();
+    fields.insert(MARK.into(), json!(true));
+    fields.insert("__label".into(), json!("New Brush Preset…"));
+    fields.insert("name".into(), json!(suggested_name(&tools.presets, tools.current_preset.as_deref())));
+    fields.insert("captureSize".into(), json!(true));
+    fields.insert("toolSettings".into(), json!(false));
+    fields.insert("color".into(), json!(false));
+    if let Some(b) = brush.and_then(|b| serde_json::to_value(b).ok()) {
+        fields.insert("brush".into(), b);
+    }
+    app.ui.open_dialog(DialogKind::Command, fields)
+}
+
+fn on(f: &Map<String, Value>, key: &str) -> bool {
+    f.get(key).and_then(Value::as_bool).unwrap_or(false)
+}
+
+fn name(f: &Map<String, Value>) -> &str {
+    f.get("name").and_then(Value::as_str).unwrap_or("").trim()
+}
+
+/// Why OK is greyed out, if it is.
+fn problem(app: &PhotocraftApp, f: &Map<String, Value>) -> Option<&'static str> {
+    if name(f).is_empty() {
+        Some(tl!("Enter a name for the brush preset"))
+    } else if taken(&app.session.tools.presets, name(f)) {
+        Some(tl!("A brush preset with this name already exists"))
+    } else {
+        None
+    }
+}
+
+fn check(ui: &mut egui::Ui, f: &mut Map<String, Value>, key: &str, label: &str) {
+    let mut v = on(f, key);
+    if widgets::checkbox(ui, &mut v, label).changed() {
+        f.insert(key.into(), json!(v));
+    }
+}
+
+/// The dialog's three columns; it owns its OK and Cancel, so they stand in their own column.
+pub fn body(app: &PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Value>, interactive: bool) -> Option<bool> {
+    let t = Tokens::get(ui.ctx());
+    let mut outcome = None;
+    let brush: BrushSettings = f.get("brush").and_then(|b| serde_json::from_value(b.clone()).ok()).unwrap_or_else(|| app.session.tools.brush.clone());
+    ui.horizontal_top(|ui| {
+        // The tip as the preset cards draw it, and the size under it.
+        let (r, _) = ui.allocate_exact_size(vec2(PREVIEW, PREVIEW), egui::Sense::hover());
+        ui.painter().rect_filled(r, t.radius_sm, t.field);
+        let tip = crate::brush_preview::tip_texture(ui.ctx(), "new-preset-tip", &brush.tip, (brush.hardness, brush.angle, brush.roundness), 64, t.text);
+        let side = (PREVIEW - 30.0) * crate::brush_sections::thumb_scale(brush.size);
+        let tr = egui::Rect::from_center_size(pos2(r.center().x, r.top() + 8.0 + (PREVIEW - 30.0) / 2.0), vec2(side, side));
+        ui.painter().image(tip.id(), tr, egui::Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+        ui.painter().text(
+            pos2(r.center().x, r.bottom() - 5.0),
+            egui::Align2::CENTER_BOTTOM,
+            format!("{}", brush.size.round() as i64),
+            egui::FontId::proportional(11.0),
+            t.text_dim,
+        );
+        ui.add_space(14.0);
+        ui.vertical(|ui| {
+            ui.horizontal(|ui| {
+                ui.label(tl!("Name:"));
+                let mut text = f.get("name").and_then(Value::as_str).unwrap_or("").to_string();
+                let id = ui.id().with("new-brush-preset-name");
+                let r = widgets::text_field(ui, id, &mut text, "", 220.0, false);
+                // Photoshop opens on the name, all of it selected, so typing replaces it.
+                let once = id.with("focused");
+                if !ui.ctx().data(|d| d.get_temp::<bool>(once).unwrap_or(false)) {
+                    r.request_focus();
+                    if egui::TextEdit::load_state(ui.ctx(), id).is_some() {
+                        crate::field_tab::select_all(ui.ctx(), id, &text);
+                        ui.ctx().data_mut(|d| d.insert_temp(once, true));
+                    }
+                }
+                if r.changed() {
+                    f.insert("name".into(), json!(text));
+                }
+            });
+            ui.add_space(6.0);
+            check(ui, f, "captureSize", tl!("Capture Brush Size in Preset"));
+            check(ui, f, "toolSettings", tl!("Include Tool Settings"));
+            // Include Color belongs to the tool settings: only with them, as in Photoshop.
+            ui.horizontal(|ui| {
+                ui.add_space(20.0);
+                ui.add_enabled_ui(on(f, "toolSettings"), |ui| check(ui, f, "color", tl!("Include Color")));
+            });
+            if let Some(why) = problem(app, f).filter(|_| !name(f).is_empty()) {
+                ui.add_space(4.0);
+                ui.colored_label(t.text_dim, why);
+            }
+        });
+        ui.add_space(14.0);
+        ui.vertical(|ui| {
+            let ok = problem(app, f).is_none();
+            if ui.add_enabled_ui(ok, |ui| widgets::primary_button(ui, tl!("OK"), 84.0)).inner.clicked() {
+                outcome = Some(true);
+            }
+            ui.add_space(4.0);
+            if widgets::secondary_button(ui, tl!("Cancel"), 84.0).clicked() {
+                outcome = Some(false);
+            }
+        });
+    });
+    if outcome.is_none() && interactive && problem(app, f).is_none() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+        outcome = Some(true);
+    }
+    outcome
+}
+
+/// OK: save the preset with the boxes as chosen. It becomes the current brush, as in Photoshop.
+pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value, String> {
+    if let Some(why) = problem(app, f) {
+        return Err(why.into());
+    }
+    let tool_settings = on(f, "toolSettings");
+    let mut p = json!({
+        "name": name(f),
+        "captureSize": on(f, "captureSize"),
+        "toolSettings": tool_settings,
+        "color": tool_settings && on(f, "color"),
+    });
+    if let Some(b) = f.get("brush") {
+        p["brush"] = b.clone();
+    }
+    app.run("brush.presets.save", p)
+}
+
+#[cfg(test)]
+#[path = "brush_preset_dialog_tests.rs"]
+mod tests;
diff --git a/crates/ui-egui/src/brush_preset_dialog_tests.rs b/crates/ui-egui/src/brush_preset_dialog_tests.rs
new file mode 100644
index 0000000000..3e13ebc381
--- /dev/null
+++ b/crates/ui-egui/src/brush_preset_dialog_tests.rs
@@ -0,0 +1,138 @@
+use egui::vec2;
+use egui_kittest::Harness;
+use egui_kittest::kittest::{NodeT, Queryable};
+
+use super::*;
+
+fn harness() -> Harness<'static, PhotocraftApp> {
+    let mut h = Harness::builder().with_size(vec2(1440.0, 900.0)).with_max_steps(64).build_eframe(|cc| {
+        PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+        PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default())
+    });
+    h.state_mut().run("file.new", json!({"width": 400, "height": 300})).unwrap();
+    h.state_mut().ui.tool = crate::state::Tool::Brush;
+    h.run_steps(4);
+    h
+}
+
+/// The open New Brush Preset dialog, if there is one (and never two).
+fn dialog(h: &Harness<'_, PhotocraftApp>) -> Option<u64> {
+    let open: Vec<u64> = h.state().ui.dialogs.iter().filter(|d| owns(&d.fields)).map(|d| d.id).collect();
+    assert!(open.len() <= 1, "one dialog at a time: {open:?}");
+    open.first().copied()
+}
+
+fn field<'a>(h: &'a Harness<'_, PhotocraftApp>, id: u64, key: &str) -> &'a Value {
+    &h.state().ui.dialogs.iter().find(|d| d.id == id).unwrap().fields[key]
+}
+
+/// Every way of making a preset opens the dialog, and Cancel saves nothing.
+#[test]
+fn every_new_preset_button_opens_the_dialog_and_cancel_saves_nothing() {
+    let mut h = harness();
+    let before = h.state().session.tools.presets.clone();
+    let brush = h.state().session.tools.brush.clone();
+    let mut opened = 0;
+    let mut cancel = |h: &mut Harness<'_, PhotocraftApp>| {
+        dialog(h).expect("the dialog opened");
+        h.run_steps(2);
+        h.get_by_label("Cancel").click();
+        h.run_steps(3);
+        assert!(dialog(h).is_none(), "Cancel closes it");
+        assert_eq!(h.state().session.tools.presets, before, "and saves nothing");
+        assert_eq!(h.state().session.tools.brush, brush, "nor touches the brush");
+        opened += 1;
+    };
+    // The picker's [+] and its gear menu.
+    h.state_mut().ui.brush_picker = Some([300.0, 120.0]);
+    h.run_steps(3);
+    h.get_by_label("New Brush Preset").click();
+    h.run_steps(3);
+    cancel(&mut h);
+    h.state_mut().ui.brush_picker = Some([300.0, 120.0]);
+    h.run_steps(3);
+    h.get_by_label("Brush Preset Options").click();
+    h.run_steps(2);
+    h.get_by_label("New Brush Preset…").click();
+    h.run_steps(3);
+    cancel(&mut h);
+    // Brush Settings' [+], then the Brushes tab's.
+    h.state_mut().ui.brush_picker = None;
+    h.state_mut().ui.panels.brush_settings = true;
+    h.state_mut().ui.brush_tab = 0;
+    h.run_steps(3);
+    h.get_by_label("Create new brush from these settings").click();
+    h.run_steps(3);
+    cancel(&mut h);
+    h.state_mut().ui.brush_tab = 1;
+    h.run_steps(3);
+    h.get_by_label("Create new brush from the current settings").click();
+    h.run_steps(3);
+    cancel(&mut h);
+    assert_eq!(opened, 4);
+}
+
+/// The dialog suggests the current brush's name and the next free number, never a name in use; OK
+/// saves under the typed name with the boxes as set, and the next one suggests the next number.
+#[test]
+fn ok_saves_under_the_name_with_the_boxes_as_set() {
+    let mut h = harness();
+    h.state_mut().run("tools.setBrush", json!({"preset": "Chalk"})).unwrap();
+    let id = open(h.state_mut(), None);
+    h.run_steps(3);
+    assert_eq!(field(&h, id, "name"), "Chalk 1");
+    assert_eq!((field(&h, id, "captureSize"), field(&h, id, "toolSettings"), field(&h, id, "color")), (&json!(true), &json!(false), &json!(false)));
+    // Include Color waits for Include Tool Settings.
+    assert!(h.get_by_label("Include Color").accesskit_node().is_disabled(), "Include Color is greyed out");
+    h.get_by_label("Include Tool Settings").click();
+    h.run_steps(2);
+    assert!(!h.get_by_label("Include Color").accesskit_node().is_disabled());
+    h.get_by_label("Include Color").click();
+    h.get_by_label("Capture Brush Size in Preset").click();
+    h.run_steps(2);
+    h.get_by_label("OK").click();
+    h.run_steps(3);
+    assert!(dialog(&h).is_none());
+    let p = h.state().session.tools.presets.iter().find(|p| p.name == "Chalk 1").expect("saved");
+    assert_eq!(p.captures, photocraft_paint::PresetCaptures { size: false, tool_settings: true, color: true });
+    assert!(h.state().session.tools.presets.iter().any(|p| p.name == "Chalk"), "the preset it came from is still there");
+    assert_eq!(h.state().session.tools.current_preset.as_deref(), Some("Chalk 1"));
+
+    // Again: the next number, and a name in use greys OK out.
+    let id = open(h.state_mut(), None);
+    h.run_steps(3);
+    assert_eq!(field(&h, id, "name"), "Chalk 1 1", "named after the current brush, now Chalk 1");
+    h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("name".into(), json!("chalk"));
+    h.run_steps(2);
+    assert!(h.get_by_label("OK").accesskit_node().is_disabled(), "Chalk exists");
+    assert!(h.query_by_label("A brush preset with this name already exists").is_some());
+    assert!(crate::dialogs::confirm(h.state_mut(), id).is_err(), "automation can't overwrite it either");
+}
+
+/// Include Color unchecked with it ticked earlier: the preset doesn't take the colour.
+#[test]
+fn include_color_needs_include_tool_settings() {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    let id = open(&mut app, None);
+    let f = &mut app.ui.dialog_mut(id).unwrap().fields;
+    f.insert("name".into(), json!("Mine"));
+    f.insert("color".into(), json!(true));
+    crate::dialogs::confirm(&mut app, id).unwrap();
+    let p = app.session.tools.presets.iter().find(|p| p.name == "Mine").unwrap();
+    assert_eq!(p.captures, photocraft_paint::PresetCaptures { size: true, tool_settings: false, color: false });
+}
+
+/// The dialog opens on the name, all of it selected: typing replaces it, and Enter is OK.
+#[test]
+fn typing_replaces_the_suggested_name_and_enter_is_ok() {
+    let mut h = harness();
+    let id = open(h.state_mut(), None);
+    h.run_steps(4);
+    h.event(egui::Event::Text("Inky".into()));
+    h.run_steps(2);
+    assert_eq!(field(&h, id, "name"), "Inky");
+    h.key_press(egui::Key::Enter);
+    h.run_steps(3);
+    assert!(dialog(&h).is_none(), "Enter is OK");
+    assert_eq!(h.state().session.tools.current_preset.as_deref(), Some("Inky"));
+}
diff --git a/crates/ui-egui/src/brush_preview.rs b/crates/ui-egui/src/brush_preview.rs
index a3d2d83121..ec6b36c07b 100644
--- a/crates/ui-egui/src/brush_preview.rs
+++ b/crates/ui-egui/src/brush_preview.rs
@@ -353,7 +353,7 @@ mod tests {
         let s = tip_alpha(&TipShape::Sampled(bar), 1.0, 0.0, 1.0, (false, false), n);
         assert!(at(&s, 3, 16) > 0.9 && at(&s, 16, 2) < 0.01);
         // Degenerate input never panics.
-        let empty = paint::GrayTile { width: 0, height: 0, data: vec![] };
+        let empty = paint::GrayTile { width: 0, height: 0, data: vec![].into() };
         assert!(tip_alpha(&TipShape::Sampled(empty), 1.0, 0.0, 0.0, (true, true), 0).iter().all(|v| *v == 0.0));
     }
 }
diff --git a/crates/ui-egui/src/brush_resize.rs b/crates/ui-egui/src/brush_resize.rs
index c4239a3586..dfba8e5166 100644
--- a/crates/ui-egui/src/brush_resize.rs
+++ b/crates/ui-egui/src/brush_resize.rs
@@ -111,9 +111,17 @@ pub fn release_stale(app: &mut PhotocraftApp, secondary_down: bool) {
 }
 
 fn update(app: &mut PhotocraftApp, r: Resize, x: f64, y: f64) {
-    // Right is bigger on screen, also in a flipped view (View › Flip Horizontal).
-    let dx = (x - r.anchor[0]) * if app.ui.view.flip_horizontal { -1.0 } else { 1.0 };
-    let (size, v) = resized(r.start, dx, y - r.anchor[1], app.point_zoom());
+    // Screen-relative, as in Photoshop (#4228): right is bigger and down harder on screen, however
+    // the view is rotated or flipped. The screen delta over the zoom is in document pixels at 0°.
+    let (dx, dy, zoom) = match ViewXform::active(app) {
+        Some(xf) if xf.zoom.is_finite() && xf.zoom > 0.0 => {
+            let d = xf.to_screen(x as f32, y as f32) - xf.to_screen(r.anchor[0] as f32, r.anchor[1] as f32);
+            (f64::from(d.x / xf.zoom), f64::from(d.y / xf.zoom), xf.zoom)
+        }
+        // No view: document axes, mirrored by View › Flip Horizontal.
+        _ => ((x - r.anchor[0]) * if app.ui.view.flip_horizontal { -1.0 } else { 1.0 }, y - r.anchor[1], app.point_zoom()),
+    };
+    let (size, v) = resized(r.start, dx, dy, zoom);
     // "Vary Round Brush Hardness on HUD" (Preferences ▸ Tools, on by default): off, the vertical
     // movement takes the opacity instead of the hardness, as in Photoshop.
     let vary = app.session.prefs().tools.vary_round_brush_hardness_on_hud;
@@ -484,6 +492,39 @@ mod tests {
         }
     }
 
+    /// One Control+Alt drag by `(dx, dy)` document pixels from (100, 100) in a view turned by
+    /// `rotation` degrees (flipped with `flip`): the resulting (size, hardness).
+    fn drag_in_view(rotation: f32, flip: bool, dx: f64, dy: f64) -> (f32, f32) {
+        let mut app = app(Tool::Brush);
+        app.sync_views();
+        app.ui.views[0].rotation = rotation;
+        app.ui.view.flip_horizontal = flip;
+        tool_event(&mut app, ToolEvent::Down { x: 100.0, y: 100.0, pressure: 1.0 }, CTRL_ALT);
+        tool_event(&mut app, ToolEvent::Up { x: 100.0 + dx, y: 100.0 + dy }, CTRL_ALT);
+        let b = &app.session.tools.brush;
+        (b.size, b.hardness)
+    }
+
+    /// #4228: the HUD is screen-relative, as in Photoshop: horizontal on screen is the size and
+    /// vertical the hardness however the view is rotated or flipped.
+    #[test]
+    fn a_rotated_view_keeps_horizontal_for_size_and_vertical_for_hardness() {
+        // Unrotated, with and without View › Flip Horizontal: unchanged.
+        assert_eq!(drag_in_view(0.0, false, 30.0, 0.0), (100.0, 0.2), "right grows");
+        assert_eq!(drag_in_view(0.0, false, 0.0, 40.0), (40.0, 0.4), "down hardens");
+        assert_eq!(drag_in_view(0.0, true, -30.0, 0.0), (100.0, 0.2), "flipped: screen right grows");
+        assert_eq!(drag_in_view(0.0, true, 0.0, 40.0), (40.0, 0.4), "flipped: down hardens");
+        // 90° clockwise: document +y points screen-left and document +x screen-down.
+        assert_eq!(drag_in_view(90.0, false, 0.0, 10.0), (20.0, 0.2), "screen-left shrinks, the hardness stays");
+        assert_eq!(drag_in_view(90.0, false, 0.0, -30.0), (100.0, 0.2), "screen-right grows");
+        assert_eq!(drag_in_view(90.0, false, 40.0, 0.0), (40.0, 0.4), "screen-down hardens, the size stays");
+        // 180°: document -x is screen right.
+        assert_eq!(drag_in_view(180.0, false, -30.0, 0.0), (100.0, 0.2), "screen right still grows");
+        assert_eq!(drag_in_view(180.0, false, 0.0, -40.0), (40.0, 0.4), "screen down still hardens");
+        // 90° and flipped: document +y points screen-right.
+        assert_eq!(drag_in_view(90.0, true, 0.0, 30.0), (100.0, 0.2), "rotated and flipped: screen right grows");
+    }
+
     /// Preferences ▸ Cursors ▸ Brush Preview colour tints the HUD's tip preview (red by default).
     #[test]
     fn the_tip_preview_uses_the_brush_preview_colour() {
diff --git a/crates/ui-egui/src/brush_sections.rs b/crates/ui-egui/src/brush_sections.rs
index 7fae63ffd0..ff7ca5d292 100644
--- a/crates/ui-egui/src/brush_sections.rs
+++ b/crates/ui-egui/src/brush_sections.rs
@@ -89,11 +89,16 @@ fn dynamic(ui: &mut egui::Ui, id: &str, label: &str, d: &mut Dynamic, max: f32,
     pct(ui, label, &mut d.jitter, max);
     control_row(ui, id, d, angle);
     if let Some(m) = minimum {
-        pct(ui, m, &mut d.minimum, 1.0);
+        minimum_row(ui, m, d);
     }
     ui.add_space(6.0);
 }
 
+/// Minimum belongs to the control. Off disables editing without discarding its saved value.
+fn minimum_row(ui: &mut egui::Ui, label: &str, d: &mut Dynamic) {
+    ui.add_enabled_ui(d.control != Control::Off, |ui| pct(ui, label, &mut d.minimum, 1.0));
+}
+
 /// Size: a value field over a logarithmic slider (small sizes get most of the travel).
 /// `restore` adds Photoshop's "Restore original size" button (sampled tips).
 fn size_row(ui: &mut egui::Ui, label: &str, size: &mut f32, max: f32, restore: Option<f32>) {
@@ -332,7 +337,7 @@ fn shape_dynamics(ui: &mut egui::Ui, b: &mut BrushSettings) {
     let sd = &mut b.shape_dynamics;
     pct(ui, tl!("Size Jitter"), &mut sd.size.jitter, 1.0);
     control_row(ui, "brush-size-ctl", &mut sd.size, false);
-    pct(ui, tl!("Minimum Diameter"), &mut sd.size.minimum, 1.0);
+    minimum_row(ui, tl!("Minimum Diameter"), &mut sd.size);
     // Tilt Scale applies with the size control on Pen Tilt (greyed out otherwise, like Photoshop).
     let tilt = sd.size.control == Control::PenTilt;
     ui.add_enabled_ui(tilt, |ui| pct(ui, tl!("Tilt Scale"), &mut sd.tilt_scale, 2.0));
@@ -395,14 +400,9 @@ fn pattern_swatch(ui: &mut egui::Ui, tx: &paint::Texture) {
                     _ => paint::tile::PatternImage { width: 1, height: 1, data: vec![0.5] },
                 },
             };
-            let (br, ct) = (tx.brightness.clamp(-1.0, 1.0), tx.contrast.clamp(-1.0, 1.0));
             let px: Vec<u8> = (0..n * n)
                 .flat_map(|i| {
-                    let v = img.sample_wrap((i % n) as f32, (i / n) as f32);
-                    let mut x = ((v - 0.5) * (1.0 + ct) + 0.5 + br).clamp(0.0, 1.0);
-                    if tx.invert {
-                        x = 1.0 - x;
-                    }
+                    let x = tx.level(img.sample_wrap((i % n) as f32, (i / n) as f32));
                     let g = (x * 255.0).round() as u8;
                     [g, g, g, 255]
                 })
@@ -512,10 +512,7 @@ fn color_dynamics(ui: &mut egui::Ui, b: &mut BrushSettings) {
     widgets::checkbox(ui, &mut c.per_tip, tl!("Apply Per Tip"));
     ui.add_space(6.0);
     dynamic(ui, "brush-fgbg-ctl", tl!("Foreground/Background Jitter"), &mut c.fg_bg, 1.0, None, false);
-    let mut h = (c.hue_jitter * 100.0).round();
-    if widgets::slider_row(ui, tl!("Hue Jitter"), &mut h, 0.0..=100.0, "%", Some(&widgets::hue_stops())).changed() {
-        c.hue_jitter = (h.round() / 100.0).clamp(0.0, 1.0);
-    }
+    pct(ui, tl!("Hue Jitter"), &mut c.hue_jitter, 1.0);
     pct(ui, tl!("Saturation Jitter"), &mut c.saturation_jitter, 1.0);
     pct(ui, tl!("Brightness Jitter"), &mut c.brightness_jitter, 1.0);
     signed_pct(ui, tl!("Purity"), &mut c.purity, -1.0, 1.0);
@@ -614,6 +611,150 @@ pub fn section_body(ui: &mut egui::Ui, b: &mut BrushSettings, i: usize, presets:
 #[cfg(test)]
 mod tests {
     use super::*;
+    use egui::accesskit::Role;
+    use egui_kittest::{
+        Harness,
+        kittest::{NodeT, Queryable},
+    };
+
+    fn minimum_brush() -> BrushSettings {
+        let mut b = BrushSettings::default();
+        b.shape_dynamics.size.minimum = 0.2;
+        b.shape_dynamics.roundness.minimum = 0.35;
+        b.transfer.opacity.minimum = 0.4;
+        b.transfer.flow.minimum = 0.55;
+        b.transfer.wetness.minimum = 0.6;
+        b.transfer.mix.minimum = 0.75;
+        b
+    }
+
+    fn section_harness(section: usize, b: BrushSettings) -> Harness<'static, BrushSettings> {
+        let mut ready = false;
+        let mut h = Harness::builder().with_size(vec2(340.0, 1100.0)).build_ui_state(
+            move |ui, b: &mut BrushSettings| {
+                if !ready {
+                    crate::PhotocraftApp::setup_context(ui.ctx(), theme::ThemeKind::ProMedium);
+                    ready = true;
+                    return;
+                }
+                section_body(ui, b, section, &[], None);
+            },
+            b,
+        );
+        h.run_steps(3);
+        h
+    }
+
+    /// #3825: jitter is an amount, not a hue selector; it uses the themed amount track.
+    #[test]
+    fn hue_jitter_paints_an_amount_track_in_every_theme() {
+        for kind in theme::ThemeKind::ALL {
+            let mut b = BrushSettings::default();
+            b.color_dynamics.hue_jitter = 0.37;
+            let mut h = section_harness(5, b.clone());
+            crate::PhotocraftApp::setup_context(&h.ctx, kind);
+            h.run_steps(3);
+            let label = h.get_by_label("Hue Jitter").rect();
+            let t = Tokens::get(&h.ctx);
+            assert!(
+                h.output().shapes.iter().any(|c| matches!(&c.shape, egui::Shape::Rect(r)
+                    if r.rect.width() > 150.0 && (r.rect.height() - 3.0).abs() < 0.1
+                    && r.rect.top() > label.bottom() && r.rect.bottom() < label.bottom() + 30.0
+                    && r.fill == t.field_border)),
+                "{kind:?}: Hue Jitter paints the same neutral track as other percentage amounts"
+            );
+            assert!(h.query_all_by_role(Role::SpinButton).any(|n| n.accesskit_node().numeric_value() == Some(37.0)));
+            assert_eq!(h.state(), &b, "rendering does not change saved brush settings");
+        }
+    }
+
+    fn set_controls(b: &mut BrushSettings, control: Control) {
+        for d in [
+            &mut b.shape_dynamics.size,
+            &mut b.shape_dynamics.roundness,
+            &mut b.transfer.opacity,
+            &mut b.transfer.flow,
+            &mut b.transfer.wetness,
+            &mut b.transfer.mix,
+        ] {
+            d.control = control;
+        }
+    }
+
+    /// #3825: all six minimum fields follow their own Control; jitter remains editable.
+    #[test]
+    fn minimum_fields_are_disabled_only_when_their_control_is_off() {
+        for (section, values) in [(1, vec![20.0, 35.0]), (6, vec![40.0, 55.0, 60.0, 75.0])] {
+            let mut h = section_harness(section, minimum_brush());
+            for (control, _) in CONTROLS {
+                set_controls(h.state_mut(), control);
+                h.run_steps(2);
+                for value in &values {
+                    let field = h.query_all_by_role(Role::SpinButton).find(|n| n.accesskit_node().numeric_value() == Some(*value)).expect("minimum input");
+                    assert_eq!(field.accesskit_node().is_disabled(), control == Control::Off, "section {section}, minimum {value}, {control:?}");
+                }
+                assert!(
+                    h.query_all_by_role(Role::SpinButton).any(|n| n.accesskit_node().numeric_value() == Some(0.0) && !n.accesskit_node().is_disabled()),
+                    "jitter stays editable"
+                );
+            }
+            set_controls(h.state_mut(), Control::PenPressure);
+            if section == 1 {
+                h.state_mut().shape_dynamics.size.control = Control::Off;
+            } else {
+                h.state_mut().transfer.opacity.control = Control::Off;
+            }
+            h.run_steps(2);
+            for (index, value) in values.iter().enumerate() {
+                let field = h.query_all_by_role(Role::SpinButton).find(|n| n.accesskit_node().numeric_value() == Some(*value)).unwrap();
+                assert_eq!(field.accesskit_node().is_disabled(), index == 0, "each minimum follows its own control");
+            }
+        }
+    }
+
+    fn drag(h: &mut Harness<'static, BrushSettings>, from: egui::Pos2, to: egui::Pos2) {
+        h.event(egui::Event::PointerMoved(from));
+        h.run_steps(1);
+        h.event(egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE });
+        h.run_steps(1);
+        h.event(egui::Event::PointerMoved(to));
+        h.run_steps(1);
+        h.event(egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE });
+        h.run_steps(2);
+    }
+
+    #[test]
+    fn disabled_minimum_ignores_input_and_keeps_its_value_for_reactivation() {
+        let mut h = section_harness(1, minimum_brush());
+        let before = h.state().clone();
+        let field = h.query_all_by_role(Role::SpinButton).find(|n| n.accesskit_node().numeric_value() == Some(20.0)).unwrap();
+        let center = field.rect().center();
+        field.click();
+        h.key_press(egui::Key::ArrowUp);
+        h.event(egui::Event::Text("99".into()));
+        h.key_press(egui::Key::Enter);
+        // The slider below the number and its scrubby label are disabled too.
+        let track = pos2(300.0, center.y + 24.0);
+        drag(&mut h, track, track);
+        let label = h.get_by_label("Minimum Diameter").rect().center();
+        drag(&mut h, label, label + vec2(60.0, 0.0));
+        assert_eq!(h.state(), &before, "disabled interactions never rewrite brush settings");
+
+        h.state_mut().shape_dynamics.size.control = Control::PenPressure;
+        h.run_steps(2);
+        let field = h.query_all_by_role(Role::SpinButton).find(|n| n.accesskit_node().numeric_value() == Some(20.0)).unwrap();
+        assert!(!field.accesskit_node().is_disabled());
+        field.click();
+        h.key_press(egui::Key::ArrowUp);
+        h.run_steps(2);
+        assert_eq!(h.state().shape_dynamics.size.minimum, 0.21, "active minimum is editable");
+        drag(&mut h, track, track);
+        let minimum = h.state().shape_dynamics.size.minimum;
+        assert!(minimum > 0.8, "the active slider accepts the same pointer position: {minimum}");
+        h.state_mut().shape_dynamics.size.control = Control::Off;
+        h.run_steps(2);
+        assert_eq!(h.state().shape_dynamics.size.minimum, minimum, "Off keeps the saved minimum");
+    }
 
     #[test]
     fn ellipse_widget_drags_angle_and_roundness() {
diff --git a/crates/ui-egui/src/brushes_tab.rs b/crates/ui-egui/src/brushes_tab.rs
index 59b3ba6df5..703b6e0290 100644
--- a/crates/ui-egui/src/brushes_tab.rs
+++ b/crates/ui-egui/src/brushes_tab.rs
@@ -2,9 +2,10 @@
 //! preview, name) or a grid of tips, with a size slider and a search field.
 //!
 //! Presets and groups are organised like Photoshop's panel: drag a preset within its group or
-//! into another group or folder (onto a preset, or onto a header to append), drag a group's
-//! header to reorder groups (a nested folder's header to reorder it among its sibling folders),
-//! and right-click for Rename and Delete. Groups hold nested folders ([`BrushPreset::folder`],
+//! into another group or folder (onto a preset, or onto a header to append), drag a group's or
+//! folder's header onto another header to put it inside that folder (or onto the header's upper
+//! edge to place it before, which reorders siblings and moves a folder out to the top level), and
+//! right-click for Rename and Delete. Groups hold nested folders ([`BrushPreset::folder`],
 //! e.g. an imported `.abr` file's own folders), drawn indented under their group and opened or
 //! closed like groups. Every change is a `brush.presets.*` command, so it is journaled, drivable,
 //! and persisted by the preset store.
@@ -16,9 +17,7 @@ use egui::{Color32, RichText, Sense, Stroke, pos2, vec2};
 use photocraft_engine::paint::{BrushPreset, MAX_BRUSH_SIZE};
 use serde_json::json;
 
-use crate::brush_panel::{
-    BrushesPanelState, BrushesView, Renaming, UNGROUPED, WIDTH, commit_gesture, full_uv, grouped_presets, new_preset_name, run_or_status,
-};
+use crate::brush_panel::{BrushesPanelState, BrushesView, Renaming, UNGROUPED, WIDTH, commit_gesture, full_uv, grouped_presets, run_or_status};
 use crate::brush_preview;
 use crate::theme::{self, Tokens};
 use crate::{PhotocraftApp, icons, widgets};
@@ -59,6 +58,15 @@ pub enum Action {
         folder: Vec<String>,
         before: Option<String>,
     },
+    /// Move a group (`folder` empty) or nested folder into another folder: `into` is (group,
+    /// folder path, `[]` = directly in the group), or `None` for the top level (it becomes a
+    /// group). `before` is a folder (or top-level group) there to land before.
+    MoveInto {
+        group: String,
+        folder: Vec<String>,
+        into: Option<(String, Vec<String>)>,
+        before: Option<String>,
+    },
     /// View only: show the rename bar for a preset or group ([`preset_list`] applies it).
     BeginRename(Renaming),
     /// Commit a rename typed in the rename bar.
@@ -238,6 +246,20 @@ pub fn apply(app: &mut PhotocraftApp, acts: Vec<Action>) {
                 }
                 run_or_status(app, "brush.presets.moveGroup", p);
             }
+            Action::MoveInto { group, folder, into, before } => {
+                let into = match into {
+                    Some((g, f)) => json!({ "group": g, "folder": f }),
+                    None => json!({}),
+                };
+                let mut p = json!({ "group": group, "into": into });
+                if !folder.is_empty() {
+                    p["folder"] = json!(folder);
+                }
+                if let Some(b) = before {
+                    p["before"] = json!(b);
+                }
+                run_or_status(app, "brush.presets.moveGroup", p);
+            }
             Action::Rename(r) => {
                 let text = r.text.trim().to_string();
                 let old = r.folder.last().unwrap_or(&r.name);
@@ -453,6 +475,22 @@ fn darker(c: Color32, f: f32) -> Color32 {
     Color32::from_rgba_unmultiplied((r as f32 * f).round() as u8, (g as f32 * f).round() as u8, (b as f32 * f).round() as u8, a)
 }
 
+/// Where a card's tip thumbnail goes in its `cell`. `number_h` is the height of the size number
+/// under it, `None` on compact cards (no number: the tip takes the cell whole). Otherwise the
+/// number keeps a band at the bottom of the cell and the tip is centred in what's left above it,
+/// at [`CARD_TIP_BASE`] × `scale` or that room's side, whichever is smaller, times the preset's
+/// [`crate::brush_sections::thumb_scale`]: big brushes still read bigger than small ones, and
+/// none of them reaches down over the number.
+fn card_tip_rect(cell: egui::Rect, number_h: Option<f32>, size: f32, scale: f32) -> egui::Rect {
+    let Some(number_h) = number_h else {
+        return egui::Rect::from_center_size(cell.center(), egui::Vec2::splat((cell.width().min(cell.height()) - 2.0).max(1.0)));
+    };
+    // The number sits 1 pt off the cell's bottom, with a 1 pt gap above it.
+    let room = egui::Rect::from_min_max(cell.min, pos2(cell.right(), (cell.bottom() - number_h - 2.0).max(cell.top())));
+    let side = (CARD_TIP_BASE * scale).min(room.width().min(room.height())).max(0.0) * crate::brush_sections::thumb_scale(size);
+    egui::Rect::from_center_size(room.center(), egui::Vec2::splat(if side.is_finite() { side.max(1.0) } else { 1.0 }))
+}
+
 /// One preset in the Brush Preset picker: a 2 × 2 grid whose bottom row (the name) spans both
 /// columns — tip at the top left, stroke preview at the top right. A part that's off loses its
 /// cell (the other takes the room): with only the tip and the name on, the name moves into the
@@ -523,18 +561,13 @@ fn preset_card(
         let tip_w = if tip_only { top.width() } else { (CARD_TIP_W * scale).min(top.width() * 0.5) };
         let cell = egui::Rect::from_min_size(top.left_top(), vec2(tip_w, top_h));
         let tip = brush_preview::tip_texture(ui.ctx(), &format!("brushes-tip:{}", p.name), &pb.tip, (pb.hardness, pb.angle, pb.roundness), 36, t.text);
-        let side = if compact { (cell.width().min(cell.height()) - 2.0).max(1.0) } else { CARD_TIP_BASE * scale * crate::brush_sections::thumb_scale(pb.size) };
-        let center = if compact { cell.center() } else { pos2(cell.center().x, cell.center().y - 2.0 * scale_h) };
-        let tr = egui::Rect::from_center_size(center, vec2(side, side));
+        let number =
+            (!compact).then(|| ui.painter().layout_no_wrap(format!("{}", pb.size.round() as i64), egui::FontId::proportional(CARD_NUM_FONT), t.text_faint));
+        let tr = card_tip_rect(cell, number.as_ref().map(|g| g.size().y), pb.size, scale);
         ui.painter().image(tip.id(), tr, full_uv(), Color32::WHITE);
-        if !compact {
-            ui.painter().text(
-                pos2(cell.center().x, cell.bottom() - 1.0),
-                egui::Align2::CENTER_BOTTOM,
-                format!("{}", pb.size.round() as i64),
-                egui::FontId::proportional(CARD_NUM_FONT),
-                t.text_faint,
-            );
+        if let Some(g) = number {
+            let at = pos2(cell.center().x - g.size().x / 2.0, cell.bottom() - 1.0 - g.size().y);
+            ui.painter().galley(at, g, t.text_faint);
         }
         x = cell.right();
     }
@@ -582,9 +615,41 @@ fn preset_card(
 /// Indent of one nested folder level.
 const FOLDER_INDENT: f32 = 16.0;
 
-/// A group's or nested folder's header: chevron, folder, name, count. Click toggles; drag
-/// reorders groups (a folder among its sibling folders); a preset dropped here moves to the end of
-/// the group or folder. `key` is the group key, `folder` the nested folder's path (empty for the
+/// What dropping the group or folder (`src_group`, `src_folder`; a group when `src_folder` is
+/// empty) on the header of (`group`, `folder`) does, as in Photoshop's Brushes panel: on the
+/// header's upper edge (`edge`) it lands before that folder, next to it (reordering when they are
+/// siblings); anywhere else it goes into that folder. `None` when the drop does nothing: onto
+/// itself, into one of its own folders, or into the folder it is already in.
+pub fn folder_drop(src_group: &str, src_folder: &[String], group: &str, folder: &[String], edge: bool) -> Option<Action> {
+    if src_group == group && folder.starts_with(src_folder) {
+        return None;
+    }
+    let src = (src_group.to_string(), src_folder.to_vec());
+    if !edge {
+        let parent = src_folder.split_last().map(|(_, p)| p);
+        if src_group == group && parent == Some(folder) {
+            return None;
+        }
+        return Some(Action::MoveInto { group: src.0, folder: src.1, into: Some((group.to_string(), folder.to_vec())), before: None });
+    }
+    match folder.split_last() {
+        // Before a top-level group: groups reorder; a nested folder moves out to the top level.
+        None if src_folder.is_empty() => Some(Action::MoveGroup { group: src.0, folder: src.1, before: Some(group.to_string()) }),
+        None => Some(Action::MoveInto { group: src.0, folder: src.1, into: None, before: Some(group.to_string()) }),
+        Some((leaf, parent)) => {
+            let sibling = src_group == group && src_folder.split_last().map(|(_, p)| p) == Some(parent);
+            if sibling {
+                Some(Action::MoveGroup { group: src.0, folder: src.1, before: Some(leaf.clone()) })
+            } else {
+                Some(Action::MoveInto { group: src.0, folder: src.1, into: Some((group.to_string(), parent.to_vec())), before: Some(leaf.clone()) })
+            }
+        }
+    }
+}
+
+/// A group's or nested folder's header: chevron, folder, name, count. Click toggles; a group or
+/// folder dragged here lands before it (its upper edge) or goes into it ([`folder_drop`]); a
+/// preset dropped here moves to the end of the group or folder. `key` is the group key, `folder` the nested folder's path (empty for the
 /// group), `label` the group's panel label.
 fn group_header(ui: &mut egui::Ui, label: &str, key: &str, folder: &[String], open: bool, count: usize, acts: &mut Vec<Action>) {
     let t = Tokens::get(ui.ctx());
@@ -616,31 +681,27 @@ fn group_header(ui: &mut egui::Ui, label: &str, key: &str, folder: &[String], op
         [] => BrushDrag::Group(key.to_string()),
         f => BrushDrag::Folder { group: key.to_string(), folder: f.to_vec() },
     };
-    // A folder moves among its siblings: same group, same parent, not itself.
-    let sibling = |g: &str, f: &[String]| {
-        g == key && !folder.is_empty() && f.len() == folder.len() && f != folder && f.split_last().map(|x| x.1) == folder.split_last().map(|x| x.1)
-    };
     resp.dnd_set_drag_payload(me);
+    // The upper third of the header places a dragged folder before this one; the rest drops it in.
+    let edge = ui.ctx().pointer_interact_pos().is_some_and(|p| p.y < r.top() + r.height() / 3.0);
+    let folder_action = |d: &BrushDrag| match d {
+        BrushDrag::Group(g) => folder_drop(g, &[], key, folder, edge),
+        BrushDrag::Folder { group, folder: f } => folder_drop(group, f, key, folder, edge),
+        BrushDrag::Preset(_) => None,
+    };
     if let Some(d) = resp.dnd_hover_payload::<BrushDrag>() {
-        match &*d {
-            BrushDrag::Group(g) if folder.is_empty() && g != key => widgets::drop_line(ui, r, false, false, &t),
-            BrushDrag::Folder { group, folder: f } if sibling(group, f) => widgets::drop_line(ui, r, false, false, &t),
-            BrushDrag::Preset(_) => {
+        match (&*d, folder_action(&d)) {
+            (BrushDrag::Preset(_), _) | (_, Some(Action::MoveInto { before: None, .. })) => {
                 ui.painter().rect_stroke(r, t.radius_sm, Stroke::new(1.5, t.accent), egui::StrokeKind::Inside);
             }
+            (_, Some(_)) => widgets::drop_line(ui, r, false, false, &t),
             _ => {}
         }
     }
     if let Some(d) = resp.dnd_release_payload::<BrushDrag>() {
         match &*d {
-            BrushDrag::Group(g) if folder.is_empty() && g != key => {
-                acts.push(Action::MoveGroup { group: g.clone(), folder: Vec::new(), before: Some(key.to_string()) })
-            }
-            BrushDrag::Folder { group, folder: f } if sibling(group, f) => {
-                acts.push(Action::MoveGroup { group: group.clone(), folder: f.clone(), before: Some(shown.to_string()) })
-            }
             BrushDrag::Preset(n) => acts.push(Action::Move { name: n.clone(), group: key.to_string(), folder: Some(folder.to_vec()), index: None }),
-            _ => {}
+            other => acts.extend(folder_action(other)),
         }
     }
     if resp.clicked() {
@@ -892,7 +953,7 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     ui.horizontal(|ui| {
         icons::paint(ui, egui::Rect::from_min_size(ui.cursor().min + vec2(0.0, 3.0), vec2(16.0, 16.0)), "search", 14.0, t.text_faint);
         ui.add_space(20.0);
-        ui.add(egui::TextEdit::singleline(&mut app.ui.brushes_panel.filter).hint_text(tl!("Search Brushes")).desired_width(WIDTH - 120.0));
+        widgets::text_field(ui, ui.id().with("brush-search"), &mut app.ui.brushes_panel.filter, tl!("Search Brushes"), WIDTH - 120.0, false);
         ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
             let view = &mut app.ui.brushes_panel.view;
             let grid_tip = "Grid view";
@@ -923,9 +984,9 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             {
                 run_or_status(app, "brush.presets.delete", json!({ "name": name }));
             }
-            if icons::button(ui, "square-plus", 24.0, false, "Create new brush from the current settings").clicked() {
-                let name = new_preset_name(&app.session.tools.presets);
-                run_or_status(app, "brush.presets.save", json!({ "name": name }));
+            let new = icons::button(ui, "square-plus", 24.0, false, "Create new brush from the current settings");
+            if crate::brush_picker::named(new, "Create new brush from the current settings").clicked() {
+                crate::brush_preset_dialog::open(app, None);
             }
             if icons::button(ui, "folder-open", 24.0, false, "Import Brushes… (.abr)").clicked() {
                 let _ = app.open_dialog_file();
diff --git a/crates/ui-egui/src/brushes_tab_tests.rs b/crates/ui-egui/src/brushes_tab_tests.rs
index 3a225aa6c6..4c61ecc54d 100644
--- a/crates/ui-egui/src/brushes_tab_tests.rs
+++ b/crates/ui-egui/src/brushes_tab_tests.rs
@@ -265,3 +265,56 @@ fn the_brushes_tab_grid_is_centred_past_its_indent() {
     h.run_steps(6);
     rows_are_centred(&h, PANEL_LIST.indent, 2);
 }
+
+/// #4454: a card's size number sat under the tip thumbnail of any medium or large brush (the
+/// tip took up to 44.8 pt of a 42 pt cell, the number anchored to the cell's bottom), so the
+/// "30" of Hard Round and the "45" of Soft Round couldn't be read. At every footer scale that
+/// shows numbers, in each card kind, the tip now stays above the number, and bigger brushes still
+/// get bigger tips.
+#[test]
+fn card_tips_never_cover_their_size_number() {
+    let number_h = std::rc::Rc::new(std::cell::Cell::new(0.0_f32));
+    let seen = number_h.clone();
+    let mut h = Harness::new_ui(move |ui| {
+        let g = ui.painter().layout_no_wrap("45".into(), egui::FontId::proportional(CARD_NUM_FONT), Color32::WHITE);
+        seen.set(g.size().y);
+    });
+    PhotocraftApp::setup_context(&h.ctx, Default::default());
+    h.run();
+    let number_h = number_h.get();
+    assert!(number_h > 8.0, "the number has a real height: {number_h}");
+    let mut scale = CARD_COMPACT_SCALE + 0.01;
+    while scale <= *crate::brush_picker::SCALE_RANGE.end() + 1e-3 {
+        let scale_h = scale.max(CARD_MIN_H_SCALE);
+        // The tip cell of a full card (name row under it), a tip-and-name card and a tip-only one,
+        // as [`preset_card`] sizes them in a wide column.
+        let cells = [
+            vec2(CARD_TIP_W * scale, (CARD_MAX_H - CARD_PAD * 2.0 - CARD_NAME_H) * scale_h),
+            vec2(CARD_TIP_W * scale, (CARD_TIP_NAME_H - CARD_PAD * 2.0) * scale_h),
+            vec2((CARD_TIP_ONLY_W - 16.0) * scale, (CARD_TIP_ONLY_H - CARD_PAD * 2.0) * scale_h),
+        ];
+        for size in cells {
+            let cell = Rect::from_min_size(egui::pos2(10.0, 20.0), size);
+            let number_top = cell.bottom() - 1.0 - number_h;
+            let mut last = 0.0;
+            for brush in [1.0, 5.0, 13.0, 30.0, 45.0, 100.0, 2500.0] {
+                let tip = card_tip_rect(cell, Some(number_h), brush, scale);
+                assert!(tip.bottom() <= number_top + 1e-3, "scale {scale}, cell {size:?}, {brush} px: tip {tip:?} reaches the number at {number_top}");
+                assert!(cell.expand(1e-3).contains_rect(tip), "scale {scale}, {brush} px: tip {tip:?} leaves its cell {cell:?}");
+                assert!(tip.width() >= last, "scale {scale}, {brush} px: a bigger brush gets a smaller tip");
+                last = tip.width();
+            }
+        }
+        scale += 0.05;
+    }
+    // The tip-only grid's cells are tall enough for the number: a big brush's tip still spans
+    // the cell's width.
+    let cell = Rect::from_min_size(egui::pos2(0.0, 0.0), vec2(CARD_TIP_ONLY_W - 16.0, CARD_TIP_ONLY_H - CARD_PAD * 2.0));
+    assert!((card_tip_rect(cell, Some(number_h), 45.0, 1.0).width() - cell.width()).abs() < 1e-3);
+    // Compact cards: no number, the tip fills the cell; nonsense never makes a non-finite rect.
+    assert_eq!(card_tip_rect(cell, None, 45.0, 0.5).width(), cell.width() - 2.0);
+    for (n, size, scale) in [(f32::NAN, 30.0, 1.0), (500.0, f32::NAN, 1.0), (12.0, 30.0, f32::INFINITY), (12.0, -5.0, 0.0)] {
+        let r = card_tip_rect(cell, Some(n), size, scale);
+        assert!(r.min.is_finite() && r.max.is_finite(), "{n} {size} {scale}: {r:?}");
+    }
+}
diff --git a/crates/ui-egui/src/cam_preview.rs b/crates/ui-egui/src/cam_preview.rs
new file mode 100644
index 0000000000..4065e3353c
--- /dev/null
+++ b/crates/ui-egui/src/cam_preview.rs
@@ -0,0 +1,285 @@
+//! Content-Aware Move drags and its Transform On Drop box shown with the result: once the pointer
+//! (or the box) rests for a moment, the move is computed as a background job
+//! ([`photocraft_engine::retouch_cmds::content_aware_move_preview`]: a smaller sampling window than
+//! the command and only small selections) and the canvas shows the document with it. Any change of
+//! the offset, scale or rotation cancels the job and starts the wait again, so the UI never waits
+//! for the blend. Releasing (or Enter) runs the exact `paint.contentAwareMove`; the document is
+//! untouched until then. Not available on wasm (no threads).
+
+use std::sync::Arc;
+use std::sync::mpsc::{Receiver, TryRecvError};
+
+use photocraft_doc::{DocId, Document};
+use photocraft_engine::jobs::JobCtx;
+use serde_json::Value;
+
+use crate::PhotocraftApp;
+use crate::state::Tool;
+
+/// Preview keys: `BASE + n`, one per result shown (see `canvas::display_doc`).
+const BASE: u64 = 1 << 45;
+/// How long the move must stay unchanged before a preview is computed.
+const DEBOUNCE_MS: f64 = 150.0;
+/// How often a running job is polled for its result.
+const POLL_MS: u64 = 40;
+
+struct Running {
+    key: String,
+    ctx: JobCtx,
+    rx: Receiver<photocraft_engine::Result<Document>>,
+}
+
+pub(crate) struct CamPreview {
+    doc: DocId,
+    revision: u64,
+    /// The params the move has now, and when they last changed (ms).
+    key: String,
+    since: f64,
+    /// Params whose preview failed (too large a selection, say): not tried again.
+    failed: Option<String>,
+    running: Option<Running>,
+    /// The latest finished preview, with the params it shows.
+    shown: Option<(String, Arc<Document>)>,
+    serial: u64,
+}
+
+impl CamPreview {
+    fn stop(&mut self) {
+        if let Some(r) = self.running.take() {
+            r.ctx.cancel();
+        }
+    }
+}
+
+impl Drop for CamPreview {
+    fn drop(&mut self) {
+        self.stop();
+    }
+}
+
+/// `paint.contentAwareMove`'s params for what the pointer or the box has now; `None` without a
+/// move to preview.
+fn wanted(app: &mut PhotocraftApp) -> Option<Value> {
+    if app.ui.tool != Tool::ContentAwareMove || cfg!(target_arch = "wasm32") {
+        return None;
+    }
+    if let Some(t) = &app.ui.cam_transform {
+        let place = crate::cam_transform::placement(t)?;
+        if place.offset == [0, 0] && place.is_plain_move() {
+            return None;
+        }
+        return Some(crate::cam_transform::params(app, &place));
+    }
+    let d = app.drag.as_ref().filter(|d| d.tool == Tool::ContentAwareMove)?;
+    let (start, mods) = (d.start, d.modifiers);
+    let end = d.points.last().map_or(start, |p| [p[0], p[1]]);
+    if !crate::retouch_ui::patch_drags_selection(app, start, mods) {
+        return None;
+    }
+    let off = crate::retouch_ui::patch_offset(app, start, end);
+    (off != [0, 0]).then(|| crate::retouch_ui::content_aware_move_params(app, off.map(i64::from)))
+}
+
+/// The document to show for the move on document `idx`: with the move applied, once its preview
+/// has been computed for the current offset and transform.
+pub(crate) fn display_doc(app: &mut PhotocraftApp, idx: usize) -> Option<(Arc<Document>, u64)> {
+    if app.session.active_index() != Some(idx) {
+        return None;
+    }
+    step(app, crate::gpu_canvas::now_ms())
+}
+
+fn step(app: &mut PhotocraftApp, now: f64) -> Option<(Arc<Document>, u64)> {
+    let Some(params) = wanted(app) else {
+        app.cam_preview = None;
+        return None;
+    };
+    let st = app.session.active()?;
+    let (doc, revision) = (st.doc.id, st.revision);
+    let key = params.to_string();
+    if app.cam_preview.as_ref().is_some_and(|p| p.doc != doc || p.revision != revision) {
+        app.cam_preview = None;
+    }
+    let p = app.cam_preview.get_or_insert_with(|| CamPreview {
+        doc,
+        revision,
+        key: String::new(),
+        since: now,
+        failed: None,
+        running: None,
+        shown: None,
+        serial: 0,
+    });
+    if p.key != key {
+        p.key = key.clone();
+        p.since = now;
+        // What is computing is already out of date.
+        if p.running.as_ref().is_some_and(|r| r.key != key) {
+            p.stop();
+        }
+    }
+    if let Some(r) = &p.running {
+        match r.rx.try_recv() {
+            Ok(result) => {
+                let r = p.running.take();
+                match (result, r) {
+                    (Ok(d), Some(r)) => {
+                        // Duotone documents display through their inks.
+                        let d = photocraft_engine::mode_cmds::display_document(&d).unwrap_or(d);
+                        p.shown = Some((r.key, Arc::new(d)));
+                        p.serial += 1;
+                    }
+                    (_, Some(r)) => p.failed = Some(r.key),
+                    _ => {}
+                }
+            }
+            Err(TryRecvError::Disconnected) => {
+                if let Some(r) = p.running.take() {
+                    p.failed = Some(r.key);
+                }
+            }
+            Err(TryRecvError::Empty) => {}
+        }
+    }
+    let settled = now - p.since >= DEBOUNCE_MS;
+    let done = p.shown.as_ref().is_some_and(|s| s.0 == key);
+    if settled && !done && p.running.is_none() && p.failed.as_deref() != Some(&key) {
+        match start(app, &params, key.clone()) {
+            Some(r) => app.cam_preview.as_mut()?.running = Some(r),
+            None => app.cam_preview.as_mut()?.failed = Some(key.clone()),
+        }
+    }
+    let p = app.cam_preview.as_ref()?;
+    // Only a preview of the move as it is now: an older one would show a wrong place.
+    let (_, d) = p.shown.as_ref().filter(|s| s.0 == key)?;
+    Some((d.clone(), BASE + p.serial))
+}
+
+/// Compute the preview of `params` on a worker thread.
+fn start(app: &PhotocraftApp, params: &Value, key: String) -> Option<Running> {
+    let job = photocraft_engine::retouch_cmds::content_aware_move_preview(&app.session, params).ok()?;
+    let ctx = JobCtx::new();
+    let (tx, rx) = std::sync::mpsc::channel();
+    let worker = ctx.clone();
+    std::thread::Builder::new()
+        .name("cam-preview".into())
+        .spawn(move || {
+            let _ = tx.send(job.run(&worker).map(|(d, _)| d));
+        })
+        .ok()?;
+    Some(Running { key, ctx, rx })
+}
+
+/// Keep frames coming while a preview waits out its debounce or computes.
+pub(crate) fn wake(app: &PhotocraftApp, ctx: &egui::Context) {
+    let Some(p) = &app.cam_preview else { return };
+    if p.running.is_some() {
+        ctx.request_repaint_after(std::time::Duration::from_millis(POLL_MS));
+    } else if p.shown.as_ref().is_none_or(|s| s.0 != p.key) && p.failed.as_deref() != Some(&p.key) {
+        let left = (DEBOUNCE_MS - (crate::gpu_canvas::now_ms() - p.since)).max(1.0);
+        ctx.request_repaint_after(std::time::Duration::from_millis(left as u64));
+    }
+}
+
+/// Whether the canvas shows a preview.
+pub(crate) fn showing(app: &PhotocraftApp) -> bool {
+    app.cam_preview.as_ref().is_some_and(|p| p.shown.as_ref().is_some_and(|s| s.0 == p.key))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::canvas::{ToolEvent, tool_event};
+    use serde_json::json;
+
+    fn blue(d: &Document, x: i32, y: i32) -> bool {
+        d.layers[0].surface().unwrap().rgba(x, y)[0] < 0.5
+    }
+
+    #[test]
+    fn the_drag_previews_the_move_after_it_rests_and_never_touches_the_document() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 100, "height": 60})).unwrap();
+        app.run("paint.pencil", json!({"points": [[16, 30], [28, 30]], "size": 4, "color": "#0000ff"})).unwrap();
+        app.run("select.lasso", json!({"points": [[6, 14], [38, 14], [38, 46], [6, 46]]})).unwrap();
+        app.ui.tool = Tool::ContentAwareMove;
+        let m = egui::Modifiers::NONE;
+        let steps = app.session.active().unwrap().history.past_len();
+
+        // Nothing to preview before the patch moves.
+        tool_event(&mut app, ToolEvent::Down { x: 22.0, y: 30.0, pressure: 1.0 }, m);
+        assert!(step(&mut app, 0.0).is_none() && app.cam_preview.is_none());
+        tool_event(&mut app, ToolEvent::Move { x: 72.0, y: 30.0, pressure: 1.0 }, m);
+        // Still moving: the wait starts and nothing is computed or shown yet.
+        assert!(step(&mut app, 1000.0).is_none());
+        assert!(step(&mut app, 1000.0 + DEBOUNCE_MS / 2.0).is_none() && app.cam_preview.as_ref().unwrap().running.is_none());
+        // At rest: the job runs, off this thread, and its result shows once it arrives.
+        let mut now = 1000.0 + DEBOUNCE_MS;
+        let mut shown = step(&mut app, now);
+        for _ in 0..600 {
+            if shown.is_some() {
+                break;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+            now += 10.0;
+            shown = step(&mut app, now);
+        }
+        let (preview, key) = shown.expect("a preview once the pointer rested");
+        assert!(key > BASE && showing(&app));
+        assert!(blue(&preview, 72, 30) && !blue(&preview, 22, 30), "the preview shows the move");
+        let doc = app.session.active().unwrap().doc.clone();
+        assert!(blue(&doc, 22, 30) && !blue(&doc, 72, 30), "the document is untouched");
+        assert_eq!(app.session.active().unwrap().history.past_len(), steps);
+
+        // Moving on drops the stale preview at once and cancels what is not shown yet.
+        tool_event(&mut app, ToolEvent::Move { x: 60.0, y: 30.0, pressure: 1.0 }, m);
+        assert!(step(&mut app, now + 5.0).is_none() && !showing(&app));
+        // Release commits the exact move; the preview is gone.
+        tool_event(&mut app, ToolEvent::Up { x: 60.0, y: 30.0 }, m);
+        assert!(step(&mut app, now + 10.0).is_none() && app.cam_preview.is_none());
+    }
+
+    #[test]
+    fn the_transform_on_drop_box_previews_the_dropped_patch() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 100, "height": 60})).unwrap();
+        app.run("paint.pencil", json!({"points": [[16, 30], [28, 30]], "size": 4, "color": "#0000ff"})).unwrap();
+        app.run("select.lasso", json!({"points": [[6, 14], [38, 14], [38, 46], [6, 46]]})).unwrap();
+        app.ui.tool = Tool::ContentAwareMove;
+        app.ui.tool_options.cam_transform_on_drop = true;
+        let m = egui::Modifiers::NONE;
+        tool_event(&mut app, ToolEvent::Down { x: 22.0, y: 30.0, pressure: 1.0 }, m);
+        tool_event(&mut app, ToolEvent::Move { x: 72.0, y: 30.0, pressure: 1.0 }, m);
+        tool_event(&mut app, ToolEvent::Up { x: 72.0, y: 30.0 }, m);
+        assert!(crate::cam_transform::active(&app));
+        let (mut now, mut shown) = (0.0, step(&mut app, 0.0));
+        for _ in 0..800 {
+            if shown.is_some() {
+                break;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+            now += 10.0;
+            shown = step(&mut app, now);
+        }
+        let (preview, _) = shown.expect("the box shows the result");
+        assert!(blue(&preview, 72, 30) && !blue(&preview, 22, 30));
+        // Cancelling the box drops the preview.
+        crate::cam_transform::cancel(&mut app);
+        assert!(step(&mut app, now + 1.0).is_none() && app.cam_preview.is_none());
+    }
+
+    #[test]
+    fn a_selection_too_large_to_preview_is_not_retried() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 600, "height": 400})).unwrap();
+        app.run("select.rect", json!({"x": 10, "y": 10, "width": 300, "height": 300})).unwrap();
+        app.ui.tool = Tool::ContentAwareMove;
+        let m = egui::Modifiers::NONE;
+        tool_event(&mut app, ToolEvent::Down { x: 100.0, y: 100.0, pressure: 1.0 }, m);
+        tool_event(&mut app, ToolEvent::Move { x: 140.0, y: 100.0, pressure: 1.0 }, m);
+        assert!(step(&mut app, 0.0).is_none());
+        assert!(step(&mut app, DEBOUNCE_MS + 1.0).is_none());
+        let p = app.cam_preview.as_ref().unwrap();
+        assert!(p.running.is_none() && p.failed.as_deref() == Some(p.key.as_str()));
+    }
+}
diff --git a/crates/ui-egui/src/cam_transform.rs b/crates/ui-egui/src/cam_transform.rs
index 33912a28e8..a2afa8d812 100644
--- a/crates/ui-egui/src/cam_transform.rs
+++ b/crates/ui-egui/src/cam_transform.rs
@@ -59,6 +59,7 @@ pub(crate) fn begin(app: &mut PhotocraftApp, offset: [i32; 2]) -> bool {
         made: None,
         mode: Default::default(),
         content_aware: None,
+        skew_v: 0.0,
     };
     app.ui.cam_transform = Some(CamTransform { document, revision, offset, frame, gesture: None });
     app.ui.status = crate::i18n::fmt(tl!("Scale or rotate the moved area, then press {key}"), &[("key", &crate::shortcuts::pretty("Enter"))]);
@@ -112,6 +113,17 @@ pub(crate) fn cancel_stale(app: &mut PhotocraftApp) {
     }
 }
 
+/// `paint.contentAwareMove`'s params for the box's placement and the options bar.
+pub(crate) fn params(app: &PhotocraftApp, place: &Placement) -> serde_json::Value {
+    let mut p = crate::retouch_ui::content_aware_move_params(app, place.offset);
+    if !place.is_plain_move() {
+        p["scaleX"] = place.scale[0].into();
+        p["scaleY"] = place.scale[1].into();
+        p["rotate"] = place.rotate.into();
+    }
+    p
+}
+
 /// ↩ / ✓: the move with the transformed patch, as one background job and History step.
 pub(crate) fn commit(app: &mut PhotocraftApp) {
     cancel_stale(app);
@@ -122,12 +134,7 @@ pub(crate) fn commit(app: &mut PhotocraftApp) {
         crate::retouch_ui::patch_hint(app);
         return;
     }
-    let mut p = crate::retouch_ui::content_aware_move_params(app, place.offset);
-    if !place.is_plain_move() {
-        p["scaleX"] = place.scale[0].into();
-        p["scaleY"] = place.scale[1].into();
-        p["rotate"] = place.rotate.into();
-    }
+    let p = params(app, &place);
     if let Err(e) = app.run("paint.contentAwareMove", p) {
         app.ui.status = e;
         app.ui.status_error = true;
diff --git a/crates/ui-egui/src/camera_raw_detail_ui.rs b/crates/ui-egui/src/camera_raw_detail_ui.rs
index f8cbf66c0c..7b445f1775 100644
--- a/crates/ui-egui/src/camera_raw_detail_ui.rs
+++ b/crates/ui-egui/src/camera_raw_detail_ui.rs
@@ -341,17 +341,51 @@ fn visible_pixels(image: Rect, viewport: Rect, area: PixelRect, max_side: usize)
     (crop.width() as usize <= max_side && crop.height() as usize <= max_side && crop.width() as u64 * crop.height() as u64 <= 16_777_216).then_some(crop)
 }
 
+/// Pixels per band [`display_image`] reads and colour-converts at once: at least `photocraft-cms`'s
+/// parallel threshold (16K pixels), and small enough that a band's float scratch is 1 MiB.
+const CROP_BAND_PIXELS: usize = 64 * 1024;
+
+/// The visible pixels of `surface`, as the canvas shows them.
 fn crop_image(surface: &Surface, area: PixelRect, display: &photocraft_engine::display_color::CanvasDisplay) -> ColorImage {
-    let width = area.width() as usize;
-    let mut row = vec![[0.0; 4]; width];
-    let mut pixels = Vec::with_capacity(width * area.height() as usize);
-    for y in area.y0..area.y1 {
-        surface.read_rgba_into(PixelRect::new(area.x0, y, area.x1, y + 1), &mut row);
-        let buf = photocraft_compose::Buffer { rect: photocraft_geom::Rect::new(area.x0, y, area.x1, y + 1), px: row.clone() };
-        let img = display.to_rgba8(&buf);
-        pixels.extend(img.pixels.as_chunks::<4>().0.iter().map(|&[r, g, b, a]| Color32::from_rgba_unmultiplied(r, g, b, a)));
+    display_image(area, display, |rect, out| surface.read_rgba_into(rect, out))
+}
+
+/// `area` as the canvas shows it, with `read` filling each band's float pixels. Converted in
+/// bands of rows, in parallel off wasm, not one row or one whole copy at a time: a row is below
+/// `photocraft-cms`'s parallel threshold, so a per-row conversion ran the display transform (any
+/// document profile other than the monitor's, such as an Adobe RGB photo on sRGB) on one core of
+/// the UI thread for every edit (#4682).
+pub(crate) fn display_image(
+    area: PixelRect,
+    display: &photocraft_engine::display_color::CanvasDisplay,
+    read: impl Fn(PixelRect, &mut [[f32; 4]]) + Sync,
+) -> ColorImage {
+    let (width, height) = (area.width() as usize, area.height() as usize);
+    let mut pixels = vec![Color32::TRANSPARENT; width * height];
+    if width == 0 {
+        return ColorImage::new([width, height], pixels);
     }
-    ColorImage::new([width, area.height() as usize], pixels)
+    let band_rows = (CROP_BAND_PIXELS / width).max(1);
+    let band = |index: usize, out: &mut [Color32]| {
+        let y0 = area.y0.saturating_add((index * band_rows) as i32);
+        let rect = PixelRect::new(area.x0, y0, area.x1, y0.saturating_add((out.len() / width) as i32));
+        let mut buf = photocraft_compose::Buffer { rect, px: vec![[0.0; 4]; out.len()] };
+        read(rect, &mut buf.px);
+        let img = display.to_rgba8(&buf);
+        for (o, &[r, g, b, a]) in out.iter_mut().zip(img.pixels.as_chunks::<4>().0) {
+            *o = Color32::from_rgba_unmultiplied(r, g, b, a);
+        }
+    };
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        use rayon::prelude::*;
+        pixels.par_chunks_mut(band_rows * width).enumerate().for_each(|(i, out)| band(i, out));
+    }
+    #[cfg(target_arch = "wasm32")]
+    for (i, out) in pixels.chunks_mut(band_rows * width).enumerate() {
+        band(i, out);
+    }
+    ColorImage::new([width, height], pixels)
 }
 
 #[cfg(test)]
@@ -467,4 +501,47 @@ mod tests {
         assert!(visible_pixels(image, Rect::from_min_size(Pos2::ZERO, vec2(8000.0, 6000.0)), area, 4096).is_none());
         assert!(visible_pixels(Rect::NOTHING, visible, area, 4096).is_none());
     }
+
+    #[test]
+    fn banded_crop_matches_one_conversion_of_the_whole_area() {
+        // Several bands, a ragged last one and an area off the image origin, through a real
+        // transform (an Adobe RGB document on an sRGB monitor) and without one.
+        let area = PixelRect::new(-3, 5, 1021, 5 + 2 * (CROP_BAND_PIXELS / 1024) as i32 + 7);
+        let mut source = Surface::new(PixelFormat { mode: photocraft_color::ColorMode::Rgb, sample: photocraft_color::SampleType::U8, alpha: true });
+        let n = (area.width() * area.height()) as usize;
+        let px: Vec<f32> = (0..n).flat_map(|i| [(i % 251) as f32 / 255.0, (i % 241) as f32 / 255.0, (i % 239) as f32 / 255.0, (i % 7) as f32 / 6.0]).collect();
+        source.write_region(area, &px);
+        for profile in [photocraft_cms::Builtin::AdobeRgbCompat, photocraft_cms::Builtin::Srgb] {
+            let mut doc =
+                photocraft_doc::Document::new("test", photocraft_geom::Size::new(1024, 1024), photocraft_doc::ColorMode::Rgb, photocraft_doc::SampleType::U8);
+            doc.icc_profile = Some(profile.profile().to_bytes());
+            let mut color = photocraft_engine::color_cmds::ColorState::default();
+            color.settings.monitor_profile = "srgb".into();
+            let display = color.canvas_display(&doc).unwrap();
+            assert_eq!(display.transform.is_some(), profile == photocraft_cms::Builtin::AdobeRgbCompat);
+            let mut whole = photocraft_compose::Buffer { rect: area, px: vec![[0.0; 4]; n] };
+            source.read_rgba_into(area, &mut whole.px);
+            let expected = display.to_rgba8(&whole);
+            let image = crop_image(&source, area, &display);
+            assert_eq!(image.size, [area.width() as usize, area.height() as usize]);
+            let expected: Vec<Color32> = expected.pixels.as_chunks::<4>().0.iter().map(|&[r, g, b, a]| Color32::from_rgba_unmultiplied(r, g, b, a)).collect();
+            assert_eq!(image.pixels, expected, "{profile:?}");
+        }
+        assert_eq!(
+            crop_image(
+                &source,
+                PixelRect::new(0, 0, 0, 4),
+                &photocraft_engine::color_cmds::ColorState::default()
+                    .canvas_display(&photocraft_doc::Document::new(
+                        "t",
+                        photocraft_geom::Size::new(1, 1),
+                        photocraft_doc::ColorMode::Rgb,
+                        photocraft_doc::SampleType::U8
+                    ))
+                    .unwrap()
+            )
+            .size,
+            [0, 4]
+        );
+    }
 }
diff --git a/crates/ui-egui/src/camera_raw_preview_ui.rs b/crates/ui-egui/src/camera_raw_preview_ui.rs
index e0f4938116..f71959d5d5 100644
--- a/crates/ui-egui/src/camera_raw_preview_ui.rs
+++ b/crates/ui-egui/src/camera_raw_preview_ui.rs
@@ -122,10 +122,8 @@ pub(crate) fn interact(ui: &mut Ui, state: &mut CameraRawPreviewState, viewport:
             crate::tool_cursor::hand(ui.ctx(), false)
         } else if !zoom_tool {
             egui::CursorIcon::Crosshair
-        } else if modifiers.alt {
-            egui::CursorIcon::ZoomOut
         } else {
-            egui::CursorIcon::ZoomIn
+            crate::tool_cursor::zoom(ui.ctx(), modifiers.alt)
         });
     }
     let capture_id = response.id.with("zoom-capture");
diff --git a/crates/ui-egui/src/camera_raw_ui.rs b/crates/ui-egui/src/camera_raw_ui.rs
index 8b77e7a08e..f3e2aa8fbb 100644
--- a/crates/ui-egui/src/camera_raw_ui.rs
+++ b/crates/ui-egui/src/camera_raw_ui.rs
@@ -7,7 +7,9 @@
 //! one history step (or a smart filter on a smart object) and exactly replayable.
 //!
 //! Control channel: `ui.menu.invoke {"id":"filter.cameraRaw","params":{"ui":{"set":{…},
-//! "commit":true | "cancel":true}}}`; the reply describes the dialog.
+//! "commit":true | "cancel":true}}}`; the reply describes the dialog. `{"ui":{"saveSettings":true}}`
+//! and `{"ui":{"loadSettings":true}}` run Save Settings… / Load Settings… (Camera Raw `.xmp`
+//! settings files, see [`photocraft_io::camera_raw_xmp`]) through the file dialog.
 
 use egui::{Align2, Color32, FontId, Pos2, Rect as ERect, Sense, Stroke, TextureHandle, pos2, vec2};
 use photocraft_algo::camera_raw::{CameraRaw, Wheel, curve_lut};
@@ -64,6 +66,9 @@ pub struct CameraRawDialog {
     pub render_ms: f64,
     /// Set for the open-time dialog ([`Target::OpenRaw`]).
     raw_open: Option<RawOpen>,
+    /// The open-time dialog's camera tone curve: Shadows / Highlights act on the raw data there,
+    /// in linear light before this curve, and the preview undoes it to show the same.
+    raw_curve: Option<Vec<[f32; 2]>>,
 }
 
 impl CameraRawDialog {
@@ -119,9 +124,14 @@ impl CameraRawDialog {
     }
 
     fn image(px: &[[f32; 4]], w: usize, h: usize, display: &photocraft_engine::display_color::CanvasDisplay) -> egui::ColorImage {
-        let buf = photocraft_compose::Buffer { rect: Rect::new(0, 0, w as i32, h as i32), px: px.to_vec() };
-        let img = display.to_rgba8(&buf);
-        egui::ColorImage::from_rgba_unmultiplied([img.width as usize, img.height as usize], &img.pixels)
+        // Bands copied straight from `px`, converted in parallel (#4682), not a whole copy of the
+        // proxy converted on one thread.
+        super::camera_raw_detail_ui::display_image(Rect::new(0, 0, w as i32, h as i32), display, |r, out| {
+            let start = (r.y0.max(0) as usize).saturating_mul(w);
+            if let Some(src) = px.get(start..start.saturating_add(out.len())) {
+                out.copy_from_slice(src);
+            }
+        })
     }
 
     pub(crate) fn render(&mut self, ctx: &egui::Context) {
@@ -129,6 +139,11 @@ impl CameraRawDialog {
         let mut px = self.proxy.clone();
         let mut p = self.params.clone();
         p.pixel_scale = (self.pw as f32 / self.full_w.max(1) as f32).min(1.0);
+        if let Some(curve) = &self.raw_curve {
+            let tone = raw_stage(&p);
+            photocraft_io::raw::retone(&mut px, self.pw, self.ph, curve, tone);
+            (p.shadows, p.highlights, p.clarity, p.texture, p.dehaze) = (0.0, 0.0, 0.0, 0.0, 0.0);
+        }
         photocraft_algo::camera_raw::develop(&mut px, self.pw, self.ph, &p, self.float);
         if let Some(mask) = &self.selection {
             for ((out, original), coverage) in px.iter_mut().zip(&self.proxy).zip(mask) {
@@ -174,9 +189,10 @@ enum Target {
 
 /// A raw file opened interactively, shown in Camera Raw before it is kept (as Photoshop opens
 /// raws in Adobe Camera Raw first). The document is already developed with the defaults; Open
-/// re-develops it when Temperature, Tint or Exposure changed (those act on the sensor data, see
-/// [`photocraft_io::raw::import_raw_tuned`]) and applies the other settings as one Camera Raw
-/// step, then marks the document unmodified. Cancel closes it.
+/// re-develops it when Temperature, Tint, Exposure, Shadows, Highlights, Clarity, Texture or
+/// Dehaze changed (those act on the sensor data, see [`photocraft_io::raw::import_raw_tuned`])
+/// and applies the other settings as one Camera Raw step, then marks the document unmodified.
+/// Cancel closes it.
 #[derive(Clone, Debug)]
 pub struct RawOpen {
     pub document: photocraft_doc::DocId,
@@ -216,8 +232,15 @@ fn open_raw(app: &mut PhotocraftApp, ctx: &egui::Context, raw: RawOpen) -> Resul
     app.session.set_active(index);
     let (layer, surf, _) = crate::distort_ui::active_pixels(app)?;
     open_pixels(app, ctx, layer, surf, CameraRaw::default(), Coverage::None, Target::OpenRaw)?;
+    let curve = match (&raw.bytes, &raw.path) {
+        (Some(b), _) => Some(photocraft_io::raw::tone_curve(b)),
+        #[cfg(not(target_arch = "wasm32"))]
+        (None, Some(p)) => std::fs::read(p).ok().map(|b| photocraft_io::raw::tone_curve(&b)),
+        _ => None,
+    };
     if let Some(d) = app.camera_raw.as_mut() {
         d.layer_name = raw.name.clone();
+        d.raw_curve = curve;
         d.raw_open = Some(raw);
     }
     Ok(())
@@ -256,6 +279,11 @@ pub struct Redevelop {
     filter_step: bool,
 }
 
+/// The sliders a raw open applies while developing, before the tone curve (as Camera Raw does).
+fn raw_stage(p: &CameraRaw) -> photocraft_io::raw::Tone {
+    photocraft_io::raw::Tone { shadows: p.shadows, highlights: p.highlights, clarity: p.clarity, texture: p.texture, dehaze: p.dehaze }
+}
+
 /// Open: re-develop for raw-stage settings, apply the rest, keep the document unmodified.
 ///
 /// Re-developing reads and decodes the whole raw again, so in the desktop app (background jobs
@@ -264,7 +292,16 @@ pub struct Redevelop {
 /// (tests, the web) it runs inline.
 fn commit_open_raw(app: &mut PhotocraftApp, params: &CameraRaw, raw: &RawOpen) -> Result<Value, String> {
     let index = document_index(app, raw.document).ok_or("the raw document was closed")?;
-    let tuning = photocraft_io::raw::RawTuning { temperature: params.temperature, tint: params.tint, exposure: params.exposure };
+    let tuning = photocraft_io::raw::RawTuning {
+        temperature: params.temperature,
+        tint: params.tint,
+        exposure: params.exposure,
+        shadows: params.shadows,
+        highlights: params.highlights,
+        clarity: params.clarity,
+        texture: params.texture,
+        dehaze: params.dehaze,
+    };
     // Without the file the raw-stage settings stay RGB adjustments, like the filter's.
     let source = match (&raw.bytes, &raw.path) {
         (Some(b), _) => Some(photocraft_engine::jobs::OpenSource::Bytes(b.clone())),
@@ -346,6 +383,11 @@ fn finish_redevelop(app: &mut PhotocraftApp, params: &CameraRaw, raw: &RawOpen,
     crate::notices::io_warnings(app, &format!("Opened {}", raw.name), &without_develop_note(&warnings));
     let mut rest = params.clone();
     rest.exposure = 0.0;
+    rest.shadows = 0.0;
+    rest.highlights = 0.0;
+    rest.clarity = 0.0;
+    rest.texture = 0.0;
+    rest.dehaze = 0.0;
     if v.get("wb").and_then(Value::as_bool) == Some(true) {
         rest.temperature = 0.0;
         rest.tint = 0.0;
@@ -482,6 +524,10 @@ fn open_pixels(
     let st = app.session.active().ok_or("no document")?;
     let canvas = st.doc.bounds();
     let name = st.doc.layer(layer).map(|l| l.name.clone()).unwrap_or_default();
+    let mut params = params;
+    if params.encoding_gamma == 0.0 {
+        params.encoding_gamma = photocraft_engine::lens_cmds::encoding_gamma(&st.doc);
+    }
     // Use the engine filter domain, including pixels outside the canvas: spatial Camera Raw
     // stages (vignette, grain, local contrast) must agree with the committed result.
     let area = canvas.union(&surf.content_bounds());
@@ -591,6 +637,7 @@ fn open_pixels(
         curve_rect: None,
         render_ms: 0.0,
         raw_open: None,
+        raw_curve: None,
     };
     d.render(ctx);
     app.camera_raw = Some(d);
@@ -629,14 +676,22 @@ pub fn menu(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, params: &Val
     for (key, value) in fields {
         match key.as_str() {
             "set" | "scope" | "view" => {}
-            "before" | "commit" | "cancel" if value.is_boolean() => {}
-            "before" | "commit" | "cancel" => return Some(Err(format!("Camera Raw {key} must be a boolean"))),
+            "before" | "commit" | "cancel" | "saveSettings" | "loadSettings" if value.is_boolean() => {}
+            "before" | "commit" | "cancel" | "saveSettings" | "loadSettings" => return Some(Err(format!("Camera Raw {key} must be a boolean"))),
             _ => return Some(Err(format!("unknown Camera Raw ui property {key}"))),
         }
     }
     if ui.get("commit").and_then(Value::as_bool) == Some(true) && ui.get("cancel").and_then(Value::as_bool) == Some(true) {
         return Some(Err("Camera Raw cannot commit and cancel together".into()));
     }
+    for (key, run) in [("saveSettings", save_settings as fn(&mut PhotocraftApp) -> Result<Value, String>), ("loadSettings", load_settings)] {
+        if ui.get(key).and_then(Value::as_bool) == Some(true) {
+            if fields.len() > 1 {
+                return Some(Err(format!("Camera Raw {key} must be sent on its own")));
+            }
+            return Some(run(app));
+        }
+    }
     let was_closed = app.camera_raw.is_none();
     let previous_view = app.ui.camera_raw_scope.clone();
     let previous_navigation = app.ui.camera_raw_preview;
@@ -726,6 +781,52 @@ fn menu_update(app: &mut PhotocraftApp, ctx: &egui::Context, ui: &Value) -> Opti
     Some(Ok(app.camera_raw.as_ref().map(|d| d.describe(&app.ui.camera_raw_scope, &app.ui.camera_raw_preview)).unwrap_or(Value::Null)))
 }
 
+/// Save Settings…: the dialog's settings as a Camera Raw `.xmp` settings file.
+fn save_settings(app: &mut PhotocraftApp) -> Result<Value, String> {
+    let d = app.camera_raw.as_ref().ok_or(tl!("Camera Raw isn't open"))?;
+    let bytes = photocraft_io::camera_raw_xmp::save(&d.params).into_bytes();
+    app.pick_save("Camera Raw Settings.xmp", move |app, path| {
+        let write = app.services.write.as_mut().ok_or("no writer configured")?;
+        write(&path, &bytes)?;
+        Ok(json!({"path": path}))
+    })
+}
+
+/// Load Settings…: applies a Camera Raw `.xmp` settings file's supported settings over the
+/// dialog's; the status bar names how many were not supported.
+fn load_settings(app: &mut PhotocraftApp) -> Result<Value, String> {
+    app.camera_raw.as_ref().ok_or(tl!("Camera Raw isn't open"))?;
+    app.pick_file_bytes_filtered(&["xmp"], |app, name, bytes| {
+        let file = crate::file_open::display_name(&name);
+        let d = app.camera_raw.as_mut().ok_or(tl!("Camera Raw isn't open"))?;
+        let mut next = d.params.clone();
+        let report = photocraft_io::camera_raw_xmp::load(&mut next, &bytes).map_err(|e| format!("{file}: {e}"))?;
+        next.validate_changes(&d.original).map_err(|e| format!("{file}: {e}"))?;
+        if d.params.point_curve != next.point_curve {
+            d.curve_state = Default::default();
+        }
+        d.dirty |= d.params != next;
+        d.params = next;
+        app.ui.status_error = false;
+        app.ui.status = if report.ignored.is_empty() {
+            crate::i18n::fmt(tl!("Loaded Camera Raw settings from {file}"), &[("file", &file)])
+        } else {
+            let template = "Loaded Camera Raw settings from {file} ({n} not supported)";
+            crate::i18n::fmt(tl!(template), &[("file", &file), ("n", &report.ignored.len().to_string())])
+        };
+        Ok(json!({"applied": report.applied, "ignored": report.ignored}))
+    })
+}
+
+fn report_file_error(app: &mut PhotocraftApp, r: Result<Value, String>) {
+    if let Err(e) = r
+        && e != crate::file_dialog::CANCELLED
+    {
+        app.ui.status_error = true;
+        app.ui.status = e;
+    }
+}
+
 fn commit(app: &mut PhotocraftApp) -> Result<Value, String> {
     let d = app.camera_raw.as_ref().ok_or(tl!("Camera Raw isn't open"))?;
     let result = match d.target {
@@ -937,7 +1038,8 @@ fn draw(app: &mut PhotocraftApp, ctx: &egui::Context, own_window: bool) {
             // Never tile a checker across the offscreen extent of a highly zoomed image.
             widgets::checker(preview.painter(), r.intersect(view), 8.0);
             preview.painter().image(tex.id(), r, ERect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
-            let detail_needed = r.width() * ctx.pixels_per_point() > d.pw as f32 || r.height() * ctx.pixels_per_point() > d.ph as f32;
+            let raw_tone = d.raw_curve.is_some() && !raw_stage(&d.params).is_neutral();
+            let detail_needed = !raw_tone && (r.width() * ctx.pixels_per_point() > d.pw as f32 || r.height() * ctx.pixels_per_point() > d.ph as f32);
             d.detail.paint(&preview, r, d.preview_revision, d.show_before, &d.params, detail_needed, &d.display);
             if d.detail.pending() {
                 ctx.request_repaint_after(std::time::Duration::from_millis(50));
@@ -1092,6 +1194,13 @@ fn draw(app: &mut PhotocraftApp, ctx: &egui::Context, own_window: bool) {
         fu.add_space(12.0);
         widgets::checkbox(&mut fu, &mut d.show_before, tl!("Before (Y)"));
         fu.label(egui::RichText::new(format!("{:.0} ms", d.render_ms)).color(t.text_faint));
+        fu.add_space(12.0);
+        if fu.button(tl!("Save Settings…")).on_hover_text(tl!("Save these settings as a Camera Raw .xmp file")).clicked() {
+            action = Some("save");
+        }
+        if fu.button(tl!("Load Settings…")).on_hover_text(tl!("Load settings from a Camera Raw .xmp file")).clicked() {
+            action = Some("load");
+        }
     });
     super::camera_raw_scope_ui::persist(app, ctx);
     if ctx.input(|i| i.key_pressed(egui::Key::Y))
@@ -1109,6 +1218,14 @@ fn draw(app: &mut PhotocraftApp, ctx: &egui::Context, own_window: bool) {
             }
         }
         Some("cancel") => cancel(app),
+        Some("save") => {
+            let r = save_settings(app);
+            report_file_error(app, r);
+        }
+        Some("load") => {
+            let r = load_settings(app);
+            report_file_error(app, r);
+        }
         _ => {}
     }
 }
@@ -1318,6 +1435,9 @@ mod tests {
         let ctx = egui::Context::default();
         let warnings = app.open_bytes("IMG_0001.dng", &dng).unwrap();
         assert!(warnings.iter().any(|w| w.contains(photocraft_io::raw::DEVELOPED_NOTE)), "{warnings:?}");
+        // A raw has no embedded profile (ProPhoto RGB is the space it is developed into), so Ask
+        // When Opening (on by default) has nothing to ask about.
+        assert!(app.ui.dialogs.is_empty(), "no profile prompt for a raw");
         let raw = app.pending_raw_open.take().expect("a raw open queues the dialog");
         open_raw(&mut app, &ctx, raw).unwrap();
         let d = app.camera_raw.as_ref().unwrap();
@@ -1336,6 +1456,46 @@ mod tests {
         assert!(mean_red(&app) > before + 0.05, "{before} → {}", mean_red(&app));
     }
 
+    #[test]
+    fn shadows_of_a_raw_open_act_on_the_raw_data_and_the_preview_shows_it() {
+        let (mut app, dng) = raw_app();
+        let ctx = egui::Context::default();
+        app.open_bytes("IMG_0002.dng", &dng).unwrap();
+        let raw = app.pending_raw_open.take().unwrap();
+        open_raw(&mut app, &ctx, raw).unwrap();
+        assert!(app.camera_raw.as_ref().unwrap().raw_curve.is_some(), "the preview knows how the raw was developed");
+        let mean = |px: &[[f32; 4]]| px.iter().map(|p| p[0] + p[1] + p[2]).sum::<f32>() / px.len() as f32;
+        let preview_before = mean(&app.camera_raw.as_ref().unwrap().processed);
+        let before = mean_red(&app);
+        menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"set": {"shadows": 100}}})).unwrap().unwrap();
+        let d = app.camera_raw.as_mut().unwrap();
+        d.render(&ctx);
+        assert!(mean(&d.processed) > preview_before + 0.01, "{preview_before} → {}", mean(&d.processed));
+        let r = menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"commit": true}})).unwrap().unwrap();
+        assert_eq!(r["redeveloped"], true, "{r}");
+        assert!(r.get("filter").is_none(), "Shadows acts while developing, not as a later filter step: {r}");
+        assert!(mean_red(&app) > before + 0.01, "{before} → {}", mean_red(&app));
+    }
+
+    #[test]
+    fn clarity_texture_and_dehaze_of_a_raw_open_act_on_the_raw_data() {
+        let (mut app, dng) = raw_app();
+        let ctx = egui::Context::default();
+        app.open_bytes("IMG_0003.dng", &dng).unwrap();
+        let raw = app.pending_raw_open.take().unwrap();
+        open_raw(&mut app, &ctx, raw).unwrap();
+        let before = mean_red(&app);
+        let preview_before = app.camera_raw.as_ref().unwrap().processed.clone();
+        menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"set": {"clarity": 60, "texture": 40, "dehaze": 50}}})).unwrap().unwrap();
+        let d = app.camera_raw.as_mut().unwrap();
+        d.render(&ctx);
+        assert_ne!(d.processed, preview_before, "the preview shows the raw-stage change");
+        let r = menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"commit": true}})).unwrap().unwrap();
+        assert_eq!(r["redeveloped"], true, "{r}");
+        assert!(r.get("filter").is_none(), "they act while developing, not as a later filter step: {r}");
+        assert!(mean_red(&app) < before, "Dehaze darkens: {before} → {}", mean_red(&app));
+    }
+
     #[test]
     fn background_redevelop_keeps_the_tab_position_and_view() {
         let (mut app, dng) = raw_app();
@@ -1398,4 +1558,68 @@ mod tests {
         // A non-raw never queues the dialog; a closed document is an error, not a panic.
         assert!(open_raw(&mut app, &ctx, RawOpen { document: photocraft_doc::DocId(u64::MAX), name: "x".into(), path: None, bytes: None }).is_err());
     }
+
+    #[test]
+    fn save_and_load_settings_round_trip_through_xmp_files() {
+        use crate::file_dialog::FileDialogAnswer;
+        use std::sync::{Arc, Mutex};
+        type Written = Arc<Mutex<Vec<(String, Vec<u8>)>>>;
+        let written: Written = Arc::default();
+        let w = written.clone();
+        let foreign = br#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+            <rdf:Description xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:Clarity2012="+25" crs:RedHue="-5"/>
+            </rdf:RDF></x:xmpmeta>"#;
+        let answers = vec![
+            Some(FileDialogAnswer::SaveTo("/out/Look.xmp".into())),
+            Some(FileDialogAnswer::Contents("Look.xmp".into(), Vec::new())),
+            Some(FileDialogAnswer::Contents("Other.xmp".into(), foreign.to_vec())),
+            Some(FileDialogAnswer::Contents("Broken.xmp".into(), b"<nope".to_vec())),
+        ];
+        let services = crate::Services {
+            file_dialog: Some(crate::file_dialog::fake(answers).0),
+            write: Some(Box::new(move |p: &str, b: &[u8]| {
+                w.lock().unwrap().push((p.to_string(), b.to_vec()));
+                Ok(())
+            })),
+            ..Default::default()
+        };
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), services);
+        let ctx = egui::Context::default();
+        let frame = |app: &mut PhotocraftApp| app.poll_file_dialog(&egui::Context::default(), None);
+        app.run("file.new", json!({"width": 16, "height": 16})).unwrap();
+        app.run("layer.new.layer", json!({})).unwrap();
+        app.run("edit.fill", json!({"color": "#808080"})).unwrap();
+        menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"set": {"exposure": 0.75, "contrast": -20, "hslSat": [0, 0, 0, 30, 0, 0, 0, 0]}}}))
+            .unwrap()
+            .unwrap();
+        let saved_params = app.camera_raw.as_ref().unwrap().params.clone();
+        assert!(menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"saveSettings": true, "before": true}})).unwrap().is_err());
+        assert_eq!(menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"saveSettings": true}})).unwrap().unwrap()["fileDialog"], "save");
+        frame(&mut app);
+        let (path, bytes) = written.lock().unwrap()[0].clone();
+        assert_eq!(path, "/out/Look.xmp");
+        let text = String::from_utf8(bytes.clone()).unwrap();
+        assert!(text.contains("crs:Exposure2012=\"+0.75\"") && text.contains("crs:SaturationAdjustmentGreen=\"+30\""), "{text}");
+        // Reset, then load the saved file back (the fake dialog's second answer, with its bytes).
+        app.camera_raw.as_mut().unwrap().params = CameraRaw::default();
+        let mut svc = crate::file_dialog::fake(vec![Some(FileDialogAnswer::Contents("Look.xmp".into(), bytes))]).0;
+        std::mem::swap(app.services.file_dialog.as_mut().unwrap(), &mut svc);
+        menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"loadSettings": true}})).unwrap().unwrap();
+        frame(&mut app);
+        assert_eq!(app.camera_raw.as_ref().unwrap().params, saved_params);
+        std::mem::swap(app.services.file_dialog.as_mut().unwrap(), &mut svc);
+        // The original service's next answer is the empty file: an error, settings untouched.
+        menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"loadSettings": true}})).unwrap().unwrap();
+        frame(&mut app);
+        assert_eq!(app.camera_raw.as_ref().unwrap().params, saved_params);
+        // A foreign preset applies what it holds over the current settings and reports the rest.
+        menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"loadSettings": true}})).unwrap().unwrap();
+        frame(&mut app);
+        let p = &app.camera_raw.as_ref().unwrap().params;
+        assert_eq!((p.clarity, p.exposure), (25.0, 0.75));
+        assert!(app.ui.status.contains("Other.xmp") && app.ui.status.contains('1'), "{}", app.ui.status);
+        menu(&mut app, &ctx, "filter.cameraRaw", &json!({"ui": {"loadSettings": true}})).unwrap().unwrap();
+        frame(&mut app);
+        assert_eq!(app.camera_raw.as_ref().unwrap().params.clarity, 25.0);
+    }
 }
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index 5b68f6579c..db0efe31fa 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -40,12 +40,25 @@ fn draw_clone_preview(app: &mut PhotocraftApp, painter: &egui::Painter, xf: &Vie
     let rect = DRect::new((at[0] - radius).floor() as i32, (at[1] - radius).floor() as i32, (at[0] + radius).ceil() as i32, (at[1] + radius).ceil() as i32);
     let Some(st) = app.session.active() else { return };
     let (display, display_key) = canvas_display(app, &st.doc, output);
+    // A shaped tip (sampled bitmap, or a rotated / flattened round one) clips the overlay to its
+    // outline instead of a circle, as Photoshop does with Clipped on.
+    let tip_rings = if overlay.clipped { crate::brush_cursor::rings(painter.ctx(), &app.session.tools.brush, true) } else { None };
+    let tip_key = tip_rings.as_ref().map(|r| {
+        use std::hash::{Hash, Hasher};
+        let mut h = std::collections::hash_map::DefaultHasher::new();
+        r.iter().flatten().for_each(|p| (p[0].to_bits(), p[1].to_bits()).hash(&mut h));
+        (h.finish(), radius.to_bits(), at.map(f64::to_bits))
+    });
     let key = format!(
-        "{:?}:{}:{:?}:{rect:?}:{map:?}:{}:{}:{}:{}",
-        st.doc.id, st.revision, st.active_layer, app.ui.tool_options.clone_sample, display_key, overlay.invert, overlay.blend
+        "{:?}:{}:{:?}:{rect:?}:{map:?}:{}:{}:{}:{}:{}:{tip_key:?}",
+        st.doc.id, st.revision, st.active_layer, app.ui.tool_options.clone_sample, display_key, overlay.invert, overlay.blend, app.ui.view.pattern_preview
     );
     if app.clone_preview.as_ref().is_none_or(|c| c.key != key) {
-        let Ok(mut buf) = photocraft_engine::retouch_cmds::clone_preview(&app.session, rect, &map, &app.ui.tool_options.clone_sample) else { return };
+        let Ok(mut buf) =
+            photocraft_engine::retouch_cmds::clone_preview_periodic(&app.session, rect, &map, &app.ui.tool_options.clone_sample, app.ui.view.pattern_preview)
+        else {
+            return;
+        };
         if overlay.invert {
             for px in &mut buf.px {
                 for c in px.iter_mut().take(3) {
@@ -57,11 +70,21 @@ fn draw_clone_preview(app: &mut PhotocraftApp, painter: &egui::Painter, xf: &Vie
         // composite, whatever Sample reads), so Difference turns black where they line up.
         if overlay.blend != "normal" {
             let here = Mapping { source: (0.0, 0.0), anchor: (0.0, 0.0), m: [1.0, 0.0, 0.0, 1.0] };
-            let Ok(under) = photocraft_engine::retouch_cmds::clone_preview(&app.session, rect, &here, "all") else { return };
+            let Ok(under) = photocraft_engine::retouch_cmds::clone_preview_periodic(&app.session, rect, &here, "all", app.ui.view.pattern_preview) else {
+                return;
+            };
             for (px, d) in buf.px.iter_mut().zip(&under.px) {
                 *px = overlay_blend(&overlay.blend, *px, *d);
             }
         }
+        if let Some(rings) = &tip_rings {
+            let mask = crate::brush_cursor::tip_mask(rings, at, radius, [rect.x0, rect.y0, rect.x1, rect.y1]);
+            for (px, inside) in buf.px.iter_mut().zip(mask) {
+                if !inside {
+                    *px = [0.0; 4];
+                }
+            }
+        }
         let image = display_image(display.as_deref(), &buf);
         match app.clone_preview.as_mut() {
             Some(cache) => {
@@ -80,7 +103,7 @@ fn draw_clone_preview(app: &mut PhotocraftApp, painter: &egui::Painter, xf: &Vie
         uv: pos2((x - f64::from(rect.x0)) as f32 / rect.width() as f32, (y - f64::from(rect.y0)) as f32 / rect.height() as f32),
         color: tint,
     };
-    if !overlay.clipped {
+    if !overlay.clipped || tip_rings.is_some() {
         for (x, y) in [(rect.x0, rect.y0), (rect.x1, rect.y0), (rect.x1, rect.y1), (rect.x0, rect.y1)] {
             mesh.vertices.push(vertex(f64::from(x), f64::from(y)));
         }
@@ -559,15 +582,16 @@ pub(crate) fn pencil_tip_is_round(size: f32) -> bool {
 
 /// Whether a brush-tip circle draws its centre mark.
 /// Clone Stamp and Healing Brush stay an empty circle until Option is held, the source-point
-/// cursor. Other brushes follow the cursor preference, the large-tip mark, or the Background Eraser.
-fn brush_tip_centre(tool: Tool, option: bool, show_crosshair: bool, radius: f32) -> bool {
+/// cursor. Other brushes follow Preferences › Cursors › Show Crosshair in Brush Tip, as in
+/// Photoshop; the Background Eraser always shows its sampling hotspot.
+fn brush_tip_centre(tool: Tool, option: bool, show_crosshair: bool) -> bool {
     if tool == Tool::QuickSelection {
         return false;
     }
     if matches!(tool, Tool::CloneStamp | Tool::Healing) {
         return option || show_crosshair;
     }
-    show_crosshair || radius > 6.0 || tool == Tool::BackgroundEraser
+    show_crosshair || tool == Tool::BackgroundEraser
 }
 
 /// The display colour of an RGB triple (0..1 per channel) as an egui colour.
@@ -679,6 +703,28 @@ fn feed_live_stroke(app: &mut PhotocraftApp) {
     }
 }
 
+/// The points the live retouching stroke has rendered.
+#[cfg(test)]
+pub(crate) fn live_retouch_points(app: &PhotocraftApp) -> Option<Vec<photocraft_engine::paint::StrokePoint>> {
+    match &app.live_stroke.as_ref()?.stroke {
+        EngineStroke::Retouch(l) => Some(l.points().to_vec()),
+        _ => None,
+    }
+}
+
+/// Offer the Clone Stamp's or History Brush's live stroke, with the drag points it hasn't rendered
+/// yet, to the command `retouch_ui::finish_stroke` commits, which then takes its pixels.
+fn offer_live_retouch(app: &mut PhotocraftApp, d: &Drag) {
+    if !matches!(d.tool, Tool::CloneStamp | Tool::HistoryBrush) {
+        return;
+    }
+    let Some(LiveStroke { stroke: EngineStroke::Retouch(mut live), fed, .. }) = app.live_stroke.take() else { return };
+    let rest: Vec<_> = d.points.get(fed..).unwrap_or_default().iter().map(|q| photocraft_engine::paint::StrokePoint::new(q[0], q[1], q[2] as f32)).collect();
+    if rest.is_empty() || live.push(&rest).is_ok() {
+        let _ = app.session.offer_live_retouch(live);
+    }
+}
+
 /// A pen tap (a drag still at its one press point when released) paints its dab at the highest
 /// pressure the pen reached during the contact, not just the first sample's (#1798). A mouse is
 /// unchanged at full pressure.
@@ -841,6 +887,15 @@ impl ViewXform {
         vec2((d.x * c + d.y * s) / self.sx(), -d.x * s + d.y * c)
     }
 
+    /// A document-space vector on screen: stretched, rotated, flipped and zoomed as the view
+    /// draws it (the inverse of [`Self::unmap_vec`], with the zoom).
+    pub fn map_vec(self, d: Vec2) -> Vec2 {
+        let (c, s) = self.sincos();
+        let dx = d.x * self.sx();
+        let v = vec2(dx * c - d.y * s, dx * s + d.y * c) * self.zoom;
+        if self.flip { vec2(-v.x, v.y) } else { v }
+    }
+
     pub fn to_screen(&self, x: f32, y: f32) -> Pos2 {
         let (c, s) = self.sincos();
         let dx = (x - self.center[0]) * self.sx();
@@ -855,6 +910,14 @@ impl ViewXform {
         let u = self.unmap_vec(d);
         [(u.x + self.center[0]) as f64, (u.y + self.center[1]) as f64]
     }
+    /// On-screen bounds of the image, including camera rotation and pixel aspect correction.
+    pub fn image_bounds(self, size: [u32; 2]) -> Rect {
+        let (c, s) = self.sincos();
+        let w = size[0] as f32 * self.sx() * self.zoom;
+        let h = size[1] as f32 * self.zoom;
+        let center = self.to_screen(size[0] as f32 / 2.0, size[1] as f32 / 2.0);
+        Rect::from_center_size(center, vec2(c.abs() * w + s.abs() * h, s.abs() * w + c.abs() * h))
+    }
     pub fn doc_rect(&self, r: DRect) -> Rect {
         let pts = [
             self.to_screen(r.x0 as f32, r.y0 as f32),
@@ -887,8 +950,10 @@ pub fn doc_point_at(app: &PhotocraftApp, pos: Pos2) -> Option<[f64; 2]> {
 pub fn fit_view(view: &mut View, doc: &Document, area: Vec2, ppp: f32, aspect: f32) {
     let (w, h) = (doc.size.width as f32, doc.size.height as f32);
     let shown_w = w * if aspect.is_finite() && aspect > 0.0 { aspect } else { 1.0 };
-    let points = ((area.x - 40.0) / shown_w).min((area.y - 40.0) / h).min(1.0);
-    let zoom = crate::zoom_levels::clamp(points * ppp, [doc.size.width, doc.size.height]);
+    // Fit never magnifies past 100%: one image pixel per *physical* pixel, so the cap applies
+    // after the points → device pixels conversion (a 150% display would otherwise open at 150%).
+    let fit = ((area.x - 40.0) / shown_w).min((area.y - 40.0) / h) * ppp;
+    let zoom = crate::zoom_levels::clamp(fit.min(1.0), [doc.size.width, doc.size.height]);
     view.zoom = zoom;
     view.center = [w / 2.0, h / 2.0];
     view.fit_pending = false;
@@ -931,18 +996,51 @@ fn checker(app: &mut PhotocraftApp, ctx: &egui::Context) -> egui::TextureId {
 }
 
 fn buffer_to_image(buf: &photocraft_compose::Buffer) -> egui::ColorImage {
-    let img = buf.to_rgba8();
-    egui::ColorImage::from_rgba_unmultiplied([img.width as usize, img.height as usize], &img.pixels)
+    // `buf.to_rgba8()` then `color_image`, fused: one parallel pass, no intermediate image.
+    let q = |v: f32| (v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
+    let mut pixels = vec![egui::Color32::TRANSPARENT; buf.px.len()];
+    let convert = |out: &mut [egui::Color32], src: &[[f32; 4]]| {
+        for (o, p) in out.iter_mut().zip(src) {
+            *o = egui::Color32::from_rgba_unmultiplied(q(p[0]), q(p[1]), q(p[2]), q(p[3]));
+        }
+    };
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        use rayon::prelude::*;
+        pixels.par_chunks_mut(16 * 1024).zip(buf.px.par_chunks(16 * 1024)).for_each(|(o, s)| convert(o, s));
+    }
+    #[cfg(target_arch = "wasm32")]
+    convert(&mut pixels, &buf.px);
+    egui::ColorImage::new([buf.rect.width() as usize, buf.rect.height() as usize], pixels)
+}
+
+/// `img` as an egui image: `ColorImage::from_rgba_unmultiplied`, in parallel off wasm. egui's own
+/// conversion runs on one thread and took 37 ms of a 24 MP canvas or preview update, three times
+/// the quantize before it.
+fn color_image(img: &photocraft_raster::Rgba8Image) -> egui::ColorImage {
+    let size = [img.width as usize, img.height as usize];
+    let src = img.pixels.as_chunks::<4>().0;
+    let mut pixels = vec![egui::Color32::TRANSPARENT; src.len()];
+    let convert = |out: &mut [egui::Color32], src: &[[u8; 4]]| {
+        for (o, &[r, g, b, a]) in out.iter_mut().zip(src) {
+            *o = egui::Color32::from_rgba_unmultiplied(r, g, b, a);
+        }
+    };
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        use rayon::prelude::*;
+        pixels.par_chunks_mut(16 * 1024).zip(src.par_chunks(16 * 1024)).for_each(|(o, s)| convert(o, s));
+    }
+    #[cfg(target_arch = "wasm32")]
+    convert(&mut pixels, src);
+    egui::ColorImage::new(size, pixels)
 }
 
 /// A composite as monitor pixels: document profile → monitor profile (nothing to do in the
 /// common sRGB-on-sRGB case).
-fn display_image(display: Option<&photocraft_engine::display_color::CanvasDisplay>, buf: &photocraft_compose::Buffer) -> egui::ColorImage {
+pub(crate) fn display_image(display: Option<&photocraft_engine::display_color::CanvasDisplay>, buf: &photocraft_compose::Buffer) -> egui::ColorImage {
     match display {
-        Some(d) if !d.is_identity() => {
-            let img = d.to_rgba8(buf);
-            egui::ColorImage::from_rgba_unmultiplied([img.width as usize, img.height as usize], &img.pixels)
-        }
+        Some(d) if !d.is_identity() => color_image(&d.to_rgba8(buf)),
         _ => buffer_to_image(buf),
     }
 }
@@ -950,7 +1048,11 @@ fn display_image(display: Option<&photocraft_engine::display_color::CanvasDispla
 /// The canvas display of `doc` on `display` (`None`: the main window's) and a key that changes
 /// with it (folded into the canvas caches' preview keys, so a monitor or profile change
 /// re-renders).
-fn canvas_display(app: &PhotocraftApp, doc: &Document, display: Option<u32>) -> (Option<std::sync::Arc<photocraft_engine::display_color::CanvasDisplay>>, u64) {
+pub(crate) fn canvas_display(
+    app: &PhotocraftApp,
+    doc: &Document,
+    display: Option<u32>,
+) -> (Option<std::sync::Arc<photocraft_engine::display_color::CanvasDisplay>>, u64) {
     match app.session.color.canvas_display_for(doc, display.or(app.session.color.main_display)) {
         Ok(d) => {
             let k = d.key;
@@ -1015,6 +1117,10 @@ pub(crate) fn display_doc(app: &mut PhotocraftApp, idx: usize) -> (std::sync::Ar
     if let Some(shown) = crate::patch_preview::display_doc(app, idx) {
         return shown;
     }
+    // Content-Aware Move drag or box: the result, once computed in the background.
+    if let Some(shown) = crate::cam_preview::display_doc(app, idx) {
+        return shown;
+    }
     // A blend mode hovered in the Layers panel.
     if let Some(shown) = crate::blend_preview::display_doc(app, idx) {
         return shown;
@@ -1054,29 +1160,61 @@ pub(crate) fn display_doc(app: &mut PhotocraftApp, idx: usize) -> (std::sync::Ar
             return (doc.clone(), key);
         }
     }
-    if let Some((layer, params)) = &app.live_adjust
-        && let Some(l) = st.doc.layer(*layer)
+    let snapshot = st.doc.clone();
+    if let Some((layer, params)) = app.live_adjust.clone()
+        && let Some(l) = snapshot.layer(layer)
         && let LayerContent::Adjustment(a) = &l.content
     {
-        let kind = photocraft_engine::commands::adjustment_kind(a);
-        let preview = photocraft_engine::adjust_params::from_params(kind, params, Some(a), st.doc.mode).unwrap_or_else(|_| a.clone());
-        let mut doc = (*st.doc).clone();
-        if let Some(lm) = doc.layer_mut(*layer) {
-            lm.content = LayerContent::Adjustment(preview);
-        }
         let key = 1 + params.to_string().bytes().fold(0u64, |h, b| h.wrapping_mul(31).wrapping_add(b as u64));
-        return (std::sync::Arc::new(doc), key);
+        let shown = memo_display(app, &snapshot, key, || {
+            let kind = photocraft_engine::commands::adjustment_kind(a);
+            let preview = photocraft_engine::adjust_params::from_params(kind, &params, Some(a), snapshot.mode).unwrap_or_else(|_| a.clone());
+            let mut doc = (*snapshot).clone();
+            if let Some(lm) = doc.layer_mut(layer) {
+                lm.content = LayerContent::Adjustment(preview);
+            }
+            Some(doc)
+        });
+        if let Some(doc) = shown {
+            return (doc, key);
+        }
     }
     // Duotone documents display through their inks.
-    if let Some(shown) = photocraft_engine::mode_cmds::display_document(&st.doc) {
-        return (std::sync::Arc::new(shown), 1 << 41);
+    if let Some(shown) = memo_display(app, &snapshot, 1 << 41, || photocraft_engine::mode_cmds::display_document(&snapshot)) {
+        return (shown, 1 << 41);
     }
-    (st.doc.clone(), 0)
+    (snapshot, 0)
+}
+
+/// `display_doc`'s live-adjust and Duotone documents, built once per document snapshot and key
+/// rather than on each of its 3–4 calls a frame (#4527): each build clones the whole document.
+fn memo_display(
+    app: &mut PhotocraftApp,
+    snapshot: &std::sync::Arc<Document>,
+    key: u64,
+    build: impl FnOnce() -> Option<Document>,
+) -> Option<std::sync::Arc<Document>> {
+    let id = snapshot.id;
+    if let Some((doc, k, shown)) = app.display_memo.get(&id)
+        && *k == key
+        && doc.ptr_eq(&std::sync::Arc::downgrade(snapshot))
+    {
+        return Some(shown.clone());
+    }
+    let Some(shown) = build().map(std::sync::Arc::new) else {
+        app.display_memo.remove(&id);
+        return None;
+    };
+    // Entries of closed documents go when another is stored.
+    app.display_memo.retain(|_, (doc, _, _)| doc.strong_count() > 0);
+    app.display_memo.insert(id, (std::sync::Arc::downgrade(snapshot), key, shown.clone()));
+    Some(shown)
 }
 
 /// Longest side of the Navigator panel's image (about twice the panel's width, for HiDPI).
 pub const NAVIGATOR_SIDE: u32 = 512;
-pub(crate) type NavigatorCache = (std::sync::Weak<Document>, u64, egui::TextureHandle);
+/// The navigator image of a document: its snapshot, preview key and revision, and the texture.
+pub(crate) type NavigatorCache = (std::sync::Weak<Document>, u64, u64, egui::TextureHandle);
 /// How long adjustment-dialog settings must stay unchanged before the navigator shows them.
 const NAVIGATOR_SETTLE_MS: f64 = 200.0;
 
@@ -1084,36 +1222,85 @@ const NAVIGATOR_SETTLE_MS: f64 = 200.0;
 /// of document `idx` and catches up on release: each step of the drag is a new preview, and a
 /// thumbnail composite of the whole document per step makes painting lag on large images.
 fn navigator_waits_for_drag(app: &PhotocraftApp, idx: usize) -> bool {
-    crate::move_ui::showing(app) || crate::patch_preview::showing(app) || live_stroke(app, idx).is_some()
+    crate::move_ui::showing(app) || crate::patch_preview::showing(app) || crate::cam_preview::showing(app) || live_stroke(app, idx).is_some()
 }
 
 /// The Navigator panel's image of document `idx`. With the CPU canvas that is the canvas texture
 /// itself; with the GPU canvas a thumbnail cached per revision, so an edit to a huge document
 /// doesn't also pay a full-resolution CPU composite for the navigator.
+/// The Navigator's preview from the GPU canvas (#4518): the main canvas's texture of the
+/// document, drawn at `rect` with its own mip chain, so an edit costs no CPU composite. `None`
+/// while the canvas isn't showing the plain document on the GPU (the CPU thumbnail then).
+pub fn navigator_gpu_view(app: &PhotocraftApp, idx: usize, rect: Rect, ctx: &egui::Context) -> Option<crate::gpu_canvas::ViewParams> {
+    app.gpu.as_ref()?;
+    let st = app.session.documents().get(idx)?;
+    let params = *app.navigator_gpu.get(&st.doc.id)?;
+    let [w, h] = params.doc_size;
+    if w == 0 || h == 0 || !rect.is_positive() || [st.doc.size.width, st.doc.size.height] != params.doc_size {
+        return None;
+    }
+    Some(crate::gpu_canvas::ViewParams {
+        zoom: rect.width() / w as f32,
+        center: [w as f32 / 2.0, h as f32 / 2.0],
+        rotation: 0.0,
+        shadow: false,
+        pixel_grid: false,
+        view_key: egui::Id::new(("pc-navigator", ctx.viewport_id(), idx)).value(),
+        offset: [0.0, 0.0],
+        ..params
+    })
+}
+
+/// Frames the Navigator waits for the GPU canvas to draw a document it hasn't drawn yet, rather
+/// than build a CPU thumbnail it would only use once (a full composite on a large document).
+const NAVIGATOR_WAIT_FRAMES: u32 = 3;
+
+/// Whether the Navigator should wait a frame for the GPU canvas (#4518): the GPU canvas is on but
+/// hasn't drawn document `idx` yet (the Navigator can draw before the canvas in a frame). After
+/// [`NAVIGATOR_WAIT_FRAMES`] it stops waiting, so it never stays empty.
+pub fn navigator_waits_for_gpu(app: &PhotocraftApp, idx: usize, ctx: &egui::Context) -> bool {
+    if app.gpu.is_none() {
+        return false;
+    }
+    let Some(id) = app.session.documents().get(idx).map(|st| st.doc.id) else { return false };
+    if app.canvases.keys().any(|(d, _)| *d == id) {
+        return false;
+    }
+    let key = egui::Id::new(("navigator-waits", id.0));
+    let waited = ctx.data(|d| d.get_temp::<u32>(key)).unwrap_or(0);
+    if waited >= NAVIGATOR_WAIT_FRAMES {
+        return false;
+    }
+    ctx.data_mut(|d| d.insert_temp(key, waited + 1));
+    ctx.request_repaint();
+    true
+}
+
 pub fn navigator_texture(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize) -> Option<egui::TextureId> {
     if app.gpu.is_none() {
         return ensure_texture(app, ctx, idx, app.session.color.main_display).map(|(t, _)| t);
     }
     // Keyed by the document snapshot, not its revision: selecting a layer changes no pixels.
-    let (snapshot, id) = app.session.documents().get(idx).map(|st| (std::sync::Arc::downgrade(&st.doc), st.doc.id))?;
+    let (snapshot, id, revision, last_damage) =
+        app.session.documents().get(idx).map(|st| (std::sync::Arc::downgrade(&st.doc), st.doc.id, st.revision, st.last_damage))?;
     let (doc, preview_key) = display_doc(app, idx);
     let (display, display_key) = canvas_display(app, &doc, None);
     let preview_key = preview_key ^ display_key;
     let cached = app.navigator_textures.get(&id).cloned();
-    if let Some((r, p, t)) = &cached
+    if let Some((r, p, _, t)) = &cached
         && r.ptr_eq(&snapshot)
         && *p == preview_key
     {
         return Some(t.id());
     }
-    if let Some((_, _, t)) = &cached
+    if let Some((_, _, _, t)) = &cached
         && navigator_waits_for_drag(app, idx)
     {
         return Some(t.id());
     }
     // While an adjustment dialog's settings are changing, the navigator keeps its image and
     // catches up once they settle (a thumbnail composite per change would cost more than the canvas).
-    if let Some((r, _, t)) = &cached
+    if let Some((r, _, _, t)) = &cached
         && r.ptr_eq(&snapshot)
         && crate::adjust_preview::settling(app, NAVIGATOR_SETTLE_MS)
     {
@@ -1121,19 +1308,49 @@ pub fn navigator_texture(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usiz
         return Some(t.id());
     }
     let t0 = crate::gpu_canvas::now_ms();
+    // One edit since the cached image, with the area it changed: update just that part (nothing
+    // for a rename, a selection or a new empty layer). A thumbnail composite of the whole
+    // document on every edit cost a full-resolution CPU composite on the UI thread.
+    let size = photocraft_compose::thumbnail_size(&doc, NAVIGATOR_SIDE);
+    if let Some((_, p, rev, t)) = &cached
+        && *p == preview_key
+        && rev.checked_add(1) == Some(revision)
+        && let Some(d) = last_damage
+        && t.size() == [size.0 as usize, size.1 as usize]
+    {
+        let mut t = t.clone();
+        if !d.is_empty() {
+            let buf = photocraft_compose::render_reduced_damage(&doc, size.0, size.1, d.inflate(effect_reach(&doc.layers)));
+            let r = buf.rect;
+            if !r.is_empty() {
+                t.set_partial([r.x0 as usize, r.y0 as usize], display_image(display.as_deref(), &buf), TextureOptions::LINEAR);
+            }
+        }
+        app.perf.span("navigator", crate::gpu_canvas::now_ms() - t0);
+        app.navigator_textures.insert(id, (snapshot, preview_key, revision, t.clone()));
+        return Some(t.id());
+    }
     let image = display_image(display.as_deref(), &photocraft_compose::thumbnail_buffer(&doc, NAVIGATOR_SIDE));
     let tex = match cached {
-        Some((_, _, mut t)) => {
+        Some((_, _, _, mut t)) => {
             t.set(image, TextureOptions::LINEAR);
             t
         }
         None => ctx.load_texture(format!("navigator-{}", id.0), image, TextureOptions::LINEAR),
     };
     app.perf.span("navigator", crate::gpu_canvas::now_ms() - t0);
-    app.navigator_textures.insert(id, (snapshot, preview_key, tex.clone()));
+    app.navigator_textures.insert(id, (snapshot, preview_key, revision, tex.clone()));
     Some(tex.id())
 }
 
+/// The CPU canvas texture's sampling (#4810). Zoomed in, a full-resolution texture shows each
+/// document pixel as a crisp square, as the GPU canvas's sharp nearest filter and Photoshop do;
+/// zoomed out it is still filtered. A reduced texture (`factor` > 1) stays bilinear: its texels
+/// are averages of several pixels, and squares of them would be blocks the image doesn't have.
+fn canvas_texture_options(factor: u32) -> TextureOptions {
+    if factor > 1 { TextureOptions::LINEAR } else { TextureOptions { magnification: egui::TextureFilter::Nearest, ..TextureOptions::LINEAR } }
+}
+
 /// Make sure the canvas texture for document `idx` on `display` is current; returns (texture
 /// id, scale).
 pub fn ensure_texture(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize, display: Option<u32>) -> Option<(egui::TextureId, f32)> {
@@ -1178,7 +1395,7 @@ pub fn ensure_texture(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize,
             let r = buf.rect;
             if !r.is_empty() {
                 let t1 = crate::gpu_canvas::now_ms();
-                t.set_partial([r.x0 as usize, r.y0 as usize], display_image(display.as_deref(), &buf), TextureOptions::LINEAR);
+                t.set_partial([r.x0 as usize, r.y0 as usize], display_image(display.as_deref(), &buf), canvas_texture_options(factor));
                 let px = (r.width() as u64 * r.height() as u64).saturating_mul(u64::from(factor).pow(2));
                 app.perf.record("rect", px, t1 - t0, crate::gpu_canvas::now_ms() - t1);
             }
@@ -1188,8 +1405,8 @@ pub fn ensure_texture(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize,
             let t1 = crate::gpu_canvas::now_ms();
             let (img, scale) = (display_image(display.as_deref(), &full), 1.0 / factor as f32);
             match cache.texture.as_mut() {
-                Some(t) if t.size() == img.size => t.set(img, TextureOptions::LINEAR),
-                _ => cache.texture = Some(ctx.load_texture(format!("canvas-{}-{}", id.0, cache_key(id, output).1), img, TextureOptions::LINEAR)),
+                Some(t) if t.size() == img.size => t.set(img, canvas_texture_options(factor)),
+                _ => cache.texture = Some(ctx.load_texture(format!("canvas-{}-{}", id.0, cache_key(id, output).1), img, canvas_texture_options(factor))),
             }
             cache.scale = scale;
             app.perf.record("full", doc.size.width as u64 * doc.size.height as u64, t1 - t0, crate::gpu_canvas::now_ms() - t1);
@@ -1310,7 +1527,7 @@ pub(crate) fn effect_reach(layers: &[photocraft_doc::Layer]) -> i32 {
 /// GPU path: make sure document `idx` is current in the GPU canvas. Edits draw their damage;
 /// unchanged lower-stack composites can be reused by the compositor inside that region.
 /// Returns false if there is no GPU canvas.
-fn ensure_gpu(app: &mut PhotocraftApp, idx: usize, visible: DRect) -> bool {
+fn ensure_gpu(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize, visible: DRect) -> bool {
     let Some(gpu) = app.gpu.clone() else { return false };
     let Some((revision, last_damage, id)) = app
         .session
@@ -1333,7 +1550,17 @@ fn ensure_gpu(app: &mut PhotocraftApp, idx: usize, visible: DRect) -> bool {
         damage = Some(crate::adjust_preview::switch_damage(app, raw_key, r, visible));
     }
     let preview_key = raw_key ^ display_key;
+    // The Navigator may draw this texture only while it holds the plain document (no live
+    // preview, which can be composited only where the view is).
+    if raw_key == 0 {
+        app.navigator_plain.insert(id);
+    } else {
+        app.navigator_plain.remove(&id);
+        app.navigator_gpu.remove(&id);
+    }
     let size = [doc.size.width, doc.size.height];
+    // A full CPU redraw running in the background: show the blocks it has finished.
+    crate::background_redraw::poll(app, &gpu, id);
     let cache = app.canvases.entry((id, GPU_OUTPUT)).or_insert(CanvasCache {
         revision: 0,
         texture: None,
@@ -1356,22 +1583,37 @@ fn ensure_gpu(app: &mut PhotocraftApp, idx: usize, visible: DRect) -> bool {
     // Display textures for a canvas this large would not fit the GPU: the reduced CPU canvas
     // draws it (checked before the memory budget, which walks the history, every frame).
     if !gpu.fits_canvas(&doc) {
+        crate::background_redraw::cancel(app, id);
         return false;
     }
     let partial = present && damage.is_some();
     gpu_budget(app, &gpu, idx, partial, visible);
-    let r = gpu.refresh(id.0, &doc, if partial { damage } else { None }, display.as_deref());
+    let defer = crate::background_redraw::enabled(app);
+    let r = gpu.refresh_with(id.0, &doc, if partial { damage } else { None }, display.as_deref(), defer);
     if r.kind == "lost" || r.kind == crate::gpu_canvas::REFRESH_OVER_BUDGET {
         // The device is gone (`gpu_status` then drops the GPU canvas) or the canvas is over the
         // texture budget: draw this frame on the CPU path.
+        crate::background_redraw::cancel(app, id);
         return false;
     }
+    if r.kind == crate::gpu_canvas::REFRESH_DEFERRED {
+        // Composited off the UI thread, the visible part first (#4024).
+        let region = if partial { damage.unwrap_or(doc.bounds()) } else { doc.bounds() };
+        crate::background_redraw::start(app, ctx, &gpu, doc.clone(), display.clone(), visible, region, r.fallback.clone());
+    } else if partial {
+        // The edit drew its damage; blocks of a running redraw still to come follow the edit.
+        crate::background_redraw::restart(app, ctx, &gpu, doc.clone(), display.clone(), visible);
+    } else {
+        crate::background_redraw::cancel(app, id);
+    }
     if let Some(e) = &r.fallback
         && app.perf.gpu_fallback.as_deref() != Some(e.as_str())
     {
         log::info!("{e}; using the CPU compositor");
     }
-    app.perf.record(r.kind, r.px, r.composite_ms, r.upload_ms);
+    if r.kind != crate::gpu_canvas::REFRESH_DEFERRED {
+        app.perf.record(r.kind, r.px, r.composite_ms, r.upload_ms);
+    }
     if r.kind == "full" {
         crate::notices::slow_cpu_refresh(app, id.0, r.composite_ms + r.upload_ms, r.fallback.as_deref());
     }
@@ -1438,8 +1680,16 @@ pub(crate) fn ensure_filter_preview(app: &mut PhotocraftApp, idx: usize, ctx: &e
     let st = app.session.documents().get(idx)?;
     // Filters whose features don't scale with a proxy preview at full resolution (#2063).
     let k = crate::filter_dialog::preview_factor(&cmd, &params, crate::proxy::preview_factor(&st.doc, crate::proxy::reduced_previews(app)));
-    let request =
-        crate::filter_dialog::FilterPreviewKey { doc: st.doc.id, revision: st.revision, dialog: d.id, active: st.active_layer, command: cmd, params, k };
+    let request = crate::filter_dialog::FilterPreviewKey {
+        doc: st.doc.id,
+        revision: st.revision,
+        dialog: d.id,
+        active: st.active_layer,
+        target: st.channel_view.target,
+        command: cmd,
+        params,
+        k,
+    };
     let key = request.doc.0 ^ (1u64 << 61);
     // Every filter's preview computes off the UI thread in the desktop app: Gaussian Blur at
     // 1000 px takes long enough to freeze the window. Once the slider settles, a preview still
@@ -1461,10 +1711,21 @@ pub(crate) fn ensure_filter_preview(app: &mut PhotocraftApp, idx: usize, ctx: &e
         let fresh = app.filter_preview.as_ref().is_some_and(|p| p.key == request);
         if !fresh && !app.filter_preview_worker.busy() {
             let doc = app.session.documents().get(idx)?.doc.clone();
+            let documents: Vec<_> = app.session.documents().iter().map(|d| d.doc.clone()).collect();
             let task = request.clone();
             if let Err(error) = app.filter_preview_worker.start(request.clone(), ctx.clone(), move |cancel| {
                 let t0 = crate::gpu_canvas::now_ms();
-                let result = crate::filter_dialog::preview_document_with(&doc, task.active, &task.command, &task.params, task.k, Some(cancel)).map(|doc| {
+                let result = crate::filter_dialog::preview_document_for_target(
+                    &doc,
+                    task.active,
+                    &task.command,
+                    &task.params,
+                    task.k,
+                    Some(cancel),
+                    task.target,
+                    &documents,
+                )
+                .map(|doc| {
                     let buffer = photocraft_compose::flatten(&doc);
                     (std::sync::Arc::new(doc), buffer)
                 });
@@ -1484,6 +1745,7 @@ pub(crate) fn ensure_filter_preview(app: &mut PhotocraftApp, idx: usize, ctx: &e
             || preview.key.revision != request.revision
             || preview.key.dialog != request.dialog
             || preview.key.active != request.active
+            || preview.key.target != request.target
             || preview.key.k != request.k
             || preview.key.command != request.command
         {
@@ -1497,8 +1759,19 @@ pub(crate) fn ensure_filter_preview(app: &mut PhotocraftApp, idx: usize, ctx: &e
     let _ = ctx;
     if app.filter_preview.as_ref().is_none_or(|p| p.key != request) {
         let doc = app.session.documents().get(idx)?.doc.clone();
+        let documents: Vec<_> = app.session.documents().iter().map(|d| d.doc.clone()).collect();
         let t0 = crate::gpu_canvas::now_ms();
-        let result = crate::filter_dialog::preview_document(&doc, request.active, &request.command, &request.params, request.k).map(std::sync::Arc::new);
+        let result = crate::filter_dialog::preview_document_for_target(
+            &doc,
+            request.active,
+            &request.command,
+            &request.params,
+            request.k,
+            None,
+            request.target,
+            &documents,
+        )
+        .map(std::sync::Arc::new);
         if let Some(r) = &result {
             let buf = photocraft_compose::flatten(r);
             let t1 = crate::gpu_canvas::now_ms();
@@ -1516,6 +1789,18 @@ pub(crate) fn ensure_filter_preview(app: &mut PhotocraftApp, idx: usize, ctx: &e
     Some((preview.key.k, key, [result.size.width, result.size.height]))
 }
 
+/// Channel overlays must use the filter's current proxy too, including on the CPU canvas.
+/// The cache key changes with the completed request; unchanged frames reuse the overlay texture.
+pub(crate) fn filter_channel_preview(app: &mut PhotocraftApp, idx: usize, ctx: &egui::Context) -> Option<(std::sync::Arc<Document>, u64)> {
+    use std::hash::{Hash, Hasher};
+    ensure_filter_preview(app, idx, ctx)?;
+    let preview = app.filter_preview.as_ref()?;
+    let doc = preview.result.as_ref()?.clone();
+    let mut key = std::collections::hash_map::DefaultHasher::new();
+    format!("{:?}", preview.key).hash(&mut key);
+    Some((doc, key.finish() | (1 << 59)))
+}
+
 fn publish_filter_preview(
     app: &mut PhotocraftApp,
     idx: usize,
@@ -1656,6 +1941,7 @@ pub(crate) fn retain_gpu_documents(app: &mut PhotocraftApp) {
         live.extend(crate::adjust_preview::gpu_keys(app));
         gpu.retain(&live);
     }
+    crate::background_redraw::retain(app);
     // Upload markers must not outlive the resources they describe: native reopen can reuse
     // both the document ID and revision before the next frame while a preview dialog stays open.
     let documents = app.session.documents();
@@ -1762,6 +2048,7 @@ fn tabs(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> TabStrip {
     let mut close = None;
     let mut tab_action = None;
     let mut tab_move = None;
+    let mut tear_off = None;
     let (mut focus_open, mut cancel_open) = (None, None);
     let focused_open = app.jobs.focus.is_some();
     // Layers dragged over a tab show its document (`layer_transfer`).
@@ -1851,18 +2138,10 @@ fn tabs(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> TabStrip {
             } else if resp.clicked() {
                 activate = Some(i);
             }
-            // Drag a tab sideways to reorder it (#217); a line shows where it will land.
-            if resp.dragged()
-                && let Some(p) = resp.interact_pointer_pos()
-            {
-                tab_drop_line(ui, &placed, p.x, &t);
-            }
-            if resp.drag_stopped() {
-                let x = resp.interact_pointer_pos().or_else(|| ui.input(|i| i.pointer.interact_pos())).map_or(r.center().x, |p| p.x);
-                let to = tab_move_target(i, tab_drop_index(&placed, x));
-                if to != i {
-                    tab_move = Some((i, to));
-                }
+            match tab_drag(ui, &resp, i, r, row, &placed, &t) {
+                Some(TabDrop::Move(to)) => tab_move = Some((i, to)),
+                Some(TabDrop::Float(at)) => tear_off = Some((i, at)),
+                None => {}
             }
             let has_path = st.path.is_some();
             resp.context_menu(|ui| {
@@ -1925,6 +2204,7 @@ fn tabs(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> TabStrip {
         app.ui.status = e;
         app.ui.status_error = true;
     }
+    float_torn_off(app, ui.ctx(), tear_off);
     if let Some((id, params)) = tab_action
         && let Err(e) = crate::menus::invoke(app, ui.ctx(), id, params)
     {
@@ -1968,6 +2248,70 @@ fn tab_context_menu(ui: &mut egui::Ui, index: usize, count: usize, has_path: boo
 
 /// Where a tab dragged to `x` would land: before the first shown tab whose middle is right of
 /// `x`, else after the last shown tab (its document index + 1), like [`TabStrip::slot`].
+/// How far (points) above or below the tab strip a dragged tab must be to tear off (#3733).
+const TEAR_OFF: f32 = 24.0;
+
+/// Whether a tab dragged to `p` has left the strip and floats into its own window, as in
+/// Photoshop; sideways drags along the strip still reorder (#217).
+fn torn_off(strip: Rect, p: egui::Pos2) -> bool {
+    p.y > strip.bottom() + TEAR_OFF || p.y < strip.top() - TEAR_OFF
+}
+
+/// What a finished document-tab drag asks for.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum TabDrop {
+    /// Reorder the tab to this index.
+    Move(usize),
+    /// Float the document in its own OS window at this screen position (points), when known.
+    Float(Option<[f32; 2]>),
+}
+
+/// Drag a document tab: along the strip it reorders (a line shows where it will land); off the
+/// strip it tears off into a floating window that can go anywhere, other screens included
+/// (an outline under the pointer shows it). Returns the drop once the drag ends.
+fn tab_drag(ui: &egui::Ui, resp: &egui::Response, i: usize, r: Rect, strip: Rect, placed: &[(usize, Rect)], t: &crate::theme::Tokens) -> Option<TabDrop> {
+    if resp.dragged()
+        && let Some(p) = resp.interact_pointer_pos()
+    {
+        if torn_off(strip, p) {
+            let ghost = Rect::from_min_size(p - egui::vec2(40.0, 12.0), egui::vec2(240.0, 160.0));
+            let painter = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Tooltip, ui.id().with("tab-tear-off")));
+            painter.rect_filled(ghost, t.radius_sm, t.accent.gamma_multiply(0.12));
+            painter.rect_stroke(ghost, t.radius_sm, Stroke::new(1.5, t.accent), egui::StrokeKind::Inside);
+        } else {
+            tab_drop_line(ui, placed, p.x, t);
+        }
+    }
+    if !resp.drag_stopped() {
+        return None;
+    }
+    let p = resp.interact_pointer_pos().or_else(|| ui.input(|i| i.pointer.interact_pos()));
+    if let Some(p) = p.filter(|&p| torn_off(strip, p)) {
+        // The pointer is in this window's points; the OS wants screen coordinates. Keep the new
+        // window's title bar under the pointer, as the ghost showed.
+        let at = ui.ctx().input(|i| i.viewport().inner_rect).map(|inner| {
+            let s = inner.min + p.to_vec2() - egui::vec2(40.0, 12.0);
+            [s.x, s.y]
+        });
+        return Some(TabDrop::Float(at));
+    }
+    let to = tab_move_target(i, tab_drop_index(placed, p.map_or(r.center().x, |p| p.x)));
+    (to != i).then_some(TabDrop::Move(to))
+}
+
+/// Float a torn-off tab's document in its own window (`window.arrange.floatInWindow`).
+fn float_torn_off(app: &mut PhotocraftApp, ctx: &egui::Context, tear_off: Option<(usize, Option<[f32; 2]>)>) {
+    let Some((doc, at)) = tear_off else { return };
+    let params = match at {
+        Some(at) => json!({"document": doc, "position": at}),
+        None => json!({"document": doc}),
+    };
+    if let Err(e) = crate::menus::invoke(app, ctx, "window.arrange.floatInWindow", params) {
+        app.ui.status = e;
+        app.ui.status_error = true;
+    }
+}
+
 fn tab_drop_index(placed: &[(usize, Rect)], x: f32) -> usize {
     match placed.iter().find(|(_, r)| r.center().x >= x) {
         Some(&(i, _)) => i,
@@ -2027,7 +2371,7 @@ const STUDIO_TAB_GAP: f32 = 4.0;
 fn pro_tab_title(app: &PhotocraftApp, i: usize) -> String {
     let Some(st) = app.session.documents().get(i) else { return String::new() };
     let zoom = app.ui.views.get(i).map_or(100.0, |v| v.zoom * 100.0);
-    let active_layer = st.active_layer.and_then(|id| st.doc.layer(id)).filter(|l| !(l.name == "Background" && l.locks.transparency));
+    let active_layer = st.active_layer.and_then(|id| st.doc.layer(id)).filter(|l| !st.doc.is_background(l.id));
     let mask = app.session.active_index() == Some(i) && app.ui.mask_target && active_layer.is_some_and(|l| l.mask.is_some());
     let model = if mask { tl!("Layer Mask").to_string() } else { mode_label(&st.doc).to_string() };
     let layer = active_layer.map(|l| format!("{}, ", l.name)).unwrap_or_default();
@@ -2051,6 +2395,7 @@ fn pro_tabs(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> TabStrip {
     let (mut activate, mut close) = (None, None);
     let mut tab_action = None;
     let mut tab_move = None;
+    let mut tear_off = None;
     let tab_count = app.session.documents().len();
     let dragging = crate::layer_transfer::pointer_if_armed(app, ui.ctx());
     let mut drag_over = None;
@@ -2111,18 +2456,10 @@ fn pro_tabs(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> TabStrip {
         } else if resp.clicked() {
             activate = Some(i);
         }
-        // Drag a tab sideways to reorder it (#217); a line shows where it will land.
-        if resp.dragged()
-            && let Some(p) = resp.interact_pointer_pos()
-        {
-            tab_drop_line(ui, &placed, p.x, &t);
-        }
-        if resp.drag_stopped() {
-            let x = resp.interact_pointer_pos().or_else(|| ui.input(|i| i.pointer.interact_pos())).map_or(r.center().x, |p| p.x);
-            let to = tab_move_target(i, tab_drop_index(&placed, x));
-            if to != i {
-                tab_move = Some((i, to));
-            }
+        match tab_drag(ui, &resp, i, r, strip, &placed, &t) {
+            Some(TabDrop::Move(to)) => tab_move = Some((i, to)),
+            Some(TabDrop::Float(at)) => tear_off = Some((i, at)),
+            None => {}
         }
         let has_path = app.session.documents().get(i).is_some_and(|d| d.path.is_some());
         resp.context_menu(|ui| {
@@ -2179,6 +2516,7 @@ fn pro_tabs(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> TabStrip {
         app.ui.status = e;
         app.ui.status_error = true;
     }
+    float_torn_off(app, ui.ctx(), tear_off);
     if let Some((id, params)) = tab_action
         && let Err(e) = crate::menus::invoke(app, ui.ctx(), id, params)
     {
@@ -2519,7 +2857,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
         fill_view(&mut view, &doc, rect.size(), ppp, aspect);
     }
     // Preferences › Tools › Overscroll off: clamp before anything is drawn (scrollbars.rs).
-    if !app.session.prefs().tools.overscroll && crate::scrollbars::clamp_view(&mut view, rect.size() / vec2(aspect, 1.0), ppp) {
+    if !app.session.prefs().tools.overscroll && crate::scrollbars::clamp_view_with_aspect(&mut view, rect.size(), ppp, aspect) {
         ctx.request_repaint();
     }
     let flip = app.ui.view.flip_horizontal;
@@ -2569,6 +2907,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                 ensure_adjust_proxy(app, idx, view.zoom).or_else(|| ensure_filter_preview(app, idx, &ctx)).or_else(|| ensure_proxy_preview(app, idx))
         {
             on_gpu = true;
+            app.navigator_gpu.remove(&doc.id);
             let original_size = [doc.size.width.div_ceil(k), doc.size.height.div_ceil(k)];
             let params = crate::gpu_canvas::ViewParams {
                 doc: key,
@@ -2592,7 +2931,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                 offset: [0.0, 0.0],
             };
             paint_gpu_view(&painter, rect, params, &pattern);
-        } else if gpu_ok && ensure_gpu(app, idx, visible_doc_rect(&xf)) {
+        } else if gpu_ok && ensure_gpu(app, &ctx, idx, visible_doc_rect(&xf)) {
             on_gpu = true;
             app.perf.gpu = true;
             // Shadow, checkerboard, document and pixel grid in one custom shader (gpu_canvas.rs).
@@ -2613,8 +2952,14 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                 hdr: hdr_preview(app, &doc),
                 offset: [0.0, 0.0],
             };
+            if app.navigator_plain.contains(&doc.id) {
+                app.navigator_gpu.insert(doc.id, params);
+            } else {
+                app.navigator_gpu.remove(&doc.id);
+            }
             paint_gpu_view(&painter, rect, params, &pattern);
         } else {
+            app.navigator_gpu.remove(&doc.id);
             if !crate::theme::Tokens::get(&ctx).bevel && drop_shadow {
                 painter.add(egui::Shadow { offset: [0, 8], blur: 28, spread: 0, color: Color32::from_black_alpha(150) }.as_shape(img_rect, 0));
             }
@@ -2677,6 +3022,12 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
             crate::pixel_grid::paint(app, &painter, &xf, idx, output, visible_doc_rect(&xf));
         }
 
+        // Developer tile grid (`ui.set {"tileGrid": true}`): the active layer's storage tiles.
+        // Not tied to View › Extras (⌘H), which hides only the View › Show overlays.
+        if app.ui.view.tile_grid {
+            crate::tile_overlay::paint(app, &ctx, &painter, &xf, idx, visible_doc_rect(&xf));
+        }
+
         // View › Show › Layer Edges: drawn at this depth, but only once this frame's tool events are
         // in (`layer_edges_rect`), so a press that Auto-Selects a layer outlines that layer.
         let layer_edges = painter.add(egui::Shape::Noop);
@@ -2765,6 +3116,10 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
     // Under an open dialog the canvas widget is inert, but the image still pans and zooms.
     let under_dialog = !app.ui.dialogs.is_empty();
     let free_hover = under_dialog && crate::dialogs::free_pointer_over(&ctx, rect).is_some();
+    // A press on the canvas while a tool letter is held makes that tool temporary (#2672).
+    if !under_dialog && ctx.input(|i| i.pointer.any_pressed() && i.pointer.interact_pos().is_some_and(|p| rect.contains(p))) {
+        crate::spring_tools::note_canvas_press(app);
+    }
     // Navigation (wheel_nav.rs): scroll pans (⇧ or ⌘/Ctrl sideways); pinch and ⌥-scroll zoom around the pointer.
     let wheel =
         crate::wheel_nav::read(&ctx, app.session.prefs().general.zoom_with_scroll_wheel, app.session.prefs().enhanced_controls.zoom_with_trackpad_pinch);
@@ -2779,7 +3134,9 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                 // zooms nor slides the image towards the pointer.
                 let nz = crate::zoom_levels::clamp(view.zoom * f, view.doc_size);
                 if nz != view.zoom {
-                    zoom_about(&mut view, &xf, p, nz, false, ppp);
+                    // Over the pasteboard the anchor is the image's nearest point (#3720).
+                    let at = wheel_anchor(&xf, p, view.doc_size);
+                    zoom_about(&mut view, &xf, at, nz, false, ppp);
                 }
             }
             (Some(crate::wheel_nav::Wheel::Pan(scroll)), _) => {
@@ -2791,7 +3148,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
         }
         let rotate_trackpad = app.session.prefs().enhanced_controls.rotate_view_with_trackpad;
         if let Some(delta) = crate::rotate_view::trackpad_delta(&ctx, rotate_trackpad) {
-            let next = view.rotation + delta;
+            let next = view.rotation + crate::rotate_view::screen_delta(delta, xf.flip);
             if next.is_finite() {
                 view.rotation = crate::rotate_view::wrap_deg(next);
             }
@@ -2847,16 +3204,19 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
 
     if under_dialog {
         // With a colour dialog picker armed the image is its eyedropper, whatever the tool; Space
-        // and the middle button still pan. Curves uses the same merged-composite sampler as the
-        // Color Picker, never the reduced adjustment preview.
+        // and the middle button still pan. Curves and Replace Color use the same merged-composite
+        // sampler as the Color Picker, never the reduced adjustment preview.
         let curves_picking = crate::adjust_dialog::picker_armed(app);
-        let picking = primary && (crate::color_picker_ui::top(app).is_some() || curves_picking);
+        let replace_picking = crate::filter_dialog::color_eyedropper_armed(app);
+        let picking = primary && (crate::color_picker_ui::top(app).is_some() || curves_picking || replace_picking);
         let range_picking =
             primary && app.ui.dialogs.last().is_some_and(|d| crate::color_range_ui::owns(&d.fields) && crate::color_range_ui::controls(&d.fields).sampling);
         // Select and Mask's Refine Edge Brush paints on the image.
         let refine_brushing =
             primary && app.ui.dialogs.last().is_some_and(|d| crate::select_mask_view::owns(&d.fields) && crate::select_mask_view::brush_on(&d.fields));
-        let hand = app.ui.tool == Tool::Hand && !picking && !range_picking && !refine_brushing;
+        // Field Blur's pins are placed and dragged on the image (`blur_pins`).
+        let pinning = primary && app.ui.dialogs.last().is_some_and(|d| crate::blur_pins::owns(&d.fields));
+        let hand = app.ui.tool == Tool::Hand && !picking && !range_picking && !refine_brushing && !pinning;
         if let Some(d) = crate::dialogs::pan_delta(&ctx, rect, hand) {
             let d = xf.unmap_vec(d) / (view.zoom / ppp);
             view.center[0] -= d.x;
@@ -2874,10 +3234,18 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                 let d = xf.to_doc(p);
                 if curves_picking {
                     crate::adjust_dialog::sample_at(app, d[0], d[1]);
+                } else if replace_picking {
+                    crate::filter_dialog::color_eyedropper_sample(app, d[0], d[1]);
                 } else {
                     crate::color_picker_ui::sample_at(app, d[0], d[1]);
                 }
             }
+        } else if pinning
+            && !middle
+            && let Some(p) = crate::dialogs::free_pointer_over(&ctx, rect)
+        {
+            let press = crate::dialogs::free_press(&ctx, rect);
+            crate::blur_pins::canvas(app, &ctx, &xf, p, press);
         } else if refine_brushing
             && !middle
             && let Some(p) = crate::dialogs::free_pointer_over(&ctx, rect)
@@ -2911,7 +3279,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
             view.center[1] -= d.y;
         }
         // Overscroll off: the glide stops at the pan limit, as the scrollbars do.
-        if !app.session.prefs().tools.overscroll && crate::scrollbars::clamp_view(&mut view, rect.size() / vec2(aspect, 1.0), ppp) {
+        if !app.session.prefs().tools.overscroll && crate::scrollbars::clamp_view_with_aspect(&mut view, rect.size(), ppp, aspect) {
             ctx.data_mut(|m| m.get_temp_mut_or_default::<crate::flick_pan::Flick>(flick_id).stop());
         }
     }
@@ -3025,7 +3393,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                     crate::canvas_tool_menu::open_view(app, &ctx, tool, [p.x, p.y], xf.to_doc(p));
                 }
             } else {
-                crate::canvas_tool_menu::open(app, &ctx, tool, [p.x, p.y]);
+                crate::canvas_tool_menu::open_at(app, &ctx, tool, [p.x, p.y], Some(xf.to_doc(p)));
             }
         }
         // The (temporary) Hand pans above; its gestures never reach the tool underneath. While a
@@ -3040,7 +3408,8 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
             (buttons.started, buttons.dragged, buttons.stopped, buttons.clicked) = (false, false, false, false);
         }
         // Zoom tool drags: scrubby zoom or a zoom rectangle (zoom_tool.rs); clicks step below.
-        if tool == Tool::Zoom && crate::zoom_tool::drag(app, &ctx, &mut view, &xf, &buttons, response.interact_pointer_pos()) {
+        // Like the Hand, the selected Zoom yields to an open Free Transform box (#4799).
+        if tool == Tool::Zoom && !transform_owns_pointer && crate::zoom_tool::drag(app, &ctx, &mut view, &xf, &buttons, response.interact_pointer_pos()) {
             (buttons.started, buttons.dragged, buttons.stopped) = (false, false, false);
         }
         // A drag is only recognised once the pointer has moved past egui's click distance: the
@@ -3174,7 +3543,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
             let click_mods = ui.input(|i| pointer_button_modifiers(&i.events, click_button)).unwrap_or(mods);
             let d = xf.to_doc(p);
             match tool {
-                Tool::Zoom => {
+                Tool::Zoom if !transform_owns_pointer => {
                     let nz = crate::zoom_levels::step(view.zoom, if zoom_out(click_mods.alt) { -1 } else { 1 }, view.doc_size);
                     let center = app.session.prefs().tools.zoom_clicked_point_to_center;
                     zoom_about(&mut view, &xf, p, nz, center, ppp);
@@ -3286,6 +3655,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
         let resizing = crate::brush_resize::draw(app, &painter, &xf);
         draw_transform_controls(app, &painter, &xf);
         crate::move_hover::draw(app, &painter, &xf, idx, response.hover_pos());
+        crate::object_finder::draw(app, &painter, &xf, idx, response.hover_pos());
         crate::layer_pick_ui::show(app, &ctx);
         let shown = app.ui.views.get(idx).cloned();
         crate::canvas_tool_menu::show(app, &ctx);
@@ -3306,6 +3676,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
         crate::type_tool::draw_overlay(app, &painter, &xf);
         crate::transform_tool::draw_overlay(app, &painter, &xf);
         crate::cam_transform::draw(app, &painter, &xf);
+        crate::cam_preview::wake(app, painter.ctx());
         crate::distort_ui::draw_overlay(app, &painter, &xf);
         crate::perspective_crop_ui::draw_overlay(app, &painter, &xf);
         crate::retouch_ui::draw_source_marker(app, &painter, &xf);
@@ -3326,16 +3697,30 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
         });
         if let Some((vertical, _)) = guide_hover {
             ui.ctx().set_cursor_icon(if vertical { egui::CursorIcon::ResizeHorizontal } else { egui::CursorIcon::ResizeVertical });
-        } else if let Some(c) =
-            response.hover_pos().and_then(|p| crate::transform_tool::cursor(app, xf.to_doc(p), ui.input(|i| i.modifiers.alt || i.modifiers.command)))
+        } else if let Some(p) = response.hover_pos()
+            && let Some(c) = crate::transform_tool::cursor(app, xf.to_doc(p), ui.input(|i| i.modifiers.alt || i.modifiers.command))
         {
             ui.ctx().set_cursor_icon(c);
+            // CursorIcon::None hides the pointer; the curved arrow has to be drawn or the
+            // rotate zone looks like a plain cursor (#4050).
+            let d = xf.to_doc(p);
+            if let Some(k) = crate::transform_tool::rotate_cursor_dir(app, d) {
+                let toward = xf.to_screen((d[0] + k[0] * 16.0) as f32, (d[1] + k[1] * 16.0) as f32) - p;
+                crate::crop_ui::draw_turn_cursor(&ctx, p, toward);
+            }
+        } else if let Some(c) = response.hover_pos().and_then(|p| crate::symmetry_ui::cursor(app, &xf, xf.to_doc(p))) {
+            ui.ctx().set_cursor_icon(c);
         } else if let Some(c) = response.hover_pos().and_then(|p| crate::cam_transform::cursor(app, &ctx, &xf, p)) {
             ui.ctx().set_cursor_icon(c);
-        } else if let Some(c) = response.hover_pos().and_then(|p| transform_controls_rect(app, &xf).and_then(|r| transform_controls_cursor(r, p))) {
+        } else if let Some((r, p, c)) =
+            response.hover_pos().and_then(|p| transform_controls_rect(app, &xf).and_then(|r| transform_controls_cursor(r, p).map(|c| (r, p, c))))
+        {
             // The Move tool draws handles without opening a Free Transform session.
             // Give them their resize/rotate cursors before the first pointer press (#2871).
             ui.ctx().set_cursor_icon(c);
+            if let Some(toward) = transform_controls_turn(r, p) {
+                crate::crop_ui::draw_turn_cursor(&ctx, p, toward);
+            }
         } else if let Some(c) = response.hover_pos().filter(|_| tool.is_type()).and_then(|p| {
             let mods = crate::workspace_ui::sticky_mods(app, ui.input(|i| i.modifiers));
             crate::type_transform::cursor(app, &ctx, &xf, p, mods)
@@ -3407,11 +3792,6 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                         let painting = app.drag.is_some();
                         let brush = &app.session.tools.brush;
                         let full = (brush.size / 2.0 * xf.zoom).max(1.0);
-                        let r = if cur.painting == PaintingCursor::NormalTip {
-                            photocraft_paint::half_coverage_radius(full, brush.hardness).max(1.0)
-                        } else {
-                            full
-                        };
                         match cur.painting {
                             PaintingCursor::Standard => egui::CursorIcon::Default,
                             PaintingCursor::Precise => crate::tool_cursor::crosshair(&painter, p, 6.0, 0.0),
@@ -3442,33 +3822,61 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                                 egui::CursorIcon::None
                             }
                             // A shaped tip (sampled bitmap, or a rotated/flattened round tip)
-                            // traces its outline; a plain round tip keeps the circle.
+                            // traces its outline, turned and flipped with the view; a plain round
+                            // tip keeps the circle.
                             _ => {
-                                let centre = brush_tip_centre(tool, alt || app.ui.shell.sticky_alt, cur.show_crosshair_in_brush_tip, r);
-                                crate::brush_cursor::cursor(&painter, p, brush, full, cur.painting == PaintingCursor::NormalTip, centre)
+                                let centre = brush_tip_centre(tool, alt || app.ui.shell.sticky_alt, cur.show_crosshair_in_brush_tip);
+                                let axes = crate::brush_cursor::tip_axes(&xf, brush.size);
+                                crate::brush_cursor::cursor(&painter, p, brush, full, axes, cur.painting == PaintingCursor::NormalTip, centre)
                             }
                         }
                     }
                 }
                 // The Eyedropper: the comparison ring follows the pointer while it samples (#213);
-                // otherwise its pipette, or the crosshair for Precise Other Cursors.
+                // otherwise its pipette, or the crosshair for precise Other Cursors.
                 Tool::Eyedropper => {
                     if let Some(icon) = eyedropper_ring(app, &painter, &xf, p, response.is_pointer_button_down_on()) {
                         icon
-                    } else if app.session.prefs().cursors.other == photocraft_engine::prefs::OtherCursor::Precise {
+                    } else if precise_other_cursor(app) {
                         egui::CursorIcon::Crosshair
                     } else {
                         pipette_cursor(ui.ctx(), p)
                     }
                 }
-                // The Color Sampler: a pipette, or the crosshair for Precise Other Cursors.
+                // The Color Sampler: a pipette, or the crosshair for precise Other Cursors.
                 Tool::ColorSampler => {
-                    if app.session.prefs().cursors.other == photocraft_engine::prefs::OtherCursor::Precise {
+                    if precise_other_cursor(app) {
                         egui::CursorIcon::Crosshair
                     } else {
                         pipette_cursor(ui.ctx(), p)
                     }
                 }
+                // The Paint Bucket: a bucket, or the crosshair for precise Other Cursors (#3968).
+                Tool::PaintBucket => {
+                    if precise_other_cursor(app) {
+                        egui::CursorIcon::Crosshair
+                    } else {
+                        paint_bucket_cursor(ui.ctx(), p)
+                    }
+                }
+                // Over the first anchor, the close-path pointer (#4596), before the pens' own cursors.
+                Tool::Pen | Tool::CurvaturePen
+                    if {
+                        let [x, y] = xf.to_doc(p);
+                        crate::vector_ui::closes_path_at(app, tool, x, y)
+                    } =>
+                {
+                    crate::tool_cursor::close_path(&painter, p)
+                }
+                // The pen tools: their own icon with its nib on the point, or the crosshair for
+                // precise Other Cursors (#4639).
+                Tool::Pen | Tool::FreeformPen | Tool::CurvaturePen | Tool::AddAnchorPoint | Tool::DeleteAnchorPoint | Tool::ConvertPoint => {
+                    if precise_other_cursor(app) {
+                        egui::CursorIcon::Crosshair
+                    } else {
+                        pen_cursor(ui.ctx(), tool, p)
+                    }
+                }
                 // Preferences › Cursors › Other Cursors: Precise shows a crosshair for every tool.
                 Tool::Move | Tool::Type | Tool::VerticalType | Tool::HorizontalTypeMask | Tool::VerticalTypeMask
                     if app.session.prefs().cursors.other == photocraft_engine::prefs::OtherCursor::Precise =>
@@ -3479,13 +3887,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
                 // Dragging is handled with the pan itself, above.
                 Tool::Hand => crate::tool_cursor::hand(ui.ctx(), false),
                 Tool::RotateView => crate::rotate_view::cursor(response.dragged()),
-                Tool::Zoom => {
-                    if zoom_out(alt) {
-                        egui::CursorIcon::ZoomOut
-                    } else {
-                        egui::CursorIcon::ZoomIn
-                    }
-                }
+                Tool::Zoom => crate::tool_cursor::zoom(ui.ctx(), zoom_out(alt)),
                 Tool::Type | Tool::VerticalType | Tool::HorizontalTypeMask | Tool::VerticalTypeMask => egui::CursorIcon::Text,
                 Tool::MagneticLasso => crate::magnetic_lasso_ui::cursor(app, &painter, p, xf.zoom),
                 Tool::RedEye => {
@@ -3515,10 +3917,26 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
             crate::stroke_constraint::draw_line_preview(app, &painter, &xf, p, tool, held.shift);
         }
     }
+    if primary && hand_pan && response.dragged() {
+        crate::transform_tool::draw_overlay(app, &painter, &xf);
+    }
     app.tool_override = None;
     if let Some(b) = layer_edges_rect(app, idx) {
         painter.set(layer_edges, egui::Shape::rect_stroke(xf.doc_rect(b), 0, Stroke::new(1.0, LAYER_EDGES), egui::StrokeKind::Outside));
     }
+    // A tool drag held past the canvas edge scrolls the view toward the pointer (#4183); the
+    // drag's next move then extends into what scrolled in.
+    if primary
+        && app.drag.is_some()
+        && tool != Tool::Hand
+        && !middle
+        && let Some(p) = ui.input(|i| i.pointer.primary_down().then(|| i.pointer.latest_pos()).flatten())
+    {
+        let step = crate::canvas_autoscroll::edge_step(p, rect, ui.input(|i| i.stable_dt));
+        if crate::canvas_autoscroll::scroll(&mut view, step, xf) {
+            ctx.request_repaint();
+        }
+    }
     // Scrollbars (scrollbars.rs): drawn over the canvas edges, they take the pointer there.
     let t0 = crate::gpu_canvas::now_ms();
     let before = view.center;
@@ -3557,6 +3975,20 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
 /// Zoom to `new_zoom` about the pointer `p`. By default the document point under it stays under
 /// it; with Preferences › Tools › Zoom Clicked Point to Center (`center_on_point`) it moves to the
 /// centre of the view instead (#204).
+/// Where a wheel or pinch zoom anchors for a pointer at `p`: the pointer itself over the image,
+/// otherwise the nearest point of the image (#3720). Anchoring on a pointer out on the gray
+/// pasteboard slid the image away from it, out of the window after a few notches; Photoshop keeps
+/// the image in view. Clamped in document space, so a rotated or flipped view behaves the same.
+fn wheel_anchor(xf: &ViewXform, p: Pos2, doc_size: [u32; 2]) -> Pos2 {
+    let [w, h] = doc_size;
+    let d = xf.to_doc(p);
+    if w == 0 || h == 0 || !(d[0].is_finite() && d[1].is_finite()) {
+        return p;
+    }
+    let c = [d[0].clamp(0.0, f64::from(w)), d[1].clamp(0.0, f64::from(h))];
+    if c == d { p } else { xf.to_screen(c[0] as f32, c[1] as f32) }
+}
+
 fn zoom_about(view: &mut View, xf: &ViewXform, p: Pos2, new_zoom: f32, center_on_point: bool, ppp: f32) {
     let before = xf.to_doc(p);
     view.zoom = new_zoom;
@@ -3663,9 +4095,21 @@ fn marching_ants_segments(painter: &egui::Painter, xf: &ViewXform, segs: &[crate
 pub(crate) fn marching_ants_mapped(painter: &egui::Painter, segs: &[crate::outline::Segment], time: f64, to_screen: impl Fn([i32; 2]) -> Pos2) {
     let dash = 4.0f32;
     let phase = ((time * 10.0) % (dash as f64 * 2.0)) as f32;
-    let white = Stroke::new(1.0, Color32::WHITE);
-    let black = Stroke::new(1.0, Color32::BLACK);
     let clip = painter.clip_rect();
+    // Horizontal and vertical segments go in one mesh of 1 px quads, which egui draws as it is: a
+    // line shape per dash took egui ~35 ms a frame to tessellate for a speckled selection seen
+    // whole (about 10⁵ segments), ten frames a second while the selection is shown. A slanted
+    // segment (a transformed outline) stays a line shape, which egui antialiases.
+    let mut mesh = egui::Mesh::default();
+    // A 1 px wide quad from `a` to `b` (`side` is half a pixel across the line).
+    let mut quad = |a: egui::Pos2, b: egui::Pos2, side: egui::Vec2, color: Color32| {
+        let i = mesh.vertices.len() as u32;
+        for p in [a + side, a - side, b - side, b + side] {
+            mesh.colored_vertex(p, color);
+        }
+        mesh.add_triangle(i, i + 1, i + 2);
+        mesh.add_triangle(i, i + 2, i + 3);
+    };
     for (a, b) in segs {
         let pa = to_screen(*a);
         let pb = to_screen(*b);
@@ -3674,12 +4118,19 @@ pub(crate) fn marching_ants_mapped(painter: &egui::Painter, segs: &[crate::outli
         }
         let pa = pos2(pa.x.round() + 0.5, pa.y.round() + 0.5);
         let pb = pos2(pb.x.round() + 0.5, pb.y.round() + 0.5);
-        painter.line_segment([pa, pb], white);
         let len = pa.distance(pb);
         if len < 0.5 {
             continue;
         }
         let dir = (pb - pa) / len;
+        let side = dir.rot90() * 0.5;
+        let straight = pa.x == pb.x || pa.y == pb.y;
+        if straight {
+            // The white base runs half a pixel past both ends, so joined segments meet at corners.
+            quad(pa - dir * 0.5, pb + dir * 0.5, side, Color32::WHITE);
+        } else {
+            painter.line_segment([pa, pb], Stroke::new(1.0, Color32::WHITE));
+        }
         // Phase by screen position so dashes line up across joined segments.
         let start = (pa.x + pa.y + phase).rem_euclid(dash * 2.0);
         let mut t = -start;
@@ -3687,11 +4138,18 @@ pub(crate) fn marching_ants_mapped(painter: &egui::Painter, segs: &[crate::outli
             let s0 = t.max(0.0);
             let s1 = (t + dash).min(len);
             if s1 > s0 {
-                painter.line_segment([pa + dir * s0, pa + dir * s1], black);
+                if straight {
+                    quad(pa + dir * s0, pa + dir * s1, side, Color32::BLACK);
+                } else {
+                    painter.line_segment([pa + dir * s0, pa + dir * s1], Stroke::new(1.0, Color32::BLACK));
+                }
             }
             t += dash * 2.0;
         }
     }
+    if !mesh.is_empty() {
+        painter.add(egui::Shape::mesh(mesh));
+    }
 }
 
 #[allow(dead_code)]
@@ -3995,6 +4453,7 @@ fn draw_tool_state(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform,
         crate::tool_feedback::draw_ants(painter, &pts, false);
     }
     crate::crop_straighten::draw(app, painter, |p| xf.to_screen(p[0] as f32, p[1] as f32), hover);
+    crate::blur_pins::draw(app, painter, xf);
     if let Some(c) = app.ui.crop_rect {
         let deg = crate::crop_ui::angle(app);
         let shield = crate::crop_shield::current(app, painter.ctx());
@@ -4067,7 +4526,28 @@ fn transform_controls_cursor(r: Rect, p: Pos2) -> Option<egui::CursorIcon> {
             });
         }
     }
-    (r.expand(18.0).contains(p) && !r.expand(5.0).contains(p)).then_some(egui::CursorIcon::Alias)
+    // The rotation band: the pointer gives way to the curved rotate arrow (`transform_controls_turn`).
+    in_rotation_band(r, p).then_some(egui::CursorIcon::None)
+}
+
+fn in_rotation_band(r: Rect, p: Pos2) -> bool {
+    r.expand(18.0).contains(p) && !r.expand(5.0).contains(p)
+}
+
+/// In the rotation band just outside the Move tool's transform controls, the screen direction the
+/// curved rotate arrow bends round: into the box along the nearest corner's bisector, as Free
+/// Transform draws it (#4658). Before, the band showed a plain alias pointer, so nothing said a
+/// drag there rotates.
+fn transform_controls_turn(r: Rect, p: Pos2) -> Option<Vec2> {
+    if !in_rotation_band(r, p)
+        || [r.left_top(), r.center_top(), r.right_top(), r.right_center(), r.right_bottom(), r.center_bottom(), r.left_bottom(), r.left_center()]
+            .into_iter()
+            .any(|h| h.distance(p) <= crate::transform_tool::HANDLE_PX as f32)
+    {
+        return None;
+    }
+    let corner = pos2(if p.x < r.center().x { r.left() } else { r.right() }, if p.y < r.center().y { r.top() } else { r.bottom() });
+    Some(vec2((r.center().x - corner.x).signum(), (r.center().y - corner.y).signum()).normalized() * 16.0)
 }
 
 /// A visible handle starts scaling; the narrow band just outside the box starts rotation.
@@ -4118,6 +4598,8 @@ fn draw_smoothing_string(painter: &egui::Painter, xf: &ViewXform, (brush, pointe
 
 fn draw_drag_preview(app: &mut PhotocraftApp, painter: &egui::Painter, xf: &ViewXform) {
     draw_tool_state(app, painter, xf, painter.ctx().input(|i| i.pointer.hover_pos()));
+    // Remove strokes waiting for ↩ stay tinted between drags.
+    crate::retouch_ui::draw_remove_pending(app, painter, xf);
     let Some(d) = &app.drag else {
         app.trail = None;
         return;
@@ -4237,6 +4719,26 @@ pub(crate) fn alt_samples(tool: Tool, mods: egui::Modifiers) -> bool {
     mods.alt && !mods.ctrl && matches!(tool, Tool::Brush | Tool::Pencil | Tool::Gradient | Tool::PaintBucket)
 }
 
+/// Preferences › Cursors › Other Cursors asks for the precise crosshair, or Caps Lock swaps the
+/// standard cursor for it (and back), as in Photoshop (#4639).
+fn precise_other_cursor(app: &PhotocraftApp) -> bool {
+    (app.session.prefs().cursors.other == photocraft_engine::prefs::OtherCursor::Precise) != app.caps_lock
+}
+
+/// A pen tool's standard cursor: its toolbar icon with the nib (the Convert Point tool: the
+/// anchor) on `p`. Draws it at `p` and returns the OS cursor to set (hidden).
+pub(crate) fn pen_cursor(ctx: &egui::Context, tool: Tool, p: Pos2) -> egui::CursorIcon {
+    // Where each icon's point is in its 24-unit box: the full-size pen's nib at (2.3, 2.3); the
+    // Freeform and Curvature pens draw it at 0.68 × from (7, 7); Convert Point's apex anchor.
+    let hot = match tool {
+        Tool::FreeformPen | Tool::CurvaturePen => vec2(8.56, 8.56),
+        Tool::ConvertPoint => vec2(12.0, 7.0),
+        _ => vec2(2.3, 2.3),
+    };
+    crate::icons::cursor(ctx, crate::icons::tool_icon(tool), p, hot / 24.0, 22.0);
+    egui::CursorIcon::None
+}
+
 /// The sampling cursor: a pipette whose tip is the sampled pixel. Draws it at `p` and returns the
 /// OS cursor to set (hidden).
 pub(crate) fn pipette_cursor(ctx: &egui::Context, p: Pos2) -> egui::CursorIcon {
@@ -4245,6 +4747,14 @@ pub(crate) fn pipette_cursor(ctx: &egui::Context, p: Pos2) -> egui::CursorIcon {
     egui::CursorIcon::None
 }
 
+/// The Paint Bucket's cursor: a bucket whose pouring corner is the filled pixel. Draws it at `p`
+/// and returns the OS cursor to set (hidden).
+pub(crate) fn paint_bucket_cursor(ctx: &egui::Context, p: Pos2) -> egui::CursorIcon {
+    // The left corner of the icon's bucket is at (2, 12) of its 24-unit box.
+    crate::icons::cursor(ctx, "paint-bucket", p, vec2(2.0, 12.0) / 24.0, 22.0);
+    egui::CursorIcon::None
+}
+
 /// Decided when the press starts, so ⌥ pressed or released mid-stroke never switches between
 /// painting and sampling.
 fn alt_eyedropper(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers) -> bool {
@@ -4486,10 +4996,29 @@ pub fn tool_event(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers)
                 let target = app.ui.tool_options.move_target.clone();
                 let mode = if mods.shift { "add" } else { "replace" };
                 let before = app.session.active().map(|st| st.selected_layers());
+                // A locked layer under the pointer (the Background) can't move. Photoshop draws
+                // the layer marquee instead of reporting the lock (#4058). Probe without
+                // selecting so a locked hit doesn't become the selection first.
+                let probe = app.run("layer.pickAt", json!({"x": x, "y": y, "target": target, "select": false}));
+                let locked_hit = probe.as_ref().ok().and_then(|v| v["layer"].as_u64()).is_some_and(|id| {
+                    app.session.active().is_some_and(|st| {
+                        let id = photocraft_doc::LayerId(id);
+                        let locks = st.doc.effective_locks(id);
+                        locks.position || locks.all || st.doc.is_background(id)
+                    })
+                });
+                if locked_hit || (probe.as_ref().is_ok_and(|v| v["layer"].is_null()) && crate::move_box::empty_at(app, [x, y])) {
+                    if locked_hit {
+                        // A click still selects the locked layer, as in Photoshop; a drag's
+                        // marquee then replaces that selection on release.
+                        let _ = app.run("layer.pickAt", json!({"x": x, "y": y, "target": target, "mode": mode}));
+                    }
+                    crate::move_box::begin(app, [x, y], mods.shift);
+                    return;
+                }
                 let picked = app.run("layer.pickAt", json!({"x": x, "y": y, "target": target, "mode": mode}));
                 // No pixels there at all (an empty spot, or off the canvas): drag a marquee that
-                // selects the layers it touches instead (move_box.rs). A fully locked layer's
-                // pixels still say it is locked once the pointer moves (`move_lock`).
+                // selects the layers it touches instead (move_box.rs).
                 if picked.is_ok_and(|v| v["layer"].is_null()) && crate::move_box::empty_at(app, [x, y]) {
                     crate::move_box::begin(app, [x, y], mods.shift);
                     return;
@@ -4587,6 +5116,14 @@ pub fn tool_event(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers)
                 return;
             }
             match tool {
+                Tool::PathSelection => {
+                    let tol = 6.0 / f64::from(app.point_zoom().max(0.01));
+                    if let Some(st) = app.session.active()
+                        && let Some(id) = crate::vector_ui::pick_shape_at(&st.doc, [x, y], tol)
+                    {
+                        let _ = app.run("layer.select", json!({"layer": id.0}));
+                    }
+                }
                 Tool::Pen => {
                     if !(mods.alt && crate::vector_ui::pen_grab_handle(app, x, y)) {
                         crate::vector_ui::pen_down(app, x, y);
@@ -4644,10 +5181,16 @@ pub fn tool_event(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers)
             // Clear mode (`~` held, or chosen in the options bar) erases with the tool's own brush.
             let clear = crate::paint_mouse::clears(app, tool);
             let erase = std::mem::take(&mut app.secondary_erase) || tool == Tool::Eraser || clear;
+            // A 1 px pencil line depends on the pixels, not where inside the pixel the click
+            // landed (#4071). Snap both ends of the stroke to the aliased tip's grid.
+            let (x, y) = snap_aliased_tip(app, tool, x, y);
             // ⇧-click connects to the last endpoint, including its pen pressure (#2827), so
             // the renderer interpolates size and opacity across the segment.
             let active = app.session.active().map(|st| st.doc.id);
-            let from = app.last_stroke_end.filter(|(doc, _)| mods.shift && crate::stroke_constraint::connects(tool) && Some(*doc) == active).map(|(_, p)| p);
+            let from = app.last_stroke_end.filter(|(doc, _)| mods.shift && crate::stroke_constraint::connects(tool) && Some(*doc) == active).map(|(_, p)| {
+                let (sx, sy) = snap_aliased_tip(app, tool, p[0], p[1]);
+                [sx, sy, p[2]]
+            });
             let mut points = vec![[x, y, pressure as f64]];
             if let Some(p) = from {
                 points.insert(0, p);
@@ -4933,8 +5476,22 @@ fn commit_brush_stroke(app: &mut PhotocraftApp, d: &Drag) {
     }
 }
 
+/// Pencil (and a Pencil-mode Eraser) dabs sit on the pixel grid. Clicks anywhere inside one
+/// pixel must produce the same point, or a ⇧-click line changes with the sub-pixel position.
+fn snap_aliased_tip(app: &PhotocraftApp, tool: Tool, x: f64, y: f64) -> (f64, f64) {
+    let pencil = tool == Tool::Pencil || crate::eraser_ui::pencil_mode(app, tool);
+    if !pencil {
+        return (x, y);
+    }
+    let (cx, cy) = photocraft_engine::paint::grid_center(x, y, app.session.tools.brush.size);
+    (f64::from(cx), f64::from(cy))
+}
+
 pub(crate) fn finish_gesture(app: &mut PhotocraftApp, d: Drag) {
-    let end = d.points.last().copied().unwrap_or([d.start[0], d.start[1], 1.0]);
+    let mut end = d.points.last().copied().unwrap_or([d.start[0], d.start[1], 1.0]);
+    let (sx, sy) = snap_aliased_tip(app, d.tool, end[0], end[1]);
+    end[0] = sx;
+    end[1] = sy;
     if let Some(floating) = d.sel_move {
         finish_selection_drag(app, floating, d.start, [end[0], end[1]]);
         return;
@@ -4945,11 +5502,15 @@ pub(crate) fn finish_gesture(app: &mut PhotocraftApp, d: Drag) {
     {
         app.last_stroke_end = Some((st.doc.id, end));
     }
-    // A live Clone Stamp preview ends here; the commit below replaces it.
+    // A live Clone Stamp preview ends here; the commit below replaces it (the Clone Stamp's and
+    // History Brush's with the pixels it already drew).
+    offer_live_retouch(app, &d);
     if live_retouch_command(d.tool).is_some() || crate::retouch_ui::dab_params(app, d.tool).is_some() || d.tool == Tool::ColorReplacement {
         app.live_stroke = None;
     }
-    if crate::eraser_ui::finish_stroke(app, d.tool, &d.points) || crate::retouch_ui::finish_stroke(app, d.tool, &d.points, d.modifiers) {
+    let finished = crate::eraser_ui::finish_stroke(app, d.tool, &d.points) || crate::retouch_ui::finish_stroke(app, d.tool, &d.points, d.modifiers);
+    app.session.clear_live_stroke();
+    if finished {
         return;
     }
     match d.tool {
@@ -4957,7 +5518,7 @@ pub(crate) fn finish_gesture(app: &mut PhotocraftApp, d: Drag) {
         Tool::FreeformPen => crate::vector_ui::freeform_finish(app, &d.points, d.lasso.as_ref().map_or(&[], |l| l.straight())),
         // Photoshop: a click without dragging opens Create Rectangle / Ellipse / … instead.
         t if crate::vector_ui::is_shape_tool(t)
-            && crate::shape_dialog::is_click(d.start, &d.points, app.current_zoom())
+            && crate::shape_dialog::is_click(d.start, &d.points, app.point_zoom())
             && crate::shape_dialog::open(app, t, d.start).is_some() => {}
         t if crate::vector_ui::is_shape_tool(t) => crate::vector_ui::finish_shape(app, t, d.start, [end[0], end[1]], d.live),
         Tool::PathSelection => crate::vector_ui::path_selection_finish(app, d.start, [end[0], end[1]]),
@@ -5031,7 +5592,10 @@ pub fn extra_windows(app: &mut PhotocraftApp, ctx: &egui::Context) {
         let Some(st) = app.session.documents().get(w.document) else { continue };
         let title = format!("{} — window {}", st.doc.name, w.id);
         let vid = egui::ViewportId::from_hash_of(("docwin", w.id));
-        let builder = egui::ViewportBuilder::default().with_title(title).with_inner_size([800.0, 600.0]);
+        let mut builder = egui::ViewportBuilder::default().with_title(title).with_inner_size([800.0, 600.0]);
+        if let Some([x, y]) = w.position {
+            builder = builder.with_position([x, y]);
+        }
         let mut view = w.view.clone();
         let mut close = false;
         ctx.show_viewport_immediate(vid, builder, |ui, _class| {
@@ -5089,6 +5653,7 @@ fn polygon_click(app: &mut PhotocraftApp, x: f64, y: f64, mods: egui::Modifiers)
         return;
     }
     if app.ui.polygon.is_empty() {
+        app.ui.polygon_doc = app.session.active().map(|st| st.doc.id);
         // ⌥ with nothing selected draws freehand; there is nothing to subtract from.
         let nothing_selected = app.session.active().is_none_or(|st| st.doc.selection.is_none());
         let intent = if nothing_selected { egui::Modifiers { alt: false, ..mods } } else { mods };
@@ -5112,6 +5677,22 @@ pub fn polygon_retract(app: &mut PhotocraftApp) -> bool {
     true
 }
 
+/// The polygon in progress belongs to the document it was started on (`UiState::polygon_doc`):
+/// once another document becomes active it is dropped, so its outline doesn't show on (or get
+/// committed to) the other document, and the selection it would have replaced is shown again.
+/// Switching tools is handled in `PhotocraftApp::sync_views`. Like the Lasso's
+/// ([`crate::lasso_ui::cancel_stale`]) and the Magnetic Lasso's ([`crate::magnetic_lasso_ui::frame`]).
+pub fn polygon_cancel_stale(app: &mut PhotocraftApp) {
+    let active = app.session.active().map(|st| st.doc.id);
+    if app.ui.polygon.is_empty() {
+        app.ui.polygon_doc = None;
+    } else if app.ui.polygon_doc.is_some_and(|d| Some(d) != active) {
+        app.ui.polygon.clear();
+        app.ui.polygon_mode.clear();
+        app.ui.polygon_doc = None;
+    }
+}
+
 /// A new-selection polygonal (or magnetic) lasso is being drawn, so the selection it will replace
 /// is hidden.
 pub fn polygon_replaces_selection(app: &PhotocraftApp) -> bool {
@@ -5166,7 +5747,8 @@ pub fn commit_crop(app: &mut PhotocraftApp) {
     }
 }
 
-/// "mask" when the Layers panel targets (or the canvas shows) the active layer's mask, else "pixels".
+/// "mask" when the Layers panel targets (or the canvas shows) the active layer's mask, or the layer
+/// is an adjustment layer with one (it has no pixels: #4298), else "pixels".
 pub fn paint_target(app: &PhotocraftApp) -> serde_json::Value {
     use photocraft_engine::channel_cmds::ChannelTarget;
     let Some(st) = app.session.active() else { return json!("pixels") };
@@ -5180,7 +5762,8 @@ pub fn paint_target(app: &PhotocraftApp) -> serde_json::Value {
     let has_mask = st.active_layer.and_then(|id| st.doc.layer(id)).is_some_and(|l| l.mask.is_some());
     // Viewing the mask (⌥-click its thumbnail, #196) paints the mask.
     let viewing = photocraft_engine::mask_view_cmds::current(st).is_some();
-    json!(if (app.ui.mask_target || viewing) && has_mask { "mask" } else { "pixels" })
+    let mask = app.ui.mask_target || viewing || crate::adjustment_layer_active(st);
+    json!(if mask && has_mask { "mask" } else { "pixels" })
 }
 
 #[cfg(test)]
@@ -5201,6 +5784,33 @@ mod tabs_tests;
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn display_image_matches_egui_unmultiplied_conversion() {
+        // Several parallel pieces and a ragged one; translucent, out-of-range and NaN values.
+        let n: usize = 3 * 16 * 1024 + 77;
+        let px: Vec<[f32; 4]> = (0..n)
+            .map(|i| {
+                let v = match i % 9 {
+                    0 => f32::NAN,
+                    1 => -0.5,
+                    2 => 3.25,
+                    _ => (i % 1001) as f32 / 1000.0,
+                };
+                [v, (i % 257) as f32 / 256.0, 1.0 - (i % 113) as f32 / 112.0, (i % 6) as f32 / 5.0]
+            })
+            .collect();
+        let buf = photocraft_compose::Buffer { rect: photocraft_geom::Rect::new(0, 0, n as i32, 1), px };
+        let reference = |img: photocraft_raster::Rgba8Image| egui::ColorImage::from_rgba_unmultiplied([img.width as usize, img.height as usize], &img.pixels);
+        assert_eq!(super::display_image(None, &buf).pixels, reference(buf.to_rgba8()).pixels);
+        let mut doc = photocraft_doc::Document::new("t", photocraft_geom::Size::new(1, 1), photocraft_doc::ColorMode::Rgb, photocraft_doc::SampleType::U8);
+        doc.icc_profile = Some(photocraft_cms::Builtin::AdobeRgbCompat.profile().to_bytes());
+        let mut color = photocraft_engine::color_cmds::ColorState::default();
+        color.settings.monitor_profile = "srgb".into();
+        let d = color.canvas_display(&doc).unwrap();
+        assert!(!d.is_identity());
+        assert_eq!(super::display_image(Some(&d), &buf).pixels, reference(d.to_rgba8(&buf)).pixels);
+    }
+
     #[cfg(not(target_arch = "wasm32"))]
     #[test]
     fn every_filter_previews_off_the_ui_thread_and_a_newer_value_cancels_the_old() {
@@ -5234,6 +5844,7 @@ mod tests {
             revision: st.revision,
             dialog: d.id,
             active: st.active_layer,
+            target: st.channel_view.target,
             command: "filter.blur.gaussianBlur".into(),
             params: json!({"radius": 999.0}),
             k: 1,
@@ -5281,6 +5892,7 @@ mod tests {
                 revision: st.revision,
                 dialog: d.id,
                 active: st.active_layer,
+                target: st.channel_view.target,
                 command: "image.mode.indexedColor".into(),
                 params: app.with_mask_target("image.mode.indexedColor", crate::filter_dialog::params_of(&d.fields)),
                 k: 1,
@@ -5371,7 +5983,7 @@ mod tests {
         // The same handle ownership as navigator_texture, without requiring a GPU adapter.
         let tex = ctx.load_texture("navigator-test", egui::ColorImage::filled([64, 64], egui::Color32::WHITE), TextureOptions::LINEAR);
         let nav = tex.id();
-        app.navigator_textures.insert(first.id, (std::sync::Arc::downgrade(&first), 0, tex));
+        app.navigator_textures.insert(first.id, (std::sync::Arc::downgrade(&first), 0, 0, tex));
         app.run("file.new", json!({"width":32,"height":32})).unwrap();
         let other = app.session.active().unwrap().doc.id;
         let b = ensure_texture(&mut app, &ctx, 1, Some(1)).unwrap().0;
@@ -5435,6 +6047,46 @@ mod tests {
         assert_eq!((app.canvases[&(id, 1)].tex_revision, app.canvases[&(id, 4)].tex_revision), (rev, rev));
     }
 
+    #[test]
+    fn cpu_canvas_shows_crisp_pixels_when_zoomed_in() {
+        // #4810: above 100% the CPU canvas shows each pixel as a square, like the GPU canvas's
+        // sharp nearest filter; below 100% it still filters. Both the first upload and a
+        // damage-rect update carry the sampling, since the renderer takes it from each delta.
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": 2, "height": 2})).unwrap();
+        let ctx = egui::Context::default();
+        let tex = ensure_texture(&mut app, &ctx, 0, None).unwrap().0;
+        let uploads = |ctx: &egui::Context| {
+            let mut delta = ctx.tex_manager().write().take_delta();
+            let seen = delta.set.get(&tex).into_iter().flatten().map(|d| (d.pos.is_some(), d.options)).collect::<Vec<_>>();
+            delta.clear();
+            seen
+        };
+        let crisp = TextureOptions { magnification: egui::TextureFilter::Nearest, ..TextureOptions::LINEAR };
+        assert_eq!(uploads(&ctx), vec![(false, crisp)]);
+        app.run("select.rect", json!({"x": 0, "y": 0, "width": 1, "height": 1})).unwrap();
+        ensure_texture(&mut app, &ctx, 0, None).unwrap();
+        uploads(&ctx);
+        app.run("edit.fill", json!({"color": "#ff0000"})).unwrap();
+        assert_eq!(ensure_texture(&mut app, &ctx, 0, None).unwrap().0, tex);
+        assert_eq!(uploads(&ctx), vec![(true, crisp)], "a partial update keeps the crisp sampling");
+    }
+
+    #[test]
+    fn cpu_canvas_of_a_reduced_document_stays_bilinear() {
+        // Over MAX_TEXTURE the texture holds one texel per `factor` pixels: a texel is not a
+        // document pixel, so showing it as a square would draw blocks that aren't in the image.
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": MAX_TEXTURE + 1, "height": 2})).unwrap();
+        let ctx = egui::Context::default();
+        let (tex, scale) = ensure_texture(&mut app, &ctx, 0, None).unwrap();
+        assert!(scale < 1.0);
+        let mut delta = ctx.tex_manager().write().take_delta();
+        let uploads: Vec<_> = delta.set.get(&tex).into_iter().flatten().map(|d| d.options).collect();
+        delta.clear();
+        assert_eq!(uploads, vec![TextureOptions::LINEAR]);
+    }
+
     #[test]
     fn gpu_display_luts_are_per_display() {
         let Ok(rs) = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) else {
@@ -5463,6 +6115,45 @@ mod tests {
         assert_eq!(texture_key(canvas_display(&app, &doc, Some(1)).0.as_deref()), texture_key(canvas_display(&app, &doc, Some(4)).0.as_deref()));
     }
 
+    /// The navigator's update after an edit (its image with the edit's damage, grown by the
+    /// effect reach, rendered over it) equals a new thumbnail of the edited document.
+    #[test]
+    fn navigator_damage_updates_match_a_full_thumbnail() {
+        use photocraft_compose::{render_reduced_damage, thumbnail_buffer, thumbnail_size};
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": 1500, "height": 900, "background": "white"})).unwrap();
+        app.run("layer.new.layer", json!({})).unwrap();
+        app.run("select.rect", json!({"x": 200, "y": 150, "width": 300, "height": 200})).unwrap();
+        app.run("edit.fill", json!({"color": "#3070a0"})).unwrap();
+        app.run("select.deselect", json!({})).unwrap();
+        app.run("layer.layerStyle.dropShadow", json!({"distance": 30, "size": 20})).unwrap();
+        let steps = [
+            ("layer.translate", json!({"dx": 37, "dy": -11})),
+            ("layer.setProps", json!({"opacity": 0.4})),
+            ("paint.stroke", json!({"points": [[700, 500], [900, 520]], "size": 25})),
+            ("layer.setProps", json!({"blend": "Multiply"})),
+            ("layer.new.layer", json!({})),
+        ];
+        for (id, p) in steps {
+            let before = app.session.active().unwrap().doc.clone();
+            app.run(id, p).unwrap();
+            let st = app.session.active().unwrap();
+            let d = st.last_damage.unwrap_or_else(|| panic!("{id}: a bounded damage"));
+            let (w, h) = thumbnail_size(&st.doc, NAVIGATOR_SIDE);
+            let mut shown = thumbnail_buffer(&before, NAVIGATOR_SIDE);
+            assert_eq!((shown.rect.width(), shown.rect.height()), (w, h));
+            if !d.is_empty() {
+                let patch = render_reduced_damage(&st.doc, w, h, d.inflate(effect_reach(&st.doc.layers)));
+                let r = patch.rect;
+                for y in 0..r.height() as usize {
+                    let at = (r.y0 as usize + y) * w as usize + r.x0 as usize;
+                    shown.px[at..at + r.width() as usize].copy_from_slice(&patch.px[y * r.width() as usize..][..r.width() as usize]);
+                }
+            }
+            assert!(shown.px == thumbnail_buffer(&st.doc, NAVIGATOR_SIDE).px, "{id}: the updated navigator differs from a new thumbnail");
+        }
+    }
+
     #[test]
     fn tab_context_uses_clicked_document_and_existing_close_commands() {
         let items = tab_context_items(2, 3, true);
@@ -5688,6 +6379,49 @@ mod tests {
         }
     }
 
+    /// Dragging a tab off the strip floats its document in its own OS window instead of
+    /// reordering (#3733), in both strips; a short wobble below the strip still reorders.
+    #[test]
+    fn dragging_a_tab_off_the_strip_floats_it_in_a_window() {
+        use egui_kittest::kittest::Queryable;
+        let strip = Rect::from_min_size(egui::pos2(0.0, 0.0), egui::vec2(700.0, 26.0));
+        assert!(!torn_off(strip, egui::pos2(50.0, 13.0)));
+        assert!(!torn_off(strip, egui::pos2(50.0, 26.0 + TEAR_OFF - 1.0)), "a wobble below the strip still reorders");
+        assert!(torn_off(strip, egui::pos2(50.0, 26.0 + TEAR_OFF + 1.0)));
+        assert!(torn_off(strip, egui::pos2(50.0, -TEAR_OFF - 1.0)), "dragged up, off the window's top");
+        for kind in [crate::theme::ThemeKind::Studio, crate::theme::ThemeKind::Pro] {
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            for name in ["a", "b", "c"] {
+                app.run("file.new", json!({"width": 8, "height": 8, "name": name})).unwrap();
+            }
+            app.sync_views();
+            let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(700.0, 300.0)).build_ui_state(
+                |ui, (app, ready): &mut (PhotocraftApp, bool)| {
+                    if *ready {
+                        tabs(app, ui);
+                    }
+                },
+                (app, false),
+            );
+            PhotocraftApp::setup_context(&h.ctx, kind);
+            h.state_mut().1 = true;
+            h.run_steps(2);
+            let b = h.get_by_label_contains("b").rect();
+            let target = egui::pos2(b.center().x, b.bottom() + 150.0);
+            h.drag_at(b.center());
+            h.run_steps(1);
+            h.hover_at(target);
+            h.run_steps(1);
+            h.drop_at(target);
+            h.run_steps(2);
+            let app = &h.state().0;
+            let names: Vec<&str> = app.session.documents().iter().map(|d| d.doc.name.as_str()).collect();
+            assert_eq!(names, ["a", "b", "c"], "{kind:?}: tearing off doesn't reorder");
+            assert_eq!(app.ui.windows.iter().map(|w| w.document).collect::<Vec<_>>(), [1], "{kind:?}: b floats in its own window");
+            assert_eq!(app.session.active_index(), Some(1), "{kind:?}: the floated document is active");
+        }
+    }
+
     #[test]
     fn clone_overlay_is_circular_and_respects_visibility() {
         let ctx = egui::Context::default();
@@ -5718,6 +6452,16 @@ mod tests {
         assert!(mesh.vertices.iter().all(|v| v.pos.distance(center) <= 10.01));
         assert_eq!(app.session.active().unwrap().revision, revision);
         assert!(app.session.presets.clone.active().anchor.is_none());
+        let ordinary_key = app.clone_preview.as_ref().unwrap().key.clone();
+        app.ui.view.pattern_preview = true;
+        let mut periodic_output = ctx.run_ui(Default::default(), |ui| {
+            let painter = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Foreground, egui::Id::new("clone-test")));
+            draw_clone_preview(&mut app, &painter, &xf, [32.0, 32.0], None);
+        });
+        assert_ne!(app.clone_preview.as_ref().unwrap().key, ordinary_key, "toggling Pattern Preview invalidates source pixels");
+        assert!(!periodic_output.textures_delta.set.is_empty(), "the overlay texture is refreshed without a document edit");
+        periodic_output.textures_delta.clear();
+        assert_eq!(app.session.active().unwrap().revision, revision);
         app.session.presets.clone.overlay.show = false;
         let mut output = ctx.run_ui(Default::default(), |ui| {
             let ctx = ui.ctx();
@@ -5760,6 +6504,39 @@ mod tests {
         assert_eq!(centre("lighten"), Color32::WHITE);
     }
 
+    /// A shaped tip clips the Clone Source overlay to its outline, not to the brush circle.
+    #[test]
+    fn clone_overlay_is_clipped_to_a_shaped_tip() {
+        let ctx = egui::Context::default();
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": 64, "height": 64})).unwrap();
+        app.run("cloneSource.set", json!({"source": [16,16]})).unwrap();
+        app.ui.tool = Tool::CloneStamp;
+        app.session.tools.brush.size = 20.0;
+        app.session.tools.brush.roundness = 0.25;
+        let xf =
+            ViewXform { rect: Rect::from_min_size(Pos2::ZERO, vec2(100.0, 100.0)), zoom: 1.0, center: [32.0, 32.0], flip: false, rotation: 0.0, aspect: 1.0 };
+        let mut output = ctx.run_ui(Default::default(), |ui| {
+            let painter = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Foreground, egui::Id::new("clone-test")));
+            draw_clone_preview(&mut app, &painter, &xf, [32.0, 32.0], None);
+        });
+        let image = output
+            .textures_delta
+            .set
+            .values()
+            .flatten()
+            .find_map(|d| match &d.image {
+                egui::ImageData::Color(c) if c.size == [20, 20] => Some(c.clone()),
+                _ => None,
+            })
+            .expect("the overlay uploads a texture");
+        output.textures_delta.clear();
+        let alpha = |x: usize, y: usize| image.pixels[y * image.width() + x].a();
+        assert_eq!(alpha(10, 10), 255, "the tip's centre shows the source");
+        assert_eq!(alpha(10, 2), 0, "inside the circle but outside the flat tip: clipped");
+        assert_eq!(alpha(1, 10), 255, "the tip's long axis stays");
+    }
+
     #[test]
     fn wayland_start_screen_hint_does_not_claim_file_drop_works() {
         let x11 = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
@@ -5864,20 +6641,23 @@ mod tests {
 
     #[test]
     fn clone_stamp_centre_appears_only_with_option() {
-        assert!(!brush_tip_centre(Tool::CloneStamp, false, false, 20.0));
-        assert!(brush_tip_centre(Tool::CloneStamp, true, false, 20.0));
-        assert!(brush_tip_centre(Tool::Healing, true, false, 20.0));
-        assert!(!brush_tip_centre(Tool::Healing, false, false, 20.0));
-        assert!(brush_tip_centre(Tool::CloneStamp, false, true, 20.0));
-        assert!(brush_tip_centre(Tool::PatternStamp, false, false, 20.0));
-        assert!(
-            brush_tip_centre(Tool::PatternStamp, true, false, 20.0),
-            "Pattern Stamp keeps the brush centre; Option does not switch it to a clone-source mark"
-        );
-        assert!(!brush_tip_centre(Tool::PatternStamp, false, false, 2.0));
-        assert!(brush_tip_centre(Tool::Brush, false, false, 20.0));
-        assert!(!brush_tip_centre(Tool::QuickSelection, false, false, 20.0));
-        assert!(brush_tip_centre(Tool::BackgroundEraser, false, false, 2.0));
+        assert!(!brush_tip_centre(Tool::CloneStamp, false, false));
+        assert!(brush_tip_centre(Tool::CloneStamp, true, false));
+        assert!(brush_tip_centre(Tool::Healing, true, false));
+        assert!(!brush_tip_centre(Tool::Healing, false, false));
+        assert!(brush_tip_centre(Tool::CloneStamp, false, true));
+        assert!(!brush_tip_centre(Tool::PatternStamp, true, false), "Pattern Stamp keeps the brush cursor; Option does not switch it to a clone-source mark");
+        assert!(!brush_tip_centre(Tool::QuickSelection, false, true));
+        assert!(brush_tip_centre(Tool::BackgroundEraser, false, false));
+    }
+
+    #[test]
+    fn brush_tip_centre_follows_the_crosshair_preference_at_any_size() {
+        // A large tip used to show the centre mark whatever Show Crosshair in Brush Tip said.
+        for tool in [Tool::Brush, Tool::Eraser, Tool::PatternStamp, Tool::Dodge] {
+            assert!(!brush_tip_centre(tool, false, false), "{tool:?}: off");
+            assert!(brush_tip_centre(tool, false, true), "{tool:?}: on");
+        }
     }
 
     #[test]
@@ -5935,6 +6715,41 @@ mod tests {
         assert!(app.session.tools.foreground[1] > 0.99 && app.session.tools.foreground[0] < 0.01);
     }
 
+    /// #4298: an adjustment layer has no pixels, so after its icon thumbnail is clicked (the
+    /// Layers panel no longer targets the mask) Fill, the fill keys and the Paint Bucket still
+    /// edit its mask, as in Photoshop, instead of failing with "not a pixel layer".
+    #[test]
+    fn fills_on_an_adjustment_layer_edit_its_mask_when_the_icon_is_targeted() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": 40, "height": 20, "background": "white"})).unwrap();
+        app.run("layer.newAdjustmentLayer.curves", json!({})).unwrap();
+        // Click the Curves icon thumbnail: the panel targets the layer, not its mask.
+        app.ui.mask_target = false;
+        app.sync_mask_targets();
+        assert!(!app.ui.mask_target, "the panel's target is the icon");
+        let mask_at = |app: &PhotocraftApp| {
+            let st = app.session.active().unwrap();
+            st.doc.layer(st.active_layer.unwrap()).unwrap().mask.as_ref().unwrap().surface.sample_channel(10, 10, 0)
+        };
+        assert_eq!(paint_target(&app), json!("mask"));
+        assert!(crate::menus::is_enabled(&app, "edit.fill"), "Edit > Fill (⇧F5) is enabled");
+        assert!(crate::menus::is_enabled(&app, "edit.fillForeground"));
+        app.ui.tool = Tool::PaintBucket;
+        app.run("tools.setColors", json!({"foreground": [0.0, 0.0, 0.0, 1.0], "background": [1.0, 1.0, 1.0, 1.0]})).unwrap();
+        tool_event(&mut app, ToolEvent::Down { x: 10.0, y: 10.0, pressure: 1.0 }, egui::Modifiers::NONE);
+        tool_event(&mut app, ToolEvent::Up { x: 10.0, y: 10.0 }, egui::Modifiers::NONE);
+        assert_eq!(mask_at(&app), 0.0, "the Paint Bucket filled the mask black");
+        app.run("edit.fill", json!({"contents": "white"})).unwrap();
+        assert_eq!(mask_at(&app), 1.0, "Edit > Fill filled the mask white");
+        assert!(!app.ui.mask_target, "filling doesn't move the panel's target");
+        // A pixel layer with an untargeted mask still paints its pixels.
+        app.run("layer.new.layer", json!({})).unwrap();
+        app.run("layer.layerMask.revealAll", json!({})).unwrap();
+        app.ui.mask_target = false;
+        assert_eq!(paint_target(&app), json!("pixels"));
+        assert!(!app.layer_mask_targeted());
+    }
+
     #[test]
     fn alt_with_a_painting_tool_samples_the_foreground_instead_of_painting() {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
@@ -6149,12 +6964,12 @@ mod tests {
         let (shown, key) = display_doc(&mut app, 0);
         assert_ne!(key, 0);
         // A partial value two thirds of the way out: the soft tip, not a hard flat stand-in.
-        assert!(alpha(&shown, 40, 30) > 0.5 && (0.01..0.5).contains(&alpha(&shown, 40, 36)), "soft stroke while drawing");
+        assert!(alpha(&shown, 40, 30) > 0.5 && (0.01..0.95).contains(&alpha(&shown, 40, 36)), "soft stroke while drawing");
         assert_eq!(alpha(&app.session.documents()[0].doc, 40, 30), 0.0, "not committed yet");
         // The canvas redraws only what the stroke touched.
         let dk = canvas_display(&app, &app.session.documents()[0].doc, None).1;
         let d = damage_since(&app, 0, (rev, dk), (rev, key), dk, None).unwrap();
-        assert!(d.contains(40, 30) && !d.contains(40, 2) && d.width() < 120, "{d:?}");
+        assert!(d.contains(40, 30) && !d.contains(40, 2) && d.height() < 60, "{d:?}");
         tool_event(&mut app, ToolEvent::Up { x: 100.0, y: 30.0 }, m);
         let doc = app.session.documents()[0].doc.clone();
         assert!(app.live_stroke.is_none() && display_doc(&mut app, 0).1 == 0);
@@ -6615,7 +7430,9 @@ mod tests {
             }
         }
         assert!(soft > 50, "a soft brush shows a soft edge");
-        assert_eq!(trail.coverage(50, 30 + 10), 0, "half pressure halves the 30 px tip");
+        // Half pressure halves the 30 px tip: nothing past its (soft) reach.
+        let reach = photocraft_paint::tip_reach(7.5, app.session.tools.brush.hardness).ceil() as usize + 2;
+        assert_eq!(trail.coverage(50, 30 + reach), 0, "half pressure halves the 30 px tip");
     }
 
     #[test]
@@ -6640,6 +7457,46 @@ mod tests {
         assert!(app.style_preview.is_none());
     }
 
+    /// Layer Style opened while Free Transform is open applies the box first, as Photoshop does,
+    /// so the dialog previews on the transformed layer (#4821): a dropped file (placed in the box,
+    /// untouched) and a box opened by hand and moved.
+    #[test]
+    fn layer_style_opened_during_free_transform_applies_the_box_and_previews() {
+        for placed in [true, false] {
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+            app.run("file.new", json!({"width": 64, "height": 64})).unwrap();
+            app.run("layer.new.layer", json!({})).unwrap();
+            app.run("select.rect", json!({"x": 8, "y": 8, "width": 16, "height": 16})).unwrap();
+            app.run("edit.fill", json!({"color": "#0000ff"})).unwrap();
+            app.run("select.deselect", json!({})).unwrap();
+            app.sync_views();
+            let ctx = egui::Context::default();
+            let dx = if placed {
+                crate::transform_tool::begin_placed(&mut app, &ctx).unwrap();
+                0
+            } else {
+                crate::transform_tool::begin(&mut app, &ctx).unwrap();
+                app.ui.transform.as_mut().unwrap().quad = [[28.0, 8.0], [44.0, 8.0], [44.0, 24.0], [28.0, 24.0]];
+                20
+            };
+            crate::layer_style::open(&mut app, Some("dropShadow")).unwrap();
+            assert!(app.ui.transform.is_none() && app.transform_preview.is_none(), "placed {placed}: the box is applied");
+            let (shown, _) = display_doc(&mut app, 0);
+            let rect = photocraft_geom::Rect::new(0, 0, 64, 64);
+            let with = photocraft_compose::render(&shown, rect);
+            let without = photocraft_compose::render(&app.session.documents()[0].doc, rect);
+            assert!(
+                with.get(16 + dx, 16)[0] < 0.1 && with.get(16 + dx, 16)[2] > 0.9,
+                "placed {placed}: the blue block where the box left it, not the white under it"
+            );
+            // The shadow darkens the white around the block, which the document doesn't have yet.
+            let block = |x: i32, y: i32| (8 + dx..24 + dx).contains(&x) && (8..24).contains(&y);
+            let shadow =
+                (0..64).flat_map(|y| (0..64).map(move |x| (x, y))).filter(|&(x, y)| !block(x, y) && without.get(x, y)[0] - with.get(x, y)[0] > 0.05).count();
+            assert!(shadow > 20, "placed {placed}: the Drop Shadow is previewed ({shadow} px)");
+        }
+    }
+
     #[test]
     fn fill_view_covers_the_canvas_and_centres_the_document() {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
@@ -6658,13 +7515,22 @@ mod tests {
         fill_view(&mut view, &doc, vec2(600.0, 600.0), 2.0, 1.0);
         assert_eq!(view.zoom, 6.0);
 
-        // Fit never magnifies past the 1 point-per-pixel cap; on a scaled display the cap is 2.
+        // Fit never magnifies past 100% = one image pixel per physical pixel, at any display
+        // scale (it used to cap at one per *point*, so a 150% display opened images at 150%).
+        for ppp in [1.0f32, 1.5, 2.0] {
+            let mut view = View { fit_pending: true, ..View::default() };
+            fit_view(&mut view, &doc, vec2(600.0, 600.0), ppp, 1.0);
+            assert_eq!(view.zoom, 1.0, "ppp {ppp}: a small image opens at 100%");
+        }
+        // A large image still shrinks to fit: 1000×500 into 440 points is 0.44 pt/px, so 0.66
+        // physical at ppp 1.5.
+        let big = {
+            app.run("file.new", json!({"width": 1000, "height": 500})).unwrap();
+            app.session.active().unwrap().doc.clone()
+        };
         let mut view = View { fit_pending: true, ..View::default() };
-        fit_view(&mut view, &doc, vec2(600.0, 600.0), 1.0, 1.0);
-        assert_eq!(view.zoom, 1.0);
-        let mut view = View { fit_pending: true, ..View::default() };
-        fit_view(&mut view, &doc, vec2(600.0, 600.0), 2.0, 1.0);
-        assert_eq!(view.zoom, 2.0);
+        fit_view(&mut view, &big, vec2(480.0, 480.0), 1.5, 1.0);
+        assert!((view.zoom - 0.66).abs() < 1e-5, "{}", view.zoom);
     }
 
     #[test]
@@ -6687,6 +7553,23 @@ mod tests {
         }
     }
 
+    #[test]
+    fn wheel_anchor_is_the_pointer_over_the_image_and_the_nearest_image_point_off_it() {
+        let rect = Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0));
+        for (rotation, flip) in [(0.0, false), (30.0, false), (90.0, true)] {
+            let xf = ViewXform { rect, zoom: 0.5, center: [400.0, 300.0], flip, rotation, aspect: 1.0 };
+            let inside = xf.to_screen(100.0, 200.0);
+            assert_eq!(wheel_anchor(&xf, inside, [800, 600]), inside);
+            for (p, want) in [((-300.0, -200.0), [0.0, 0.0]), ((1200.0, 300.0), [800.0, 300.0]), ((400.0, 900.0), [400.0, 600.0])] {
+                let a = xf.to_doc(wheel_anchor(&xf, xf.to_screen(p.0, p.1), [800, 600]));
+                assert!((a[0] - want[0]).abs() < 0.01 && (a[1] - want[1]).abs() < 0.01, "rot {rotation}: {p:?} -> {a:?}");
+            }
+        }
+        let p = pos2(5.0, 5.0);
+        let xf = ViewXform { rect, zoom: 1.0, center: [400.0, 300.0], flip: false, rotation: 0.0, aspect: 1.0 };
+        assert_eq!(wheel_anchor(&xf, p, [0, 0]), p, "no document: the pointer");
+    }
+
     #[test]
     fn zoom_about_centres_the_clicked_point_with_the_preference() {
         let rect = Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0));
@@ -6834,14 +7717,23 @@ mod transform_controls_tests {
             (r.center_bottom(), egui::CursorIcon::ResizeVertical),
             (r.right_center(), egui::CursorIcon::ResizeHorizontal),
             (r.left_center(), egui::CursorIcon::ResizeHorizontal),
-            // Between handles: the rotation band (a point above the top-centre handle is that handle).
-            (pos2(r.left() + r.width() * 0.25, r.top() - 12.0), egui::CursorIcon::Alias),
+            // Between handles: the rotation band (a point above the top-centre handle is that handle),
+            // where the curved rotate arrow replaces the pointer (#4658).
+            (pos2(r.left() + r.width() * 0.25, r.top() - 12.0), egui::CursorIcon::None),
         ] {
             assert_eq!(transform_controls_cursor(r, p), Some(expected), "hover at {p:?}");
             assert!(transform_controls_hit(r, p), "same region must start a transform");
         }
         assert_eq!(transform_controls_cursor(r, r.center()), None, "interior stays Move");
         assert_eq!(transform_controls_cursor(r, pos2(r.center().x, r.top() - 30.0)), None);
+        // The rotate arrow bends round the nearest corner, pointing into the box; handles and the
+        // interior have none.
+        let into = |p: Pos2| transform_controls_turn(r, p).map(|v| (v.x.signum(), v.y.signum()));
+        assert_eq!(into(pos2(r.left() + r.width() * 0.25, r.top() - 12.0)), Some((1.0, 1.0)), "top left");
+        assert_eq!(into(pos2(r.right() + 12.0, r.bottom() - r.height() * 0.25)), Some((-1.0, -1.0)), "bottom right");
+        assert_eq!(into(pos2(r.left() - 12.0, r.bottom() + 12.0)), Some((1.0, -1.0)), "beyond the bottom-left corner");
+        assert_eq!(into(r.left_top()), None);
+        assert_eq!(into(r.center()), None);
 
         // Changing the active shape changes the hover bounds without requiring a drag first.
         app.session.execute("shape.create", json!({"kind": "rect", "rect": [120, 100, 40, 50], "fill": "#00ff00"})).unwrap();
@@ -6869,6 +7761,200 @@ mod rotation_preview_isolation_tests {
     use super::*;
     use serde_json::json;
 
+    #[test]
+    fn channel_overlay_shows_filter_preview_and_restores_on_cancel() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.background_jobs = false;
+        app.run("file.new", json!({"width":16,"height":16})).unwrap();
+        app.run("channel.new", json!({"name":"Alpha","fill":"black"})).unwrap();
+        app.session
+            .edit("Fixture", |doc, _| {
+                for y in 0..16 {
+                    for x in 0..8 {
+                        doc.channels[0].surface.write_pixel(x, y, &[1.0]);
+                    }
+                }
+                Ok(())
+            })
+            .unwrap();
+        let before = app.session.active().unwrap().doc.clone();
+        let ctx = egui::Context::default();
+        let texture = crate::channel_view::ensure(&mut app, &ctx, 0).unwrap();
+        ctx.tex_manager().write().take_delta().clear();
+        let dialog = crate::filter_dialog::open(&mut app, "filter.blur.gaussianBlur").unwrap();
+        app.ui.dialogs.last_mut().unwrap().fields.insert("radius".into(), json!(2.0));
+        ensure_filter_preview(&mut app, 0, &ctx).unwrap();
+        crate::channel_view::ensure(&mut app, &ctx, 0);
+        let mut delta = ctx.tex_manager().write().take_delta();
+        let egui::ImageData::Color(image) = &delta.set.get(&texture).expect("filter preview must update channel overlay")[0].image;
+        let st = app.session.active().unwrap();
+        let original = crate::channel_view::render(&before, &st.channel_view, before.bounds(), 1, false, st.active_layer).unwrap();
+        assert_ne!(image.pixels, original, "a nontrivial filter must be visible before OK");
+        delta.clear();
+        assert!(std::sync::Arc::ptr_eq(&before, &app.session.active().unwrap().doc));
+        app.ui.dialogs.last_mut().unwrap().fields.insert("__preview".into(), json!(false));
+        crate::channel_view::ensure(&mut app, &ctx, 0);
+        let mut delta = ctx.tex_manager().write().take_delta();
+        let egui::ImageData::Color(image) = &delta.set.get(&texture).expect("Preview off restores channel")[0].image;
+        assert_eq!(image.pixels, original);
+        delta.clear();
+        app.ui.dialogs.last_mut().unwrap().fields.insert("__preview".into(), json!(true));
+        crate::channel_view::ensure(&mut app, &ctx, 0);
+        ctx.tex_manager().write().take_delta().clear();
+        crate::dialogs::cancel(&mut app, dialog).unwrap();
+        crate::channel_view::ensure(&mut app, &ctx, 0);
+        let mut delta = ctx.tex_manager().write().take_delta();
+        let egui::ImageData::Color(image) = &delta.set.get(&texture).expect("Cancel restores channel")[0].image;
+        assert_eq!(image.pixels, original);
+        delta.clear();
+        assert!(std::sync::Arc::ptr_eq(&before, &app.session.active().unwrap().doc));
+    }
+
+    fn assert_filter_preview_target(target: photocraft_engine::channel_cmds::ChannelTarget) {
+        for depth in [8, 16, 32] {
+            let mut session = photocraft_engine::Session::new();
+            session.execute("file.new", json!({"width":16,"height":16,"depth":depth})).unwrap();
+            session.execute("channel.new", json!({"name":"Alpha","fill":"black"})).unwrap();
+            session
+                .edit("Fixture", |doc, active| {
+                    let layer = doc.layer_mut(active.unwrap()).unwrap();
+                    layer.mask = Some(photocraft_doc::LayerMask::hide_all());
+                    for y in 0..16 {
+                        for x in 0..8 {
+                            layer.surface_mut().unwrap().write_pixel(x, y, &[0.0, 0.25, 0.5, 1.0]);
+                            layer.mask.as_mut().unwrap().surface.write_pixel(x, y, &[1.0]);
+                        }
+                    }
+                    for y in 0..16 {
+                        for x in 0..8 {
+                            doc.channels[0].surface.write_pixel(x, y, &[1.0]);
+                        }
+                    }
+                    Ok(())
+                })
+                .unwrap();
+            session.active_mut().unwrap().channel_view.target = target;
+            let mut app = PhotocraftApp::new(session, crate::Services::default());
+            app.background_jobs = false;
+            let dialog = crate::filter_dialog::open(&mut app, "filter.blur.gaussianBlur").unwrap();
+            app.ui.dialogs.last_mut().unwrap().fields.insert("radius".into(), json!(2.0));
+            ensure_filter_preview(&mut app, 0, &egui::Context::default()).unwrap();
+            let preview = app.filter_preview.as_ref().unwrap().result.as_ref().unwrap().clone();
+            crate::dialogs::confirm(&mut app, dialog).unwrap();
+            let final_doc = &app.session.active().unwrap().doc;
+            let bounds = final_doc.bounds();
+            assert_eq!(
+                preview.layers[0].surface().unwrap().read_region(bounds),
+                final_doc.layers[0].surface().unwrap().read_region(bounds),
+                "RGB: {depth} {target:?}"
+            );
+            assert_eq!(preview.channels[0].surface.read_region(bounds), final_doc.channels[0].surface.read_region(bounds), "alpha: {depth} {target:?}");
+            assert_eq!(
+                preview.layers[0].mask.as_ref().unwrap().surface.read_region(bounds),
+                final_doc.layers[0].mask.as_ref().unwrap().surface.read_region(bounds),
+                "mask: {depth} {target:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn filter_preview_matches_applied_alpha_target() {
+        assert_filter_preview_target(photocraft_engine::channel_cmds::ChannelTarget::Alpha(0));
+    }
+
+    #[test]
+    fn filter_preview_matches_applied_color_target() {
+        assert_filter_preview_target(photocraft_engine::channel_cmds::ChannelTarget::Color(0));
+    }
+
+    #[test]
+    fn filter_preview_matches_applied_layer_mask_target() {
+        assert_filter_preview_target(photocraft_engine::channel_cmds::ChannelTarget::LayerMask);
+    }
+
+    #[test]
+    fn filter_preview_refreshes_when_channel_target_changes() {
+        use photocraft_engine::channel_cmds::ChannelTarget;
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.background_jobs = false;
+        app.run("file.new", json!({"width":16,"height":16})).unwrap();
+        for name in ["First", "Second"] {
+            app.run("channel.new", json!({"name":name,"fill":"black"})).unwrap();
+        }
+        app.session
+            .edit("Fixture", |doc, _| {
+                for y in 0..16 {
+                    for x in 0..8 {
+                        doc.channels[1].surface.write_pixel(x, y, &[1.0]);
+                    }
+                }
+                Ok(())
+            })
+            .unwrap();
+        app.session.active_mut().unwrap().channel_view.target = ChannelTarget::Alpha(0);
+        let revision = app.session.active().unwrap().revision;
+        let dialog = crate::filter_dialog::open(&mut app, "filter.blur.gaussianBlur").unwrap();
+        app.ui.dialogs.last_mut().unwrap().fields.insert("radius".into(), json!(2.0));
+        let ctx = egui::Context::default();
+        let (first, first_key) = filter_channel_preview(&mut app, 0, &ctx).unwrap();
+        app.session.active_mut().unwrap().channel_view.target = ChannelTarget::Alpha(1);
+        let (second, second_key) = filter_channel_preview(&mut app, 0, &ctx).unwrap();
+        assert_eq!(app.session.active().unwrap().revision, revision);
+        assert_ne!(first_key, second_key);
+        assert_ne!(first.channels[1].surface.read_region(first.bounds()), second.channels[1].surface.read_region(second.bounds()));
+        let (unchanged, unchanged_key) = filter_channel_preview(&mut app, 0, &ctx).unwrap();
+        assert!(std::sync::Arc::ptr_eq(&second, &unchanged));
+        assert_eq!(second_key, unchanged_key);
+        crate::dialogs::confirm(&mut app, dialog).unwrap();
+        let applied = &app.session.active().unwrap().doc;
+        assert_eq!(second.channels[1].surface.read_region(second.bounds()), applied.channels[1].surface.read_region(applied.bounds()));
+    }
+
+    #[test]
+    fn filter_preview_overlay_matches_quick_mask_and_mixed_color_views() {
+        for quick_mask in [false, true] {
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            app.background_jobs = false;
+            app.run("file.new", json!({"width":16,"height":16})).unwrap();
+            app.session
+                .edit("Fixture", |doc, active| {
+                    if quick_mask {
+                        doc.quick_mask =
+                            Some(photocraft_doc::AlphaChannel::new("Quick Mask", photocraft_raster::Surface::new(photocraft_color::PixelFormat::GRAY8)));
+                    }
+                    for y in 0..16 {
+                        for x in 0..8 {
+                            if let Some(mask) = &mut doc.quick_mask {
+                                mask.surface.write_pixel(x, y, &[1.0]);
+                            } else {
+                                doc.layer_mut(active.unwrap()).unwrap().surface_mut().unwrap().write_pixel(x, y, &[0.0, 0.25, 0.5, 1.0]);
+                            }
+                        }
+                    }
+                    Ok(())
+                })
+                .unwrap();
+            if !quick_mask {
+                let view = &mut app.session.active_mut().unwrap().channel_view;
+                view.target = photocraft_engine::channel_cmds::ChannelTarget::Color(0);
+                view.set_color_visible(2, false);
+            }
+            let ctx = egui::Context::default();
+            let texture = crate::channel_view::ensure(&mut app, &ctx, 0).unwrap();
+            ctx.tex_manager().write().take_delta().clear();
+            let dialog = crate::filter_dialog::open(&mut app, "filter.blur.gaussianBlur").unwrap();
+            app.ui.dialogs.last_mut().unwrap().fields.insert("radius".into(), json!(2.0));
+            crate::channel_view::ensure(&mut app, &ctx, 0).unwrap();
+            let mut delta = ctx.tex_manager().write().take_delta();
+            let egui::ImageData::Color(image) = &delta.set.get(&texture).expect("preview must refresh overlay")[0].image;
+            crate::dialogs::confirm(&mut app, dialog).unwrap();
+            let st = app.session.active().unwrap();
+            let expected = crate::channel_view::render(&st.doc, &st.channel_view, st.doc.bounds(), 1, false, st.active_layer).unwrap();
+            assert_eq!(image.pixels, expected, "quick_mask={quick_mask}");
+            delta.clear();
+        }
+    }
+
     /// A CPU-only app must be able to generate the actual rotation preview without a
     /// GPU adapter; checking the result also verifies Preview off and document integrity.
     #[test]
@@ -6909,3 +7995,7 @@ mod rotation_preview_isolation_tests {
         assert!(ensure_filter_preview(&mut app, 0, &egui::Context::default()).is_none(), "an inactive tab must never inherit the command preview");
     }
 }
+
+#[cfg(test)]
+#[path = "canvas_display_memo_tests.rs"]
+mod display_memo_tests;
diff --git a/crates/ui-egui/src/canvas_autoscroll.rs b/crates/ui-egui/src/canvas_autoscroll.rs
new file mode 100644
index 0000000000..2fafbdb105
--- /dev/null
+++ b/crates/ui-egui/src/canvas_autoscroll.rs
@@ -0,0 +1,223 @@
+//! Auto-scroll while a tool drag runs past the canvas edge (#4183). As in Photoshop, dragging a
+//! marquee, lasso, brush stroke or crop off the visible part of a zoomed image scrolls the view
+//! toward the pointer, so a selection can be larger than what is on screen. The view stops at the
+//! scroll limits (it never auto-scrolls an image that already fits into empty pasteboard).
+
+use crate::canvas::ViewXform;
+use crate::state::View;
+use egui::{Pos2, Rect, Vec2, vec2};
+
+/// Slowest and fastest auto-scroll, in egui points per second.
+const MIN_SPEED: f32 = 120.0;
+const MAX_SPEED: f32 = 2400.0;
+/// Extra speed per point the pointer is past the edge.
+const GAIN: f32 = 12.0;
+/// A long frame moves at most this many seconds' worth, so a stall doesn't jump the view.
+const MAX_DT: f32 = 0.05;
+
+/// How far, in screen points, to scroll this frame for a drag whose pointer is at `pointer` over a
+/// canvas of `rect`. Zero while the pointer is inside the canvas. Each axis points toward the
+/// pointer and speeds up the further past the edge it is.
+pub fn edge_step(pointer: Pos2, rect: Rect, dt: f32) -> Vec2 {
+    if !pointer.x.is_finite() || !pointer.y.is_finite() || !dt.is_finite() || dt <= 0.0 || rect.width() <= 0.0 || rect.height() <= 0.0 {
+        return Vec2::ZERO;
+    }
+    let past = |p: f32, lo: f32, hi: f32| {
+        if p < lo {
+            p - lo
+        } else if p > hi {
+            p - hi
+        } else {
+            0.0
+        }
+    };
+    let dt = dt.min(MAX_DT);
+    let axis = |d: f32| if d == 0.0 { 0.0 } else { d.signum() * (MIN_SPEED + GAIN * d.abs()).min(MAX_SPEED) * dt };
+    vec2(axis(past(pointer.x, rect.left(), rect.right())), axis(past(pointer.y, rect.top(), rect.bottom())))
+}
+
+/// Move the camera by `step` in screen points, never past the image's on-screen bounds in the
+/// direction of travel. A view the user already panned past a limit (Overscroll on) is not pulled
+/// back: it just doesn't scroll further out. True when the view moved.
+pub fn scroll(view: &mut View, step: Vec2, xf: ViewXform) -> bool {
+    if !step.is_finite() || step == Vec2::ZERO || !xf.zoom.is_finite() || xf.zoom <= 0.0 {
+        return false;
+    }
+    let image = xf.image_bounds(view.doc_size);
+    if !image.is_finite() || !xf.rect.is_finite() {
+        return false;
+    }
+    // Compare screen axes before unrotating: a document axis that fits before rotation may
+    // be clipped afterwards, and a vertical screen drag must remain vertical at any angle.
+    let axis = |step: f32, lo: f32, hi: f32, v0: f32, v1: f32| {
+        if hi - lo <= v1 - v0 {
+            0.0
+        } else if step > 0.0 {
+            step.min((hi - v1).max(0.0))
+        } else {
+            step.max((lo - v0).min(0.0))
+        }
+    };
+    let step = vec2(
+        axis(step.x, image.left(), image.right(), xf.rect.left(), xf.rect.right()),
+        axis(step.y, image.top(), image.bottom(), xf.rect.top(), xf.rect.bottom()),
+    );
+    let d = xf.unmap_vec(step) / xf.zoom;
+    let moved = d.is_finite() && (d.x.abs() > 1e-3 || d.y.abs() > 1e-3);
+    if moved {
+        view.center[0] += d.x;
+        view.center[1] += d.y;
+    }
+    moved
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use egui::pos2;
+
+    // Existing unrotated cases express their requested movement in document pixels.
+    fn scroll(view: &mut View, doc_step: Vec2, size: Vec2, ppp: f32) -> bool {
+        let xf = ViewXform {
+            rect: Rect::from_min_size(Pos2::ZERO, size),
+            zoom: view.zoom / ppp,
+            center: view.center,
+            flip: false,
+            rotation: view.rotation,
+            aspect: 1.0,
+        };
+        super::scroll(view, doc_step * xf.zoom, xf)
+    }
+
+    fn rect() -> Rect {
+        Rect::from_min_max(pos2(100.0, 50.0), pos2(500.0, 350.0))
+    }
+
+    #[test]
+    fn inside_the_canvas_does_not_scroll() {
+        assert_eq!(edge_step(pos2(300.0, 200.0), rect(), 1.0 / 60.0), Vec2::ZERO);
+        assert_eq!(edge_step(pos2(100.0, 350.0), rect(), 1.0 / 60.0), Vec2::ZERO, "the edge itself is inside");
+    }
+
+    #[test]
+    fn past_an_edge_scrolls_toward_the_pointer() {
+        let dt = 1.0 / 60.0;
+        let right = edge_step(pos2(520.0, 200.0), rect(), dt);
+        assert!(right.x > 0.0 && right.y == 0.0, "{right:?}");
+        let left = edge_step(pos2(80.0, 200.0), rect(), dt);
+        assert!(left.x < 0.0 && left.y == 0.0, "{left:?}");
+        let corner = edge_step(pos2(90.0, 360.0), rect(), dt);
+        assert!(corner.x < 0.0 && corner.y > 0.0, "{corner:?}");
+    }
+
+    #[test]
+    fn further_out_is_faster_up_to_a_cap() {
+        let dt = 1.0 / 60.0;
+        let near = edge_step(pos2(505.0, 200.0), rect(), dt).x;
+        let far = edge_step(pos2(600.0, 200.0), rect(), dt).x;
+        let very_far = edge_step(pos2(50_000.0, 200.0), rect(), dt).x;
+        assert!(near < far, "{near} < {far}");
+        assert!((very_far - MAX_SPEED * dt).abs() < 1e-3, "capped: {very_far}");
+    }
+
+    #[test]
+    fn hostile_input_does_not_scroll() {
+        let dt = 1.0 / 60.0;
+        assert_eq!(edge_step(pos2(f32::NAN, 200.0), rect(), dt), Vec2::ZERO);
+        assert_eq!(edge_step(pos2(f32::INFINITY, 200.0), rect(), dt), Vec2::ZERO);
+        assert_eq!(edge_step(pos2(600.0, 200.0), rect(), f32::NAN), Vec2::ZERO);
+        assert_eq!(edge_step(pos2(600.0, 200.0), rect(), -1.0), Vec2::ZERO);
+        assert_eq!(edge_step(pos2(600.0, 200.0), Rect::NOTHING, dt), Vec2::ZERO);
+        // A multi-second stall moves no more than one capped frame.
+        assert!(edge_step(pos2(600.0, 200.0), rect(), 10.0).x <= MAX_SPEED * MAX_DT + 1e-3);
+    }
+
+    fn view(zoom: f32, center: [f32; 2]) -> View {
+        View { zoom, center, doc_size: [2000, 1000], ..Default::default() }
+    }
+
+    #[test]
+    fn a_zoomed_view_scrolls_and_stops_at_the_limit() {
+        // 2000 × 1000 at 100 % in a 400 × 300 canvas: the centre can range over 200..1800 in x.
+        let size = vec2(400.0, 300.0);
+        let mut v = view(1.0, [1000.0, 500.0]);
+        assert!(scroll(&mut v, vec2(50.0, 0.0), size, 1.0));
+        assert_eq!(v.center, [1050.0, 500.0]);
+        let mut v = view(1.0, [1790.0, 500.0]);
+        assert!(scroll(&mut v, vec2(50.0, 0.0), size, 1.0));
+        assert_eq!(v.center, [1800.0, 500.0], "stops at the right limit");
+        assert!(!scroll(&mut v, vec2(50.0, 0.0), size, 1.0), "and stays there");
+    }
+
+    #[test]
+    fn an_image_that_fits_does_not_scroll() {
+        let mut v = view(0.1, [1000.0, 500.0]);
+        assert!(!scroll(&mut v, vec2(50.0, 50.0), vec2(400.0, 300.0), 1.0));
+        assert_eq!(v.center, [1000.0, 500.0]);
+        // Wider than the view but not taller: only x scrolls.
+        let mut v = view(0.25, [1000.0, 500.0]);
+        assert!(scroll(&mut v, vec2(50.0, 50.0), vec2(400.0, 300.0), 1.0));
+        assert_eq!(v.center, [1050.0, 500.0]);
+    }
+
+    #[test]
+    fn an_overscrolled_view_is_not_pulled_back() {
+        // Already panned past the right limit (Overscroll on): scrolling further right does
+        // nothing, scrolling left moves normally.
+        let size = vec2(400.0, 300.0);
+        let mut v = view(1.0, [1900.0, 500.0]);
+        assert!(!scroll(&mut v, vec2(50.0, 0.0), size, 1.0));
+        assert_eq!(v.center, [1900.0, 500.0]);
+        assert!(scroll(&mut v, vec2(-50.0, 0.0), size, 1.0));
+        assert_eq!(v.center, [1850.0, 500.0]);
+    }
+
+    #[test]
+    fn non_finite_steps_are_ignored() {
+        let mut v = view(1.0, [1000.0, 500.0]);
+        assert!(!scroll(&mut v, vec2(f32::NAN, 0.0), vec2(400.0, 300.0), 1.0));
+        assert_eq!(v.center, [1000.0, 500.0]);
+    }
+
+    #[test]
+    fn quarter_turn_limits_follow_the_displayed_image_with_hidpi_and_pixel_aspect() {
+        for rotation in [-90.0, 90.0] {
+            for flip in [false, true] {
+                let mut v = View { zoom: 2.0, center: [300.0, 600.0], doc_size: [600, 1200], rotation, ..Default::default() };
+                let xf = ViewXform { rect: Rect::from_min_size(Pos2::ZERO, vec2(800.0, 400.0)), zoom: 1.0, center: v.center, flip, rotation, aspect: 2.0 };
+                assert!(super::scroll(&mut v, vec2(0.0, 10_000.0), xf));
+                // At 2:1 pixel aspect the document's 600-pixel width is 1200 screen points
+                // tall after rotation. The 400-point viewport exposes 200 document pixels.
+                let want = if rotation > 0.0 { 500.0 } else { 100.0 };
+                assert!((v.center[0] - want).abs() < 0.01, "{rotation}, flip={flip}: {:?}", v.center);
+                assert!((v.center[1] - 600.0).abs() < 0.01);
+                assert!(!crate::scrollbars::clamp_view_with_aspect(&mut v, xf.rect.size(), 2.0, 2.0), "the next frame preserves the auto-scroll limit");
+                let xf = ViewXform { center: v.center, ..xf };
+                assert!(!super::scroll(&mut v, vec2(0.0, 20.0), xf));
+                v.center = [300.0, 600.0];
+                let xf = ViewXform { center: v.center, ..xf };
+                assert!(super::scroll(&mut v, vec2(10_000.0, 0.0), xf));
+                let want_y = if (rotation > 0.0) == flip { 800.0 } else { 400.0 };
+                assert!((v.center[1] - want_y).abs() < 0.01 && (v.center[0] - 300.0).abs() < 0.01, "mirrored horizontal limit: {:?}", v.center);
+                assert!(!crate::scrollbars::clamp_view_with_aspect(&mut v, xf.rect.size(), 2.0, 2.0));
+            }
+        }
+    }
+
+    #[test]
+    fn oblique_rotation_keeps_a_vertical_scroll_vertical_and_a_fitting_axis_still() {
+        for flip in [false, true] {
+            let mut v = View { zoom: 1.0, center: [300.0, 300.0], doc_size: [600, 600], rotation: 45.0, ..Default::default() };
+            let xf =
+                ViewXform { rect: Rect::from_min_size(Pos2::ZERO, vec2(900.0, 400.0)), zoom: 1.0, center: v.center, flip, rotation: v.rotation, aspect: 1.0 };
+            // A 600-pixel square at 45 degrees is about 849 points across: it fits horizontally
+            // but is clipped vertically. Gating document axes would produce a diagonal drift.
+            assert!(!super::scroll(&mut v, vec2(30.0, 0.0), xf));
+            assert!(super::scroll(&mut v, vec2(0.0, 30.0), xf));
+            let after = ViewXform { center: v.center, ..xf };
+            let displacement = after.to_screen(300.0, 300.0) - xf.to_screen(300.0, 300.0);
+            assert!(displacement.x.abs() < 0.01 && (displacement.y + 30.0).abs() < 0.01, "{displacement:?}");
+            assert!(!crate::scrollbars::clamp_view_with_aspect(&mut v, xf.rect.size(), 1.0, 1.0));
+        }
+    }
+}
diff --git a/crates/ui-egui/src/canvas_display_memo_tests.rs b/crates/ui-egui/src/canvas_display_memo_tests.rs
new file mode 100644
index 0000000000..ec105be015
--- /dev/null
+++ b/crates/ui-egui/src/canvas_display_memo_tests.rs
@@ -0,0 +1,46 @@
+//! `display_doc` builds a Duotone or live-adjust document once per snapshot (#4527), not on each
+//! of its calls in a frame.
+
+use super::*;
+use serde_json::json;
+
+fn app() -> PhotocraftApp {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+    app.run("file.new", json!({"width": 64, "height": 48, "mode": "gray"})).unwrap();
+    app
+}
+
+#[test]
+fn duotone_display_document_is_built_once_per_snapshot() {
+    let mut app = app();
+    app.run("image.mode.duotone", json!({"type": "duotone", "inks": [{"name": "Black"}, {"name": "Orange", "color": "#ff8000"}]})).unwrap();
+    let (a, key) = display_doc(&mut app, 0);
+    assert_eq!(key, 1 << 41);
+    let (b, _) = display_doc(&mut app, 0);
+    assert!(std::sync::Arc::ptr_eq(&a, &b), "the second call reuses the first's document");
+    assert_eq!(a.layers.len(), app.session.documents()[0].doc.layers.len() + 1, "with the ink display layer");
+    app.run("edit.fill", json!({"color": "#808080"})).unwrap();
+    let (c, _) = display_doc(&mut app, 0);
+    assert!(!std::sync::Arc::ptr_eq(&a, &c), "an edit builds it again");
+    assert_eq!(c.layers.last().map(|l| l.name.as_str()), a.layers.last().map(|l| l.name.as_str()));
+}
+
+#[test]
+fn live_adjust_document_is_built_once_per_setting() {
+    let mut app = app();
+    app.run("layer.newAdjustmentLayer.levels", json!({})).unwrap();
+    let id = app.session.documents()[0].active_layer.unwrap();
+    app.live_adjust = Some((id, json!({"inBlack": 20})));
+    let (a, k1) = display_doc(&mut app, 0);
+    let (b, k2) = display_doc(&mut app, 0);
+    assert_eq!(k1, k2);
+    assert!(std::sync::Arc::ptr_eq(&a, &b));
+    app.live_adjust = Some((id, json!({"inBlack": 40})));
+    let (c, k3) = display_doc(&mut app, 0);
+    assert_ne!(k1, k3);
+    assert!(!std::sync::Arc::ptr_eq(&a, &c), "a new setting builds it again");
+    app.live_adjust = None;
+    let (d, k4) = display_doc(&mut app, 0);
+    assert_eq!(k4, 0);
+    assert!(std::sync::Arc::ptr_eq(&d, &app.session.documents()[0].doc), "no preview: the document itself");
+}
diff --git a/crates/ui-egui/src/canvas_tool_menu.rs b/crates/ui-egui/src/canvas_tool_menu.rs
index 13af25d845..e1466f09ad 100644
--- a/crates/ui-egui/src/canvas_tool_menu.rs
+++ b/crates/ui-egui/src/canvas_tool_menu.rs
@@ -31,8 +31,30 @@ pub struct CanvasToolMenu {
     /// Opened while a Type tool edits text: the text and type rows instead of the tool's actions.
     #[serde(default)]
     pub text: bool,
+    /// The misspelled word under the pointer when the type edit menu opened: its suggestions head
+    /// the menu.
+    #[serde(default)]
+    pub spelling: Option<Spelling>,
 }
 
+/// A misspelled word in the type layer being edited (`edit.checkSpelling`'s `list` entry).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Spelling {
+    pub layer: u64,
+    /// The word's characters `start..end` in the layer's text.
+    pub start: usize,
+    pub end: usize,
+    pub word: String,
+    pub suggestions: Vec<String>,
+}
+
+/// Most suggestions the type edit menu lists.
+const MAX_SUGGESTIONS: usize = 3;
+/// The spelling rows' ids: `spelling.replace.<n>` picks the n-th suggestion.
+const SPELLING_REPLACE: &str = "spelling.replace.";
+const SPELLING_NONE: &str = "spelling.none";
+const SPELLING_ADD: &str = "spelling.add";
+
 /// One menu row: label and command id. `None` is a separator.
 pub type Row = Option<(&'static str, &'static str)>;
 
@@ -123,6 +145,20 @@ const ENDS_TYPE_EDIT: [&str; 5] =
 /// The pasteboard menu's Select Custom Color… row.
 pub const PASTEBOARD_PICK: &str = "pasteboard.selectCustomColor";
 
+/// The pasteboard colours in the menu's order, which Space+F steps through.
+const CANVAS_COLORS: [CanvasColor; 6] =
+    [CanvasColor::Default, CanvasColor::Black, CanvasColor::DarkGray, CanvasColor::MediumGray, CanvasColor::LightGray, CanvasColor::Custom];
+
+/// Photoshop's Space+F (⇧Space+F backwards): the next pasteboard colour, round and round. Saved
+/// like a choice in the pasteboard menu (`interface.canvasColor`).
+pub fn cycle_canvas_color(app: &mut PhotocraftApp, backward: bool) -> Result<(), String> {
+    let n = CANVAS_COLORS.len();
+    let at = CANVAS_COLORS.iter().position(|c| *c == app.session.prefs().interface.canvas_color).unwrap_or(0);
+    let next = if backward { (at + n - 1) % n } else { (at + 1) % n };
+    let name = CANVAS_COLORS.get(next).map_or("default", |c| c.name());
+    app.run("prefs.set", json!({"values": {"interface.canvasColor": name}})).map(|_| ())
+}
+
 /// The Zoom and Hand tools' context menu: the zoom steps and fixed zooms of the View menu, plus
 /// the Hand tool's Fill Screen.
 pub const VIEW_MENU: &[Row] = &[
@@ -261,12 +297,12 @@ pub fn rows(menu: &CanvasToolMenu) -> &'static [Row] {
 
 /// Is `command` one of the open menu's rows, and enabled?
 pub fn available(app: &PhotocraftApp, menu: &CanvasToolMenu, command: &str) -> bool {
-    rows(menu).iter().flatten().any(|(_, id)| *id == command) && entry_enabled(app, menu, command)
+    (rows(menu).iter().flatten().any(|(_, id)| *id == command) || is_spelling(menu, command)) && entry_enabled(app, menu, command)
 }
 
 /// Is `command` the transform box's current mode (checked in the transform menu)?
-/// Scale and Rotate are Free Transform's mode, so only Free Transform shows it checked. Warp is
-/// not a box mode (it is its own session), and `for_command` would read it as Free.
+/// Scale stays Free Transform's mode (only Free Transform is checked). Rotate is its own mode.
+/// Warp is not a box mode (it is its own session), and `for_command` would read it as Free.
 pub(crate) fn mode_checked(app: &PhotocraftApp, menu: &CanvasToolMenu, command: &str) -> bool {
     if menu.pasteboard {
         return pasteboard_choice(command) == Some(app.session.prefs().interface.canvas_color);
@@ -275,7 +311,7 @@ pub(crate) fn mode_checked(app: &PhotocraftApp, menu: &CanvasToolMenu, command:
         return type_checked(app, command);
     }
     menu.transform
-        && matches!(command, "edit.freeTransform" | "edit.transform.skew" | "edit.transform.distort" | "edit.transform.perspective")
+        && matches!(command, "edit.freeTransform" | "edit.transform.rotate" | "edit.transform.skew" | "edit.transform.distort" | "edit.transform.perspective")
         && app.ui.transform.as_ref().is_some_and(|t| t.mode == crate::state::TransformMode::for_command(command))
 }
 
@@ -297,6 +333,49 @@ pub fn editing_text(app: &PhotocraftApp, tool: Tool) -> bool {
     tool.is_type() && app.ui.text_edit.is_some()
 }
 
+/// The misspelled word of the edited text under document point `doc`, with its suggestions.
+fn spelling_at(app: &mut PhotocraftApp, doc: [f64; 2]) -> Option<Spelling> {
+    let layer = app.ui.text_edit.as_ref()?.layer;
+    if !doc.iter().all(|v| v.is_finite()) {
+        return None;
+    }
+    let at = crate::type_tool::offset_at(app, photocraft_doc::LayerId(layer), doc[0], doc[1]);
+    let found = app.session.execute("edit.checkSpelling", json!({"action": "list", "layer": layer, "suggestions": MAX_SUGGESTIONS})).ok()?;
+    let hit = found["misspellings"].as_array()?.iter().find(|m| {
+        let (a, b) = (m["start"].as_u64().unwrap_or(u64::MAX) as usize, m["end"].as_u64().unwrap_or(0) as usize);
+        a <= at && at <= b
+    })?;
+    Some(Spelling {
+        layer,
+        start: hit["start"].as_u64()? as usize,
+        end: hit["end"].as_u64()? as usize,
+        word: hit["word"].as_str()?.to_string(),
+        suggestions: hit["suggestions"].as_array()?.iter().filter_map(|s| s.as_str().map(str::to_string)).take(MAX_SUGGESTIONS).collect(),
+    })
+}
+
+/// The spelling rows heading the type edit menu (label, id): the suggestions, or a greyed note
+/// when there are none, then Add to Dictionary. Empty away from a misspelled word.
+pub fn spelling_rows(menu: &CanvasToolMenu) -> Vec<(String, String)> {
+    let Some(sp) = menu.spelling.as_ref().filter(|_| menu.text) else { return Vec::new() };
+    let mut rows: Vec<(String, String)> = sp.suggestions.iter().enumerate().map(|(i, s)| (s.clone(), format!("{SPELLING_REPLACE}{i}"))).collect();
+    if rows.is_empty() {
+        rows.push(("No Spelling Suggestions".into(), SPELLING_NONE.into()));
+    }
+    rows.push(("Add to Dictionary".into(), SPELLING_ADD.into()));
+    rows
+}
+
+/// Is `command` one of the menu's spelling rows?
+fn is_spelling(menu: &CanvasToolMenu, command: &str) -> bool {
+    spelling_rows(menu).iter().any(|(_, id)| id == command)
+}
+
+/// Does a spelling row's label come from the UI (translated) rather than from the dictionary?
+pub fn spelling_label_is_ui(id: &str) -> bool {
+    matches!(id, SPELLING_NONE | SPELLING_ADD)
+}
+
 /// Right-click over a Free Transform box: its modes.
 pub fn open_transform(app: &mut PhotocraftApp, ctx: &Context, pos: [f32; 2]) -> bool {
     if !pos.iter().all(|v| v.is_finite()) {
@@ -314,6 +393,7 @@ pub fn open_transform(app: &mut PhotocraftApp, ctx: &Context, pos: [f32; 2]) ->
         pasteboard: false,
         anchor: None,
         text: false,
+        spelling: None,
     });
     crate::canvas_popup::mark_open(ctx, menu_id());
     true
@@ -332,10 +412,24 @@ pub fn engine_call(menu: &CanvasToolMenu, command: &str) -> (String, Value) {
         Some(c) if menu.pasteboard => ("prefs.set".into(), json!({"values": {"interface.canvasColor": c.name()}})),
         _ if menu.pasteboard => ("prefs.set".into(), json!({})),
         _ if menu.text && matches!(command, FAUX_BOLD | FAUX_ITALIC) => ("type.setStyle".into(), json!({})),
+        _ if is_spelling(menu, command) => spelling_call(menu, command),
         _ => (command.into(), json!({})),
     }
 }
 
+/// The `edit.checkSpelling` call a spelling row makes: replace the word with a suggestion, or add
+/// it to the user dictionary.
+fn spelling_call(menu: &CanvasToolMenu, command: &str) -> (String, Value) {
+    let Some(sp) = menu.spelling.as_ref() else { return ("edit.checkSpelling".into(), json!({})) };
+    let replace = command.strip_prefix(SPELLING_REPLACE).and_then(|n| n.parse::<usize>().ok()).and_then(|n| sp.suggestions.get(n));
+    match replace {
+        Some(to) => {
+            ("edit.checkSpelling".into(), json!({"action": "change", "layer": sp.layer, "start": sp.start, "end": sp.end, "word": sp.word, "replace": to}))
+        }
+        None => ("edit.checkSpelling".into(), json!({"action": "addToDictionary", "word": sp.word})),
+    }
+}
+
 /// Does a right-click with `tool` at document point `doc` open the pasteboard menu? Outside the
 /// image, for the tools whose right-click has no job there: not the painting tools (their Brush
 /// Preset picker or right-button erase), the Pen (its path menu) or text being edited.
@@ -363,6 +457,7 @@ pub fn open_pasteboard(app: &mut PhotocraftApp, ctx: &Context, tool: Tool, pos:
         pasteboard: true,
         anchor: None,
         text: false,
+        spelling: None,
     });
     crate::canvas_popup::mark_open(ctx, menu_id());
     true
@@ -392,6 +487,8 @@ pub fn entry_enabled(app: &PhotocraftApp, menu: &CanvasToolMenu, command: &str)
     }
     if menu.text {
         return match command {
+            SPELLING_NONE => false,
+            c if is_spelling(menu, c) => app.ui.text_edit.is_some(),
             FAUX_BOLD | FAUX_ITALIC => app.ui.text_edit.is_some(),
             c => TYPE_EDIT_MENU.iter().flatten().any(|(_, id)| *id == c) && crate::menus::is_enabled(app, c),
         };
@@ -435,6 +532,12 @@ pub fn entry_enabled(app: &PhotocraftApp, menu: &CanvasToolMenu, command: &str)
 }
 
 pub fn open(app: &mut PhotocraftApp, ctx: &Context, tool: Tool, pos: [f32; 2]) -> bool {
+    open_at(app, ctx, tool, pos, None)
+}
+
+/// [`open`] for a right-click at document point `doc`: over a misspelled word of the text being
+/// edited, the menu starts with its spelling suggestions.
+pub fn open_at(app: &mut PhotocraftApp, ctx: &Context, tool: Tool, pos: [f32; 2], doc: Option<[f64; 2]>) -> bool {
     let text = editing_text(app, tool);
     if !(applies(tool) || text) || !pos.iter().all(|v| v.is_finite()) {
         return false;
@@ -444,7 +547,9 @@ pub fn open(app: &mut PhotocraftApp, ctx: &Context, tool: Tool, pos: [f32; 2]) -
     let has_selection = app.session.active().is_some_and(|s| s.doc.selection.is_some());
     let has_path = crate::vector_ui::active_path_name(app).is_some() || app.ui.pen.as_ref().is_some_and(|p| p.knots.len() >= 2);
     let path_name = crate::vector_ui::active_path_name(app);
-    app.ui.canvas_tool_menu = Some(CanvasToolMenu { pos, tool, has_selection, has_path, path_name, transform: false, pasteboard: false, anchor: None, text });
+    let spelling = if text { doc.and_then(|d| spelling_at(app, d)) } else { None };
+    app.ui.canvas_tool_menu =
+        Some(CanvasToolMenu { pos, tool, has_selection, has_path, path_name, transform: false, pasteboard: false, anchor: None, text, spelling });
     crate::canvas_popup::mark_open(ctx, menu_id());
     true
 }
@@ -467,6 +572,7 @@ pub fn open_view(app: &mut PhotocraftApp, ctx: &Context, tool: Tool, pos: [f32;
         pasteboard: false,
         anchor: Some(doc),
         text: false,
+        spelling: None,
     });
     crate::canvas_popup::mark_open(ctx, menu_id());
     true
@@ -507,6 +613,8 @@ pub fn choose(app: &mut PhotocraftApp, ctx: &Context, command: &str) {
         choose_pasteboard(app, &menu, command)
     } else if menu.anchor.is_some() {
         choose_view(app, ctx, &menu, command)
+    } else if menu.text && is_spelling(&menu, command) {
+        choose_spelling(app, &menu, command)
     } else if menu.text {
         choose_type(app, ctx, command)
     } else if menu.tool == Tool::Pen && !menu.transform {
@@ -524,6 +632,19 @@ pub fn choose(app: &mut PhotocraftApp, ctx: &Context, command: &str) {
     }
 }
 
+/// A spelling row: replace the word under the pointer (the caret lands after the replacement), or
+/// add it to the user dictionary.
+fn choose_spelling(app: &mut PhotocraftApp, menu: &CanvasToolMenu, command: &str) -> Result<(), String> {
+    let (id, params) = engine_call(menu, command);
+    let result = app.run(&id, params)?;
+    if let Some(end) = result["end"].as_u64().map(|e| e as usize)
+        && let Some(e) = app.ui.text_edit.as_mut()
+    {
+        (e.caret, e.anchor) = (end, end);
+    }
+    Ok(())
+}
+
 /// A type edit row. Undo, Cut, Copy, Paste and Select All run as their Edit and Select menu items,
 /// which act on the text while it is being edited (Paste asks the window for the clipboard text).
 fn choose_type(app: &mut PhotocraftApp, ctx: &Context, command: &str) -> Result<(), String> {
@@ -654,6 +775,17 @@ pub fn show(app: &mut PhotocraftApp, ctx: &Context) {
             ui.spacing_mut().item_spacing.y = 0.0;
             ui.set_width(200.0);
             crate::widgets::menu_scroll(ui, |ui| {
+                let spelling = spelling_rows(&menu);
+                for (label, command) in &spelling {
+                    let text = if spelling_label_is_ui(command) { tl!(label).to_string() } else { label.clone() };
+                    let item = egui::Button::new(text).min_size(egui::vec2(200.0, 20.0));
+                    if ui.add_enabled(entry_enabled(app, &menu, command), item).clicked() {
+                        selected = Some(command.clone());
+                    }
+                }
+                if !spelling.is_empty() {
+                    ui.separator();
+                }
                 for row in rows(&menu) {
                     let Some((label, command)) = *row else {
                         ui.separator();
@@ -661,14 +793,14 @@ pub fn show(app: &mut PhotocraftApp, ctx: &Context) {
                     };
                     let item = egui::Button::selectable(mode_checked(app, &menu, command), tl!(label)).min_size(egui::vec2(200.0, 20.0));
                     if ui.add_enabled(entry_enabled(app, &menu, command), item).clicked() {
-                        selected = Some(command);
+                        selected = Some((*command).to_string());
                     }
                 }
             });
         });
     });
     if let Some(command) = selected {
-        choose(app, ctx, command);
+        choose(app, ctx, &command);
     } else if crate::canvas_popup::outside_pressed(ctx, id, area.response.rect) {
         app.ui.canvas_tool_menu = None;
     }
@@ -835,6 +967,37 @@ mod tests {
         assert!(app.ui.text_edit.is_none() && text_of(&app, id).is_none(), "the type layer is pixels now");
     }
 
+    #[test]
+    fn type_edit_menu_lists_spelling_suggestions_for_the_word_under_the_pointer() {
+        let mut app = app();
+        app.ui.tool = Tool::Type;
+        let id = app.run("type.create", json!({"text": "Teh cat", "size": 12, "x": 4, "y": 20})).unwrap()["layer"].as_u64().unwrap();
+        let ctx = Context::default();
+        crate::menus::invoke(&mut app, &ctx, "type.editText", json!({})).unwrap();
+        // Away from the misspelling (past the end of the line): no spelling rows.
+        assert!(open_at(&mut app, &ctx, Tool::Type, [10.0, 10.0], Some([600.0, 15.0])));
+        assert!(spelling_rows(app.ui.canvas_tool_menu.as_ref().unwrap()).is_empty());
+        // Over "Teh": its suggestions head the menu, then Add to Dictionary.
+        assert!(open_at(&mut app, &ctx, Tool::Type, [10.0, 10.0], Some([5.0, 15.0])));
+        let menu = app.ui.canvas_tool_menu.clone().unwrap();
+        let rows = spelling_rows(&menu);
+        assert!(rows.iter().any(|(l, _)| l == "The"), "{rows:?}");
+        assert_eq!(rows.last().map(|(_, id)| id.as_str()), Some(SPELLING_ADD));
+        assert!(rows.len() <= MAX_SUGGESTIONS + 1, "at most {MAX_SUGGESTIONS} suggestions and Add to Dictionary: {rows:?}");
+        assert!(available(&app, &menu, &rows[0].1));
+        let pick = rows.iter().find(|(l, _)| l == "The").unwrap().1.clone();
+        choose(&mut app, &ctx, &pick);
+        assert_eq!(text_of(&app, id).unwrap().text, "The cat");
+        assert_eq!(app.ui.text_edit.as_ref().map(|e| (e.caret, e.anchor)), Some((3, 3)), "the caret lands after the replacement");
+        // Add to Dictionary stops flagging a word.
+        app.run("type.insertText", json!({"layer": id, "text": " Zqx"})).unwrap();
+        assert!(open_at(&mut app, &ctx, Tool::Type, [10.0, 10.0], Some([600.0, 15.0])));
+        let menu = app.ui.canvas_tool_menu.clone().unwrap();
+        assert!(menu.spelling.as_ref().is_some_and(|s| s.word == "Zqx"));
+        choose(&mut app, &ctx, SPELLING_ADD);
+        assert!(app.session.prefs().user_dictionary.iter().any(|w| w == "Zqx"));
+    }
+
     #[test]
     fn right_click_outside_the_image_picks_the_pasteboard_color() {
         let mut app = app();
@@ -1303,6 +1466,9 @@ mod tests {
         choose_open(&mut app, "layer.vectorMask.fromPath");
         let st = app.session.active().unwrap();
         assert!(st.active_layer.and_then(|id| st.doc.layer(id)).is_some_and(|l| l.vector_mask.is_some()));
+        // The new vector mask's path becomes the active one (#4728); pick the Work Path again.
+        assert_eq!(app.ui.selected_path.as_deref(), Some("layer"));
+        app.ui.selected_path = Some("work".into());
         choose_open(&mut app, "edit.defineCustomShape");
         let id = app.ui.dialogs.last().map(|d| d.id).unwrap();
         let fields = &app.ui.dialogs.last().unwrap().fields;
diff --git a/crates/ui-egui/src/caps_lock_tests.rs b/crates/ui-egui/src/caps_lock_tests.rs
index f9edc587f0..1e57c40920 100644
--- a/crates/ui-egui/src/caps_lock_tests.rs
+++ b/crates/ui-egui/src/caps_lock_tests.rs
@@ -3,7 +3,9 @@
 //! tools (Brush, Pencil, Clone Stamp, Healing, Eraser, …): Move, Marquee, Crop and Zoom keep
 //! their own cursors. Tests drive the real canvas (`document_area`) and compare the painted
 //! cursor that caps lock produces with the one the Precise preference draws — they must match,
-//! and the Standard preference (off) must not.
+//! and the Standard preference (off) must not. The tools under Cursors › Other Cursors with a
+//! cursor of their own (the pens, Eyedropper, Color Sampler, Paint Bucket) swap it for the
+//! crosshair and back with caps lock (#4639).
 
 use egui::CursorIcon;
 use egui_kittest::Harness;
@@ -113,3 +115,42 @@ fn caps_lock_leaves_non_painting_tools_cursors_alone() {
         caps(&mut h, false);
     }
 }
+
+fn other(h: &mut Harness<'_, PhotocraftApp>, value: &str) {
+    h.state_mut().run("prefs.set", json!({"path": "cursors.other", "value": value})).unwrap();
+    h.run_steps(2);
+}
+
+/// #4639: the pen tools show their own icon under Standard Other Cursors and the crosshair
+/// under Precise, and caps lock swaps one for the other either way, as in Photoshop. The
+/// Eyedropper, Color Sampler and Paint Bucket, which already followed the preference, swap too.
+#[test]
+fn caps_lock_swaps_the_other_cursors_between_their_icon_and_the_crosshair() {
+    for tool in [
+        Tool::Pen,
+        Tool::FreeformPen,
+        Tool::CurvaturePen,
+        Tool::AddAnchorPoint,
+        Tool::DeleteAnchorPoint,
+        Tool::ConvertPoint,
+        Tool::Eyedropper,
+        Tool::ColorSampler,
+        Tool::PaintBucket,
+    ] {
+        let mut h = capslock_harness();
+        h.state_mut().ui.tool = tool;
+        h.run_steps(2);
+        other(&mut h, "standard");
+        let standard = fp(&h);
+        assert_eq!(standard.icon, CursorIcon::None, "{tool:?}: the standard cursor is the tool's own icon, drawn");
+        other(&mut h, "precise");
+        let precise = fp(&h);
+        assert_ne!(standard, precise, "{tool:?}: Standard and Precise differ");
+        caps(&mut h, true);
+        assert_eq!(fp(&h), standard, "{tool:?}: caps lock turns the precise crosshair back into the icon");
+        other(&mut h, "standard");
+        assert_eq!(fp(&h), precise, "{tool:?}: caps lock turns the icon into the precise crosshair");
+        caps(&mut h, false);
+        assert_eq!(fp(&h), standard, "{tool:?}: releasing caps lock restores the icon");
+    }
+}
diff --git a/crates/ui-egui/src/channel_options_ui.rs b/crates/ui-egui/src/channel_options_ui.rs
new file mode 100644
index 0000000000..c50244447e
--- /dev/null
+++ b/crates/ui-egui/src/channel_options_ui.rs
@@ -0,0 +1,215 @@
+//! Channels panel › Channel Options… (double-click an alpha or spot channel's thumbnail, or the
+//! Quick Mask row): name, Color Indicates Masked Areas / Selected Areas / Spot Color, the overlay
+//! or ink colour, and opacity (solidity for spot channels). OK runs the engine's
+//! `channel.options`, which agents can also call directly with params (#3761).
+
+use egui::{Align2, Sense, pos2, vec2};
+use photocraft_doc::ColorIndicates;
+use serde_json::{Map, Value, json};
+
+use crate::PhotocraftApp;
+use crate::theme::Tokens;
+
+pub const COMMAND: &str = "channel.options";
+const MARK: &str = "__channelOptions";
+
+pub fn owns(fields: &Map<String, Value>) -> bool {
+    fields.contains_key(MARK)
+}
+
+fn hex(rgb: [f32; 3]) -> String {
+    crate::color_picker_ui::hex(rgb)
+}
+
+/// The dialog's fields for `channel` (an alpha/spot channel index, or `"quickMask"`), or `None`
+/// when there's no document or no such channel.
+pub fn fields(app: &PhotocraftApp, channel: &Value) -> Option<Map<String, Value>> {
+    let doc = &app.session.active()?.doc;
+    let kind = |i: ColorIndicates| if i == ColorIndicates::SelectedAreas { "selected" } else { "masked" };
+    let (name, indicates, color, percent) = if channel.as_str() == Some("quickMask") {
+        let o = app.session.quick_mask_options;
+        (None, kind(o.indicates), o.color, o.opacity)
+    } else {
+        let ch = doc.channels.get(usize::try_from(channel.as_u64()?).ok()?)?;
+        match ch.spot {
+            Some((ink, solidity)) => (Some(ch.name.clone()), "spot", ink, solidity),
+            None => (Some(ch.name.clone()), kind(ch.indicates), ch.color, ch.opacity),
+        }
+    };
+    let mut f = Map::new();
+    f.insert(MARK.into(), json!(true));
+    f.insert("__command".into(), json!(COMMAND));
+    f.insert("__label".into(), json!(if name.is_some() { "Channel Options…" } else { "Quick Mask Options…" }));
+    f.insert("channel".into(), channel.clone());
+    if let Some(n) = name {
+        f.insert("name".into(), json!(n));
+    }
+    f.insert("indicates".into(), json!(indicates));
+    f.insert("color".into(), json!(hex(color.to_rgb())));
+    f.insert("opacity".into(), json!((percent.clamp(0.0, 1.0) * 100.0).round()));
+    Some(f)
+}
+
+/// Opens Channel Options on `channel`, or `None` if it doesn't exist.
+pub fn open(app: &mut PhotocraftApp, channel: &Value) -> Option<u64> {
+    let f = fields(app, channel)?;
+    Some(app.ui.open_dialog(crate::state::DialogKind::Command, f))
+}
+
+/// The `channel.options` params for the dialog's fields: spot channels take `solidity`, the
+/// others `opacity`.
+pub fn params(f: &Map<String, Value>) -> Value {
+    let spot = f.get("indicates").and_then(Value::as_str) == Some("spot");
+    let mut p = Map::new();
+    for key in ["channel", "name", "indicates", "color"] {
+        if let Some(v) = f.get(key) {
+            p.insert(key.into(), v.clone());
+        }
+    }
+    if let Some(v) = f.get("opacity") {
+        p.insert(if spot { "solidity" } else { "opacity" }.into(), v.clone());
+    }
+    Value::Object(p)
+}
+
+pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value, String> {
+    app.run(COMMAND, params(f))
+}
+
+fn label(ui: &mut egui::Ui, text: &str) {
+    let t = Tokens::get(ui.ctx());
+    let (r, _) = ui.allocate_exact_size(vec2(84.0, 22.0), Sense::hover());
+    ui.painter().text(pos2(r.right() - 6.0, r.center().y), Align2::RIGHT_CENTER, text, egui::FontId::proportional(12.0), t.text_dim);
+}
+
+pub fn body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
+    ui.spacing_mut().item_spacing.y = 6.0;
+    let quick = f.get("channel").and_then(Value::as_str) == Some("quickMask");
+    if let Some(mut name) = f.get("name").and_then(Value::as_str).map(str::to_string) {
+        ui.horizontal(|ui| {
+            label(ui, tl!("Name:"));
+            if ui.add(egui::TextEdit::singleline(&mut name).desired_width(200.0)).changed() {
+                f.insert("name".into(), json!(name));
+            }
+        });
+    }
+    crate::widgets::section_label(ui, tl!("Color Indicates:"));
+    crate::widgets::hairline(ui);
+    let mut indicates = f.get("indicates").and_then(Value::as_str).unwrap_or("masked").to_string();
+    let before = indicates.clone();
+    ui.indent("channel-options-indicates", |ui| {
+        ui.radio_value(&mut indicates, "masked".to_string(), tl!("Masked Areas"));
+        ui.radio_value(&mut indicates, "selected".to_string(), tl!("Selected Areas"));
+        // Quick Mask can't be a spot channel.
+        if !quick {
+            ui.radio_value(&mut indicates, "spot".to_string(), tl!("Spot Color"));
+        }
+    });
+    if indicates != before {
+        f.insert("indicates".into(), json!(indicates));
+    }
+    let spot = indicates == "spot";
+    ui.add_space(4.0);
+    crate::widgets::section_label(ui, tl!("Color"));
+    crate::widgets::hairline(ui);
+    ui.horizontal(|ui| {
+        label(ui, "");
+        let current = f.get("color").and_then(Value::as_str).and_then(crate::color_picker_ui::parse_hex).unwrap_or([1.0, 0.0, 0.0]);
+        let c = current.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8);
+        let what = if spot { tl!("Spot Color") } else { tl!("Channel Color") };
+        if crate::widgets::color_swatch_button(ui, egui::Color32::from_rgb(c[0], c[1], c[2]), what).clicked() {
+            crate::color_picker_ui::request(f, &crate::color_picker_ui::title_for(what));
+        }
+        ui.add_space(12.0);
+        ui.label(if spot { tl!("Solidity:") } else { tl!("Opacity:") });
+        let mut pct = f.get("opacity").and_then(Value::as_f64).unwrap_or(50.0) as f32;
+        if crate::widgets::value_field(ui, &mut pct, 0.0..=100.0, "%", 64.0).changed() {
+            f.insert("opacity".into(), json!(pct.round()));
+        }
+    });
+}
+
+// ---------------------------------------------------------------------------------------------
+// New Spot Channel…: Name and Ink Characteristics (Color, Solidity). OK runs `channel.newSpot`
+// (from the selection, as Photoshop does) and remembers the ink and solidity for next time.
+
+pub const NEW_SPOT: &str = "channel.newSpot";
+const NEW_SPOT_MARK: &str = "__newSpot";
+
+pub fn owns_new_spot(fields: &Map<String, Value>) -> bool {
+    fields.contains_key(NEW_SPOT_MARK)
+}
+
+/// The New Spot Channel fields: the next "Spot Color N" name and the last ink and solidity
+/// (red and 0% at first), or `None` without a document.
+pub fn new_spot_fields(app: &PhotocraftApp) -> Option<Map<String, Value>> {
+    let doc = &app.session.active()?.doc;
+    let saved = app.session.prefs().dialogs.get(NEW_SPOT).cloned().unwrap_or_default();
+    let color = saved.get("color").and_then(Value::as_str).filter(|h| crate::color_picker_ui::parse_hex(h).is_some()).unwrap_or("#ff0000");
+    let solidity = saved.get("solidity").and_then(Value::as_f64).filter(|v| (0.0..=100.0).contains(v)).unwrap_or(0.0);
+    let mut f = Map::new();
+    f.insert(NEW_SPOT_MARK.into(), json!(true));
+    f.insert("__command".into(), json!(NEW_SPOT));
+    f.insert("__label".into(), json!("New Spot Channel…"));
+    f.insert("name".into(), json!(photocraft_engine::channel_cmds::next_alpha_name(doc, "Spot Color")));
+    f.insert("color".into(), json!(color));
+    f.insert("solidity".into(), json!(solidity));
+    Some(f)
+}
+
+/// Opens New Spot Channel, or `None` without a document.
+pub fn open_new_spot(app: &mut PhotocraftApp) -> Option<u64> {
+    let f = new_spot_fields(app)?;
+    Some(app.ui.open_dialog(crate::state::DialogKind::Command, f))
+}
+
+pub fn new_spot_params(f: &Map<String, Value>) -> Value {
+    let mut p = Map::new();
+    for key in ["name", "color", "solidity"] {
+        if let Some(v) = f.get(key) {
+            p.insert(key.into(), v.clone());
+        }
+    }
+    Value::Object(p)
+}
+
+pub fn confirm_new_spot(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value, String> {
+    let p = new_spot_params(f);
+    let result = app.run(NEW_SPOT, p.clone());
+    if result.is_ok() {
+        let remembered = json!({ "color": p.get("color"), "solidity": p.get("solidity") });
+        app.session.prefs.edit(|prefs| prefs.dialogs.insert(NEW_SPOT.into(), remembered));
+    }
+    result
+}
+
+pub fn new_spot_body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
+    ui.spacing_mut().item_spacing.y = 6.0;
+    let mut name = f.get("name").and_then(Value::as_str).unwrap_or_default().to_string();
+    ui.horizontal(|ui| {
+        label(ui, tl!("Name:"));
+        if ui.add(egui::TextEdit::singleline(&mut name).desired_width(200.0)).changed() {
+            f.insert("name".into(), json!(name));
+        }
+    });
+    crate::widgets::section_label(ui, tl!("Ink Characteristics"));
+    crate::widgets::hairline(ui);
+    ui.horizontal(|ui| {
+        label(ui, tl!("Color:"));
+        let current = f.get("color").and_then(Value::as_str).and_then(crate::color_picker_ui::parse_hex).unwrap_or([1.0, 0.0, 0.0]);
+        let c = current.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8);
+        if crate::widgets::color_swatch_button(ui, egui::Color32::from_rgb(c[0], c[1], c[2]), tl!("Spot Color")).clicked() {
+            crate::color_picker_ui::request(f, &crate::color_picker_ui::title_for(tl!("Spot Color")));
+        }
+        ui.add_space(12.0);
+        ui.label(tl!("Solidity:"));
+        let mut pct = f.get("solidity").and_then(Value::as_f64).unwrap_or(0.0) as f32;
+        if crate::widgets::value_field(ui, &mut pct, 0.0..=100.0, "%", 64.0).changed() {
+            f.insert("solidity".into(), json!(pct.round()));
+        }
+    });
+}
+
+#[cfg(test)]
+#[path = "channel_options_ui_tests.rs"]
+mod tests;
diff --git a/crates/ui-egui/src/channel_options_ui_tests.rs b/crates/ui-egui/src/channel_options_ui_tests.rs
new file mode 100644
index 0000000000..9a4a3d4c37
--- /dev/null
+++ b/crates/ui-egui/src/channel_options_ui_tests.rs
@@ -0,0 +1,177 @@
+use serde_json::json;
+
+use super::*;
+
+fn app() -> PhotocraftApp {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+    app.run("file.new", json!({"width": 16, "height": 16})).unwrap();
+    app.run("select.rect", json!({"x": 2, "y": 2, "width": 8, "height": 8})).unwrap();
+    app.run("select.saveSelection", json!({})).unwrap();
+    app
+}
+
+fn channel(app: &PhotocraftApp) -> photocraft_doc::AlphaChannel {
+    app.session.active().unwrap().doc.channels[0].clone()
+}
+
+#[test]
+fn saved_selection_becomes_a_spot_channel_with_its_ink_and_solidity() {
+    let mut app = app();
+    assert!(channel(&app).spot.is_none());
+    let id = open(&mut app, &json!(0)).unwrap();
+    let f = &app.ui.dialogs.last().unwrap().fields;
+    assert!(owns(f));
+    assert_eq!(f["indicates"], json!("masked"));
+    assert_eq!(f["name"], json!(channel(&app).name));
+    let d = app.ui.dialog_mut(id).unwrap();
+    d.fields.insert("name".into(), json!("PMS 185"));
+    d.fields.insert("indicates".into(), json!("spot"));
+    d.fields.insert("color".into(), json!("#ff0000"));
+    d.fields.insert("opacity".into(), json!(40.0));
+    crate::dialogs::confirm(&mut app, id).unwrap();
+    assert!(app.ui.dialogs.is_empty());
+    let ch = channel(&app);
+    assert_eq!(ch.name, "PMS 185");
+    let (ink, solidity) = ch.spot.expect("a spot channel");
+    assert_eq!(ink.to_rgb(), [1.0, 0.0, 0.0]);
+    assert!((solidity - 0.4).abs() < 1e-6);
+
+    // Reopened, the dialog shows the spot settings; switching back makes it an alpha channel.
+    let id = open(&mut app, &json!(0)).unwrap();
+    let f = &app.ui.dialog_mut(id).unwrap().fields;
+    assert_eq!((f["indicates"].clone(), f["color"].clone(), f["opacity"].clone()), (json!("spot"), json!("#ff0000"), json!(40.0)));
+    app.ui.dialog_mut(id).unwrap().fields.insert("indicates".into(), json!("selected"));
+    crate::dialogs::confirm(&mut app, id).unwrap();
+    let ch = channel(&app);
+    assert!(ch.spot.is_none());
+    assert_eq!(ch.indicates, ColorIndicates::SelectedAreas);
+}
+
+#[test]
+fn cancel_leaves_the_channel_alone() {
+    let mut app = app();
+    let before = app.session.active().unwrap().history.past_len();
+    let id = open(&mut app, &json!(0)).unwrap();
+    app.ui.dialog_mut(id).unwrap().fields.insert("indicates".into(), json!("spot"));
+    app.ui.close_dialog(id);
+    assert!(channel(&app).spot.is_none());
+    assert_eq!(app.session.active().unwrap().history.past_len(), before);
+}
+
+#[test]
+fn spot_params_send_solidity_and_alpha_params_send_opacity() {
+    let mut f = Map::new();
+    f.insert(MARK.into(), json!(true));
+    f.insert("channel".into(), json!(0));
+    f.insert("indicates".into(), json!("spot"));
+    f.insert("opacity".into(), json!(25.0));
+    assert_eq!(params(&f), json!({"channel": 0, "indicates": "spot", "solidity": 25.0}));
+    f.insert("indicates".into(), json!("masked"));
+    assert_eq!(params(&f), json!({"channel": 0, "indicates": "masked", "opacity": 25.0}));
+}
+
+#[test]
+fn menu_opens_the_dialog_on_the_targeted_channel_and_refuses_otherwise() {
+    let ctx = egui::Context::default();
+    let mut empty = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+    assert!(crate::menus::invoke(&mut empty, &ctx, COMMAND, json!({})).is_err());
+
+    let mut app = app();
+    // The composite is targeted: nothing to edit.
+    assert!(crate::menus::invoke(&mut app, &ctx, COMMAND, json!({})).is_err());
+    assert!(app.ui.dialogs.is_empty());
+    app.run("channel.target", json!({"channel": 0})).unwrap();
+    let r = crate::menus::invoke(&mut app, &ctx, COMMAND, json!({})).unwrap();
+    assert!(r["dialog"].is_u64());
+    assert_eq!(app.ui.dialogs.last().unwrap().fields["channel"], json!(0));
+    // Explicit params run the engine directly, no dialog.
+    app.ui.dialogs.clear();
+    crate::menus::invoke(&mut app, &ctx, COMMAND, json!({"channel": 0, "indicates": "spot"})).unwrap();
+    assert!(app.ui.dialogs.is_empty());
+    assert!(channel(&app).spot.is_some());
+}
+
+#[test]
+fn quick_mask_options_have_no_name_or_spot_and_bad_channels_open_nothing() {
+    let mut app = app();
+    let f = fields(&app, &json!("quickMask")).unwrap();
+    assert!(!f.contains_key("name"));
+    assert_eq!(f["__label"], json!("Quick Mask Options…"));
+    assert!(fields(&app, &json!(7)).is_none());
+    assert!(fields(&app, &json!("nope")).is_none());
+    assert!(open(&mut app, &json!(-1)).is_none());
+    assert!(app.ui.dialogs.is_empty());
+}
+
+#[test]
+fn dialog_body_renders_for_alpha_spot_and_quick_mask() {
+    let mut app = app();
+    app.run("channel.options", json!({"channel": 0, "indicates": "spot"})).unwrap();
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    for channel in [json!(0), json!("quickMask")] {
+        let mut f = fields(&app, &channel).unwrap();
+        ctx.run_ui(Default::default(), |ui| body(ui, &mut f)).textures_delta.clear();
+        assert!(owns(&f));
+    }
+}
+
+#[test]
+fn new_spot_channel_dialog_creates_the_ink_from_the_selection_and_remembers_it() {
+    let mut app = app();
+    app.run("select.rect", json!({"x": 2, "y": 2, "width": 8, "height": 8})).unwrap();
+    let id = open_new_spot(&mut app).unwrap();
+    let f = &app.ui.dialogs.last().unwrap().fields;
+    assert!(owns_new_spot(f) && !owns(f));
+    assert_eq!((f["name"].clone(), f["color"].clone(), f["solidity"].clone()), (json!("Spot Color 1"), json!("#ff0000"), json!(0.0)));
+    let d = app.ui.dialog_mut(id).unwrap();
+    d.fields.insert("name".into(), json!("PMS 300"));
+    d.fields.insert("color".into(), json!("#0050ff"));
+    d.fields.insert("solidity".into(), json!(60.0));
+    crate::dialogs::confirm(&mut app, id).unwrap();
+    let doc = &app.session.active().unwrap().doc;
+    let ch = doc.channels.last().unwrap();
+    assert_eq!(ch.name, "PMS 300");
+    let (ink, solidity) = ch.spot.expect("a spot channel");
+    assert_eq!(ink.to_rgba8()[..3], [0x00, 0x50, 0xff]);
+    assert!((solidity - 0.6).abs() < 1e-6);
+    // Inked where the selection was, empty outside it.
+    let (inside, outside) = (ch.surface.rgba(4, 4)[0], ch.surface.rgba(14, 14)[0]);
+    assert!(inside > 0.99 && outside < 0.01, "{inside} {outside}");
+
+    // The next one gets a fresh name and the last ink and solidity.
+    let f = new_spot_fields(&app).unwrap();
+    assert_eq!((f["name"].clone(), f["color"].clone(), f["solidity"].clone()), (json!("Spot Color 1"), json!("#0050ff"), json!(60.0)));
+}
+
+#[test]
+fn new_spot_channel_cancel_menu_routing_and_no_document() {
+    let ctx = egui::Context::default();
+    let mut empty = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+    assert!(open_new_spot(&mut empty).is_none());
+    assert!(crate::menus::invoke(&mut empty, &ctx, NEW_SPOT, json!({})).is_err());
+
+    let mut app = app();
+    let n = app.session.active().unwrap().doc.channels.len();
+    let r = crate::menus::invoke(&mut app, &ctx, NEW_SPOT, json!({})).unwrap();
+    let id = r["dialog"].as_u64().unwrap();
+    assert!(owns_new_spot(&app.ui.dialog_mut(id).unwrap().fields));
+    app.ui.close_dialog(id);
+    assert_eq!(app.session.active().unwrap().doc.channels.len(), n, "Cancel adds nothing");
+    // Explicit params run the engine directly, no dialog.
+    crate::menus::invoke(&mut app, &ctx, NEW_SPOT, json!({"name": "Direct"})).unwrap();
+    assert!(app.ui.dialogs.is_empty());
+    assert_eq!(app.session.active().unwrap().doc.channels.last().unwrap().name, "Direct");
+}
+
+#[test]
+fn new_spot_body_renders_and_bad_saved_prefs_fall_back() {
+    let mut app = app();
+    app.session.prefs.edit(|p| p.dialogs.insert(NEW_SPOT.into(), json!({"color": "nope", "solidity": 900})));
+    let mut f = new_spot_fields(&app).unwrap();
+    assert_eq!((f["color"].clone(), f["solidity"].clone()), (json!("#ff0000"), json!(0.0)));
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    ctx.run_ui(Default::default(), |ui| new_spot_body(ui, &mut f)).textures_delta.clear();
+    assert!(owns_new_spot(&f));
+}
diff --git a/crates/ui-egui/src/channel_view.rs b/crates/ui-egui/src/channel_view.rs
index e4642d946d..b8be54d273 100644
--- a/crates/ui-egui/src/channel_view.rs
+++ b/crates/ui-egui/src/channel_view.rs
@@ -18,6 +18,22 @@ use crate::PhotocraftApp;
 
 /// Largest overlay texture side; bigger documents show a downsampled overlay.
 const MAX_SIDE: u32 = 4096;
+/// Limit the sampled float composite to 128 MiB across open documents.
+const MAX_COMPOSITE_CACHE_PIXELS: usize = 8 * 1024 * 1024;
+
+struct SampledComposite {
+    revision: u64,
+    /// `revision` minus the view-only part: what the pixels depend on.
+    content: u64,
+    preview_key: u64,
+    factor: u32,
+    pixels: Vec<[f32; 4]>,
+}
+
+struct CompositeSource<'a> {
+    cached: Option<&'a [[f32; 4]]>,
+    fresh: &'a mut Option<Vec<[f32; 4]>>,
+}
 
 pub struct Cache {
     revision: u64,
@@ -29,6 +45,7 @@ pub struct Cache {
     /// reuses its allocation) but its pixels are stale.
     valid: bool,
     tex: egui::TextureHandle,
+    source: Option<SampledComposite>,
 }
 
 fn sample(s: &Surface, r: Rect, factor: u32) -> Vec<f32> {
@@ -49,18 +66,22 @@ fn sample(s: &Surface, r: Rect, factor: u32) -> Vec<f32> {
 }
 
 /// Composite RGBA (over white, like Photoshop's channel views) at `factor` stride.
+/// Render in bands instead of allocating a full-resolution float composite to sample a preview.
 fn composite(doc: &Document, r: Rect, factor: u32) -> Vec<[f32; 4]> {
-    let buf = photocraft_compose::render(doc, r);
     let (w, h) = (r.width().div_ceil(factor), r.height().div_ceil(factor));
-    let bw = r.width();
     let mut out = Vec::with_capacity((w * h) as usize);
-    for y in 0..h {
-        for x in 0..w {
-            let p = buf.px[((y * factor) * bw + x * factor) as usize];
-            let a = p[3].clamp(0.0, 1.0);
-            out.push([p[0] * a + 1.0 - a, p[1] * a + 1.0 - a, p[2] * a + 1.0 - a, 1.0]);
+    let f = factor as i32;
+    let _ = photocraft_compose::render_bands(doc, r, 0, |band| -> Result<(), ()> {
+        let first = band.rect.y0 + (r.y0 - band.rect.y0).rem_euclid(f);
+        for y in (first..band.rect.y1).step_by(factor as usize) {
+            for x in (r.x0..r.x1).step_by(factor as usize) {
+                let p = band.get(x, y);
+                let a = p[3].clamp(0.0, 1.0);
+                out.push([p[0] * a + 1.0 - a, p[1] * a + 1.0 - a, p[2] * a + 1.0 - a, 1.0]);
+            }
         }
-    }
+        Ok(())
+    });
     out
 }
 
@@ -68,6 +89,19 @@ fn composite(doc: &Document, r: Rect, factor: u32) -> Vec<[f32; 4]> {
 /// or `None` when the plain composite is all there is to show. `in_color` shows single colour
 /// channels tinted instead of grayscale (Photoshop's "Show Channels in Color").
 pub fn render(doc: &Document, v: &ChannelView, r: Rect, factor: u32, in_color: bool, active: Option<photocraft_doc::LayerId>) -> Option<Vec<Color32>> {
+    let mut unused = None;
+    render_with_source(doc, v, r, factor, in_color, active, CompositeSource { cached: None, fresh: &mut unused })
+}
+
+fn render_with_source(
+    doc: &Document,
+    v: &ChannelView,
+    r: Rect,
+    factor: u32,
+    in_color: bool,
+    active: Option<photocraft_doc::LayerId>,
+    source: CompositeSource<'_>,
+) -> Option<Vec<Color32>> {
     if v.is_plain(doc) || r.is_empty() {
         return None;
     }
@@ -116,8 +150,11 @@ pub fn render(doc: &Document, v: &ChannelView, r: Rect, factor: u32, in_color: b
         let fmt = doc.pixel_format();
         let mode = fmt.mode;
         let shown: Vec<usize> = (0..colors).filter(|k| v.color_visible(*k)).collect();
-        composite(doc, r, factor)
-            .into_iter()
+        let computed = if source.cached.is_some_and(|px| px.len() == n) { None } else { Some(composite(doc, r, factor)) };
+        let pixels = source.cached.filter(|px| px.len() == n).or(computed.as_deref())?;
+        let converted = pixels
+            .iter()
+            .copied()
             .map(|rgba| {
                 let mut native = from_rgba(&fmt, rgba);
                 if shown.len() == 1 && !in_color {
@@ -137,7 +174,11 @@ pub fn render(doc: &Document, v: &ChannelView, r: Rect, factor: u32, in_color: b
                 let c = to_rgba(&fmt, &native);
                 [c[0], c[1], c[2], 1.0]
             })
-            .collect()
+            .collect();
+        if n <= MAX_COMPOSITE_CACHE_PIXELS {
+            *source.fresh = computed;
+        }
+        converted
     } else {
         vec![[0.0; 4]; n]
     };
@@ -212,6 +253,7 @@ pub fn ensure(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize) -> Optio
     let view = st.channel_view.clone();
     let active = st.active_layer;
     let (revision, last_damage) = (st.revision, st.last_damage);
+    let content = revision.wrapping_sub(st.view_revision);
     let id = st.doc.id.0;
     if view.is_plain(&st.doc) {
         if let Some(c) = app.channel_views.get_mut(&id) {
@@ -222,7 +264,7 @@ pub fn ensure(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize) -> Optio
     // Mask and channel views are drawn over the canvas: show the same live document,
     // otherwise an opaque grayscale mask hides the stroke until it is committed (#2078).
     // The plain-composite path above needs no preview work.
-    let (doc, preview_key) = crate::canvas::display_doc(app, idx);
+    let (doc, preview_key) = crate::canvas::filter_channel_preview(app, idx, ctx).unwrap_or_else(|| crate::canvas::display_doc(app, idx));
     // Interface ▸ Show Channels in Color tints single colour channel views on the canvas too,
     // not just the panel thumbnails (#2385). The view key carries the flag, so toggling it
     // rebuilds the texture.
@@ -231,6 +273,15 @@ pub fn ensure(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize) -> Optio
     // Never exceed what the GPU accepts (egui panics on oversized textures).
     let max_side = (ctx.input(|i| i.max_texture_side) as u32).clamp(256, MAX_SIDE);
     let factor = doc.size.width.max(doc.size.height).div_ceil(max_side).max(1);
+    // A live preview can mutate the same Arc in place. Content revision and preview_key, not
+    // pointer identity, determine whether these flattened pixels are still current.
+    if let Some(c) = app.channel_views.get_mut(&id) {
+        if let Some(s) = c.source.as_mut().filter(|s| s.factor == factor && s.content == content && s.preview_key == preview_key) {
+            s.revision = revision;
+        } else {
+            c.source = None;
+        }
+    }
     if let Some(c) = app.channel_views.get(&id)
         && c.key == key
         && c.factor == factor
@@ -264,7 +315,10 @@ pub fn ensure(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize) -> Optio
         return Some(c.tex.id());
     }
     let b = doc.bounds();
-    let px = render(&doc, &view, b, factor, in_color, active)?;
+    let cached = app.channel_views.get(&id).and_then(|c| c.source.as_ref()).map(|s| s.pixels.as_slice());
+    let mut fresh = None;
+    let px = render_with_source(&doc, &view, b, factor, in_color, active, CompositeSource { cached, fresh: &mut fresh })?;
+    let new_source = fresh.is_some();
     let size = [b.width().div_ceil(factor) as usize, b.height().div_ceil(factor) as usize];
     let img = egui::ColorImage::new(size, px);
     match app.channel_views.get_mut(&id) {
@@ -275,10 +329,21 @@ pub fn ensure(app: &mut PhotocraftApp, ctx: &egui::Context, idx: usize) -> Optio
             c.key = key;
             c.factor = factor;
             c.valid = true;
+            if let Some(pixels) = fresh.take() {
+                c.source = Some(SampledComposite { revision, content, preview_key, factor, pixels });
+            }
         }
         _ => {
             let tex = ctx.load_texture(format!("channel-view-{id}"), img, TextureOptions::LINEAR);
-            app.channel_views.insert(id, Cache { revision, key, preview_key, factor, valid: true, tex });
+            let source = fresh.map(|pixels| SampledComposite { revision, content, preview_key, factor, pixels });
+            app.channel_views.insert(id, Cache { revision, key, preview_key, factor, valid: true, tex, source });
+        }
+    }
+    if new_source {
+        for (other_id, c) in &mut app.channel_views {
+            if *other_id != id {
+                c.source = None;
+            }
         }
     }
     app.channel_views.get(&id).map(|c| c.tex.id())
@@ -297,6 +362,79 @@ mod tests {
         s
     }
 
+    #[test]
+    fn composite_bands_keep_the_downsample_grid() {
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 41, "height": 700})).unwrap();
+        s.execute("edit.fill", json!({"color": "#398db2"})).unwrap();
+        let doc = &s.active().unwrap().doc;
+        let rect = doc.bounds();
+        let full = photocraft_compose::render(doc, rect);
+        let full_ref = &full;
+        for factor in [1, 2, 3, 5] {
+            let expected: Vec<_> = (0..rect.height())
+                .step_by(factor as usize)
+                .flat_map(|y| {
+                    (0..rect.width()).step_by(factor as usize).map(move |x| {
+                        let p = full_ref.get(rect.x0 + x as i32, rect.y0 + y as i32);
+                        let a = p[3].clamp(0.0, 1.0);
+                        [p[0] * a + 1.0 - a, p[1] * a + 1.0 - a, p[2] * a + 1.0 - a, 1.0]
+                    })
+                })
+                .collect();
+            assert_eq!(composite(doc, rect, factor), expected, "factor {factor}");
+        }
+    }
+
+    #[test]
+    fn channel_eyes_reuse_composite_until_pixels_change() {
+        let mut app = PhotocraftApp::new(Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 64, "height": 32})).unwrap();
+        app.run("edit.fill", json!({"color": "#4080c0"})).unwrap();
+        app.sync_views();
+        let ctx = egui::Context::default();
+        app.run("channel.setVisible", json!({"channel": "red", "visible": false})).unwrap();
+        assert!(ensure(&mut app, &ctx, 0).is_some());
+        let id = app.session.active().unwrap().doc.id.0;
+        let first = app.channel_views.get_mut(&id).unwrap().source.as_mut().unwrap();
+        let original_sample = first.pixels[0];
+        // Mark the cache: a recomposite overwrites it, while a freed buffer's address can come back.
+        first.pixels[0] = [0.0, 1.0, 0.0, 1.0];
+
+        app.run("channel.setVisible", json!({"channel": "green", "visible": false})).unwrap();
+        assert!(ensure(&mut app, &ctx, 0).is_some());
+        let reused = app.channel_views.get(&id).unwrap().source.as_ref().unwrap();
+        assert_eq!(reused.pixels[0], [0.0, 1.0, 0.0, 1.0], "visibility does not recompose the pixels");
+
+        app.run("edit.fill", json!({"color": "#e02010"})).unwrap();
+        assert!(ensure(&mut app, &ctx, 0).is_some());
+        // A partial damage upload discards the source; a full redraw may replace it.
+        // In either case, cached samples must never refer to the pre-edit pixels.
+        if let Some(source) = app.channel_views.get(&id).unwrap().source.as_ref() {
+            assert_ne!(source.pixels[0], original_sample, "a full redraw replaces stale pixels");
+        }
+        app.run("channel.setVisible", json!({"channel": "red", "visible": true})).unwrap();
+        assert!(ensure(&mut app, &ctx, 0).is_some());
+        let refreshed = app.channel_views.get(&id).unwrap().source.as_ref().unwrap();
+        let st = app.session.active().unwrap();
+        assert_eq!(refreshed.revision, st.revision);
+        assert_ne!(refreshed.pixels[0], original_sample, "new pixels must be recomposited");
+        let expected = render(&st.doc, &st.channel_view, st.doc.bounds(), 1, false, st.active_layer).unwrap();
+        let mut unused = None;
+        let actual = render_with_source(
+            &st.doc,
+            &st.channel_view,
+            st.doc.bounds(),
+            1,
+            false,
+            st.active_layer,
+            CompositeSource { cached: Some(&refreshed.pixels), fresh: &mut unused },
+        )
+        .unwrap();
+        assert_eq!(actual, expected, "reused pixels must preserve channel colours");
+        assert!(unused.is_none(), "reuse must not create a second composite");
+    }
+
     #[test]
     fn plain_composite_draws_nothing() {
         let s = session();
diff --git a/crates/ui-egui/src/channels_panel.rs b/crates/ui-egui/src/channels_panel.rs
index 4d9ee00a4e..f232384139 100644
--- a/crates/ui-egui/src/channels_panel.rs
+++ b/crates/ui-egui/src/channels_panel.rs
@@ -2,6 +2,8 @@
 //! rows with thumbnails and eye toggles. Every action is an engine command (`channel.*`,
 //! `select.loadSelection`, `select.saveSelection`, …); the targeted channel and the eyes live in
 //! the engine's `DocState::channel_view`, so agents see the same state through `inspect`.
+//! Rows can be dragged onto the footer's buttons, as in Photoshop (#4689): New duplicates the
+//! channel, Delete deletes it, and Load Channel as Selection loads it.
 
 use egui::{Align2, Color32, Rect, RichText, Sense, Stroke, StrokeKind, pos2, vec2};
 use photocraft_doc::ColorIndicates;
@@ -11,7 +13,7 @@ use serde_json::{Value, json};
 use crate::theme::{self, Tokens};
 use crate::{PhotocraftApp, icons, widgets};
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 enum Row {
     Composite,
     Color(usize),
@@ -63,7 +65,7 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let ctx = ui.ctx().clone();
     let thumbs = app.channel_thumbs(&ctx);
     // The active layer's mask (Photoshop lists it, in italics, below the colour channels).
-    let masked = active_layer.and_then(|id| doc.layer(id)).filter(|l| l.mask.is_some()).cloned();
+    let masked = active_layer.and_then(|id| doc.layer(id)).filter(|l| l.mask.is_some());
     let mask_tex = masked.as_ref().and_then(|l| Some(app.mask_thumb(&ctx, &doc, l.id, l.mask.as_ref()?)));
     let mask_targeted = masked.is_some()
         && (app.ui.mask_target || view.target == ChannelTarget::LayerMask)
@@ -122,7 +124,10 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                 }
             };
             let row_h = if t.pro { 36.0 } else { 40.0 };
-            let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), row_h), Sense::click());
+            let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), row_h), Sense::click_and_drag());
+            if resp.drag_started() {
+                ctx.data_mut(|d| d.insert_temp(drag_id(), (row, name.clone())));
+            }
             let painter = ui.painter_at(rect.expand(1.0));
             if selected {
                 painter.rect_filled(rect, if t.pro { 0.0 } else { t.radius }, if t.pro { t.row_selected } else { t.hover });
@@ -212,8 +217,16 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                     actions.push(("channel.target".into(), json!({ "channel": target })));
                 }
             }
+            // Like Photoshop: double-clicking the thumbnail opens Channel Options (where an alpha
+            // channel becomes a spot channel, #3761), double-clicking the name renames it.
+            let on_thumb = resp.interact_pointer_pos().is_some_and(|p| p.x < cell.right() + 4.0);
+            if row == Row::QuickMask && resp.double_clicked() {
+                actions.push(("ui.channelOptions".into(), json!("quickMask")));
+            }
             if let Row::Alpha(i) = row {
-                if resp.double_clicked() {
+                if resp.double_clicked() && on_thumb {
+                    actions.push(("ui.channelOptions".into(), json!(i)));
+                } else if resp.double_clicked() {
                     ctx.data_mut(|d| d.insert_temp(rename_id, name.clone()));
                 }
                 if let Some(mut text) = ctx.data(|d| d.get_temp::<String>(rename_id)) {
@@ -245,6 +258,7 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                             item(ui, a, "Duplicate Channel", "channel.duplicate", json!({ "channel": i }));
                             item(ui, a, "Delete Channel", "channel.delete", json!({ "channel": i }));
                             item(ui, a, "Rename Channel…", "ui.renameChannel", json!(i));
+                            item(ui, a, "Channel Options…", "ui.channelOptions", json!(i));
                             ui.separator();
                             if ch.spot.is_some() {
                                 item(ui, a, "Merge Spot Channel", "channel.mergeSpot", json!({ "channel": i }));
@@ -256,6 +270,7 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                         }
                         Row::QuickMask => {
                             item(ui, a, "Exit Quick Mask", "select.editInQuickMaskMode", json!({ "on": false }));
+                            item(ui, a, "Quick Mask Options…", "ui.channelOptions", json!("quickMask"));
                             indicates_items(ui, a, json!("quickMask"), doc.quick_mask.as_ref().map(|q| q.indicates).unwrap_or_default());
                             overlay_colors(ui, a, json!("quickMask"));
                         }
@@ -270,7 +285,7 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                     }
                     ui.separator();
                     item(ui, a, "New Channel…", "channel.new", json!({}));
-                    item(ui, a, "New Spot Channel…", "channel.newSpot", json!({}));
+                    item(ui, a, "New Spot Channel…", "ui.newSpotChannel", json!({}));
                     ui.separator();
                     item(ui, a, "Split Channels", "channel.split", json!({}));
                     item(ui, a, "Merge Channels…", "channel.merge", json!({}));
@@ -278,6 +293,19 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             });
         }
     });
+    // A row being dragged: its name follows the pointer until it is dropped.
+    let dragged = ctx.data(|d| d.get_temp::<(Row, String)>(drag_id()));
+    if let Some((_, name)) = &dragged
+        && let Some(p) = ctx.input(|i| i.pointer.interact_pos())
+    {
+        crate::layer_transfer::ghost(&ctx, p, name);
+    }
+    let mask_layer = masked.as_ref().map(|l| l.id.0);
+    let drop = |ui: &egui::Ui, button: &egui::Response, on: Footer| {
+        let (row, name) = dragged.as_ref()?;
+        let action = drop_action(*row, name, mask_layer, on)?;
+        crate::panels::dropped_on(ui, button).then_some(action)
+    };
     // Photoshop's order from the left: Load as selection, Save selection, New, Delete.
     widgets::panel_footer(ui, |ui| {
         let target_ref = match view.target {
@@ -287,19 +315,29 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             ChannelTarget::LayerMask => json!("mask"),
             ChannelTarget::VectorMask => json!("vectorMask"),
         };
-        if icons::button(ui, "trash", 26.0, false, tl!("Delete current channel")).clicked() {
+        let trash = icons::button(ui, "trash", 26.0, false, tl!("Delete current channel"));
+        if trash.clicked() {
             actions.push(("channel.delete".into(), json!({})));
         }
-        if icons::button(ui, "plus", 26.0, false, tl!("Create new channel")).clicked() {
+        actions.extend(drop(ui, &trash, Footer::Delete));
+        let new = icons::button(ui, "plus", 26.0, false, tl!("Create new channel"));
+        if new.clicked() {
             actions.push(("channel.new".into(), json!({})));
         }
+        actions.extend(drop(ui, &new, Footer::New));
         if icons::button(ui, "square-dashed", 26.0, false, tl!("Save selection as channel")).clicked() {
             actions.push(("select.saveSelection".into(), json!({})));
         }
-        if icons::button(ui, "circle-dashed", 26.0, false, tl!("Load channel as selection")).clicked() {
+        let load = icons::button(ui, "circle-dashed", 26.0, false, tl!("Load channel as selection"));
+        if load.clicked() {
             actions.push(("select.loadSelection".into(), json!({ "channel": target_ref })));
         }
+        actions.extend(drop(ui, &load, Footer::Load));
     });
+    // The drag ends on any release, after the buttons have had a chance to take the drop.
+    if ctx.input(|i| i.pointer.any_released()) {
+        ctx.data_mut(|d| d.remove::<(Row, String)>(drag_id()));
+    }
     ctx.data_mut(|d| d.insert_temp(thumbs_id(), drawn));
     for (id, p) in actions {
         if id == "ui.renameChannel" {
@@ -309,6 +347,14 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             }
             continue;
         }
+        if id == "ui.newSpotChannel" {
+            crate::channel_options_ui::open_new_spot(app);
+            continue;
+        }
+        if id == "ui.channelOptions" {
+            crate::channel_options_ui::open(app, &p);
+            continue;
+        }
         let _ = app.run(&id, p);
     }
     if let Some(on) = mask_click {
@@ -317,6 +363,35 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     }
 }
 
+/// The footer buttons a row can be dropped on.
+#[derive(Clone, Copy)]
+enum Footer {
+    Delete,
+    New,
+    Load,
+}
+
+/// What dropping `row` (named `name`) on a footer button does, as in Photoshop; `None` where
+/// Photoshop does nothing either (colour channels can't be deleted here). `mask_layer` is the
+/// layer whose mask the temporary mask row shows.
+fn drop_action(row: Row, name: &str, mask_layer: Option<u64>, on: Footer) -> Option<(String, Value)> {
+    match (on, row) {
+        (Footer::Delete, Row::Alpha(i)) => Some(("channel.delete".into(), json!({ "channel": i }))),
+        // Asks "Apply mask to layer before removing?", like dropping the mask's Layers thumbnail.
+        (Footer::Delete, Row::LayerMask) => Some(crate::mask_trash_prompt::drop_action(mask_layer?, crate::mask_thumbs_ui::MaskKind::Pixel)),
+        (Footer::Delete, _) => None,
+        // The engine would name a mask's copy after the composite; Photoshop says "Layer 1 Mask copy".
+        (Footer::New, Row::LayerMask) => Some(("channel.duplicate".into(), json!({ "channel": "mask", "name": format!("{name} copy") }))),
+        (Footer::New, _) => Some(("channel.duplicate".into(), json!({ "channel": row.reference() }))),
+        (Footer::Load, Row::LayerMask) => Some(("select.loadSelection".into(), json!({ "channel": "mask", "layer": mask_layer? }))),
+        (Footer::Load, _) => Some(("select.loadSelection".into(), json!({ "channel": row.reference() }))),
+    }
+}
+
+fn drag_id() -> egui::Id {
+    egui::Id::new("channel-row-drag")
+}
+
 fn thumbs_id() -> egui::Id {
     egui::Id::new("channel-thumb-rects")
 }
@@ -425,4 +500,150 @@ mod tests {
         let thumbs_color = app.channel_thumbs(&ctx);
         assert_eq!(thumbs_gray.len(), thumbs_color.len());
     }
+
+    /// A selection-only step keeps the thumbnails; a pixel edit rebuilds them into the same
+    /// textures rather than new ones (#4518).
+    #[test]
+    fn channel_thumbs_skip_selection_steps_and_reuse_textures() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
+        let ctx = egui::Context::default();
+        // Texture uploads one pass makes (new textures and updates both count).
+        let pass = |app: &mut PhotocraftApp| {
+            ctx.begin_pass(Default::default());
+            let ids = app.channel_thumbs(&ctx);
+            let mut delta = ctx.end_pass().textures_delta;
+            let n = delta.set.len();
+            delta.clear();
+            (ids, n)
+        };
+        let (first, uploads) = pass(&mut app);
+        assert!(uploads > 0);
+        app.run("select.rect", json!({"x": 4, "y": 4, "width": 20, "height": 20})).unwrap();
+        assert_eq!(pass(&mut app), (first.clone(), 0), "a marquee changes no pixels");
+        app.run("select.deselect", json!({})).unwrap();
+        assert_eq!(pass(&mut app), (first.clone(), 0), "neither does Deselect");
+        app.run("edit.fill", json!({"color": "#336699"})).unwrap();
+        let (after, uploads) = pass(&mut app);
+        assert!(uploads > 0, "a fill rebuilds them");
+        assert_eq!(after, first, "into the same textures");
+    }
+
+    /// The Channels tab (the Layers card's second tab) of a 64×48 white document with a layer
+    /// mask on "Masked" and one alpha channel.
+    fn channels_harness() -> (egui_kittest::Harness<'static, PhotocraftApp>, u64) {
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 64, "height": 48})).unwrap();
+        let masked = s.execute("layer.new.layer", json!({"name": "Masked"})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("layer.layerMask.revealAll", json!({"layer": masked})).unwrap();
+        s.execute("channel.new", json!({})).unwrap();
+        let mut h = egui_kittest::Harness::builder().with_size(vec2(1440.0, 1000.0)).with_max_steps(64).build_eframe(move |cc| {
+            PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+            PhotocraftApp::new(s, crate::Services::default())
+        });
+        let ctx = h.ctx.clone();
+        let (req, _rx) = crate::control::ControlRequest::new(
+            "ui.set",
+            json!({"dockWidth": 290.0, "dockTabs": {"layers": 1}, "dock": {"collapsed": ["color", "properties", "history", "navigator"]}}),
+        );
+        crate::control::handle(h.state_mut(), &ctx, &req);
+        h.run_steps(8);
+        (h, masked)
+    }
+
+    /// The centre of the row or button labelled `label` (not its tooltip, which a hover leaves open).
+    fn at(h: &egui_kittest::Harness<'_, PhotocraftApp>, label: &str) -> egui::Pos2 {
+        use egui::accesskit::Role;
+        use egui_kittest::kittest::{NodeT, Queryable};
+        h.query_all_by_label(label)
+            .find(|n| matches!(n.accesskit_node().role(), Role::Button | Role::ListBoxOption | Role::Label) && n.rect().height() > 20.0)
+            .unwrap_or_else(|| panic!("no row or button {label}"))
+            .rect()
+            .center()
+    }
+
+    /// A real press, drag and release.
+    fn drag(h: &mut egui_kittest::Harness<'_, PhotocraftApp>, from: egui::Pos2, to: egui::Pos2) {
+        use egui::{Modifiers, PointerButton};
+        h.hover_at(from);
+        h.run_steps(1);
+        h.event(egui::Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+        h.run_steps(1);
+        for i in 1..=6 {
+            h.hover_at(from + (to - from) * (i as f32 / 6.0));
+            h.run_steps(1);
+        }
+        h.event(egui::Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+        h.run_steps(3);
+    }
+
+    /// Drags the row or button labelled `from` onto the one labelled `to`.
+    fn drag_to(h: &mut egui_kittest::Harness<'_, PhotocraftApp>, from: &str, to: &str) {
+        let (from, to) = (at(h, from), at(h, to));
+        drag(h, from, to);
+    }
+
+    fn alphas(h: &egui_kittest::Harness<'_, PhotocraftApp>) -> Vec<String> {
+        h.state().session.active().unwrap().doc.channels.iter().map(|c| c.name.clone()).collect()
+    }
+
+    /// #4689: as in Photoshop, a channel dropped on New is duplicated, on Delete deleted, and on
+    /// Load Channel as Selection loaded.
+    #[test]
+    fn rows_dropped_on_the_footer_duplicate_delete_and_load() {
+        let (mut h, _) = channels_harness();
+        assert_eq!(alphas(&h), ["Alpha 1"]);
+        let steps = h.state().session.active().unwrap().history.past_len();
+
+        drag_to(&mut h, "Alpha 1", "Create new channel");
+        assert_eq!(alphas(&h), ["Alpha 1", "Alpha 1 copy"]);
+        assert_eq!(h.state().session.active().unwrap().history.past_len(), steps + 1, "one history step");
+        drag_to(&mut h, "Red", "Create new channel");
+        assert_eq!(alphas(&h), ["Alpha 1", "Alpha 1 copy", "Red copy"]);
+        drag_to(&mut h, "Masked Mask", "Create new channel");
+        assert_eq!(alphas(&h), ["Alpha 1", "Alpha 1 copy", "Red copy", "Masked Mask copy"]);
+
+        drag_to(&mut h, "Alpha 1 copy", "Delete current channel");
+        assert_eq!(alphas(&h), ["Alpha 1", "Red copy", "Masked Mask copy"]);
+        // Colour channels stay: Photoshop would turn the image into Multichannel.
+        drag_to(&mut h, "Green", "Delete current channel");
+        assert_eq!(alphas(&h), ["Alpha 1", "Red copy", "Masked Mask copy"]);
+        assert_eq!(h.state().session.active().unwrap().doc.mode, photocraft_doc::ColorMode::Rgb);
+
+        assert!(h.state().session.active().unwrap().doc.selection.is_none());
+        drag_to(&mut h, "Red copy", "Load channel as selection");
+        assert!(h.state().session.active().unwrap().doc.selection.is_some(), "the white channel selects everything");
+    }
+
+    /// A plain click on a row still targets it, and a drag released elsewhere does nothing.
+    #[test]
+    fn clicks_still_target_and_a_drop_elsewhere_does_nothing() {
+        let (mut h, _) = channels_harness();
+        let p = at(&h, "Alpha 1");
+        h.hover_at(p);
+        h.run_steps(1);
+        h.event(egui::Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
+        h.run_steps(1);
+        h.event(egui::Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
+        h.run_steps(3);
+        assert_eq!(h.state().session.active().unwrap().channel_view.target, ChannelTarget::Alpha(0));
+
+        let steps = h.state().session.active().unwrap().history.past_len();
+        let (from, to) = (at(&h, "Alpha 1"), at(&h, "Blue"));
+        drag(&mut h, from, to);
+        drag_to(&mut h, "Alpha 1", "Save selection as channel");
+        assert_eq!(alphas(&h), ["Alpha 1"]);
+        assert_eq!(h.state().session.active().unwrap().history.past_len(), steps, "nothing ran");
+        assert!(h.ctx.data(|d| d.get_temp::<(Row, String)>(drag_id())).is_none(), "the drag ended");
+    }
+
+    /// The layer mask's row asks "Apply mask to layer before removing?", like its Layers thumbnail.
+    #[test]
+    fn the_layer_mask_row_on_the_trash_asks_first() {
+        let (mut h, masked) = channels_harness();
+        drag_to(&mut h, "Masked Mask", "Delete current channel");
+        assert!(h.state().ui.dialogs.iter().any(|d| crate::mask_trash_prompt::owns(&d.fields)), "the prompt is open");
+        let st = h.state().session.active().unwrap();
+        assert!(st.doc.layer(photocraft_doc::LayerId(masked)).unwrap().mask.is_some(), "nothing deleted yet");
+    }
 }
diff --git a/crates/ui-egui/src/chrome_ui.rs b/crates/ui-egui/src/chrome_ui.rs
index 81cf0fce54..b20e913a7d 100644
--- a/crates/ui-egui/src/chrome_ui.rs
+++ b/crates/ui-egui/src/chrome_ui.rs
@@ -22,7 +22,14 @@ pub struct ChromeState {
 impl ChromeState {
     /// Is the Home screen up, given the current number of open documents? With no documents it
     /// shows by itself when `auto_show` (Preferences › General › Auto show the Home Screen).
-    pub fn shows_home(&self, documents: usize, auto_show: bool) -> bool {
+    ///
+    /// `home` stores the document count when Home was opened so File › New / Open can leave it.
+    /// Closing a tab that returns to that count must not bring Home back (#3981): once the
+    /// document set has changed, the overlay is gone until the user opens Home again.
+    pub fn shows_home(&mut self, documents: usize, auto_show: bool) -> bool {
+        if self.home.is_some_and(|n| n != documents) {
+            self.home = None;
+        }
         (documents == 0 && auto_show) || self.home == Some(documents)
     }
 }
@@ -149,7 +156,7 @@ pub fn status_bar_pro(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     );
     let mut pct = app.ui.views[i].zoom * 100.0;
     let control_h = crate::panels::status_bar_heights(&t).1;
-    if widgets::compact_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[i]), "%", 64.0, control_h).changed() {
+    if widgets::compact_wrapping_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[i]), "%", vec2(64.0, control_h)).changed() {
         app.ui.views[i].zoom = crate::zoom_levels::clamp(pct / 100.0, app.ui.views[i].doc_size);
         app.ui.views[i].fit_pending = false;
     }
@@ -332,7 +339,7 @@ mod tests {
         let mut gray = doc();
         gray.mode = photocraft_doc::ColorMode::Grayscale;
         gray.icc_profile = Some(photocraft_engine::color_cmds::working_profile(gray.mode).to_bytes());
-        assert_eq!(profile_name(&gray), "sGray (sRGB tone curve, Photocraft)");
+        assert_eq!(profile_name(&gray), "Dot Gain 20%-compatible (gamma 1.732, Photocraft)");
 
         let mut custom = (*photocraft_engine::color_cmds::working_profile(photocraft_doc::ColorMode::Cmyk)).clone();
         custom.description = "PhotoCraft Studio CMYK".into();
@@ -377,6 +384,30 @@ mod tests {
         c.home = Some(2);
         assert!(c.shows_home(2, true));
         assert!(!c.shows_home(3, true));
+        assert!(c.home.is_none(), "leaving Home by opening a document dismisses it");
+        c.home = Some(1);
+        assert!(!c.shows_home(2, true));
+        assert!(!c.shows_home(1, true), "closing back to the stored count must not re-open Home");
+        assert!(c.home.is_none());
+    }
+
+    #[test]
+    fn closing_a_tab_does_not_return_to_home() {
+        use crate::PhotocraftApp;
+        use photocraft_engine::Session;
+        use serde_json::json;
+
+        let mut app = PhotocraftApp::new(Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 8, "height": 8, "name": "Keep"})).unwrap();
+        let n = app.session.documents().len();
+        app.ui.chrome.home = Some(n);
+        assert!(app.ui.chrome.shows_home(n, true));
+        app.run("file.new", json!({"width": 8, "height": 8, "name": "Other"})).unwrap();
+        assert!(!app.ui.chrome.shows_home(app.session.documents().len(), true));
+        app.run("file.close", json!({"document": 1, "discard": true})).unwrap();
+        assert_eq!(app.session.documents().len(), 1);
+        assert!(!app.ui.chrome.shows_home(1, true), "Home must stay dismissed after closing the extra tab");
+        assert_eq!(app.session.documents()[0].doc.name, "Keep");
     }
 
     #[test]
diff --git a/crates/ui-egui/src/cjk_fonts.rs b/crates/ui-egui/src/cjk_fonts.rs
index e5166310e2..e4c2739fb4 100644
--- a/crates/ui-egui/src/cjk_fonts.rs
+++ b/crates/ui-egui/src/cjk_fonts.rs
@@ -285,37 +285,60 @@ fn missing_char(ctx: &egui::Context, shapes: &[egui::epaint::ClippedShape], fall
     ctx.fonts_mut(|f| chars.into_iter().find(|c| !f.has_glyph(&font, *c)))
 }
 
-/// (ascent, descent, line gap) of a face in em, from its `hhea` table; `descent` is negative.
-fn vertical_metrics(font: &[u8], index: u32) -> Option<(f32, f32, f32)> {
-    let u16_at = |o: usize| font.get(o..o.checked_add(2)?).map(|b| u16::from_be_bytes([b[0], b[1]]));
-    let u32_at = |o: usize| font.get(o..o.checked_add(4)?).map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]));
-    let i16_at = |o: usize| u16_at(o).map(|v| v as i16 as f32);
+/// Big-endian readers over a font's bytes; `None` past the end.
+fn be_u16(font: &[u8], o: usize) -> Option<u16> {
+    font.get(o..o.checked_add(2)?).map(|b| u16::from_be_bytes([b[0], b[1]]))
+}
+
+fn be_u32(font: &[u8], o: usize) -> Option<u32> {
+    font.get(o..o.checked_add(4)?).map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]))
+}
+
+/// The offset of table `tag` in face `index` of `font` (a collection or a single face).
+fn table_offset(font: &[u8], index: u32, tag: &[u8; 4]) -> Option<usize> {
     let dir = if font.get(..4)? == b"ttcf" {
         // Collection: the offset table of face `index` follows a 12-byte header.
-        u32_at(12usize.checked_add((index as usize).checked_mul(4)?)?)? as usize
+        be_u32(font, 12usize.checked_add((index as usize).checked_mul(4)?)?)? as usize
     } else {
         0
     };
-    let tables = u16_at(dir.checked_add(4)?)? as usize;
-    let (mut hhea, mut head) = (None, None);
-    for i in 0..tables {
+    let tables = be_u16(font, dir.checked_add(4)?)? as usize;
+    (0..tables).find_map(|i| {
         let rec = dir.checked_add(12)?.checked_add(i.checked_mul(16)?)?;
-        let tag = font.get(rec..rec.checked_add(4)?)?;
-        let off = u32_at(rec.checked_add(8)?)? as usize;
-        match tag {
-            b"hhea" => hhea = Some(off),
-            b"head" => head = Some(off),
-            _ => {}
-        }
-    }
-    let (hhea, head) = (hhea?, head?);
-    let upm = u16_at(head.checked_add(18)?)? as f32;
+        (font.get(rec..rec.checked_add(4)?)? == tag).then_some(())?;
+        Some(be_u32(font, rec.checked_add(8)?)? as usize)
+    })
+}
+
+/// (ascent, descent, line gap) of a face in em, from its `hhea` table; `descent` is negative.
+fn vertical_metrics(font: &[u8], index: u32) -> Option<(f32, f32, f32)> {
+    let i16_at = |o: usize| be_u16(font, o).map(|v| v as i16 as f32);
+    let (hhea, head) = (table_offset(font, index, b"hhea")?, table_offset(font, index, b"head")?);
+    let upm = be_u16(font, head.checked_add(18)?)? as f32;
     if upm <= 0.0 {
         return None;
     }
     Some((i16_at(hhea.checked_add(4)?)? / upm, i16_at(hhea.checked_add(6)?)? / upm, i16_at(hhea.checked_add(8)?)? / upm))
 }
 
+/// The weight a variable face should be drawn at: Regular (400) within its `wght` axis, or
+/// `None` when it has no weight axis or already defaults to Regular. Noto Sans CJK's variable
+/// collection defaults to Thin (100), so the UI's CJK text came out hairline (#4820).
+fn regular_weight(font: &[u8], index: u32) -> Option<f32> {
+    let fvar = table_offset(font, index, b"fvar")?;
+    let axes = fvar.checked_add(be_u16(font, fvar.checked_add(4)?)? as usize)?;
+    let count = be_u16(font, fvar.checked_add(8)?)? as usize;
+    let size = be_u16(font, fvar.checked_add(10)?)? as usize;
+    let fixed = |o: usize| be_u32(font, o).map(|v| v as i32 as f32 / 65536.0);
+    (0..count.min(64)).find_map(|i| {
+        let rec = axes.checked_add(i.checked_mul(size)?)?;
+        (font.get(rec..rec.checked_add(4)?)? == b"wght").then_some(())?;
+        let (min, default, max) = (fixed(rec.checked_add(4)?)?, fixed(rec.checked_add(8)?)?, fixed(rec.checked_add(12)?)?);
+        let regular = 400f32.clamp(min.min(max), max.max(min));
+        (regular.is_finite() && (regular - default).abs() > 0.5).then_some(regular)
+    })
+}
+
 /// `y_offset_factor` that puts `face`'s baseline where `primary`'s would be. egui centres a
 /// fallback face's row in the primary font's row, so a face with a big line gap (Hiragino: 0.5em)
 /// otherwise rides about 0.23em high next to Latin text.
@@ -332,6 +355,9 @@ fn add_to_all_families(ctx: &egui::Context, name: String, mut data: FontData) {
     if let (Some(face), Some(primary)) = (vertical_metrics(&data.font, data.index), primary) {
         data.tweak.y_offset_factor = baseline_offset(face, primary);
     }
+    if let Some(weight) = regular_weight(&data.font, data.index) {
+        data.tweak.coords = egui::epaint::text::VariationCoords::new([(b"wght", weight)]);
+    }
     let mut families: Vec<FontFamily> = ctx.fonts(|f| f.definitions().families.keys().cloned().collect());
     for f in [FontFamily::Proportional, FontFamily::Monospace] {
         if !families.contains(&f) {
@@ -427,6 +453,68 @@ mod tests {
         }
     }
 
+    /// A font holding only an `fvar` table with the given axes (tag, min, default, max), as a
+    /// single face or as face 1 of a two-face collection.
+    fn fvar_font(axes: &[(&[u8; 4], f32, f32, f32)], collection: bool) -> Vec<u8> {
+        let fixed = |v: f32| ((v * 65536.0) as i32).to_be_bytes();
+        let mut fvar = Vec::new();
+        for x in [1u16, 0, 16, 2, axes.len() as u16, 20, 0, 0] {
+            fvar.extend(x.to_be_bytes());
+        }
+        for (tag, min, def, max) in axes {
+            fvar.extend(*tag);
+            for v in [*min, *def, *max] {
+                fvar.extend(fixed(v));
+            }
+            fvar.extend([0, 0, 1, 0]);
+        }
+        let face = |at: u32| {
+            let mut d = vec![0, 1, 0, 0, 0, 1, 0, 16, 0, 0, 0, 0];
+            d.extend(b"fvar");
+            d.extend([0; 4]);
+            d.extend(at.to_be_bytes());
+            d.extend((fvar.len() as u32).to_be_bytes());
+            d
+        };
+        if !collection {
+            let mut f = face(28);
+            f.extend(&fvar);
+            return f;
+        }
+        // ttcf header (12 + 2×4), two 28-byte directories, then the shared table.
+        let mut f = b"ttcf".to_vec();
+        f.extend([0, 1, 0, 0, 0, 0, 0, 2]);
+        f.extend(20u32.to_be_bytes());
+        f.extend(48u32.to_be_bytes());
+        f.extend(face(76));
+        f.extend(face(76));
+        f.extend(&fvar);
+        f
+    }
+
+    /// #4820: Noto Sans CJK's variable collection defaults to Thin; the fallback asks for Regular.
+    #[test]
+    fn variable_fallbacks_are_drawn_at_regular_weight() {
+        let thin = fvar_font(&[(b"wght", 100.0, 100.0, 900.0)], true);
+        assert_eq!(regular_weight(&thin, 1), Some(400.0), "Noto Sans CJK VF, face 1 of a collection");
+        assert_eq!(regular_weight(&fvar_font(&[(b"wdth", 75.0, 100.0, 100.0), (b"wght", 100.0, 100.0, 900.0)], false), 0), Some(400.0));
+        assert_eq!(regular_weight(&fvar_font(&[(b"wght", 500.0, 600.0, 900.0)], false), 0), Some(500.0), "Regular clamped into the axis");
+        assert_eq!(regular_weight(&fvar_font(&[(b"wght", 100.0, 400.0, 900.0)], false), 0), None, "already Regular");
+        assert_eq!(regular_weight(&fvar_font(&[(b"wdth", 75.0, 100.0, 100.0)], false), 0), None, "no weight axis");
+        assert_eq!(regular_weight(photocraft_text::fonts::INTER_REGULAR.as_slice(), 0), None, "static font");
+        for bad in [&thin[..thin.len() - 9], &thin[..30], &b"ttcf"[..], &[][..]] {
+            assert_eq!(regular_weight(bad, 1), None);
+        }
+        // Registered as a fallback, a static face keeps the default (no variation) coordinates.
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        ctx.run_ui(Default::default(), |_| {}).textures_delta.clear();
+        add_to_all_families(&ctx, "test-static".into(), FontData::from_static(photocraft_text::fonts::INTER_REGULAR.as_slice()));
+        ctx.run_ui(Default::default(), |_| {}).textures_delta.clear();
+        let fonts = ctx.fonts(|f| f.definitions().clone());
+        assert_eq!(fonts.font_data.get("test-static").map(|d| d.tweak.coords.clone()), Some(Default::default()));
+    }
+
     static DIR: Mutex<Option<PathBuf>> = Mutex::new(None);
 
     #[test]
diff --git a/crates/ui-egui/src/color_picker_ui.rs b/crates/ui-egui/src/color_picker_ui.rs
index dc57de68b4..0d51f5d2f5 100644
--- a/crates/ui-egui/src/color_picker_ui.rs
+++ b/crates/ui-egui/src/color_picker_ui.rs
@@ -171,7 +171,12 @@ pub fn open(app: &mut PhotocraftApp, target: &str) -> u64 {
     let c = if target == "background" { app.session.tools.background } else { app.session.tools.foreground };
     let rgb = [c[0], c[1], c[2]];
     let label = if target == "background" { "Color Picker (Background Color)" } else { "Color Picker (Foreground Color)" };
-    app.ui.open_dialog(DialogKind::Command, initial_fields(target, label, rgb))
+    let mut fields = initial_fields(target, label, rgb);
+    // A colour that was picked as CMYK shows the inks it was picked as, not what its sRGB stand-in converts to (#4196).
+    if let Some(cmyk) = app.session.tools.picked_cmyk(rgb) {
+        fields.insert("__cmyk".into(), json!(cmyk));
+    }
+    app.ui.open_dialog(DialogKind::Command, fields)
 }
 
 /// Shared initial state for every target; the picker layout is independent of its destination.
@@ -298,6 +303,15 @@ pub fn owns(f: &Map<String, Value>) -> bool {
     f.contains_key("__colorPicker")
 }
 
+/// Alt+Cancel (Reset): restore the colour from when the picker opened (same as clicking Current).
+pub fn reset(f: &mut Map<String, Value>) {
+    if !owns(f) {
+        return;
+    }
+    let orig = f.get("__orig").and_then(Value::as_str).and_then(parse_hex).unwrap_or([0.0; 3]);
+    set_rgb(f, orig, Keep::Nothing);
+}
+
 /// The Color Picker, when it is the top dialog (another dialog opened over it takes the input).
 pub fn top(app: &PhotocraftApp) -> Option<u64> {
     app.ui.dialogs.last().filter(|d| owns(&d.fields)).map(|d| d.id)
@@ -391,6 +405,36 @@ fn grid_mesh(rect: Rect, n: usize, color: impl Fn(f32, f32) -> [f32; 3]) -> Mesh
     m
 }
 
+/// Cells per side of the banded Only Web Colors field: fine enough that the band edges follow the
+/// colour model, coarse enough to stay cheap to draw each frame.
+const WEB_CELLS: usize = 64;
+
+/// Snap each channel to the web-safe ramp (00, 33, 66, 99, CC, FF).
+fn web_safe(c: [f32; 3]) -> [f32; 3] {
+    c.map(|v| (v.clamp(0.0, 1.0) * 5.0).round() / 5.0)
+}
+
+/// Like [`grid_mesh`], but every cell is one flat colour sampled at its centre, so a quantized
+/// field shows hard bands instead of blending between the snapped corners.
+fn flat_grid_mesh(rect: Rect, n: usize, color: impl Fn(f32, f32) -> [f32; 3]) -> Mesh {
+    let mut m = Mesh::default();
+    let n = n.max(1);
+    let (cw, ch) = (rect.width() / n as f32, rect.height() / n as f32);
+    for j in 0..n {
+        for i in 0..n {
+            let c = c32(color((i as f32 + 0.5) / n as f32, (j as f32 + 0.5) / n as f32));
+            let (x0, y0) = (rect.left() + i as f32 * cw, rect.top() + j as f32 * ch);
+            let a = m.vertices.len() as u32;
+            for (dx, dy) in [(0.0, 0.0), (cw, 0.0), (cw, ch), (0.0, ch)] {
+                m.colored_vertex(pos2(x0 + dx, y0 + dy), c);
+            }
+            m.add_triangle(a, a + 1, a + 2);
+            m.add_triangle(a, a + 2, a + 3);
+        }
+    }
+    m
+}
+
 /// Room for both component columns, including units, without overflowing the title's width; with
 /// the frame and title the window fits Photoshop's (about 534 x 376 points).
 pub(crate) const CONTENT_WIDTH: f32 = 488.0;
@@ -460,7 +504,12 @@ fn color_field(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
     let (fx, fy, fz) = locate(&mode, hsv, rgb, lab);
     // Colour field.
     let (field, resp) = ui.allocate_exact_size(vec2(FIELD, FIELD), Sense::click_and_drag());
-    ui.painter().add(grid_mesh(field, 32, |x, y| field_color(&mode, fz, x, y)));
+    let web_only = f.get("__webOnly").and_then(Value::as_bool).unwrap_or(false);
+    // Only Web Colors bands the field to the 216 web-safe colours, as in Photoshop (#4107).
+    let mesh = |rect: Rect, color: &dyn Fn(f32, f32) -> [f32; 3]| {
+        if web_only { flat_grid_mesh(rect, WEB_CELLS, |x, y| web_safe(color(x, y))) } else { grid_mesh(rect, 32, color) }
+    };
+    ui.painter().add(mesh(field, &|x, y| field_color(&mode, fz, x, y)));
     ui.painter().rect_stroke(field, 0.0, Stroke::new(1.0, t.field_border), StrokeKind::Outside);
     let marker = pos2(field.left() + fx * field.width(), field.top() + fy * field.height());
     ui.painter().circle_stroke(marker, 5.0, Stroke::new(1.5, if hsv[2] > 0.6 && hsv[1] < 0.4 { Color32::BLACK } else { Color32::WHITE }));
@@ -477,7 +526,7 @@ fn color_field(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
     }
     // Component slider (hue runs 360° at the top to 0° at the bottom, like Photoshop).
     let (strip, sresp) = ui.allocate_exact_size(vec2(18.0, FIELD), Sense::click_and_drag());
-    ui.painter().add(grid_mesh(strip, 32, |_, y| slider_color(&mode, 1.0 - y, hsv, rgb, lab)));
+    ui.painter().add(mesh(strip, &|_, y| slider_color(&mode, 1.0 - y, hsv, rgb, lab)));
     let sy = strip.top() + (1.0 - fz) * strip.height();
     for (x, dir) in [(strip.left() - 1.0, 1.0f32), (strip.right() + 1.0, -1.0)] {
         let tri = vec![pos2(x, sy), pos2(x - 6.0 * dir, sy - 4.0), pos2(x - 6.0 * dir, sy + 4.0)];
@@ -637,8 +686,8 @@ fn fields(ui: &mut egui::Ui, f: &mut Map<String, Value>, mode: &str, now: &Compo
                     ui.memory_mut(|m| m.request_focus(id));
                 }
                 let typing = if ui.memory(|m| m.has_focus(id)) { ui.data(|d| d.get_temp::<String>(id)) } else { None };
-                let mut h = typing.unwrap_or_else(|| hex(rgb).trim_start_matches('#').to_string());
-                let r = ui.add(egui::TextEdit::singleline(&mut h).id(id).char_limit(6).desired_width(64.0).font(crate::theme::mono(12.0)));
+                let mut h = typing.unwrap_or_else(|| hex(rgb).trim_start_matches('#').to_ascii_uppercase());
+                let r = crate::widgets::text_field_ex(ui, id, &mut h, "", 64.0, true, Some(6));
                 if r.gained_focus() {
                     crate::field_tab::select_all(ui.ctx(), id, &h);
                 }
@@ -743,7 +792,12 @@ pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value,
         // The pasteboard menu's Select Custom Color…: the custom colour, and use it.
         return app.run("prefs.set", json!({"values": {"interface.canvasColor": "custom", "interface.canvasCustomColor": color}}));
     }
-    let r = app.run("tools.setColors", json!({ target: color }))?;
+    let mut params = json!({ target: color });
+    // The CMYK values the person entered stay the colour's inks: a CMYK document is filled with them (#4196).
+    if let Some(cmyk) = parse_hex(color).and_then(|rgb| kept::<4>(f, "__cmyk", rgb, photocraft_color::convert::cmyk_to_rgb)) {
+        params[format!("{target}Cmyk")] = json!(cmyk);
+    }
+    let r = app.run("tools.setColors", params)?;
     if target == "foreground" {
         crate::type_tool::foreground_changed(app);
     }
@@ -758,6 +812,23 @@ mod tests {
 
     use super::*;
 
+    /// #4107: with Only Web Colors on, the field is drawn in flat web-safe bands.
+    #[test]
+    fn web_only_field_is_flat_web_safe_bands() {
+        let rect = Rect::from_min_size(pos2(0.0, 0.0), vec2(200.0, 200.0));
+        let m = flat_grid_mesh(rect, WEB_CELLS, |x, y| web_safe(field_color("h", 0.3, x, y)));
+        let ramp = [0u8, 51, 102, 153, 204, 255];
+        for v in &m.vertices {
+            assert!([v.color.r(), v.color.g(), v.color.b()].iter().all(|c| ramp.contains(c)), "{:?}", v.color);
+        }
+        // Each cell's four corners share one colour (no blending between bands).
+        for q in m.vertices.chunks(4) {
+            assert!(q.iter().all(|v| v.color == q[0].color));
+        }
+        let distinct: std::collections::HashSet<_> = m.vertices.iter().map(|v| v.color).collect();
+        assert!(distinct.len() > 1 && distinct.len() <= 216);
+    }
+
     fn picker(color: &str) -> Harness<'static, Map<String, Value>> {
         let mut f = Map::new();
         f.insert("__colorPicker".into(), json!("foreground"));
@@ -788,6 +859,13 @@ mod tests {
         h.state().get("color").and_then(Value::as_str).unwrap().to_string()
     }
 
+    #[test]
+    fn hex_field_shows_uppercase_without_rewriting_the_selected_color() {
+        let h = picker("#12abef");
+        assert_eq!(h.get_by_role(Role::TextInput).value().as_deref(), Some("12ABEF"));
+        assert_eq!(color(&h), "#12abef", "casing is presentation only");
+    }
+
     #[test]
     fn hex_field_takes_typed_digits() {
         let mut h = picker("#000000");
@@ -833,6 +911,18 @@ mod tests {
         assert_eq!(hex([h.state().session.tools.foreground[0], h.state().session.tools.foreground[1], h.state().session.tools.foreground[2]]), "#ff8800");
     }
 
+    #[test]
+    fn alt_reset_restores_orig_color() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.session.tools.foreground = [0.2, 0.4, 0.6, 1.0];
+        let id = open(&mut app, "foreground");
+        let f = &mut app.ui.dialog_mut(id).unwrap().fields;
+        f.insert("color".into(), json!("#ff0000"));
+        reset(f);
+        assert_eq!(f["color"], json!(hex([0.2, 0.4, 0.6])));
+        assert_eq!(f["__orig"], json!(hex([0.2, 0.4, 0.6])));
+    }
+
     #[test]
     fn lab_and_cmyk_fields_take_multi_digit_values() {
         let base = parse_hex("#336699").unwrap();
@@ -1036,6 +1126,24 @@ mod tests {
         assert_eq!(hex([app.session.tools.background[0], app.session.tools.background[1], app.session.tools.background[2]]), "#3366cc");
     }
 
+    /// #4196: CMYK values typed into the picker survive OK, so the colour fills a CMYK document with those inks and
+    /// reopening the picker shows them again.
+    #[test]
+    fn cmyk_values_survive_ok_and_a_reopen() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        let cyan = [1.0, 0.0, 0.0, 0.0];
+        let id = open(&mut app, "foreground");
+        let d = app.ui.dialog_mut(id).unwrap();
+        set_rgb(&mut d.fields, photocraft_color::convert::cmyk_to_rgb(cyan).map(|c| c.clamp(0.0, 1.0)), Keep::Cmyk(cyan));
+        let fields = d.fields.clone();
+        confirm(&mut app, &fields).unwrap();
+        let fg = app.session.tools.foreground;
+        assert_eq!(app.session.tools.picked_cmyk([fg[0], fg[1], fg[2]]), Some(cyan));
+        let id = open(&mut app, "foreground");
+        let again = current(&app.ui.dialogs.iter().find(|d| d.id == id).unwrap().fields);
+        assert_eq!(again.cmyk, cyan);
+    }
+
     fn dialog_color(app: &PhotocraftApp, id: u64) -> &str {
         app.ui.dialogs.iter().find(|d| d.id == id).and_then(|d| d.fields.get("color")).and_then(Value::as_str).unwrap()
     }
diff --git a/crates/ui-egui/src/color_range_ui.rs b/crates/ui-egui/src/color_range_ui.rs
index 18084a6cc1..80417eeec8 100644
--- a/crates/ui-egui/src/color_range_ui.rs
+++ b/crates/ui-egui/src/color_range_ui.rs
@@ -25,8 +25,7 @@ use crate::widgets;
 /// The engine command the dialog drives.
 pub const COMMAND: &str = "select.colorRange";
 
-/// Select menu entries in Photoshop's order (engine value, label). Skin Tones is left out: the
-/// engine has no skin-tone model.
+/// Select menu entries in Photoshop's order (engine value, label).
 pub const SELECTS: &[(&str, &str)] = &[
     ("sampledColors", "Sampled Colors"),
     ("reds", "Reds"),
@@ -38,6 +37,7 @@ pub const SELECTS: &[(&str, &str)] = &[
     ("highlights", "Highlights"),
     ("midtones", "Midtones"),
     ("shadows", "Shadows"),
+    ("skinTones", "Skin Tones"),
     ("outOfGamut", "Out Of Gamut"),
 ];
 
@@ -82,7 +82,7 @@ pub fn controls(f: &Map<String, Value>) -> Controls {
     let select = s(f, "select", "sampledColors");
     let sampled = select == "sampledColors";
     let tonal = matches!(select, "highlights" | "midtones" | "shadows");
-    Controls { fuzziness: sampled || tonal, sampling: sampled, range: sampled && flag(f, "localized"), tonal }
+    Controls { fuzziness: sampled || tonal || select == "skinTones", sampling: sampled, range: sampled && flag(f, "localized"), tonal }
 }
 
 /// Open the dialog with Photoshop's defaults (Sampled Colors, Fuzziness 40, the foreground colour
@@ -141,6 +141,8 @@ pub fn params(f: &Map<String, Value>) -> Value {
             p.insert("localized".into(), json!(true));
             p.insert("range".into(), json!(num(f, "range", 100.0)));
         }
+    } else if select == "skinTones" {
+        p.insert("fuzziness".into(), json!(num(f, "fuzziness", 40.0)));
     } else if c.tonal {
         p.insert("fuzziness".into(), json!(num(f, "toneFuzziness", 20.0)));
         let range = match select {
@@ -390,7 +392,9 @@ fn radio(ui: &mut egui::Ui, on: bool, label: &str) -> egui::Response {
         if on {
             ui.painter().circle_filled(r.center(), 3.0, t.accent);
         }
-        let l = ui.add(egui::Label::new(egui::RichText::new(tl!(&label)).color(t.text_dim)).sense(Sense::click()));
+        let l = ui
+            .add(egui::Label::new(egui::RichText::new(tl!(&label)).color(t.text_dim)).selectable(false).sense(Sense::click()))
+            .on_hover_cursor(egui::CursorIcon::PointingHand);
         resp.union(l)
     })
     .inner
@@ -940,6 +944,11 @@ mod tests {
         assert!(h.query_by_label("Midtones from:").is_some() && h.query_by_label("Midtones to:").is_some());
         set(&mut h, "select", json!("outOfGamut"));
         assert!(disabled(&h, "Fuzziness:") && h.query_by_label("Midtones from:").is_none());
+        // Skin Tones: Fuzziness (the colour one), no eyedroppers or clusters.
+        set(&mut h, "select", json!("skinTones"));
+        assert!(!disabled(&h, "Fuzziness:") && disabled(&h, "Localized Color Clusters") && disabled(&h, "Add to Sample"));
+        let skin: Map<String, Value> = serde_json::from_value(json!({"select": "skinTones", "fuzziness": 25.0, "points": [[1, 1]]})).unwrap();
+        assert_eq!(params(&skin), json!({"select": "skinTones", "invert": false, "fuzziness": 25.0}));
         assert_eq!(
             controls(&serde_json::from_value(json!({"select": "highlights"})).unwrap()),
             Controls { fuzziness: true, sampling: false, range: false, tonal: true }
diff --git a/crates/ui-egui/src/color_replacement_tests.rs b/crates/ui-egui/src/color_replacement_tests.rs
index bfa5037df8..64f04f3c73 100644
--- a/crates/ui-egui/src/color_replacement_tests.rs
+++ b/crates/ui-egui/src/color_replacement_tests.rs
@@ -137,7 +137,8 @@ fn live_stroke_at(depth: u32) {
     tool_event(&mut app, ToolEvent::Up { x: 70.0, y: 20.0 }, m);
     assert!(app.live_stroke.is_none());
     // The preview at the last move is the committed stroke.
-    let level = if depth == 8 { 1.0 / 255.0 + 1e-6 } else { 0.0 };
+    // 8 bits may round a level or two apart between the live working copy and the commit.
+    let level = if depth == 8 { 2.0 / 255.0 + 1e-6 } else { 0.0 };
     for y in 0..40 {
         for x in 0..80 {
             let (got, want) = (shown.rgba(x, y), rgba(&app, x, y));
diff --git a/crates/ui-egui/src/color_tab_theme_tests.rs b/crates/ui-egui/src/color_tab_theme_tests.rs
new file mode 100644
index 0000000000..b3566277e2
--- /dev/null
+++ b/crates/ui-egui/src/color_tab_theme_tests.rs
@@ -0,0 +1,55 @@
+//! The Color panel tab draws Photoshop's spectrum field in every theme (#4367): the light themes
+//! used to show HSB sliders only. Those themes keep the sliders, under the field.
+
+use egui::{Rect, pos2};
+use egui_kittest::kittest::Queryable;
+
+use crate::PhotocraftApp;
+use crate::dock::Group;
+use crate::theme::{ThemeKind, Tokens};
+
+fn left_top() -> egui::Id {
+    egui::Id::new("color-tab-test-origin")
+}
+
+/// The Color tab of `kind`, alone in a 300 pt wide panel, starting from a red foreground.
+fn color_tab(kind: ThemeKind) -> egui_kittest::Harness<'static, PhotocraftApp> {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.session.tools.foreground = [1.0, 0.0, 0.0, 1.0];
+    let tab = Group::Color.tabs(Tokens::for_kind(kind).pro).iter().position(|name| *name == "Color").unwrap();
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(300.0, 400.0)).build_ui_state(
+        move |ui, app: &mut PhotocraftApp| {
+            if ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                let origin = ui.cursor().min;
+                ui.data_mut(|d| d.insert_temp(left_top(), Rect::from_min_size(origin, egui::Vec2::ZERO)));
+                crate::panels::dock_body(app, ui, Group::Color, tab);
+            }
+        },
+        app,
+    );
+    PhotocraftApp::setup_context(&h.ctx, kind);
+    h.run_steps(3);
+    h
+}
+
+#[test]
+fn every_theme_shows_the_spectrum_field() {
+    for kind in ThemeKind::ALL {
+        let mut h = color_tab(kind);
+        let origin = h.ctx.data(|d| d.get_temp::<Rect>(left_top())).unwrap().min;
+        // Left edge of the saturation/brightness field (after the 38 pt chips and the 8 pt gap),
+        // halfway down its 120 pt: no saturation, half brightness.
+        let p = pos2(origin.x + 38.0 + 8.0 + 1.0, origin.y + 60.0);
+        h.hover_at(p);
+        h.run_steps(1);
+        h.drag_at(p);
+        h.run_steps(1);
+        h.drop_at(p);
+        h.run_steps(2);
+        let [r, g, b, _] = h.state().session.tools.foreground;
+        assert!((r - g).abs() < 0.02 && (g - b).abs() < 0.02 && (0.3..0.7).contains(&r), "{kind:?}: the field picks a mid grey, got {r} {g} {b}");
+        if !Tokens::for_kind(kind).pro {
+            assert!(h.query_by_label("Saturation").is_some(), "{kind:?}: the sliders stay under the field");
+        }
+    }
+}
diff --git a/crates/ui-egui/src/comps_ui.rs b/crates/ui-egui/src/comps_ui.rs
index d6dc3e8d82..30304f6c82 100644
--- a/crates/ui-egui/src/comps_ui.rs
+++ b/crates/ui-egui/src/comps_ui.rs
@@ -18,6 +18,12 @@ pub fn target(app: &PhotocraftApp) -> Option<u32> {
     app.ui.layer_comp_selected.filter(|id| doc.comp(*id).is_some()).or(doc.last_applied_comp.filter(|id| doc.comp(*id).is_some()))
 }
 
+/// The row's warning triangle: Clear Layer Comp Warning for that comp only (Photoshop keeps
+/// Clear All Layer Comp Warnings as a separate command).
+fn clear_warning_action(comp: u32) -> (&'static str, Value) {
+    ("layerComp.updateWarnings", json!({"clear": true, "comp": comp}))
+}
+
 fn run(app: &mut PhotocraftApp, id: &str, p: Value) {
     if let Err(e) = app.run(id, p) {
         app.ui.status = e;
@@ -124,7 +130,7 @@ pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                     ));
                     if resp.clicked() {
                         toggle_hit = true;
-                        action = Some(("layerComp.updateWarnings", json!({"clear": true})));
+                        action = Some(clear_warning_action(c.id));
                     }
                 }
                 name_x += 18.0;
@@ -185,3 +191,26 @@ pub fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use photocraft_engine::Session;
+
+    #[test]
+    fn warning_icon_clears_only_its_own_comp() {
+        // Regression for #4197.
+        let mut s = Session::new();
+        s.execute("file.new", json!({"width": 16, "height": 16})).unwrap();
+        let layer = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+        let c1 = s.execute("layerComp.new", json!({"name": "One"})).unwrap()["comp"].as_u64().unwrap() as u32;
+        let c2 = s.execute("layerComp.new", json!({"name": "Two"})).unwrap()["comp"].as_u64().unwrap() as u32;
+        s.execute("layer.delete", json!({"layer": layer})).unwrap();
+        let (id, p) = clear_warning_action(c1);
+        assert_eq!(p["comp"], c1);
+        s.execute(id, p).unwrap();
+        let doc = &s.active().unwrap().doc;
+        assert!(doc.comp(c1).unwrap().missing_layers(doc).is_empty());
+        assert_eq!(doc.comp(c2).unwrap().missing_layers(doc).iter().map(|l| l.0).collect::<Vec<_>>(), vec![layer]);
+    }
+}
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index a20101f441..db908d0943 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -46,12 +46,22 @@ pub type ControlResponse = Value;
 /// The control server's per-request reply deadline.
 pub const REPLY_DEADLINE: std::time::Duration = std::time::Duration::from_secs(60);
 
-/// The error both timeout sites return when a request's [`REPLY_DEADLINE`] passes: the
-/// transport thread waiting for a reply, and the UI thread rejecting a request it is only
-/// now draining. Built from the same constant, so the text cannot drift from the deadline.
+/// The error the transport thread returns when a dispatched command gave no reply within
+/// [`REPLY_DEADLINE`]. It warns that the command may still apply: re-sending blindly could apply
+/// an edit twice (#3662). Built from the deadline constant, so the text cannot drift from it.
 pub fn timeout_error() -> String {
     format!(
-        "timeout: no reply in {}s — the command may still be running, or the app was not drawing frames (display asleep, window fully occluded, or a long operation blocked the frame loop)",
+        "timeout: no reply in {}s — the command may still be running and may still apply, or the app was not drawing frames (display asleep, window fully occluded, or a long operation blocked the frame loop)",
+        REPLY_DEADLINE.as_secs()
+    )
+}
+
+/// The error for a request still queued when its deadline passed, from the UI thread or the
+/// transport (see [`Dispatch`]). It was dropped before dispatch, so re-sending it is safe (#3662). Same `timeout` prefix as
+/// [`timeout_error`], which machines match on.
+pub fn expired_error() -> String {
+    format!(
+        "timeout: not run — the request was still queued when its {}s deadline passed, so it was dropped before dispatch and is safe to re-send; the app was not drawing frames (display asleep, window fully occluded, or a long operation blocked the frame loop)",
         REPLY_DEADLINE.as_secs()
     )
 }
@@ -62,12 +72,44 @@ pub struct ControlRequest {
     pub reply: Sender<ControlResponse>,
     /// Requests still queued at this instant are rejected; already dispatched work continues.
     pub deadline: Option<std::time::Instant>,
+    /// Shared with the transport, so that when it stops waiting it knows whether the command ran.
+    pub dispatch: Dispatch,
 }
 
 impl ControlRequest {
     pub fn new(method: impl Into<String>, params: Value) -> (Self, std::sync::mpsc::Receiver<ControlResponse>) {
         let (tx, rx) = std::sync::mpsc::channel();
-        (Self { method: method.into(), params, reply: tx, deadline: None }, rx)
+        (Self { method: method.into(), params, reply: tx, deadline: None, dispatch: Dispatch::default() }, rx)
+    }
+}
+
+/// Whether a request was dispatched, settled once between the UI thread (about to run it) and
+/// the transport (giving up on its reply). The transport's clock runs out no later than the UI
+/// thread's, so without this it could only ever say the command may still apply (#3662).
+#[derive(Clone, Default)]
+pub struct Dispatch(std::sync::Arc<std::sync::atomic::AtomicU8>);
+
+const QUEUED: u8 = 0;
+const DISPATCHED: u8 = 1;
+const ABANDONED: u8 = 2;
+
+impl Dispatch {
+    /// The UI thread claims the request to run it: false once the transport gave up on it. A
+    /// request the UI thread rejects as expired stays queued, which `give_up` reads as not run.
+    pub(crate) fn start(&self) -> bool {
+        self.settle(DISPATCHED) == DISPATCHED
+    }
+
+    /// The transport stops waiting: the error to reply with, [`expired_error`] when the command
+    /// can no longer run and [`timeout_error`] when it was dispatched and may still apply.
+    pub fn give_up(&self) -> String {
+        if self.settle(ABANDONED) == DISPATCHED { timeout_error() } else { expired_error() }
+    }
+
+    /// Moves a queued request to `to`; returns the state it ends in.
+    fn settle(&self, to: u8) -> u8 {
+        use std::sync::atomic::Ordering;
+        self.0.compare_exchange(QUEUED, to, Ordering::AcqRel, Ordering::Acquire).map_or_else(|state| state, |_| to)
     }
 }
 
@@ -89,7 +131,7 @@ pub enum Outcome {
 /// field's value is validated before the first one is applied, so a typo, an unknown field, a
 /// bad value or a bad nested key can't reply with success while nothing — or only half of it —
 /// changed (#412).
-pub const UI_SET_FIELDS: [&str; 34] = [
+pub const UI_SET_FIELDS: [&str; 35] = [
     "tool",
     "panels",
     "dock",
@@ -124,6 +166,7 @@ pub const UI_SET_FIELDS: [&str; 34] = [
     "cropShield",
     "shapeStroke",
     "camTransformOnDrop",
+    "tileGrid",
 ];
 
 /// Most clicks one `ui.click` may queue (#982). Each click is a press and a release that the app
@@ -323,6 +366,22 @@ pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest
     outcome
 }
 
+/// The open canvas context menu's rows for `ui.state`: the spelling suggestions first (type edit
+/// menu over a misspelled word), then the menu's own rows.
+fn context_entries(app: &PhotocraftApp, menu: &crate::canvas_tool_menu::CanvasToolMenu) -> Vec<Value> {
+    use crate::canvas_tool_menu::{entry_enabled, rows, spelling_rows};
+    let spelling = spelling_rows(menu);
+    let mut entries: Vec<Value> = spelling.iter().map(|(label, id)| json!({"label": label, "id": id, "enabled": entry_enabled(app, menu, id)})).collect();
+    if !spelling.is_empty() {
+        entries.push(json!({"separator": true}));
+    }
+    entries.extend(rows(menu).iter().map(|row| match row {
+        Some((label, id)) => json!({"label": label, "id": id, "enabled": entry_enabled(app, menu, id)}),
+        None => json!({"separator": true}),
+    }));
+    entries
+}
+
 fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest) -> Outcome {
     let p = &req.params;
     let s = |k: &str| p.get(k).and_then(Value::as_str);
@@ -381,16 +440,14 @@ fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest)
             let all = p.get("job").is_none_or(Value::is_null);
             match p.get("job").and_then(Value::as_u64) {
                 Some(j) if app.session.job(photocraft_engine::jobs::JobId(j)).is_some() => {
-                    crate::jobs_ui::cancel(app, photocraft_engine::jobs::JobId(j));
-                    ok(json!({"cancelled": 1}))
+                    let cancelled = crate::jobs_ui::cancel(app, photocraft_engine::jobs::JobId(j));
+                    ok(json!({"cancelled": usize::from(cancelled)}))
                 }
                 Some(j) => err(format!("no running job {j}")),
                 None if all => {
                     let ids: Vec<_> = app.session.jobs().into_iter().map(|j| j.id).collect();
-                    for j in &ids {
-                        crate::jobs_ui::cancel(app, *j);
-                    }
-                    ok(json!({"cancelled": ids.len()}))
+                    let cancelled = ids.into_iter().filter(|j| crate::jobs_ui::cancel(app, *j)).count();
+                    ok(json!({"cancelled": cancelled}))
                 }
                 None => err("`job` must be a job id"),
             }
@@ -452,6 +509,8 @@ fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest)
                 let eyedropper_ring = bool_field(p, "eyedropperRing")?;
                 // Content-Aware Move's Transform On Drop checkbox.
                 let cam_transform_on_drop = bool_field(p, "camTransformOnDrop")?;
+                // Developer overlay of the active layer's storage tiles (tile_overlay.rs).
+                let tile_grid = bool_field(p, "tileGrid")?;
                 // The Crop tool's overlay menu (#1919).
                 let crop_overlay = match p.get("cropOverlay") {
                     Some(v) => Some(v.as_str().and_then(crate::crop_overlay::CropOverlay::from_id).ok_or_else(|| {
@@ -610,6 +669,9 @@ fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest)
                 if let Some(on) = cam_transform_on_drop {
                     app.ui.tool_options.cam_transform_on_drop = on;
                 }
+                if let Some(on) = tile_grid {
+                    app.ui.view.tile_grid = on;
+                }
                 if let Some(k) = crop_overlay {
                     app.ui.tool_options.crop_overlay = k;
                 }
@@ -810,6 +872,23 @@ fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest)
             wrap(crate::workspace_ui::confirm(app, ctx))
         }
         "ui.dialog.apply" if s("dialog") == Some(SHELL_DIALOG) => err("`ui.dialog.apply` is for Preferences; use `ui.dialog.confirm`"),
+        // The unsaved-changes prompt (closing, Revert, quitting), listed by ui.inspect with the
+        // id "discard" (#4920): confirm takes a `choice` (save, dontSave, cancel; default save).
+        "ui.dialog.confirm" if s("dialog") == Some(crate::discard_ui::CONTROL_ID) => {
+            let choice = s("choice").unwrap_or("save");
+            if choice != "cancel"
+                && let Some((command, params)) = crate::discard_ui::pending_command(app)
+                && let Some(authorize) = app.services.automation_command.as_ref()
+                && let Err(error) = authorize(&command, &params)
+            {
+                return err(error);
+            }
+            wrap(crate::discard_ui::answer_control(app, ctx, choice))
+        }
+        "ui.dialog.cancel" if s("dialog") == Some(crate::discard_ui::CONTROL_ID) => wrap(crate::discard_ui::answer_control(app, ctx, "cancel")),
+        "ui.dialog.set" | "ui.dialog.apply" if s("dialog") == Some(crate::discard_ui::CONTROL_ID) => {
+            err("the unsaved-changes prompt has no fields; use `ui.dialog.confirm` with a `choice`")
+        }
         "ui.dialog.cancel" if s("dialog") == Some(SHELL_DIALOG) => match app.ui.shell.dialog.take() {
             Some(_) => ok(Value::Null),
             None => err("no such dialog"),
@@ -981,7 +1060,7 @@ fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest)
                     }
                     if crate::canvas_tool_menu::applies(app.ui.tool) || crate::canvas_tool_menu::editing_text(app, app.ui.tool) {
                         if down {
-                            crate::canvas_tool_menu::open(app, ctx, app.ui.tool, screen_point(app, x, y));
+                            crate::canvas_tool_menu::open_at(app, ctx, app.ui.tool, screen_point(app, x, y), Some([x, y]));
                         }
                         continue;
                     }
@@ -1180,6 +1259,7 @@ pub fn inspect(app: &PhotocraftApp, ctx: &egui::Context) -> Value {
     if let Some((kind, fields)) = &app.ui.shell.dialog {
         dialogs.push(json!({"id": SHELL_DIALOG, "kind": kind, "title": crate::workspace_ui::title(kind), "fields": fields}));
     }
+    dialogs.extend(crate::discard_ui::inspect(app));
     json!({
         "window": {"width": screen.width(), "height": screen.height(), "pixelsPerPoint": ctx.pixels_per_point()},
         "tool": app.ui.tool,
@@ -1213,10 +1293,7 @@ pub fn inspect(app: &PhotocraftApp, ctx: &egui::Context) -> Value {
                 "pos": menu.pos,
                 "tool": menu.tool,
                 "pasteboard": menu.pasteboard,
-                "entries": crate::canvas_tool_menu::rows(menu).iter().map(|row| match row {
-                    Some((label, id)) => json!({"label": label, "id": id, "enabled": crate::canvas_tool_menu::entry_enabled(app, menu, id)}),
-                    None => json!({"separator": true}),
-                }).collect::<Vec<_>>()
+                "entries": context_entries(app, menu)
             })
         }),
         "panels": app.ui.panels,
@@ -1309,20 +1386,10 @@ mod tests {
             app.open_bytes("control.dng", &dng).unwrap();
             ctx.run_ui(Default::default(), |ui| crate::camera_raw_ui::show(&mut app, ui.ctx())).textures_delta.clear();
             assert!(app.camera_raw.is_some());
-            // The raw develops in ProPhoto, so opening it also asks about the working-space
-            // mismatch. Answer that prompt through the same control path before editing.
-            assert_eq!(app.ui.dialogs.len(), 1);
-            let mismatch = app.ui.dialogs.first().unwrap();
-            assert_eq!(mismatch.fields["__prefsui"], "mismatch");
-            assert_eq!(mismatch.fields["action"], "preserve");
-            assert_eq!(mismatch.fields["applied"], "preserve");
-            let mismatch_id = mismatch.id;
-            let update = json!({"id":"filter.cameraRaw","params":{"ui":{"set":{"exposure":0.5}}}});
-            assert_eq!(call(&mut app, &ctx, "ui.menu.invoke", update.clone())["ok"], false);
-            let confirmed = call(&mut app, &ctx, "ui.dialog.confirm", json!({"dialog":mismatch_id}));
-            assert_eq!(confirmed["ok"], true, "{confirmed}");
-            assert_eq!(confirmed["result"]["action"], "preserve");
+            // A developed raw has no embedded profile to ask about (`open_prompt`), so no profile
+            // prompt stands between the open and the Camera Raw dialog.
             assert!(app.ui.dialogs.is_empty());
+            let update = json!({"id":"filter.cameraRaw","params":{"ui":{"set":{"exposure":0.5}}}});
             let original = app.session.active().unwrap().doc.clone();
             let changed = call(&mut app, &ctx, "ui.menu.invoke", update);
             assert_eq!(changed["ok"], true, "{changed}");
@@ -1495,6 +1562,47 @@ mod tests {
         assert_eq!(app.ui.tool_options.stroke_width, 0.0);
     }
 
+    #[test]
+    fn the_unsaved_changes_prompt_is_listed_and_answered_through_ui_dialog() {
+        // #4920: the prompt shown on quit or close with unsaved changes wasn't in ui.inspect, and a
+        // control client couldn't answer it.
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let ctx = egui::Context::default();
+        for _ in 0..2 {
+            app.run("file.new", json!({"width": 8, "height": 8})).unwrap();
+            app.run("layer.new.layer", json!({})).unwrap();
+        }
+        let prompt = |app: &mut PhotocraftApp| {
+            let v = call(app, &ctx, "ui.inspect", json!({}));
+            v["result"]["dialogs"].as_array().unwrap().iter().find(|d| d["id"] == "discard").cloned()
+        };
+        assert!(prompt(&mut app).is_none());
+        // Closing a dirty document: listed with its choices; a bad choice and Cancel keep the document.
+        crate::menus::invoke(&mut app, &ctx, "file.close", json!({})).unwrap();
+        let d = prompt(&mut app).expect("the prompt is listed");
+        assert_eq!(d["fields"]["command"], "file.close");
+        assert_eq!(d["fields"]["choices"], json!(["save", "dontSave", "cancel"]));
+        assert_eq!(call(&mut app, &ctx, "ui.dialog.confirm", json!({"dialog": "discard", "choice": "maybe"}))["ok"], false);
+        assert_eq!(call(&mut app, &ctx, "ui.dialog.set", json!({"dialog": "discard", "field": "x", "value": 1}))["ok"], false);
+        assert_eq!(call(&mut app, &ctx, "ui.dialog.cancel", json!({"dialog": "discard"}))["ok"], true);
+        assert!(prompt(&mut app).is_none() && app.session.documents().len() == 2);
+        assert_eq!(call(&mut app, &ctx, "ui.dialog.cancel", json!({"dialog": "discard"}))["ok"], false, "nothing left to answer");
+        // Don't Save closes it.
+        crate::menus::invoke(&mut app, &ctx, "file.close", json!({})).unwrap();
+        assert_eq!(call(&mut app, &ctx, "ui.dialog.confirm", json!({"dialog": "discard", "choice": "dontSave"}))["ok"], true);
+        assert_eq!(app.session.documents().len(), 1);
+        // Quitting asks about each dirty document, then lets the window close.
+        app.run("file.new", json!({"width": 8, "height": 8})).unwrap();
+        app.run("layer.new.layer", json!({})).unwrap();
+        assert!(crate::discard_ui::intercept(&mut app, "file.exit", &Value::Null));
+        let d = prompt(&mut app).expect("the quit prompt is listed");
+        assert_eq!((d["fields"]["command"].as_str(), d["fields"]["remaining"].as_u64()), (Some("file.exit"), Some(2)));
+        assert_eq!(call(&mut app, &ctx, "ui.dialog.confirm", json!({"dialog": "discard", "choice": "dontSave"}))["result"]["open"], true);
+        assert_eq!(prompt(&mut app).unwrap()["fields"]["remaining"], 1);
+        assert_eq!(call(&mut app, &ctx, "ui.dialog.confirm", json!({"dialog": "discard", "choice": "dontSave"}))["result"]["open"], false);
+        assert!(app.allow_close && app.session.documents().is_empty());
+    }
+
     #[test]
     fn shell_dialogs_are_listed_and_driven_through_ui_dialog() {
         // #1004: Window › Workspace and View dialogs live in `ui.shell.dialog`, and ui.inspect and
@@ -1567,11 +1675,54 @@ mod tests {
         retry.deadline = Some(Instant::now() + Duration::from_secs(60));
         tx.send(retry).unwrap();
         app.drain_control(&egui::Context::default());
-        assert_eq!(expired_reply.try_recv().unwrap(), json!({"ok": false, "error": super::timeout_error()}));
+        let expired_error = expired_reply.try_recv().unwrap()["error"].as_str().unwrap().to_string();
         assert_eq!(retry_reply.try_recv().unwrap()["ok"], true);
         let after = app.session.active().unwrap();
         assert_eq!(after.doc.layers.len(), layers + 1, "only the live retry adds a layer");
         assert_eq!(after.history.past_len(), steps + 1, "the expired edit adds no undo step");
+        // #3662: a caller must be able to tell this reply, safe to re-send, from the
+        // transport's, sent while the command may still apply.
+        assert!(expired_error.starts_with("timeout"), "machines match on the prefix: {expired_error}");
+        assert!(expired_error.contains("not run"), "the expired request says it never ran: {expired_error}");
+        let transport_error = super::timeout_error();
+        assert!(!transport_error.contains("not run"), "the transport can't know it didn't run: {transport_error}");
+        assert!(transport_error.contains("may still apply"), "the transport warns against a blind re-send: {transport_error}");
+    }
+
+    #[test]
+    fn a_transport_that_gives_up_learns_whether_the_command_can_still_run() {
+        // #3662: the transport's clock runs out no later than the UI thread's, so it is the
+        // one that answers; it must still tell a request that will never run from one that may.
+        use std::time::{Duration, Instant};
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 8, "height": 8})).unwrap();
+        let layers = app.session.active().unwrap().doc.layers.len();
+        let (tx, rx) = std::sync::mpsc::channel();
+        app = app.with_control(rx);
+        let ctx = egui::Context::default();
+        let request = |deadline: Instant| {
+            let (mut req, reply) = ControlRequest::new("engine.execute", json!({"command": "layer.new.layer"}));
+            req.deadline = Some(deadline);
+            (req.dispatch.clone(), req, reply)
+        };
+
+        let (dispatch, queued, _) = request(Instant::now() + Duration::from_secs(60));
+        tx.send(queued).unwrap();
+        assert_eq!(dispatch.give_up(), super::expired_error(), "still queued: it will not run");
+        app.drain_control(&ctx);
+        assert_eq!(app.session.active().unwrap().doc.layers.len(), layers, "a request given up on never runs");
+
+        let (dispatch, expired, _) = request(Instant::now() - Duration::from_secs(1));
+        tx.send(expired).unwrap();
+        app.drain_control(&ctx);
+        assert_eq!(dispatch.give_up(), super::expired_error(), "rejected by the UI thread: it did not run");
+
+        let (dispatch, live, reply) = request(Instant::now() + Duration::from_secs(60));
+        tx.send(live).unwrap();
+        app.drain_control(&ctx);
+        assert_eq!(reply.try_recv().unwrap()["ok"], true);
+        assert_eq!(app.session.active().unwrap().doc.layers.len(), layers + 1);
+        assert_eq!(dispatch.give_up(), super::timeout_error(), "dispatched: it may still apply");
     }
 
     #[test]
@@ -1775,6 +1926,25 @@ mod tests {
         assert!(app.ui.tool_options.gradient_classic, "invalid mode must not change options");
     }
 
+    #[test]
+    fn ui_set_toggles_the_developer_tile_grid() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let ctx = egui::Context::default();
+        assert!(!app.ui.view.tile_grid, "off by default");
+        assert_eq!(call(&mut app, &ctx, "ui.set", json!({"tileGrid": true}))["ok"], true);
+        assert!(app.ui.view.tile_grid);
+        assert_eq!(call(&mut app, &ctx, "ui.inspect", json!({}))["result"]["view"]["tile_grid"], true);
+        // Not a View › Show item: Extras doesn't hide it, and Show Extras Options doesn't list it.
+        crate::menus::invoke(&mut app, &ctx, "view.extras", json!({})).unwrap();
+        assert!(!app.ui.view.extras && app.ui.view.tile_grid);
+        assert!(serde_json::to_value(app.ui.view.show).unwrap().get("tile_grid").is_none());
+        let bad = call(&mut app, &ctx, "ui.set", json!({"tileGrid": "yes"}));
+        assert_eq!(bad["ok"], false, "{bad}");
+        assert!(app.ui.view.tile_grid, "a rejected value changes nothing");
+        assert_eq!(call(&mut app, &ctx, "ui.set", json!({"tileGrid": false}))["ok"], true);
+        assert!(!app.ui.view.tile_grid);
+    }
+
     #[test]
     fn ui_set_drives_the_eyedropper_options() {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
@@ -2516,6 +2686,7 @@ mod tests {
                 name: "Linked contents".into(),
                 steps: vec![(command.into(), json!({"layer": smart.0}))],
                 disabled: Default::default(),
+                ..Default::default()
             }];
             let r = call(&mut app, &ctx, "engine.execute", json!({"command": "actions.play", "params": {"action": "Linked contents"}}));
             assert_eq!(r["ok"], true, "{r}");
@@ -2546,6 +2717,7 @@ mod tests {
             name: "Open".into(),
             steps: vec![("file.open".into(), json!({"path": "/etc/passwd"})), ("layer.new.layer".into(), json!({}))],
             disabled: Default::default(),
+            ..Default::default()
         });
         let ctx = egui::Context::default();
         let r = call(&mut app, &ctx, "engine.execute", json!({"command": "actions.play", "params": {"action": "Open"}}));
@@ -2565,6 +2737,7 @@ mod tests {
             name: "Open".into(),
             steps: vec![("file.open".into(), json!({"path": "/etc/passwd"})), ("layer.new.layer".into(), json!({}))],
             disabled: Default::default(),
+            ..Default::default()
         });
         app.automation_input = true;
         let r = app.run("actions.play", json!({"action": "Open"})).unwrap();
diff --git a/crates/ui-egui/src/crop_mode.rs b/crates/ui-egui/src/crop_mode.rs
index e19f01334a..676c97dbec 100644
--- a/crates/ui-egui/src/crop_mode.rs
+++ b/crates/ui-egui/src/crop_mode.rs
@@ -820,4 +820,89 @@ mod tests {
             }
         }
     }
+
+    /// #1919: with Delete Cropped Pixels off, a second crop's handle dragged out toward the hidden
+    /// pixels snaps exactly onto their edge (a layer edge), however far from the handle's centre
+    /// the press grabbed it, in both modes, with and without Auto Center Preview: the committed
+    /// crop has no transparent strip.
+    #[test]
+    fn a_recrop_handle_snaps_exactly_to_the_hidden_pixels_edge() {
+        // The image 200 × 100 cropped to [40, 20, 140, 70]: its pixels stay at [-40, -20, 160, 80].
+        let hidden = [-40.0, -20.0, 160.0, 80.0];
+        for classic in [false, true] {
+            for auto in [true, false] {
+                for (hx, hy) in [(1i8, 0i8), (0, -1), (-1, -1), (1, 1)] {
+                    // A corner also with the image's 2:1 ratio held, which both hidden corners keep.
+                    for (grab, ratio) in [(-4.0f32, false), (0.0, false), (4.0, false), (-4.0, true), (4.0, true)] {
+                        if ratio && (hx == 0 || hy == 0) {
+                            continue;
+                        }
+                        let what = format!("Classic Mode {classic}, Auto Center {auto}, handle ({hx}, {hy}), grabbed {grab} px off, ratio {ratio}");
+                        let mut app = app();
+                        app.ui.tool_options.crop_delete = false;
+                        app.ui.tool_options.crop_shield.classic_mode = classic;
+                        app.ui.tool_options.crop_shield.auto_center_preview = auto;
+                        crate::crop_ui::ensure_frame(&mut app);
+                        app.ui.crop_rect = Some([40.0, 20.0, 140.0, 70.0]);
+                        app.crop.default_frame = false;
+                        crate::canvas::commit_crop(&mut app);
+                        let v = &mut app.ui.views[0];
+                        (v.zoom, v.center, v.fit_pending, v.rotation) = (1.0, [50.0, 25.0], false, 0.0);
+                        app.ui.extras.snap = true;
+                        crate::crop_ui::ensure_frame(&mut app);
+                        assert_eq!(app.ui.crop_rect, Some([0.0, 0.0, 100.0, 50.0]));
+                        if ratio {
+                            app.ui.tool_options.crop_ratio = "original".into();
+                        }
+                        let grab = vec2(f32::from(hx), f32::from(hy)) * grab;
+                        let from = xf(&app).to_screen(50.0 + f32::from(hx) * 50.0, 25.0 + f32::from(hy) * 25.0) + grab;
+                        // Toward the hidden corner (or edge), a screen pixel at a time on the longer axis.
+                        let gap = vec2(f32::from(hx) * if hx < 0 { 40.0 } else { 60.0 }, f32::from(hy) * if hy < 0 { 20.0 } else { 30.0 });
+                        let dir = gap / gap.x.abs().max(gap.y.abs());
+                        let d = xf(&app).to_doc(from);
+                        tool_event(&mut app, ToolEvent::Down { x: d[0], y: d[1], pressure: 1.0 }, NONE);
+                        // Drag outward a screen pixel at a time; let go once the moving edges show
+                        // the snap to the hidden pixels' edges (as the user would).
+                        let snapped = |app: &PhotocraftApp| {
+                            let on = |vertical: bool, pos: f64| {
+                                app.prefs_rt
+                                    .snap_lines
+                                    .iter()
+                                    .any(|l| l.vertical == vertical && l.pos == pos && l.kind == photocraft_engine::snap::SnapKind::LayerEdge)
+                            };
+                            (hx == 0 || on(true, if hx < 0 { hidden[0] } else { hidden[2] }))
+                                && (hy == 0 || on(false, if hy < 0 { hidden[1] } else { hidden[3] }))
+                        };
+                        let mut end = None;
+                        for i in 1..=80 {
+                            let d = xf(&app).to_doc(from + dir * i as f32);
+                            tool_event(&mut app, ToolEvent::Move { x: d[0], y: d[1], pressure: 1.0 }, NONE);
+                            if snapped(&app) {
+                                end = Some(from + dir * i as f32);
+                                break;
+                            }
+                        }
+                        let end = end.unwrap_or_else(|| panic!("{what}: never snapped to the hidden edge"));
+                        // Released where it stopped, read through the view as it is now.
+                        let end = xf(&app).to_doc(end);
+                        tool_event(&mut app, ToolEvent::Up { x: end[0], y: end[1] }, NONE);
+                        let pick = |h: i8, lo: f64, hi: f64, a: f64, b: f64| match h {
+                            -1 => [a, hi],
+                            1 => [lo, b],
+                            _ => [lo, hi],
+                        };
+                        let [x0, x1] = pick(hx, 0.0, 100.0, hidden[0], hidden[2]);
+                        let [y0, y1] = pick(hy, 0.0, 50.0, hidden[1], hidden[3]);
+                        assert_eq!(app.ui.crop_rect, Some([x0, y0, x1, y1]), "{what}: the frame lands exactly on the hidden edge");
+                        crate::canvas::commit_crop(&mut app);
+                        let st = app.session.active().unwrap();
+                        assert_eq!((st.doc.size.width, st.doc.size.height), ((x1 - x0) as u32, (y1 - y0) as u32), "{what}");
+                        let layer = st.doc.walk().into_iter().map(|(_, _, l)| l.id).next().unwrap();
+                        let r = photocraft_engine::snap::layer_rect(&st.doc, layer).unwrap();
+                        assert_eq!(r, [hidden[0] - x0, hidden[1] - y0, hidden[2] - x0, hidden[3] - y0], "{what}: no transparent strip");
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/crates/ui-egui/src/crop_ui.rs b/crates/ui-egui/src/crop_ui.rs
index df25c568ff..54ec3795d2 100644
--- a/crates/ui-egui/src/crop_ui.rs
+++ b/crates/ui-egui/src/crop_ui.rs
@@ -863,7 +863,8 @@ pub(crate) fn resize_ratio(app: &PhotocraftApp, rect: [f64; 4], mods: Modifiers)
     preset_ratio(app).or(if mods.shift { keep } else { None })
 }
 
-/// Cursor over the canvas at document point `p`: resize arrows on the edges, move inside.
+/// Cursor over the canvas at document point `p`: resize arrows on the edges, move inside (the
+/// crosshair inside the untouched default frame, where a drag draws a new one).
 pub fn cursor(app: &PhotocraftApp, p: [f64; 2]) -> Option<CursorIcon> {
     if app.ui.tool != Tool::Crop {
         return None;
@@ -882,6 +883,8 @@ pub fn cursor(app: &PhotocraftApp, p: [f64; 2]) -> Option<CursorIcon> {
     Some(match h {
         // The arrow as the handle faces on screen: the frame's turn plus the view's.
         Hit::Handle(hx, hy) => resize_icon(hx, hy, deg + f64::from(crate::crop_mode::view_rotation(app))),
+        // Inside the untouched default frame a drag draws a new one (`pointer`), so nothing moves (#4461).
+        Hit::Inside if app.crop.default_frame => CursorIcon::Crosshair,
         Hit::Inside => CursorIcon::Move,
         // Photoshop's curved two-headed arrow (`draw_turn_cursor`, from `turn_cursor_dir`).
         Hit::Outside => CursorIcon::None,
@@ -1787,6 +1790,20 @@ mod tests {
         assert_eq!(cursor(&app, [60.0, 40.0]), None);
     }
 
+    /// #4461: inside the untouched default frame a drag draws a new frame, so the pointer is the
+    /// drawing crosshair there, not the move cursor; once the frame is changed a drag moves it.
+    #[test]
+    fn cursor_inside_the_default_frame_draws() {
+        let mut app = app(SampleType::U8);
+        ensure_frame(&mut app);
+        assert!(app.crop.default_frame && app.ui.crop_rect == Some([0.0, 0.0, 200.0, 100.0]));
+        assert_eq!(cursor(&app, [100.0, 50.0]), Some(CursorIcon::Crosshair));
+        assert_eq!(cursor(&app, [200.0, 50.0]), Some(CursorIcon::ResizeHorizontal), "its handles still resize");
+        drag(&mut app, &[[200.0, 50.0], [150.0, 50.0]], NONE);
+        assert!(!app.crop.default_frame && app.ui.crop_rect == Some([0.0, 0.0, 150.0, 100.0]));
+        assert_eq!(cursor(&app, [100.0, 50.0]), Some(CursorIcon::Move));
+    }
+
     /// One key press through the app's keyboard handling (`shortcuts::handle`).
     fn key(app: &mut PhotocraftApp, key: egui::Key, modifiers: Modifiers) {
         let ctx = egui::Context::default();
diff --git a/crates/ui-egui/src/dialog_alt_reset.rs b/crates/ui-egui/src/dialog_alt_reset.rs
new file mode 100644
index 0000000000..71e52ac8f6
--- /dev/null
+++ b/crates/ui-egui/src/dialog_alt_reset.rs
@@ -0,0 +1,93 @@
+//! Alt+Cancel → Reset for command dialogs that opt in.
+//!
+//! Holding Alt in the dialog chrome relabels Cancel as Reset and, on click, restores the dialog's
+//! fields without closing it (Photoshop). Each marker implements its own `reset`; this module only
+//! dispatches. Esc stays Cancel (`Modifiers::NONE` in the frame). Opt out with `"__altReset": false`.
+
+use serde_json::{Map, Value};
+
+use crate::PhotocraftApp;
+
+/// Whether holding Alt turns Cancel into Reset for this dialog's fields.
+pub fn supported(fields: &Map<String, Value>) -> bool {
+    if fields.get("__altReset") == Some(&Value::Bool(false)) {
+        return false;
+    }
+    match_arm(fields).is_some()
+}
+
+/// Apply Reset in place. No-op when the dialog has not opted in.
+pub fn apply(app: &mut PhotocraftApp, ctx: &egui::Context, fields: &mut Map<String, Value>) {
+    if fields.get("__altReset") == Some(&Value::Bool(false)) {
+        return;
+    }
+    // Dispatch order matches `dialogs::show` so `__adjust` wins over `__filter`.
+    if crate::guide_layout_ui::owns(fields) {
+        crate::guide_layout_ui::reset(app, fields);
+    } else if crate::fill_ui::owns(fields) {
+        crate::fill_ui::reset(app, fields);
+    } else if crate::variables_ui::owns(fields) {
+        crate::variables_ui::reset(fields);
+    } else if crate::color_picker_ui::owns(fields) {
+        crate::color_picker_ui::reset(fields);
+    } else if fields.contains_key("__sizing") {
+        crate::sizing::reset(fields);
+    } else if crate::adjust_dialog::owns(fields) {
+        crate::adjust_dialog::reset(app, ctx, fields);
+    } else if fields.contains_key("__filter") {
+        crate::filter_dialog::reset_fields(app, fields);
+    } else if fields.contains_key("__form") {
+        crate::view_cmds::reset_form(fields);
+    }
+}
+
+/// First matching opt-in arm, if any (same order as [`apply`]).
+fn match_arm(fields: &Map<String, Value>) -> Option<&'static str> {
+    if crate::guide_layout_ui::owns(fields) {
+        Some("guideLayout")
+    } else if crate::fill_ui::owns(fields) {
+        Some("fill")
+    } else if crate::variables_ui::owns(fields) && fields.contains_key("__variablesOrig") {
+        Some("variables")
+    } else if crate::color_picker_ui::owns(fields) {
+        Some("colorPicker")
+    } else if fields.contains_key("__sizing") {
+        Some("sizing")
+    } else if crate::adjust_dialog::owns(fields) {
+        Some("adjust")
+    } else if fields.contains_key("__filter") {
+        Some("filter")
+    } else if fields.contains_key("__form") && fields.contains_key("__formOrig") {
+        Some("form")
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn alt_reset_false_opts_out() {
+        let mut f = Map::new();
+        f.insert("__adjust".into(), json!("levels"));
+        f.insert("__altReset".into(), json!(false));
+        assert!(!supported(&f));
+    }
+
+    #[test]
+    fn adjust_marker_opts_in() {
+        let mut f = Map::new();
+        f.insert("__adjust".into(), json!("levels"));
+        assert!(supported(&f));
+    }
+
+    #[test]
+    fn bare_confirm_does_not_opt_in() {
+        let mut f = Map::new();
+        f.insert("__command".into(), json!("edit.purge"));
+        assert!(!supported(&f));
+    }
+}
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 1d45c03cc9..0530031f93 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -14,6 +14,11 @@ fn rects(ctx: &egui::Context) -> Vec<egui::Rect> {
     ctx.data(|m| m.get_temp(egui::Id::new(RECTS))).unwrap_or_default()
 }
 
+/// The window drag target must not cover a dialog which has been moved into the title bar.
+pub(crate) fn titlebar_drag_area_is_clear(ctx: &egui::Context, area: egui::Rect) -> bool {
+    rects(ctx).iter().all(|dialog| !dialog.intersects(area))
+}
+
 /// With a dialog open the rest of the window is inert (egui's modal layer), but like Photoshop the
 /// image can still be panned and zoomed under it. The pointer position when it is over `canvas`
 /// and not over a dialog or one of its popups.
@@ -99,9 +104,37 @@ fn older_dialog_above(ctx: &egui::Context, live: egui::LayerId, dialogs: &[Dialo
     ctx.memory(|m| m.layer_ids().skip_while(|l| *l != live).skip(1).any(|l| others.contains(&l)))
 }
 
+fn show_modal<T>(
+    modal: egui::Modal,
+    ctx: &egui::Context,
+    id: egui::Id,
+    resizable: bool,
+    interactive: bool,
+    contents: impl FnOnce(&mut egui::Ui) -> T,
+) -> egui::ModalResponse<T> {
+    modal.show(ctx, |ui| {
+        // Disable the entire older modal, including its resize grip, not just its body.
+        if !interactive {
+            ui.disable();
+        }
+        if resizable {
+            let max = (ctx.content_rect().size() - egui::vec2(40.0, 40.0)).max(egui::vec2(560.0, 400.0));
+            egui::Resize::default()
+                .id(id.with("resize"))
+                .default_size(egui::vec2(960.0, 900.0).min(max))
+                .min_size(egui::vec2(560.0, 400.0))
+                .max_size(max)
+                .show(ui, contents)
+        } else {
+            contents(ui)
+        }
+    })
+}
+
 pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
     crate::layer_style::color_picker::prune(app);
     crate::type_panels_ui::color_picker::prune(app);
+    crate::edit_history::track_dialogs(app, ctx);
     let dialogs = app.ui.dialogs.clone();
     let top = dialogs.last().map(|d| d.id);
     let mut shown = Vec::new();
@@ -124,7 +157,7 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
         // effects, extends down and right instead of re-centring.
         let pinned: Option<egui::Vec2> = ctx.data(|m| m.get_temp(id));
         let place = place_id(&d);
-        let start = pinned.or_else(|| ctx.data_mut(|m| m.get_persisted::<egui::Vec2>(place)));
+        let start = pinned.or_else(|| ctx.data_mut(|m| m.get_persisted::<egui::Vec2>(place))).or_else(|| crate::blur_pins::first_place(&d.fields, ctx));
         let mut drag = egui::Vec2::ZERO;
         let mut sizing = false;
         let area = match start {
@@ -147,12 +180,17 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
         // Tab / ⇧Tab walk the topmost dialog's text fields, not every widget (field_tab.rs).
         let tab = if top == Some(d.id) && !egui::Popup::is_any_open(ctx) { crate::field_tab::take_step(ctx) } else { 0 };
         // Photoshop doesn't dim the window behind dialogs: previews must be judged at true contrast.
-        let modal = modal.show(ctx, |ui| {
-            if !interactive {
-                ui.disable();
-            }
+        let web = fields.contains_key("__web");
+        let web_popup_open = web && egui::Popup::is_any_open(ctx);
+        let modal = show_modal(modal, ctx, id, web, interactive, |ui| {
             sizing = ui.is_sizing_pass();
-            ui.set_min_width(380.0);
+            let available = ui.available_size();
+            // A dialog of a few short fields (`__compact`, Fit Image) is narrower (#4673): the title
+            // rule and the button row fill the width they are given, so it needs its own maximum too.
+            let compact = d.fields.contains_key("__compact");
+            if !compact {
+                ui.set_min_width(380.0);
+            }
             let wide = crate::prefs_ui::width(&d.fields, (ctx.content_rect().width() - 48.0).max(380.0));
             if let Some(w) = wide {
                 ui.set_min_width(w.min(460.0));
@@ -171,13 +209,24 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
                 700.0
             } else if d.kind == DialogKind::LayerStyle || d.fields.contains_key("__export") || crate::color_picker_ui::owns(&d.fields) {
                 600.0
+            } else if compact {
+                260.0
             } else {
                 440.0
             }));
-            if let Some(w) = crate::file_ui::dialog_width(&d.fields) {
+            if web {
+                ui.set_max_width(available.x);
+                ui.set_min_size(available);
+            } else if let Some(w) = crate::file_ui::dialog_width(&d.fields) {
                 ui.set_min_width(w);
                 ui.set_max_width(w);
             }
+            // Duplicate Layer… is a fixed small grid (labels + 260 pt fields ≈ 352 pt):
+            // the generic 380 pt minimum left a dead strip on its right.
+            if crate::duplicate_layer_ui::owns(&d.fields) {
+                ui.set_min_width(360.0);
+                ui.set_max_width(360.0);
+            }
             if color_picker {
                 ui.set_width(crate::color_picker_ui::CONTENT_WIDTH);
             }
@@ -226,15 +275,22 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
                     about_tab_body(app, ui, chosen);
                 }
                 DialogKind::Command if crate::guide_layout_ui::owns(&fields) => outcome = crate::guide_layout_ui::body(app, ui, &mut fields, interactive),
+                DialogKind::Command if crate::brush_preset_dialog::owns(&fields) => {
+                    outcome = crate::brush_preset_dialog::body(app, ui, &mut fields, interactive)
+                }
                 DialogKind::Command if crate::fill_ui::owns(&fields) => crate::fill_ui::body(app, ui, &mut fields),
                 DialogKind::Command if crate::pattern_fill_ui::owns(&fields) => crate::pattern_fill_ui::body(app, ui, &mut fields),
                 DialogKind::Command if crate::stroke_ui::owns(&fields) => crate::stroke_ui::body(ui, &mut fields),
+                DialogKind::Command if crate::channel_options_ui::owns(&fields) => crate::channel_options_ui::body(ui, &mut fields),
+                DialogKind::Command if crate::channel_options_ui::owns_new_spot(&fields) => crate::channel_options_ui::new_spot_body(ui, &mut fields),
                 DialogKind::Command if crate::shape_dialog::owns(&fields) => crate::shape_dialog::body(app, ui, &mut fields),
                 DialogKind::Command if crate::delete_layer_prompt::owns(&fields) => crate::delete_layer_prompt::body(ui, &mut fields),
+                DialogKind::Command if crate::actions::owns_insert_stop(&fields) => crate::actions::insert_stop_body(ui, &mut fields),
                 DialogKind::Command if crate::new_layer_ui::owns(&fields) => crate::new_layer_ui::body(ui, &mut fields),
                 DialogKind::Command if crate::mask_trash_prompt::owns(&fields) => crate::mask_trash_prompt::body(ui, &fields),
                 DialogKind::Command if crate::rasterize_prompt::owns(&fields) => crate::rasterize_prompt::body(ui, &fields),
                 DialogKind::Command if crate::duplicate_layer_ui::owns(&fields) => crate::duplicate_layer_ui::body(app, ui, &mut fields),
+                DialogKind::Command if crate::stack_dialog::owns(&fields) => crate::stack_dialog::body(app, ui, &mut fields, d.id),
                 DialogKind::Command if crate::tool_reset::owns(&fields) => crate::tool_reset::body(ui),
                 DialogKind::Command if crate::crop_presets::owns(&fields) => crate::crop_presets::body(app, ui, &mut fields),
                 DialogKind::Command if crate::variables_ui::owns(&fields) => crate::variables_ui::body(app, ui, &mut fields),
@@ -249,16 +305,21 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
                 // Image Size and Canvas Size open on Width, selected (#2329).
                 DialogKind::Command if fields.contains_key("__sizing") => first_field_focused(ui, id, |ui| crate::sizing::body(ui, &mut fields)),
                 DialogKind::Command if crate::adjust_dialog::owns(&fields) => crate::adjust_dialog::body(app, ui, &mut fields),
+                DialogKind::Command if crate::blur_pins::owns(&fields) => crate::blur_pins::body(ui, &mut fields),
                 DialogKind::Command if fields.contains_key("__filter") => {
                     // Color Settings: the monitor profile in use can change while it is open.
                     if fields.get("__command").and_then(Value::as_str) == Some("edit.colorSettings") {
                         fields.insert("__note".into(), Value::String(crate::monitor_status::note(app)));
                     }
                     // Long parameter lists (Flame, Lighting Effects) scroll, so the title and the
-                    // OK / Cancel buttons stay inside a small window.
-                    let room = (ctx.content_rect().height() - DIALOG_CHROME).max(120.0);
+                    // OK / Cancel buttons stay inside a small window. The preview window below the
+                    // parameters reserves its own space (#3769).
+                    let room = (ctx.content_rect().height() - DIALOG_CHROME - crate::filter_preview_ui::reserved_height(&fields)).max(120.0);
                     let body = |ui: &mut egui::Ui, fields: &mut serde_json::Map<String, Value>| {
                         egui::ScrollArea::vertical().id_salt(id.with("body")).max_height(room).show(ui, |ui| crate::filter_dialog::body(ui, fields));
+                        // The in-dialog preview window sits under the scrolling parameters (#3769),
+                        // so it never shifts them.
+                        crate::filter_preview_ui::window(app, d.id, ui, fields);
                     };
                     // Select and Mask leaves the keyboard to its view keys (F, X, O, V…).
                     if crate::select_mask_view::owns(&fields) {
@@ -276,8 +337,8 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
                 }
             }
             crate::field_tab::end(ui.ctx(), tab);
-            if crate::guide_layout_ui::owns(&fields) {
-                // This dialog owns its right-side actions and validates Enter itself.
+            if crate::guide_layout_ui::owns(&fields) || crate::brush_preset_dialog::owns(&fields) {
+                // These dialogs own their right-side actions and validate Enter themselves.
             } else if crate::color_picker_ui::owns(&fields) {
                 if interactive && outcome.is_none() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
                     outcome = Some(true);
@@ -289,7 +350,14 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
                 ui.with_layout(egui::Layout::right_to_left(egui::Align::Min), |ui| {
                     ui.spacing_mut().item_spacing.x = 10.0;
                     if matches!(d.kind, DialogKind::About | DialogKind::Error) {
-                        if dialog_buttons(ui, &[DialogButton::new(ButtonRole::Default, tl!("OK"), 84.0)]).is_some() {
+                        // ↩ is OK too, as on every other dialog (#4872), from the frame after the
+                        // alert appeared: the ↩ that raised it (committing a locked layer's Free
+                        // Transform, say) must not close it again at once.
+                        let seen = id.with("alert-seen");
+                        let shown_before = ui.ctx().data(|m| m.get_temp::<bool>(seen).unwrap_or(false));
+                        ui.ctx().data_mut(|m| m.insert_temp(seen, true));
+                        let enter = interactive && shown_before && ui.input(|i| i.key_pressed(egui::Key::Enter));
+                        if dialog_buttons(ui, &[DialogButton::new(ButtonRole::Default, tl!("OK"), 84.0)]).is_some() || enter {
                             outcome = Some(false);
                         }
                     } else {
@@ -303,10 +371,11 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
                             crate::file_ui::ok_label(&d.fields).unwrap_or(tl!("OK"))
                         };
                         // Dialogs that need an input first (a preset name, a selection) grey OK out.
-                        let can_ok = crate::crop_presets::can_confirm(app, &fields);
+                        let can_ok = crate::crop_presets::can_confirm(app, &fields) && crate::stack_dialog::can_confirm(&fields);
                         let ok = DialogButton::new(ButtonRole::Default, ok_label, 84.0).enabled(can_ok);
                         // Photoshop: holding Alt turns Cancel into Reset (the dialog stays open).
-                        let reset = ui.input(|i| i.modifiers.alt) && crate::adjust_dialog::resets(&fields);
+                        // Dialogs opt in via `dialog_alt_reset::supported` (per marker).
+                        let reset = ui.input(|i| i.modifiers.alt) && crate::dialog_alt_reset::supported(&fields);
                         let cancel_label = if reset {
                             tl!("Reset")
                         } else if d.kind == DialogKind::NewDocument {
@@ -329,15 +398,36 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
                                 fields.insert("choice".into(), json!("apply"));
                             }
                             hit
+                        } else if crate::rasterize_prompt::is_filter(&fields) {
+                            // Photoshop: Convert to Smart Object / Rasterize / Cancel (#4303).
+                            let rasterize = DialogButton::new(ButtonRole::Default, tl!("Rasterize"), 84.0);
+                            let hit = if crate::rasterize_prompt::offers_smart_object(&fields) {
+                                let convert = DialogButton::new(ButtonRole::Alternate, tl!("Convert to Smart Object"), 160.0);
+                                dialog_buttons(ui, &[rasterize, cancel, convert])
+                            } else {
+                                dialog_buttons(ui, &[rasterize, cancel])
+                            };
+                            if hit == Some(ButtonRole::Alternate) {
+                                fields.insert("choice".into(), json!("smartObject"));
+                            } else if hit == Some(ButtonRole::Default) {
+                                fields.insert("choice".into(), json!("rasterize"));
+                            }
+                            hit
                         } else {
                             dialog_buttons(ui, &[ok, cancel])
                         };
                         match clicked {
-                            Some(ButtonRole::Cancel) if reset => crate::adjust_dialog::reset(ui.ctx(), &mut fields),
+                            Some(ButtonRole::Cancel) if reset => crate::dialog_alt_reset::apply(app, ui.ctx(), &mut fields),
                             Some(ButtonRole::Cancel) => outcome = Some(false),
                             Some(ButtonRole::Apply) => apply_requested = true,
                             Some(_) => outcome = Some(true),
-                            None if interactive && can_ok && ui.input(|i| i.key_pressed(egui::Key::Enter)) => outcome = Some(true),
+                            None if interactive
+                                && can_ok
+                                && (!web || (!web_popup_open && !egui::Popup::is_any_open(ui.ctx())))
+                                && ui.input(|i| i.key_pressed(egui::Key::Enter)) =>
+                            {
+                                outcome = Some(true)
+                            }
                             None => {}
                         }
                     }
@@ -349,7 +439,7 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
         // The picker has a larger frame margin; include that whole frame in the canvas hit guard.
         shown.push(if color_picker { modal.response.rect } else { modal.inner });
         // Pin once laid out at its real size (the first frame is an invisible sizing pass).
-        if !sizing && (pinned.is_none() || drag != egui::Vec2::ZERO) {
+        if !sizing && (web || pinned.is_none() || drag != egui::Vec2::ZERO) {
             let screen = ctx.content_rect();
             // Keep the whole dialog (and so its title bar) on screen.
             let room = (screen.size() - modal.response.rect.size()).max(egui::Vec2::ZERO);
@@ -478,15 +568,20 @@ pub fn confirm(app: &mut PhotocraftApp, id: u64) -> Result<Value, String> {
             r
         }
         DialogKind::Command if crate::guide_layout_ui::owns(&d.fields) => crate::guide_layout_ui::confirm(app, &d.fields),
+        DialogKind::Command if crate::brush_preset_dialog::owns(&d.fields) => crate::brush_preset_dialog::confirm(app, &d.fields),
         DialogKind::Command if crate::fill_ui::owns(&d.fields) => crate::fill_ui::confirm(app, &d.fields),
         DialogKind::Command if crate::pattern_fill_ui::owns(&d.fields) => crate::pattern_fill_ui::confirm(app, &d.fields),
         DialogKind::Command if crate::stroke_ui::owns(&d.fields) => crate::stroke_ui::confirm(app, &d.fields),
+        DialogKind::Command if crate::channel_options_ui::owns(&d.fields) => crate::channel_options_ui::confirm(app, &d.fields),
+        DialogKind::Command if crate::channel_options_ui::owns_new_spot(&d.fields) => crate::channel_options_ui::confirm_new_spot(app, &d.fields),
         DialogKind::Command if crate::shape_dialog::owns(&d.fields) => crate::shape_dialog::confirm(app, &d.fields),
         DialogKind::Command if crate::delete_layer_prompt::owns(&d.fields) => crate::delete_layer_prompt::confirm(app, &d.fields),
+        DialogKind::Command if crate::actions::owns_insert_stop(&d.fields) => crate::actions::insert_stop_confirm(app, &d.fields),
         DialogKind::Command if crate::new_layer_ui::owns(&d.fields) => crate::new_layer_ui::confirm(app, &d.fields),
         DialogKind::Command if crate::mask_trash_prompt::owns(&d.fields) => crate::mask_trash_prompt::confirm(app, &d.fields),
         DialogKind::Command if crate::rasterize_prompt::owns(&d.fields) => crate::rasterize_prompt::confirm(app, &d.fields),
         DialogKind::Command if crate::duplicate_layer_ui::owns(&d.fields) => crate::duplicate_layer_ui::confirm(app, &d.fields),
+        DialogKind::Command if crate::stack_dialog::owns(&d.fields) => crate::stack_dialog::confirm(app, &d.fields),
         DialogKind::Command if crate::tool_reset::owns(&d.fields) => crate::tool_reset::confirm(app),
         DialogKind::Command if crate::crop_presets::owns(&d.fields) => crate::crop_presets::confirm(app, &d.fields),
         DialogKind::Command if crate::variables_ui::owns(&d.fields) => crate::variables_ui::confirm(app, &d.fields),
@@ -518,6 +613,8 @@ pub fn confirm(app: &mut PhotocraftApp, id: u64) -> Result<Value, String> {
             }
             if result.is_ok() {
                 crate::filter_dialog::remember(app, &cmd, &d.fields);
+                // A step dialog of a playing action: the action continues after it.
+                crate::actions::resume(app, &d.fields);
             }
             result
         }
@@ -529,9 +626,14 @@ pub fn confirm(app: &mut PhotocraftApp, id: u64) -> Result<Value, String> {
 /// Cancel a dialog and its dependent Layer Style picker, without applying edits.
 pub fn cancel(app: &mut PhotocraftApp, id: u64) -> Result<Value, String> {
     let closed = app.ui.close_dialog(id).ok_or_else(|| format!("no dialog {id}"))?;
+    crate::actions::stopped(app, &closed.fields);
     if crate::guide_layout_ui::owns(&closed.fields) {
         app.ui.dialogs.retain(|child| child.fields.get("__dialog").and_then(Value::as_u64) != Some(id));
     }
+    // Cancel on a profile prompt opens neither its file nor the ones still to come.
+    if crate::open_prompt::owns(&closed.fields) {
+        crate::open_prompt::answer(app, None)?;
+    }
     app.ui.dialogs.retain(|d| !crate::layer_style::color_picker::child_of(&d.fields, id));
     app.filter_preview = None;
     app.color_range = None;
@@ -583,6 +685,7 @@ mod tests {
             revision: st.revision,
             dialog: id,
             active: st.active_layer,
+            target: st.channel_view.target,
             command: "filter.blur.gaussianBlur".into(),
             params: serde_json::json!({"radius": 4.0}),
             k: 1,
@@ -715,6 +818,32 @@ mod tests {
         assert_eq!(harness.state().ui.dialogs.len(), 1, "dragging must not close the dialog");
     }
 
+    /// #4872: an alert (Error, About) closes with ↩ as with OK, but not on the ↩ that raised it.
+    #[test]
+    fn enter_closes_an_alert_but_not_the_enter_that_opened_it() {
+        let app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(900.0, 600.0)).build_ui_state(|ui, app| show(app, ui.ctx()), app);
+        PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+        h.run_steps(2);
+        let alert = |h: &mut egui_kittest::Harness<'static, PhotocraftApp>| {
+            h.state_mut().ui.open_dialog(DialogKind::Error, json!({"message": crate::move_lock::MESSAGE}).as_object().cloned().unwrap_or_default())
+        };
+        // Raised in the frame its own ↩ arrives: that ↩ leaves it open.
+        alert(&mut h);
+        h.key_press(egui::Key::Enter);
+        h.run_steps(2);
+        assert_eq!(h.state().ui.dialogs.len(), 1, "the ↩ that raised the alert doesn't close it");
+        h.key_press(egui::Key::Enter);
+        h.run_steps(2);
+        assert!(h.state().ui.dialogs.is_empty(), "↩ is OK");
+        // A new alert starts over, and Esc still closes it.
+        alert(&mut h);
+        h.run_steps(2);
+        h.key_press(egui::Key::Escape);
+        h.run_steps(2);
+        assert!(h.state().ui.dialogs.is_empty(), "Esc too");
+    }
+
     fn dialog_harness(size: egui::Vec2, command: &str) -> egui_kittest::Harness<'static, PhotocraftApp> {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
         app.run("file.new", json!({"width": 64, "height": 64})).unwrap();
@@ -849,4 +978,23 @@ mod tests {
         h.run_steps(2);
         assert_eq!(radius(&h), Some(5.0), "a cancelled 9 is not remembered");
     }
+
+    /// #4673: File › Automate › Fit Image holds two numbers and a check box, so its window is as
+    /// wide as that content and its buttons, not the 380-point floor of the larger dialogs.
+    #[test]
+    fn fit_image_is_as_narrow_as_its_content() {
+        use egui_kittest::kittest::Queryable;
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 64, "height": 64})).unwrap();
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1280.0, 800.0)).build_ui_state(|ui, app| show(app, ui.ctx()), app);
+        PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+        let ctx = h.ctx.clone();
+        let d = crate::menus::invoke(h.state_mut(), &ctx, "file.automate.fitImage", json!({})).unwrap()["dialog"].as_u64().unwrap();
+        h.run_steps(4);
+        let window = h.ctx.memory(|m| m.area_rect(egui::Id::new(("dialog", d)))).expect("the Fit Image window");
+        assert!(window.width() < 300.0, "Fit Image is {} points wide", window.width());
+        for label in ["Fit Image", "Width", "Height", "OK", "Cancel"] {
+            assert!(window.contains_rect(h.get_by_label(label).rect()), "{label} inside the window");
+        }
+    }
 }
diff --git a/crates/ui-egui/src/direct_select.rs b/crates/ui-egui/src/direct_select.rs
index 4955053962..addd5fd0de 100644
--- a/crates/ui-egui/src/direct_select.rs
+++ b/crates/ui-egui/src/direct_select.rs
@@ -7,14 +7,19 @@
 //!   canvas to marquee-select anchors, click empty canvas to deselect.
 //! * Drag selected anchors to move them, a direction handle to turn it (a smooth point keeps its
 //!   handles collinear; ⌥ breaks them apart), or a segment to bend it (straight segments move).
+//!   The arrow keys nudge the selected anchors 1 px (⇧ 10 px), one history step per press.
 //! * Convert Point (the tool, or Pen + ⌥): click an anchor to make it a corner, drag from it to
 //!   pull out smooth handles, drag a handle to move it alone. The tool selects the anchor it
 //!   converts, so its handles show; a press on empty canvas or a segment does nothing, and ⌘/Ctrl
 //!   is Direct Selection, as with the Pen.
+//! * While a Pen path is being drawn, ⌘/Ctrl edits it in place (its anchors, handles and
+//!   segments) and the Pen carries on drawing from its last anchor once ⌘/Ctrl is let go; a
+//!   ⌘/Ctrl-press anywhere else ends it, as in Photoshop (#4022).
 //!
 //! A drag previews with `photocraft_vector::edit` and commits once on release through the engine
 //! (`path.moveAnchors`, `path.moveHandle`, `path.bendSegment`, `path.convertPoint`): one history
-//! step per drag, and the same commands drive it over MCP and the control channel.
+//! step per drag, and the same commands drive it over MCP and the control channel. The Pen path
+//! being drawn is not in the document yet: its edits apply to it directly, without a command.
 
 use egui::{Color32, Modifiers, Pos2};
 use photocraft_doc::vector::Path;
@@ -34,6 +39,8 @@ pub enum PathRef {
     Work,
     /// A layer's shape path, or its vector mask.
     Layer(u64),
+    /// The Pen path being drawn (`ui.pen`): edited in place, not through the engine.
+    Pen,
 }
 
 impl PathRef {
@@ -42,6 +49,8 @@ impl PathRef {
         match self {
             PathRef::Work => json!({"name": "work"}),
             PathRef::Layer(id) => json!({"name": "layer", "layer": id}),
+            // Never sent: edits to the Pen path being drawn don't go through the engine.
+            PathRef::Pen => json!({}),
         }
     }
 }
@@ -134,14 +143,34 @@ pub fn shows(app: &PhotocraftApp, mods: Modifiers) -> bool {
         || matches!(app.ui.tool, Tool::AddAnchorPoint | Tool::DeleteAnchorPoint | Tool::ConvertPoint)
 }
 
-/// The paths Direct Selection edits, front first: the targeted vector mask or the active shape
-/// layer's path, then the work path.
-pub(crate) fn candidates(app: &PhotocraftApp) -> Vec<(PathRef, Path)> {
+/// The active paths, front first: the targeted vector mask or the active shape layer's path, then
+/// the work path. The Pen's Auto Add/Delete edits these (`anchor_tools::pen_auto`).
+pub(crate) fn active_paths(app: &PhotocraftApp) -> Vec<(PathRef, Path)> {
     let layer = crate::vector_ui::targeted_vector_mask(app).or_else(|| crate::vector_ui::active_shape_path(app));
     let work = app.session.active().and_then(|st| st.doc.work_path.clone());
     layer.map(|(id, p)| (PathRef::Layer(id), p)).into_iter().chain(work.map(|p| (PathRef::Work, p))).collect()
 }
 
+/// The paths Direct Selection edits, front first: the Pen path being drawn, the active paths, then
+/// every visible shape layer.
+pub(crate) fn candidates(app: &PhotocraftApp) -> Vec<(PathRef, Path)> {
+    let pen = app.ui.pen.as_ref().filter(|p| !p.dragging && !p.knots.is_empty()).map(|p| (PathRef::Pen, crate::vector_ui::pen_path(p)));
+    let mut out: Vec<_> = pen.into_iter().chain(active_paths(app)).collect();
+    if let Some(st) = app.session.active() {
+        for (path, _, l) in st.doc.walk().iter().rev() {
+            if !l.visible || !(1..=path.len()).all(|n| st.doc.layer_at(&path[..n]).is_some_and(|a| a.visible)) {
+                continue;
+            }
+            if let photocraft_doc::LayerContent::Shape(sh) = &l.content
+                && !out.iter().any(|(r, _)| *r == PathRef::Layer(l.id.0))
+            {
+                out.push((PathRef::Layer(l.id.0), sh.path.clone()));
+            }
+        }
+    }
+    out
+}
+
 fn retracted(k: &photocraft_doc::Knot, h: Handle) -> bool {
     let c = if h == Handle::In { k.in_ctrl } else { k.out_ctrl };
     (c.x - k.anchor.x).abs() < 1e-9 && (c.y - k.anchor.y).abs() < 1e-9
@@ -176,8 +205,9 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: Modifiers) -> bool
             if !(direct(tool, mods) || convert) {
                 return false;
             }
-            if !pen_idle && tool != Tool::DirectSelection {
-                // ⌘-click ends the path being drawn, which becomes editable, as in Photoshop.
+            if !pen_idle && tool != Tool::DirectSelection && !hits_pen(app, [x, y]) {
+                // ⌘-click off the path being drawn ends it, which becomes editable, as in
+                // Photoshop. A press on it edits it in place and the Pen carries on (#4022).
                 crate::vector_ui::pen_commit(app, false);
             }
             if tool == Tool::FreeformPen {
@@ -199,8 +229,8 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: Modifiers) -> bool
             true
         }
         ToolEvent::Up { x, y } => match app.ui.direct_selection.drag.take() {
-            Some(Drag::Edit { target, edit, start, .. }) => {
-                release(app, target, &edit, start, [x, y]);
+            Some(Drag::Edit { target, base, edit, start, .. }) => {
+                release(app, target, &base, &edit, start, [x, y]);
                 true
             }
             Some(Drag::Marquee { start, add, .. }) => {
@@ -212,6 +242,16 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: Modifiers) -> bool
     }
 }
 
+/// Does a press at `p` hit the Pen path being drawn: one of its anchors, shown handles or segments?
+fn hits_pen(app: &PhotocraftApp, p: [f64; 2]) -> bool {
+    let tol = 6.0 / f64::from(app.point_zoom().max(0.01));
+    let ds = &app.ui.direct_selection;
+    candidates(app).into_iter().filter(|(r, _)| *r == PathRef::Pen).any(|(r, path)| {
+        let handles = if ds.target == Some(r) { shown_handles(ds, &path) } else { Vec::new() };
+        edit::hit(&path, Point::new(p[0], p[1]), tol, &handles).is_some()
+    })
+}
+
 /// A press: pick what's under the pointer and start a drag. False lets the Pen handle a ⌥-press
 /// that hit nothing; the Convert Point tool has nothing else to do, so it keeps the press.
 fn press(app: &mut PhotocraftApp, p: [f64; 2], mods: Modifiers, convert: bool) -> bool {
@@ -222,14 +262,19 @@ fn press(app: &mut PhotocraftApp, p: [f64; 2], mods: Modifiers, convert: bool) -
         let handles = if ds.target == Some(r) { shown_handles(ds, &path) } else { Vec::new() };
         edit::hit(&path, Point::new(p[0], p[1]), tol, &handles).map(|h| (r, path, h))
     });
-    let ds = &mut app.ui.direct_selection;
     let Some((target, base, hit)) = found else {
         if convert {
             return own_tool;
         }
-        ds.drag = Some(Drag::Marquee { start: p, end: p, add: mods.shift });
+        app.ui.direct_selection.drag = Some(Drag::Marquee { start: p, end: p, add: mods.shift });
         return true;
     };
+    if let PathRef::Layer(id) = target
+        && app.session.active().and_then(|st| st.active_layer).map(|l| l.0) != Some(id)
+    {
+        let _ = app.run("layer.select", json!({"layer": id}));
+    }
+    let ds = &mut app.ui.direct_selection;
     if ds.target != Some(target) {
         *ds = DirectSelection { target: Some(target), ..Default::default() };
     }
@@ -282,9 +327,23 @@ fn press(app: &mut PhotocraftApp, p: [f64; 2], mods: Modifiers, convert: bool) -
 }
 
 /// End of an edit drag: commit it as one command. A click (no movement) commits nothing, except
-/// Pen + ⌥ on an anchor, which makes it a corner.
-fn release(app: &mut PhotocraftApp, target: PathRef, edit: &Edit, start: [f64; 2], end: [f64; 2]) {
+/// Pen + ⌥ on an anchor, which makes it a corner. The Pen path being drawn takes the edit directly.
+fn release(app: &mut PhotocraftApp, target: PathRef, base: &Path, edit: &Edit, start: [f64; 2], end: [f64; 2]) {
     let moved = (end[0] - start[0]).hypot(end[1] - start[1]) * f64::from(app.point_zoom()) >= 1.0;
+    if target == PathRef::Pen {
+        let edited = match edit {
+            Edit::Convert(k) if !moved => {
+                let mut p = base.clone();
+                edit::convert_point(&mut p, *k, None).ok().map(|_| p)
+            }
+            _ if !moved => None,
+            e => e.preview(base, start, end),
+        };
+        if let Some(p) = edited {
+            crate::vector_ui::pen_replace(app, &p);
+        }
+        return;
+    }
     let (id, mut params) = match edit {
         Edit::Convert([s, k]) if !moved => ("path.convertPoint", json!({"subpath": s, "knot": k})),
         _ if !moved => return,
@@ -323,6 +382,37 @@ fn marquee(app: &mut PhotocraftApp, start: [f64; 2], end: [f64; 2], add: bool) {
     }
 }
 
+/// Arrow keys with Direct Selection and selected anchors (#4486), as in Photoshop: nudge them
+/// 1 px (⇧ 10 px) through `path.moveAnchors`, one history step per press. Not while a drag is
+/// in progress. Returns true when a key was used.
+pub fn arrow_keys(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
+    let ds = &app.ui.direct_selection;
+    let Some(target) = ds.target.filter(|_| app.ui.tool == Tool::DirectSelection && !ds.anchors.is_empty() && ds.drag.is_none()) else {
+        return false;
+    };
+    let anchors = ds.anchors.clone();
+    use egui::Key;
+    let keys = [(Key::ArrowLeft, -1.0, 0.0), (Key::ArrowRight, 1.0, 0.0), (Key::ArrowUp, 0.0, -1.0), (Key::ArrowDown, 0.0, 1.0)];
+    for (key, ux, uy) in keys {
+        // ⇧ first: `consume_key` ignores an extra ⇧.
+        for mods in [Modifiers::SHIFT, Modifiers::NONE] {
+            if ctx.input_mut(|i| i.consume_key(mods, key)) {
+                let k = if mods.shift { 10.0 } else { 1.0 };
+                let mut params = json!({"anchors": anchors, "move": [ux * k, uy * k]});
+                if let (Some(p), Some(t)) = (params.as_object_mut(), target.params().as_object()) {
+                    p.extend(t.clone());
+                }
+                if let Err(e) = app.run("path.moveAnchors", params) {
+                    app.ui.status = e;
+                    app.ui.status_error = true;
+                }
+                return true;
+            }
+        }
+    }
+    false
+}
+
 /// Paths with their anchors (selected ones filled), the shown handles, the drag's preview in
 /// place of its path, and the marquee. `paths` false (View › Show › Target Path off) leaves only
 /// the marquee.
diff --git a/crates/ui-egui/src/direct_select_tests.rs b/crates/ui-egui/src/direct_select_tests.rs
index 17334a1626..c6b02c79b9 100644
--- a/crates/ui-egui/src/direct_select_tests.rs
+++ b/crates/ui-egui/src/direct_select_tests.rs
@@ -118,23 +118,87 @@ fn marquee_shift_and_empty_clicks_select_like_photoshop() {
 }
 
 #[test]
-fn pen_with_command_edits_paths_and_ends_the_one_being_drawn() {
+fn pen_with_command_ends_the_path_being_drawn_when_pressed_off_it() {
     let mut app = app(Tool::Pen);
     for p in [[30.0, 30.0], [90.0, 30.0]] {
         click(&mut app, p, Modifiers::NONE);
     }
     assert_eq!(app.ui.pen.as_ref().map(|p| p.knots.len()), Some(2));
-    // ⌘-drag (Ctrl-drag off the Mac) on the second anchor: the path is finished and edited.
-    drag(&mut app, [90.0, 30.0], [90.0, 70.0], Modifiers::COMMAND);
+    // ⌘-click (Ctrl-click off the Mac) on empty canvas: the path is finished, open.
+    click(&mut app, [170.0, 170.0], Modifiers::COMMAND);
     assert!(app.ui.pen.is_none());
     assert_eq!(app.ui.tool, Tool::Pen, "the Pen stays the tool");
-    let wp = work(&app);
-    assert_eq!((wp.subpaths[0].closed, wp.subpaths[0].knots[1].anchor), (false, Point::new(90.0, 70.0)));
+    assert!(!work(&app).subpaths[0].closed);
+    // ⌘-drag then edits the finished path.
+    drag(&mut app, [90.0, 30.0], [90.0, 70.0], Modifiers::COMMAND);
+    assert_eq!(anchor(&app, 1), Point::new(90.0, 70.0));
     // Without ⌘ the Pen draws again.
     click(&mut app, [150.0, 150.0], Modifiers::NONE);
     assert_eq!(app.ui.pen.as_ref().map(|p| p.knots.len()), Some(1));
 }
 
+/// #4022: ⌘/Ctrl-dragging an anchor of the path being drawn moves it in place; the path stays
+/// unfinished, outside the document and its history, and the Pen carries on from its last anchor.
+#[test]
+fn pen_with_command_edits_the_path_being_drawn_in_place() {
+    let mut app = app(Tool::Pen);
+    for p in [[30.0, 30.0], [90.0, 30.0]] {
+        click(&mut app, p, Modifiers::NONE);
+    }
+    let before = steps(&app);
+    drag(&mut app, [90.0, 30.0], [90.0, 70.0], Modifiers::COMMAND);
+    let pen = app.ui.pen.clone().expect("still drawing");
+    assert_eq!(pen.knots.len(), 2);
+    assert_eq!(pen.knots[1][0], [90.0, 70.0], "the anchor moved");
+    assert_eq!(pen.knots[0][0], [30.0, 30.0]);
+    assert!(app.session.active().unwrap().doc.work_path.is_none(), "not committed");
+    assert_eq!(steps(&app), before, "no history step until the path is finished");
+    // Let go of ⌘: the next click adds an anchor after the moved one.
+    click(&mut app, [150.0, 150.0], Modifiers::NONE);
+    assert_eq!(app.ui.pen.as_ref().map(|p| p.knots.len()), Some(3));
+    crate::vector_ui::pen_commit(&mut app, false);
+    let wp = work(&app);
+    assert_eq!(wp.subpaths[0].knots.len(), 3);
+    assert_eq!(wp.subpaths[0].knots[1].anchor, Point::new(90.0, 70.0));
+    assert_eq!(app.ui.direct_selection.target, None, "the Pen selection is gone with the Pen path");
+}
+
+/// ⌘/Ctrl-click selects an anchor of the path being drawn, showing its handles; ⌘-dragging one
+/// turns it and the other follows (a smooth point), still without committing.
+#[test]
+fn pen_with_command_turns_a_handle_of_the_path_being_drawn() {
+    let mut app = app(Tool::Pen);
+    click(&mut app, [30.0, 30.0], Modifiers::NONE);
+    drag(&mut app, [90.0, 30.0], [110.0, 30.0], Modifiers::NONE);
+    assert_eq!(app.ui.pen.as_ref().unwrap().knots[1], [[90.0, 30.0], [70.0, 30.0], [110.0, 30.0]]);
+    click(&mut app, [90.0, 30.0], Modifiers::COMMAND);
+    assert_eq!(app.ui.direct_selection.target, Some(PathRef::Pen));
+    assert_eq!(app.ui.direct_selection.anchors, vec![[0, 1]]);
+    drag(&mut app, [110.0, 30.0], [110.0, 50.0], Modifiers::COMMAND);
+    let k = app.ui.pen.as_ref().expect("still drawing").knots[1];
+    assert_eq!(k[2], [110.0, 50.0], "the outgoing handle turned");
+    let (o, i) = ([k[2][0] - k[0][0], k[2][1] - k[0][1]], [k[1][0] - k[0][0], k[1][1] - k[0][1]]);
+    assert!((o[0] * i[1] - o[1] * i[0]).abs() < 1e-6 && o[0] * i[0] + o[1] * i[1] < 0.0, "the incoming handle stays opposite: {k:?}");
+    assert!(app.session.active().unwrap().doc.work_path.is_none());
+}
+
+/// The Curvature Pen too: ⌘/Ctrl-dragging an anchor of its path in progress moves it, and the
+/// curve through the anchors follows.
+#[test]
+fn curvature_pen_with_command_moves_an_anchor_of_the_path_being_drawn() {
+    let mut app = app(Tool::CurvaturePen);
+    for p in [[30.0, 30.0], [90.0, 30.0], [150.0, 60.0]] {
+        click(&mut app, p, Modifiers::NONE);
+    }
+    let before = app.ui.pen.clone().unwrap();
+    drag(&mut app, [90.0, 30.0], [90.0, 10.0], Modifiers::COMMAND);
+    let pen = app.ui.pen.clone().expect("still drawing");
+    assert!(pen.curvature && pen.knots.len() == 3);
+    assert_eq!(pen.knots[1][0], [90.0, 10.0]);
+    assert_ne!(pen.knots[1][1], before.knots[1][1], "the handles follow the moved anchor");
+    assert!(app.session.active().unwrap().doc.work_path.is_none());
+}
+
 #[test]
 fn pen_with_alt_converts_points() {
     let mut app = app(Tool::Pen);
@@ -225,3 +289,39 @@ fn the_convert_point_tool_shows_the_path_overlay() {
     assert!(!super::shows(&app, Modifiers::NONE));
     assert!(super::shows(&app, Modifiers::COMMAND));
 }
+
+/// One key press through the canvas arrow keys, as egui delivers it.
+fn press(app: &mut PhotocraftApp, key: egui::Key, mods: Modifiers) -> bool {
+    let ctx = egui::Context::default();
+    ctx.input_mut(|i| {
+        i.modifiers = mods;
+        i.events.push(egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: mods });
+    });
+    crate::move_mods::arrow_keys(app, &ctx)
+}
+
+/// #4486: the arrow keys nudge the selected anchors 1 px (⇧ 10 px), one history step per press,
+/// as in Photoshop. With no anchor selected they leave the path alone.
+#[test]
+fn arrow_keys_nudge_the_selected_anchors() {
+    let mut app = app(Tool::DirectSelection);
+    with_path(&mut app);
+    // The path stays targeted after a click on empty canvas, but no anchor is selected.
+    click(&mut app, [40.0, 120.0], Modifiers::NONE);
+    click(&mut app, [80.0, 80.0], Modifiers::NONE);
+    assert_eq!(app.ui.direct_selection.target, Some(PathRef::Work));
+    let n = steps(&app);
+    assert!(!press(&mut app, egui::Key::ArrowRight, Modifiers::NONE), "no anchor selected: not Direct Selection's key");
+    assert_eq!(steps(&app), n);
+    click(&mut app, [40.0, 120.0], Modifiers::NONE);
+    click(&mut app, [120.0, 120.0], Modifiers::SHIFT);
+    let (before, n) = (work(&app), steps(&app));
+    assert!(press(&mut app, egui::Key::ArrowRight, Modifiers::NONE));
+    assert_eq!((anchor(&app, 2), anchor(&app, 3)), (Point::new(121.0, 120.0), Point::new(41.0, 120.0)));
+    assert!(press(&mut app, egui::Key::ArrowDown, Modifiers::SHIFT));
+    assert_eq!((anchor(&app, 2), anchor(&app, 3)), (Point::new(121.0, 130.0), Point::new(41.0, 130.0)), "⇧ nudges 10 px");
+    assert_eq!(anchor(&app, 0), Point::new(40.0, 40.0), "unselected anchors stay");
+    assert_eq!(steps(&app), n + 2, "one history step per press");
+    assert!(app.session.undo() && app.session.undo());
+    assert_eq!(work(&app), before);
+}
diff --git a/crates/ui-egui/src/discard_ui.rs b/crates/ui-egui/src/discard_ui.rs
index b0b455ec9c..23248cd9ae 100644
--- a/crates/ui-egui/src/discard_ui.rs
+++ b/crates/ui-egui/src/discard_ui.rs
@@ -120,9 +120,9 @@ pub fn guard_window_close(app: &mut PhotocraftApp, ctx: &egui::Context) {
         ctx.send_viewport_cmd(egui::ViewportCommand::Focus);
         return;
     }
-    // A save still writing in the background finishes first (a saved copy, say, leaves nothing
-    // unsaved); `jobs_ui` repeats the close when it ends.
-    if app.saving() {
+    // A save or print worker must finish its external side effect before the process exits;
+    // `jobs_ui` repeats the close after completion and keeps errors visible.
+    if app.saving() || app.printing() {
         ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
         app.jobs.close_after_saves = true;
         return;
@@ -249,7 +249,9 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
     // The answers in the platform's words; `dialog_buttons` puts them in its order. Windows (and
     // Linux) ask Yes / No / Cancel with Y, N and Esc, as Photoshop does there; macOS asks
     // Don't Save / Cancel / Save. Esc always cancels (the modal closes on it).
-    let cancel = (ButtonRole::Cancel, "Cancel", mac.then_some(Key::C), 84.0, Answer::Cancel);
+    // Yes/No already show Y/N. Cancel gets C on every platform (#4582). macOS still hides the
+    // letters and keeps the shortcut.
+    let cancel = (ButtonRole::Cancel, "Cancel", Some(Key::C), 84.0, Answer::Cancel);
     let buttons = if reverts {
         vec![(ButtonRole::Default, "Revert", Some(Key::R), 84.0, Answer::Discard), cancel]
     } else if mac {
@@ -286,14 +288,70 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
     if answer.is_none() && ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, Key::Enter)) {
         answer = buttons.iter().find(|b| b.0 == ButtonRole::Default).map(|b| b.4);
     }
-    match answer {
-        Some(Answer::Cancel) => app.discard = None,
-        Some(Answer::Discard) => advance(app, ctx),
-        Some(Answer::Save) if save(app, ctx, doc) => advance(app, ctx),
-        _ => {}
+    if let Some(answer) = answer {
+        apply(app, ctx, doc, answer);
     }
 }
 
+/// Acts on the answer about `doc`, the document the prompt is asking about.
+fn apply(app: &mut PhotocraftApp, ctx: &egui::Context, doc: DocId, answer: Answer) {
+    match answer {
+        Answer::Cancel => app.discard = None,
+        Answer::Discard => advance(app, ctx),
+        Answer::Save if save(app, ctx, doc) => advance(app, ctx),
+        Answer::Save => {}
+    }
+}
+
+/// The id `ui.inspect` lists the prompt under; `ui.dialog.confirm` and `ui.dialog.cancel` answer
+/// it by this id, so a control client can see and answer it like the window's buttons (#4920).
+pub const CONTROL_ID: &str = "discard";
+
+/// The prompt as `ui.inspect` lists it among the dialogs: the command waiting on it, the document
+/// it asks about, how many are still to answer, and the choices `ui.dialog.confirm` takes.
+pub fn inspect(app: &PhotocraftApp) -> Option<Value> {
+    let p = app.discard.as_ref()?;
+    let doc = *p.docs.first()?;
+    let name = index_of(app, doc).and_then(|i| app.session.documents().get(i)).map(|d| d.doc.name.clone())?;
+    let reverts = p.id == "file.revert";
+    let (choices, default): (&[&str], _) = if reverts { (&["dontSave", "cancel"], "dontSave") } else { (&["save", "dontSave", "cancel"], "save") };
+    Some(json!({
+        "id": CONTROL_ID,
+        "kind": "unsavedChanges",
+        "title": if reverts { "Revert" } else { "Unsaved changes" },
+        "fields": {"command": p.id, "document": name, "remaining": p.docs.len(), "choices": choices, "default": default},
+    }))
+}
+
+/// The command the prompt holds back and its params, for the automation policy to see before a
+/// control client answers it.
+pub fn pending_command(app: &PhotocraftApp) -> Option<(String, Value)> {
+    app.discard.as_ref().map(|p| (p.id.clone(), p.params.clone()))
+}
+
+/// Answers the prompt for a control client: `save`, `dontSave` or `cancel` (Revert takes
+/// `dontSave` or `cancel`). Like the buttons, Save may first ask for a path in the save dialog.
+pub fn answer_control(app: &mut PhotocraftApp, ctx: &egui::Context, choice: &str) -> Result<Value, String> {
+    let Some(doc) = app.discard.as_ref().and_then(|p| p.docs.first().copied()) else {
+        return Err("no unsaved-changes prompt is open".into());
+    };
+    if app.file_dialog_open() || app.save_options_open() || app.saving() {
+        return Err("the unsaved-changes prompt is waiting for a save to finish".into());
+    }
+    let reverts = app.discard.as_ref().is_some_and(|p| p.id == "file.revert");
+    let answer = match choice {
+        "save" if !reverts => Answer::Save,
+        "dontSave" => Answer::Discard,
+        "cancel" => Answer::Cancel,
+        other => {
+            let choices = if reverts { "dontSave or cancel" } else { "save, dontSave or cancel" };
+            return Err(format!("unknown choice `{other}`: {choices}"));
+        }
+    };
+    apply(app, ctx, doc, answer);
+    Ok(json!({"open": app.discard.is_some(), "fileDialog": app.file_dialog_open()}))
+}
+
 #[derive(Clone, Copy)]
 enum Answer {
     Save,
@@ -506,18 +564,14 @@ mod tests {
     fn windows_and_linux_ask_yes_no_cancel_with_the_default_first() {
         for os in [egui::os::OperatingSystem::Windows, egui::os::OperatingSystem::Nix] {
             let mut h = prompt_on(os);
-            let labels = ["(Y)es", "(N)o", "Cancel"];
+            let labels = ["(Y)es", "(N)o", "(C)ancel"];
             assert_eq!(drawn_order(&h, labels), labels, "{os:?}");
             tab_walks(&mut h, labels);
             h.key_press(Key::N);
             h.run_steps(2);
             assert_eq!(docs_left(&h), Some(1), "N answered the first document");
-            // Cancel has no letter here: C does nothing, Esc cancels.
             h.key_press(Key::C);
             h.run_steps(2);
-            assert_eq!(docs_left(&h), Some(1));
-            h.key_press(Key::Escape);
-            h.run_steps(2);
             assert!(h.state().discard.is_none());
             assert_eq!(h.state().session.documents().len(), 1, "Cancel keeps the unanswered document");
         }
@@ -584,6 +638,7 @@ mod tests {
         assert_eq!(button_label(true, "Don't Save", Some(Key::D)), tl!("Don't Save"));
         assert_eq!(button_label(true, "Cancel", Some(Key::C)), tl!("Cancel"));
         assert_eq!(button_label(false, "Don't Save", Some(Key::D)), "(D)on't Save");
+        assert_eq!(button_label(false, "Cancel", Some(Key::C)), "(C)ancel");
     }
 
     #[test]
diff --git a/crates/ui-egui/src/discard_ui/tests/targa_tests.rs b/crates/ui-egui/src/discard_ui/tests/targa_tests.rs
index e4c83bda64..565fe01037 100644
--- a/crates/ui-egui/src/discard_ui/tests/targa_tests.rs
+++ b/crates/ui-egui/src/discard_ui/tests/targa_tests.rs
@@ -113,7 +113,7 @@ fn save_a_copy_to_a_targa_asks_and_keeps_the_document_unsaved() {
     crate::menus::invoke(h.state_mut(), &ctx, "file.saveACopy", json!({})).unwrap();
     h.run_steps(3);
     assert_eq!(h.state().targa_options.as_ref().map(|p| (p.bits, p.copy)), Some((TgaBits::Bits32, true)));
-    assert!(targa_options_ui::park(h.state_mut(), "other.tga".into(), false, true).is_err(), "the waiting prompt is kept");
+    assert!(targa_options_ui::park(h.state_mut(), "other.tga".into(), false, "file.saveAs").is_err(), "the waiting prompt is kept");
     assert_eq!(h.state().targa_options.as_ref().map(|p| p.path.as_str()), Some("copy.tga"));
     h.key_press(Key::Enter);
     h.run_steps(3);
@@ -140,8 +140,8 @@ fn targa_options_keeps_a_layered_save_as_a_copy() {
     assert_eq!(st.path, None);
 }
 
-/// An action being recorded keeps a Targa Save As with its bits, answered in Targa Options or
-/// scripted (#2032), and plays it back without asking; the dialog's Save a Copy isn't recorded.
+/// An action being recorded keeps a Targa Save As or Save a Copy with its bits, answered in Targa
+/// Options or scripted (#2032, #4373), and plays them back without asking.
 #[test]
 fn recorded_targa_save_as_keeps_its_bits_and_replays_without_asking() {
     let (mut h, writes) = targa_app(true, "copy.tga");
@@ -164,12 +164,22 @@ fn recorded_targa_save_as_keeps_its_bits_and_replays_without_asking() {
         &[("t.tga".to_string(), asked(Some(24))), ("copy.tga".to_string(), asked(Some(32))), ("s.tga".to_string(), asked(Some(32)))]
     );
     let steps = &h.state().session.actions.list[0].steps;
-    assert_eq!(steps, &[("file.saveAs".into(), json!({"path": "t.tga", "tgaBits": 24})), ("file.saveAs".into(), json!({"path": "s.tga", "tgaBits": 32}))]);
+    assert_eq!(
+        steps,
+        &[
+            ("file.saveAs".into(), json!({"path": "t.tga", "tgaBits": 24})),
+            ("file.saveACopy".into(), json!({"path": "copy.tga", "tgaBits": 32})),
+            ("file.saveAs".into(), json!({"path": "s.tga", "tgaBits": 32}))
+        ]
+    );
     writes.borrow_mut().clear();
     let played = h.state_mut().run("actions.play", json!({"action": 0})).unwrap();
     assert!(played.get("failed").is_none(), "{played}");
     assert!(h.state().targa_options.is_none(), "playback doesn't ask");
-    assert_eq!(writes.borrow().as_slice(), &[("t.tga".to_string(), asked(Some(24))), ("s.tga".to_string(), asked(Some(32)))]);
+    assert_eq!(
+        writes.borrow().as_slice(),
+        &[("t.tga".to_string(), asked(Some(24))), ("copy.tga".to_string(), asked(Some(32))), ("s.tga".to_string(), asked(Some(32)))]
+    );
 }
 
 /// Closing an unsaved document whose save goes to a Targa waits behind Targa Options, then closes.
diff --git a/crates/ui-egui/src/distort_ui.rs b/crates/ui-egui/src/distort_ui.rs
index 0a0d7914b0..9f0966b5c3 100644
--- a/crates/ui-egui/src/distort_ui.rs
+++ b/crates/ui-egui/src/distort_ui.rs
@@ -172,11 +172,16 @@ pub fn keys(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
         }
         return true;
     }
-    if app.distort.puppet.is_some() {
+    if let Some(p) = app.distort.puppet.as_mut() {
+        let cmd_shift = egui::Modifiers::COMMAND | egui::Modifiers::SHIFT;
         if enter(ctx) {
             crate::puppet_ui::commit(app);
         } else if esc(ctx) {
             app.distort.puppet = None;
+        } else if ctx.input_mut(|i| i.consume_key(cmd_shift, egui::Key::Z)) {
+            p.redo();
+        } else if ctx.input_mut(|i| i.consume_key(egui::Modifiers::COMMAND, egui::Key::Z)) {
+            p.undo();
         }
         return true;
     }
diff --git a/crates/ui-egui/src/doc_props_ui.rs b/crates/ui-egui/src/doc_props_ui.rs
index 2383590c79..8c10b8c442 100644
--- a/crates/ui-egui/src/doc_props_ui.rs
+++ b/crates/ui-egui/src/doc_props_ui.rs
@@ -3,15 +3,16 @@
 //! Rulers & Grids toggles. Every edit dispatches an engine or view command, so the panel stays thin.
 
 use egui::{Align2, Rect, RichText, Sense, Stroke, StrokeKind, pos2, vec2};
-use photocraft_doc::{ColorMode, Document, Layer, LayerContent, LayerId, SampleType};
+use photocraft_doc::{ColorMode, Document, Layer, LayerId, SampleType};
 use serde_json::{Value, json};
 
 use crate::theme::Tokens;
 use crate::{PhotocraftApp, icons, widgets};
 
-/// Photoshop's Background layer: the locked, opaque raster layer at the bottom of the stack.
+/// Photoshop's Background layer: the locked, opaque raster layer at the bottom of the stack,
+/// whatever its (localized) name ([`Document::background`]).
 pub fn is_background(doc: &Document, l: &Layer) -> bool {
-    l.name == "Background" && l.locks.transparency && matches!(l.content, LayerContent::Raster(_)) && doc.layers.first().is_some_and(|b| b.id == l.id)
+    doc.is_background(l.id)
 }
 
 /// Does the Properties panel show the Document view? (No layer selected, or the Background layer.)
diff --git a/crates/ui-egui/src/dock.rs b/crates/ui-egui/src/dock.rs
index 7d70a72e77..0aab2769ea 100644
--- a/crates/ui-egui/src/dock.rs
+++ b/crates/ui-egui/src/dock.rs
@@ -424,6 +424,26 @@ fn rects_id() -> egui::Id {
     egui::Id::new("dock-group-rects")
 }
 
+/// The group expanded from its collapsed tab strip (see [`show`]), if any: with Preferences ▸
+/// Workspace ▸ Auto-Collapse Iconic Panels on, the first click outside it collapses it again.
+fn peek_id() -> egui::Id {
+    egui::Id::new("dock-peek")
+}
+
+fn auto_collapse_peek(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    let Some(g) = ctx.data(|d| d.get_temp::<Option<Group>>(peek_id())).flatten() else { return };
+    let Some(p) = ctx.input(|i| i.pointer.any_pressed().then(|| i.pointer.press_origin()).flatten()) else {
+        return;
+    };
+    let inside = last_rects(ctx).into_iter().find(|(x, _)| *x == g).is_some_and(|(_, r)| r.contains(p));
+    if !inside {
+        app.ui.dock.set_collapsed(g, true);
+        ctx.data_mut(|d| {
+            d.insert_temp(peek_id(), None::<Group>);
+        });
+    }
+}
+
 /// A group's tab strip as drawn last frame (screen points), for tests and automation.
 #[derive(Clone, Debug, PartialEq)]
 pub struct StripRects {
@@ -451,6 +471,14 @@ fn strips_id() -> egui::Id {
 /// group's tab content.
 pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui, shown: &[Group], mut body: impl FnMut(&mut PhotocraftApp, &mut egui::Ui, Group, usize)) {
     let t = Tokens::get(ui.ctx());
+    let auto_collapse = app.session.prefs().workspace.auto_collapse_icon_panels;
+    if auto_collapse {
+        auto_collapse_peek(app, ui.ctx());
+    } else {
+        ui.ctx().data_mut(|d| {
+            d.insert_temp(peek_id(), None::<Group>);
+        });
+    }
     let strip = if t.pro { 28.0 } else { 40.0 };
     let order: Vec<Group> = app.ui.dock.order().into_iter().filter(|g| shown.contains(g)).collect();
     let area = ui.available_rect_before_wrap();
@@ -458,6 +486,7 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui, shown: &[Group], mut bod
     let locked = app.session.prefs().workspace_locked;
     let rects = rects_after_layout(&heights, area);
     let mut actions: Vec<Action> = Vec::new();
+    let mut peek_after: Option<Group> = None;
     let mut tab_drops: Vec<(Group, usize, Pos2)> = Vec::new();
     let mut dragging: Option<Group> = None;
     let mut strips: Vec<StripRects> = Vec::with_capacity(rects.len());
@@ -525,6 +554,11 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui, shown: &[Group], mut bod
         }
         if resp.strip.double_clicked() || resp.tab_double_clicked || (collapsed && resp.tab_clicked) {
             actions.push(Action::ToggleCollapse(g));
+            // A single click on a collapsed strip's tab expands the group as a peek: the next
+            // click outside closes it again, with Auto-Collapse Iconic Panels on.
+            if collapsed && resp.tab_clicked && !resp.tab_double_clicked && auto_collapse {
+                peek_after = Some(g);
+            }
         }
         // The strip uses visible indices; reorder in original ones.
         if !locked
@@ -567,6 +601,14 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui, shown: &[Group], mut bod
                 crate::swatches_ui::panel_menu(app, ui);
                 ui.separator();
             }
+            if tabs.get(sel) == Some(&"Brush Settings") {
+                crate::brush_panel::panel_menu(app, ui);
+                ui.separator();
+            }
+            if tabs.get(sel) == Some(&"Actions") {
+                crate::actions::panel_menu(app, ui);
+                ui.separator();
+            }
             if let Some(label) = tabs.get(sel) {
                 crate::panel_docking::legacy_menu(app, ui, label);
             }
@@ -663,6 +705,13 @@ pub fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui, shown: &[Group], mut bod
             }
         }
     }
+    if let Some(g) = peek_after
+        && !app.ui.dock.is_collapsed(g)
+    {
+        ui.ctx().data_mut(|d| {
+            d.insert_temp(peek_id(), Some(g));
+        });
+    }
     for (panel, anchor, before) in panel_moves {
         let params = if before { json!({"panel":panel,"anchor":anchor,"before":anchor}) } else { json!({"panel":panel,"anchor":anchor}) };
         if let Err(error) = app.run("window.panel.move", params) {
@@ -765,6 +814,10 @@ pub fn restore(app: &mut PhotocraftApp) {
     }
     let saved = app.session.prefs().panel_layout.clone();
     apply(app, &saved);
+    // The floating Brush Settings window is transient, not a dock panel: remembering the
+    // workspace must not leave it open on a fresh launch, especially with no document.
+    // Explicit workspace switches still use `apply` and keep their stored panel visibility.
+    app.ui.panels.brush_settings = false;
     if let Some(ws) = saved.get("workspace").and_then(Value::as_str) {
         app.ui.workspace = ws.to_string();
     }
diff --git a/crates/ui-egui/src/dock_tests.rs b/crates/ui-egui/src/dock_tests.rs
index dddcce6559..beb6b913de 100644
--- a/crates/ui-egui/src/dock_tests.rs
+++ b/crates/ui-egui/src/dock_tests.rs
@@ -350,6 +350,43 @@ fn a_single_tab_click_expands_a_collapsed_panel() {
     }
 }
 
+/// Auto-Collapse Iconic Panels: a group expanded by clicking a tab on its collapsed strip
+/// closes again when the next click lands outside it; with the preference off it stays open.
+#[test]
+fn auto_collapse_icon_panels_closes_a_peeked_panel_on_an_outside_click() {
+    for auto in [true, false] {
+        let (mut app, _, _) = app_with_layers();
+        app.session.prefs.edit(|p| p.workspace.auto_collapse_icon_panels = auto);
+        app.ui.dock.set_collapsed(Group::Color, true);
+        let mut h = harness(app, vec2(1200.0, 800.0), ThemeKind::ProMedium);
+        let collapsed_height = rect_of(&h, Group::Color).height();
+        let tab = last_strips(&h.ctx).iter().find(|s| s.group == Group::Color).unwrap().tabs[0].1.center();
+        h.event(egui::Event::PointerMoved(tab));
+        h.run_steps(1);
+        h.event(egui::Event::PointerButton { pos: tab, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+        h.step();
+        h.event(egui::Event::PointerButton { pos: tab, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+        h.run_steps(3);
+        assert!(!h.state().ui.dock.is_collapsed(Group::Color), "auto={auto}: the tab click expands the panel");
+        let rect = rect_of(&h, Group::Color);
+        // A click inside the panel leaves it open; one outside (the canvas) closes it again.
+        for p in [rect.center(), Pos2::new(rect.left() / 2.0, rect.center().y)] {
+            h.event(egui::Event::PointerMoved(p));
+            h.run_steps(1);
+            h.event(egui::Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+            h.step();
+            h.event(egui::Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+            h.run_steps(3);
+        }
+        assert_eq!(h.state().ui.dock.is_collapsed(Group::Color), auto, "auto={auto}: outside closes it when enabled");
+        if auto {
+            assert_eq!(rect_of(&h, Group::Color).height(), collapsed_height);
+        } else {
+            assert!(rect_of(&h, Group::Color).height() > collapsed_height);
+        }
+    }
+}
+
 #[test]
 fn double_clicking_a_tab_collapses_and_dragging_a_strip_reorders() {
     let (app, _, _) = app_with_layers();
@@ -1082,3 +1119,31 @@ fn a_tab_dragged_off_the_strip_moves_the_group_and_locking_stops_reordering() {
     drag(&mut h, paths.center(), paths.center() + vec2(0.0, 500.0));
     assert_eq!(h.state().ui.dock.order(), order);
 }
+
+#[test]
+fn brush_settings_window_is_closed_on_restart_but_can_be_reopened() {
+    let mut first = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    first.ui.panels.brush_settings = true;
+    first.ui.panels.history = true;
+    let saved = snapshot(&first);
+    first.session.prefs.edit(|p| {
+        p.workspace.remember_workspace_changes = true;
+        p.panel_layout = saved.clone();
+    });
+    let persisted = first.session.prefs_to_json();
+
+    let mut session = photocraft_engine::Session::new();
+    session.load_prefs_json(&persisted).unwrap();
+    let mut next = PhotocraftApp::new(session, crate::Services::default());
+    restore(&mut next);
+    assert!(!next.ui.panels.brush_settings, "a floating Brush Settings window should not reopen on startup");
+    assert!(next.ui.panels.history, "remembered dock panel visibility is preserved");
+
+    let ctx = egui::Context::default();
+    crate::menus::invoke(&mut next, &ctx, "window.toggle.brushSettings", json!({})).unwrap();
+    assert!(next.ui.panels.brush_settings, "Window > Brush Settings can still open it");
+
+    let mut workspace = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    apply(&mut workspace, &saved);
+    assert!(workspace.ui.panels.brush_settings, "switching workspaces still restores their saved layout");
+}
diff --git a/crates/ui-egui/src/duplicate_layer_ui.rs b/crates/ui-egui/src/duplicate_layer_ui.rs
index b1e7d6d994..c1b76c0ead 100644
--- a/crates/ui-egui/src/duplicate_layer_ui.rs
+++ b/crates/ui-egui/src/duplicate_layer_ui.rs
@@ -18,11 +18,16 @@ pub fn open(app: &mut PhotocraftApp) -> Result<Value, String> {
     fields.insert(MARK.into(), json!(true));
     fields.insert("__command".into(), json!("layer.duplicate"));
     fields.insert("destination".into(), json!(index));
+    // Photoshop's document-`Name` starts empty; the engine defaults it when empty.
+    fields.insert("documentName".into(), json!(""));
     fields.insert("document".into(), json!(st.doc.id.0));
     fields.insert("selected".into(), json!(selected.iter().map(|id| id.0).collect::<Vec<_>>()));
     // Several selected layers keep their names, as in Photoshop's Duplicate Layers.
     if selected.len() > 1 {
         fields.insert("__label".into(), json!("Duplicate Layers…"));
+    } else if layer.is_group() {
+        fields.insert("__label".into(), json!("Duplicate Group…"));
+        fields.insert("name".into(), json!(st.doc.copy_name(&layer.name)));
     } else {
         fields.insert("__label".into(), json!("Duplicate Layer…"));
         fields.insert("name".into(), json!(st.doc.copy_name(&layer.name)));
@@ -32,9 +37,14 @@ pub fn open(app: &mut PhotocraftApp) -> Result<Value, String> {
 }
 
 pub fn body(app: &PhotocraftApp, ui: &mut egui::Ui, fields: &mut Map<String, Value>) {
-    let documents: Vec<(usize, String)> = app.session.documents().iter().enumerate().map(|(i, d)| (i, d.doc.name.clone())).collect();
-    let options: Vec<(usize, &str)> = documents.iter().map(|(i, n)| (*i, n.as_str())).collect();
-    let mut destination = fields.get("destination").and_then(Value::as_u64).and_then(|i| usize::try_from(i).ok()).unwrap_or(0);
+    let documents: Vec<(String, String)> = app.session.documents().iter().enumerate().map(|(i, d)| (i.to_string(), d.doc.name.clone())).collect();
+    let mut options: Vec<(String, &str)> = documents.iter().map(|(k, n)| (k.clone(), n.as_str())).collect();
+    options.push(("new".to_string(), tl!("New")));
+    let mut destination = match fields.get("destination") {
+        Some(Value::String(s)) if s == "new" => "new".to_string(),
+        Some(Value::Number(n)) => n.to_string(),
+        _ => String::new(),
+    };
     egui::Grid::new("duplicate-layer").num_columns(2).spacing([12.0, 6.0]).show(ui, |ui| {
         if let Some(name) = fields.get("name").and_then(Value::as_str) {
             let mut name = name.to_string();
@@ -48,8 +58,20 @@ pub fn body(app: &PhotocraftApp, ui: &mut egui::Ui, fields: &mut Map<String, Val
         ui.label(tl!("Document"));
         crate::widgets::dropdown(ui, "duplicate-layer-document", &mut destination, &options, 260.0);
         ui.end_row();
+        // Photoshop's document-`Name` is only there when the destination is a new document.
+        if destination == "new" {
+            let mut doc_name = fields.get("documentName").and_then(Value::as_str).unwrap_or("").to_string();
+            ui.label(tl!("Name:"));
+            ui.add(egui::TextEdit::singleline(&mut doc_name).desired_width(260.0));
+            fields.insert("documentName".into(), json!(doc_name));
+            ui.end_row();
+        }
     });
-    fields.insert("destination".into(), json!(destination));
+    if destination == "new" {
+        fields.insert("destination".into(), json!("new"));
+    } else if let Ok(i) = destination.parse::<u64>() {
+        fields.insert("destination".into(), json!(i));
+    }
 }
 
 pub fn confirm(app: &mut PhotocraftApp, fields: &Map<String, Value>) -> Result<Value, String> {
@@ -60,16 +82,29 @@ pub fn confirm(app: &mut PhotocraftApp, fields: &Map<String, Value>) -> Result<V
     {
         return Err("The document or selected layers changed. Choose Duplicate Layer again.".into());
     }
-    let destination = fields.get("destination").and_then(Value::as_u64).and_then(|i| usize::try_from(i).ok()).ok_or("no destination document")?;
     let mut params = Map::new();
     if let Some(name) = fields.get("name").and_then(Value::as_str) {
         params.insert("name".into(), json!(name));
     }
-    if destination == index {
-        app.run_command("layer.duplicate", Value::Object(params))
-    } else {
-        params.insert("document".into(), json!(destination));
-        app.run_command("layer.copyToDocument", Value::Object(params))
+    match fields.get("destination") {
+        Some(Value::String(s)) if s == "new" => {
+            if let Some(doc_name) = fields.get("documentName").and_then(Value::as_str).filter(|n| !n.is_empty()) {
+                params.insert("documentName".into(), json!(doc_name));
+            }
+            params.insert("document".into(), json!("new"));
+            app.run_command("layer.duplicate", Value::Object(params))
+        }
+        Some(Value::Number(n)) => {
+            let destination =
+                n.as_u64().and_then(|i| usize::try_from(i).ok()).filter(|i| *i < app.session.documents().len()).ok_or("no destination document")?;
+            if destination == index {
+                app.run_command("layer.duplicate", Value::Object(params))
+            } else {
+                params.insert("document".into(), json!(destination));
+                app.run_command("layer.copyToDocument", Value::Object(params))
+            }
+        }
+        _ => Err("no destination document".into()),
     }
 }
 
@@ -114,6 +149,42 @@ mod tests {
         assert!(names(&app, 1).contains(&"Ink copy".to_string()));
     }
 
+    #[test]
+    fn a_new_destination_makes_a_named_document_holding_just_the_copy() {
+        let mut app = make_app();
+        let dialog = invoke(&mut app);
+        let fields = &mut app.ui.dialog_mut(dialog).unwrap().fields;
+        fields.insert("destination".into(), json!("new"));
+        fields.insert("documentName".into(), json!("Card"));
+        crate::dialogs::confirm(&mut app, dialog).unwrap();
+        assert_eq!(app.session.documents().len(), 2);
+        assert_eq!(app.session.active_index(), Some(1));
+        assert_eq!(app.session.documents()[1].doc.name, "Card");
+        assert_eq!(app.session.documents()[0].doc.layer_count(), 2, "the source is untouched");
+        assert!(names(&app, 1).contains(&"Ink copy".to_string()));
+    }
+
+    #[test]
+    fn a_new_destination_without_a_name_defaults_it_and_refuses_a_dead_index() {
+        let mut app = make_app();
+        let dialog = invoke(&mut app);
+        app.ui.dialog_mut(dialog).unwrap().fields.insert("destination".into(), json!("new"));
+        crate::dialogs::confirm(&mut app, dialog).unwrap();
+        assert_eq!(app.session.documents()[1].doc.name, "Poster copy");
+        let dialog = invoke(&mut app);
+        app.ui.dialog_mut(dialog).unwrap().fields.insert("destination".into(), json!(7));
+        assert!(crate::dialogs::confirm(&mut app, dialog).is_err());
+        assert_eq!(app.session.documents().len(), 2);
+    }
+
+    #[test]
+    fn a_single_group_gets_the_group_title() {
+        let mut app = make_app();
+        app.session.execute("layer.new.group", json!({"name": "Pack"})).unwrap();
+        let _dialog = invoke(&mut app);
+        assert_eq!(app.ui.dialogs[0].fields["__label"], "Duplicate Group…");
+    }
+
     #[test]
     fn a_changed_document_refuses_and_direct_runs_stay_dialog_free() {
         let mut app = make_app();
diff --git a/crates/ui-egui/src/edit_history.rs b/crates/ui-egui/src/edit_history.rs
new file mode 100644
index 0000000000..2012f912c7
--- /dev/null
+++ b/crates/ui-egui/src/edit_history.rs
@@ -0,0 +1,241 @@
+//! Undo inside a dialog (#4697): ⌘Z / ⇧⌘Z step through the open dialog's own settings, as in
+//! Photoshop, instead of reaching the document's History beneath it (which the dialog previews
+//! and is about to change), or doing nothing.
+//!
+//! A dialog keeps an [`EditHistory`] of its settings and calls [`EditHistory::settle`] every frame
+//! and after a control-channel edit. A change becomes one step once no edit is in progress, so a
+//! slider drag is one step rather than one per frame. Liquify, Puppet Warp and Camera Raw keep
+//! their own histories.
+
+use std::collections::HashMap;
+
+use serde_json::{Map, Value};
+
+use crate::PhotocraftApp;
+use crate::state::DialogKind;
+
+/// Most steps a dialog keeps.
+const LIMIT: usize = 100;
+
+pub struct EditHistory<T> {
+    undo: Vec<T>,
+    redo: Vec<T>,
+    /// The settings as of the latest step.
+    settled: T,
+}
+
+impl<T: Clone + PartialEq> EditHistory<T> {
+    pub fn new(now: &T) -> Self {
+        Self { undo: Vec::new(), redo: Vec::new(), settled: now.clone() }
+    }
+
+    /// Records a change since the latest step as a new step, unless `busy` (a drag in progress).
+    pub fn settle(&mut self, now: &T, busy: bool) {
+        if busy || *now == self.settled {
+            return;
+        }
+        if self.undo.len() >= LIMIT {
+            self.undo.remove(0);
+        }
+        self.undo.push(std::mem::replace(&mut self.settled, now.clone()));
+        self.redo.clear();
+    }
+
+    /// Steps `now` back (`Undo`) or forward (`Redo`); an unfinished edit is the latest step.
+    /// False when there is nowhere to go.
+    pub fn step(&mut self, now: &mut T, step: Step) -> bool {
+        self.settle(now, false);
+        let (from, to) = match step {
+            Step::Undo => (&mut self.undo, &mut self.redo),
+            Step::Redo => (&mut self.redo, &mut self.undo),
+        };
+        let Some(next) = from.pop() else { return false };
+        to.push(std::mem::replace(now, next.clone()));
+        self.settled = next;
+        true
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Step {
+    Undo,
+    Redo,
+}
+
+/// ⌘Z or ⇧⌘Z pressed this frame, consumed.
+fn take_step(ctx: &egui::Context) -> Option<Step> {
+    let cmd_shift = egui::Modifiers::COMMAND | egui::Modifiers::SHIFT;
+    if ctx.input_mut(|i| i.consume_key(cmd_shift, egui::Key::Z)) {
+        Some(Step::Redo)
+    } else if ctx.input_mut(|i| i.consume_key(egui::Modifiers::COMMAND, egui::Key::Z)) {
+        Some(Step::Undo)
+    } else {
+        None
+    }
+}
+
+/// A parameter dialog's settings: its fields without the private `__` keys (preview toggle,
+/// command, label…).
+fn settings(fields: &Map<String, Value>) -> Map<String, Value> {
+    fields.iter().filter(|(k, _)| !k.starts_with("__")).map(|(k, v)| (k.clone(), v.clone())).collect()
+}
+
+/// The parameter dialogs' histories, by dialog id.
+pub type DialogEdits = HashMap<u64, EditHistory<Map<String, Value>>>;
+
+/// Once a frame: records each open parameter dialog's settings and forgets closed dialogs.
+pub fn track_dialogs(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    let busy = ctx.input(|i| i.pointer.any_down());
+    let dialogs = &app.ui.dialogs;
+    app.dialog_edits.retain(|id, _| dialogs.iter().any(|d| d.id == *id));
+    for d in dialogs.iter().filter(|d| d.kind == DialogKind::Command) {
+        let now = settings(&d.fields);
+        app.dialog_edits.entry(d.id).or_insert_with(|| EditHistory::new(&now)).settle(&now, busy);
+    }
+}
+
+/// ⌘Z / ⇧⌘Z while a dialog with its own history is in front: steps that dialog, and the keys
+/// never reach the document's History beneath it. A focused text field keeps them for its typing.
+pub fn keys(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    if ctx.text_edit_focused() {
+        return;
+    }
+    if let Some(top) = app.ui.dialogs.last() {
+        if top.kind != DialogKind::Command {
+            return;
+        }
+        let id = top.id;
+        let mut now = settings(&top.fields);
+        if let Some(step) = take_step(ctx)
+            && app.dialog_edits.entry(id).or_insert_with(|| EditHistory::new(&now)).step(&mut now, step)
+            && let Some(d) = app.ui.dialog_mut(id)
+        {
+            d.fields.retain(|k, _| k.starts_with("__"));
+            d.fields.extend(now);
+        }
+    } else if let Some(d) = app.distort.gallery.as_mut() {
+        if let Some(step) = take_step(ctx) {
+            d.step(step);
+        }
+    } else if let Some(d) = app.wide_angle.as_mut() {
+        if let Some(step) = take_step(ctx) {
+            d.step(step);
+        }
+    } else if let Some(s) = app.distort.vanishing.as_mut()
+        && let Some(step) = take_step(ctx)
+    {
+        s.step(step);
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    /// One frame of the shell's key handling with ⌘Z (plus `modifiers`) pressed.
+    pub(crate) fn press_z(app: &mut PhotocraftApp, ctx: &egui::Context, modifiers: egui::Modifiers) {
+        let raw = egui::RawInput {
+            events: vec![egui::Event::Key { key: egui::Key::Z, physical_key: None, pressed: true, repeat: false, modifiers }],
+            ..Default::default()
+        };
+        let mut out = ctx.run_ui(raw, |ui| crate::shortcuts::handle(app, ui.ctx()));
+        out.textures_delta.clear();
+    }
+
+    fn app() -> PhotocraftApp {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": 120, "height": 80})).unwrap();
+        app.run("layer.new.layer", json!({})).unwrap();
+        app.run("edit.fill", json!({"color": "#808080"})).unwrap();
+        app
+    }
+
+    fn past(app: &PhotocraftApp) -> usize {
+        app.session.active().unwrap().history.past_len()
+    }
+
+    #[test]
+    fn a_drag_is_one_step_and_a_new_edit_drops_redo() {
+        let mut h = EditHistory::new(&0);
+        for v in 1..=5 {
+            h.settle(&v, true);
+        }
+        h.settle(&5, false);
+        h.settle(&7, false);
+        let mut now = 7;
+        assert!(h.step(&mut now, Step::Undo));
+        assert_eq!(now, 5);
+        assert!(h.step(&mut now, Step::Undo));
+        assert_eq!(now, 0, "the whole drag was one step");
+        assert!(!h.step(&mut now, Step::Undo));
+        assert!(h.step(&mut now, Step::Redo));
+        assert_eq!(now, 5);
+        now = 9;
+        assert!(!h.step(&mut now, Step::Redo), "a new edit drops what was undone");
+        assert!(h.step(&mut now, Step::Undo));
+        assert_eq!(now, 5, "an unsettled edit is undone first");
+    }
+
+    #[test]
+    fn command_z_steps_a_parameter_dialog_and_leaves_its_private_keys() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        let steps = past(&app);
+        let id = crate::dialogs::open_command_dialog(&mut app, "filter.lensCorrection", "Lens Correction");
+        track_dialogs(&mut app, &ctx);
+        let field = |app: &PhotocraftApp, k: &str| app.ui.dialogs.iter().find(|d| d.id == id).unwrap().fields.get(k).cloned();
+        let vertical = field(&app, "vertical");
+        let private: Vec<String> = app.ui.dialog_mut(id).unwrap().fields.keys().filter(|k| k.starts_with("__")).cloned().collect();
+        assert!(!private.is_empty());
+        app.ui.dialog_mut(id).unwrap().fields.insert("vertical".into(), json!(-50.0));
+        track_dialogs(&mut app, &ctx);
+        app.ui.dialog_mut(id).unwrap().fields.insert("horizontal".into(), json!(30.0));
+        track_dialogs(&mut app, &ctx);
+        press_z(&mut app, &ctx, egui::Modifiers::COMMAND);
+        assert_ne!(field(&app, "horizontal"), Some(json!(30.0)));
+        assert_eq!(field(&app, "vertical"), Some(json!(-50.0)), "one step at a time");
+        press_z(&mut app, &ctx, egui::Modifiers::COMMAND);
+        assert_eq!(field(&app, "vertical"), vertical);
+        assert_eq!(past(&app), steps, "the document beneath is untouched");
+        for k in &private {
+            assert!(field(&app, k).is_some(), "{k} survives");
+        }
+        press_z(&mut app, &ctx, egui::Modifiers::COMMAND | egui::Modifiers::SHIFT);
+        assert_eq!(field(&app, "vertical"), Some(json!(-50.0)));
+    }
+
+    #[test]
+    fn command_z_steps_the_filter_gallery_stack() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        let steps = past(&app);
+        crate::distort_ui::menu(&mut app, &ctx, "filter.filterGallery", &json!({})).unwrap().unwrap();
+        let before = app.distort.gallery.as_ref().unwrap().effects.clone();
+        crate::distort_ui::menu(&mut app, &ctx, "filter.filterGallery", &json!({"ui": {"add": true}})).unwrap().unwrap();
+        assert_eq!(app.distort.gallery.as_ref().unwrap().effects.len(), before.len() + 1);
+        press_z(&mut app, &ctx, egui::Modifiers::COMMAND);
+        let d = app.distort.gallery.as_ref().unwrap();
+        assert_eq!(d.effects, before);
+        assert!(d.selected < d.effects.len());
+        assert_eq!(past(&app), steps);
+    }
+
+    #[test]
+    fn command_z_steps_vanishing_point_planes() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        let steps = past(&app);
+        crate::distort_ui::menu(&mut app, &ctx, "filter.vanishingPoint", &json!({})).unwrap().unwrap();
+        let plane = json!([{"corners": [[30, 20], [90, 20], [110, 70], [10, 70]]}]);
+        crate::distort_ui::menu(&mut app, &ctx, "filter.vanishingPoint", &json!({"ui": {"planes": plane}})).unwrap().unwrap();
+        press_z(&mut app, &ctx, egui::Modifiers::COMMAND);
+        let s = app.distort.vanishing.as_ref().unwrap();
+        assert!(s.planes.is_empty());
+        assert_eq!(s.selected, None, "no selection left on a plane that is gone");
+        assert_eq!(past(&app), steps);
+        press_z(&mut app, &ctx, egui::Modifiers::COMMAND | egui::Modifiers::SHIFT);
+        assert_eq!(app.distort.vanishing.as_ref().unwrap().planes.len(), 1);
+    }
+}
diff --git a/crates/ui-egui/src/egui_fonts.rs b/crates/ui-egui/src/egui_fonts.rs
new file mode 100644
index 0000000000..4c71705e64
--- /dev/null
+++ b/crates/ui-egui/src/egui_fonts.rs
@@ -0,0 +1,91 @@
+//! egui's default fonts (Ubuntu Light, Hack, Noto Emoji and emoji-icon-font: the fallback stack
+//! behind Inter and JetBrains Mono, for symbols and emoji), stored deflated.
+//!
+//! egui's `default_fonts` feature embeds them uncompressed (1.4 MB), which the web build's 24 MiB
+//! size gate (packaging/web/package.sh) can't afford. The app builds egui without it; build.rs
+//! deflates the same files from the `epaint_default_fonts` crate (0.78 MB) and they are inflated
+//! once, the first time the fonts are installed. Test builds keep the feature (dev-dependencies),
+//! so egui's own definitions are the oracle for [`definitions`].
+
+use std::sync::{Arc, LazyLock};
+
+use egui::{FontData, FontDefinitions, FontFamily, FontTweak};
+
+/// A font deflated by build.rs.
+macro_rules! deflated {
+    ($name:literal) => {
+        include_bytes!(concat!(env!("OUT_DIR"), "/egui_fonts/", $name, ".ttf.deflate"))
+    };
+}
+
+static HACK: LazyLock<Vec<u8>> = LazyLock::new(|| inflate(deflated!("Hack-Regular")));
+static NOTO_EMOJI: LazyLock<Vec<u8>> = LazyLock::new(|| inflate(deflated!("NotoEmoji-Regular")));
+static UBUNTU_LIGHT: LazyLock<Vec<u8>> = LazyLock::new(|| inflate(deflated!("Ubuntu-Light")));
+static EMOJI_ICON: LazyLock<Vec<u8>> = LazyLock::new(|| inflate(deflated!("emoji-icon-font")));
+
+/// Inflated fonts are bounded (the largest is 0.42 MB), so corrupt data can't exhaust memory.
+const MAX_FONT_BYTES: u64 = 16 << 20;
+
+/// Inflate a font. Data that doesn't inflate gives empty bytes (the font is left out), never a panic.
+fn inflate(deflated: &[u8]) -> Vec<u8> {
+    use std::io::Read as _;
+    let mut out = Vec::new();
+    match flate2::read::DeflateDecoder::new(deflated).take(MAX_FONT_BYTES + 1).read_to_end(&mut out) {
+        Ok(_) if out.len() as u64 <= MAX_FONT_BYTES => out,
+        _ => Vec::new(),
+    }
+}
+
+/// `FontDefinitions::default()` with egui's default fonts, whether or not egui was built with
+/// `default_fonts`: the same faces, tweaks and family order.
+pub fn definitions() -> FontDefinitions {
+    let fonts = FontDefinitions::default();
+    if fonts.font_data.is_empty() { from_deflated() } else { fonts }
+}
+
+/// egui's default definitions, built from the deflated copies.
+fn from_deflated() -> FontDefinitions {
+    let mut fonts = FontDefinitions::empty();
+    let faces: [(&str, &'static [u8], f32); 4] = [
+        ("Hack", HACK.as_slice(), 1.0),
+        // egui draws its emoji fonts a little smaller.
+        ("NotoEmoji-Regular", NOTO_EMOJI.as_slice(), 0.81),
+        ("Ubuntu-Light", UBUNTU_LIGHT.as_slice(), 1.0),
+        ("emoji-icon-font", EMOJI_ICON.as_slice(), 0.90),
+    ];
+    for (name, bytes, scale) in faces {
+        if bytes.is_empty() {
+            log::error!("egui default font {name} is unavailable");
+            continue;
+        }
+        let data = FontData::from_static(bytes).tweak(FontTweak { scale, ..Default::default() });
+        fonts.font_data.insert(name.to_owned(), Arc::new(data));
+    }
+    let stack = |names: &[&str]| -> Vec<String> { names.iter().filter(|n| fonts.font_data.contains_key(**n)).map(|n| (*n).to_owned()).collect() };
+    let mono = stack(&["Hack", "Ubuntu-Light", "NotoEmoji-Regular", "emoji-icon-font"]);
+    let proportional = stack(&["Ubuntu-Light", "NotoEmoji-Regular", "emoji-icon-font"]);
+    fonts.families.insert(FontFamily::Monospace, mono);
+    fonts.families.insert(FontFamily::Proportional, proportional);
+    fonts
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The definitions built from the deflated copies are egui's own: the same bytes, tweaks and
+    /// family order (test builds enable `default_fonts`, so `FontDefinitions::default()` is egui's).
+    #[test]
+    fn deflated_fonts_match_egui_defaults() {
+        let egui = FontDefinitions::default();
+        assert!(!egui.font_data.is_empty(), "test builds enable egui's default_fonts (dev-dependencies)");
+        assert_eq!(from_deflated(), egui);
+        assert_eq!(definitions(), egui);
+    }
+
+    #[test]
+    fn corrupt_font_data_is_left_out_not_a_panic() {
+        assert!(inflate(b"not deflate data").is_empty());
+        assert!(inflate(&[]).is_empty());
+    }
+}
diff --git a/crates/ui-egui/src/export_dialog.rs b/crates/ui-egui/src/export_dialog.rs
index b16fbc31ae..a322ee108d 100644
--- a/crates/ui-egui/src/export_dialog.rs
+++ b/crates/ui-egui/src/export_dialog.rs
@@ -3,6 +3,8 @@
 //! pixel count, so the dialog stays instant on 36 MP documents.
 
 use std::sync::Arc;
+#[cfg(not(target_arch = "wasm32"))]
+use std::sync::Mutex;
 
 use photocraft_doc::Document;
 use serde_json::{Map, Value, json};
@@ -11,7 +13,47 @@ use crate::state::DialogKind;
 use crate::theme::Tokens;
 use crate::{ExportSettings, PhotocraftApp};
 
-const FORMATS: [(&str, &str); 5] = [("png", "PNG"), ("jpg", "JPG"), ("webp", "WebP"), ("tif", "TIFF"), ("tga", "TGA")];
+const FORMATS: [(&str, &str); 6] = [("png", "PNG"), ("jpg", "JPG"), ("webp", "WebP"), ("tif", "TIFF"), ("tga", "TGA"), ("ico", "ICO")];
+
+/// Preferences ▸ remembered dialog settings: Export As writes the settings it was used with
+/// last under its command id and seeds the next dialog from them, as Fill, Liquify and the
+/// filter dialogs do.
+pub(crate) const COMMAND: &str = "file.export.exportAs";
+
+/// The dialog is seeded from the settings it was used with last (see [`COMMAND`]); a value that
+/// no longer matches a control (a hand-edited preferences file) is left at its default.
+fn seed_remembered(app: &PhotocraftApp, f: &mut Map<String, Value>) {
+    let Some(Value::Object(saved)) = app.session.prefs().dialogs.get(COMMAND) else { return };
+    if let Some(v) = saved.get("format").and_then(Value::as_str).filter(|v| FORMATS.iter().any(|(k, _)| k == v)) {
+        f.insert("format".into(), json!(v));
+    }
+    if let Some(v) = saved.get("quality").and_then(Value::as_f64).filter(|v| (1.0..=100.0).contains(v)) {
+        f.insert("quality".into(), json!(v));
+    }
+    if let Some(v) = saved.get("scale").and_then(Value::as_f64).filter(|v| (1.0..=1000.0).contains(v)) {
+        f.insert("scale".into(), json!(v));
+    }
+    for key in ["lossless", "transparency"] {
+        if let Some(v) = saved.get(key).and_then(Value::as_bool) {
+            f.insert(key.into(), json!(v));
+        }
+    }
+    if let Some(v) = saved.get("metadata").and_then(Value::as_str).filter(|v| ["none", "all"].contains(v)) {
+        f.insert("metadata".into(), json!(v));
+    }
+    if let Some(v) = saved.get("tgaBits").and_then(Value::as_str).filter(|v| ["auto", "24", "32"].contains(v)) {
+        f.insert("tgaBits".into(), json!(v));
+    }
+}
+
+/// Record the settings for the next Export As (see [`seed_remembered`]).
+fn remember(app: &mut PhotocraftApp, f: &Map<String, Value>) {
+    const KEYS: [&str; 7] = ["format", "quality", "lossless", "transparency", "scale", "metadata", "tgaBits"];
+    let saved: Map<String, Value> = KEYS.iter().filter_map(|k| f.get(*k).map(|v| ((*k).to_string(), v.clone()))).collect();
+    app.session.prefs.edit(|p| {
+        p.dialogs.insert(COMMAND.into(), Value::Object(saved));
+    });
+}
 
 pub fn open(app: &mut PhotocraftApp) -> Result<u64, String> {
     let st = app.session.active().ok_or("no document")?;
@@ -27,6 +69,7 @@ pub fn open(app: &mut PhotocraftApp) -> Result<u64, String> {
     f.insert("tgaBits".into(), json!("auto"));
     f.insert("__w".into(), json!(st.doc.size.width));
     f.insert("__h".into(), json!(st.doc.size.height));
+    seed_remembered(app, &mut f);
     Ok(app.ui.open_dialog(DialogKind::Command, f))
 }
 
@@ -37,13 +80,30 @@ pub fn open_layer(app: &mut PhotocraftApp, layer: photocraft_doc::LayerId) -> Re
     let id = open(app)?;
     if let Some(d) = app.ui.dialogs.iter_mut().find(|d| d.id == id) {
         d.fields.insert("__layer".into(), json!(layer.0));
-        d.fields.insert("__label".into(), json!(format!("Export As: {}", ldoc.name)));
+        d.fields.insert("__label".into(), json!(crate::i18n::fmt(crate::i18n::t("Export As: {name}"), &[("name", &ldoc.name)])));
         d.fields.insert("__w".into(), json!(ldoc.size.width));
         d.fields.insert("__h".into(), json!(ldoc.size.height));
     }
     Ok(id)
 }
 
+/// Layer › Export As… with several layers (artboards, say) selected: the same dialog, then one
+/// file per layer with its settings (#3629). The preview shows the first layer.
+pub fn open_layers(app: &mut PhotocraftApp, layers: &[photocraft_doc::LayerId]) -> Result<u64, String> {
+    let (first, n) = match layers {
+        [] => return Err("no selected layers".into()),
+        [one] => return open_layer(app, *one),
+        [first, ..] => (*first, layers.len()),
+    };
+    let id = open_layer(app, first)?;
+    if let Some(d) = app.ui.dialogs.iter_mut().find(|d| d.id == id) {
+        d.fields.insert("__layers".into(), json!(layers.iter().map(|l| l.0).collect::<Vec<_>>()));
+        let template = "Export As: {n} layers";
+        d.fields.insert("__label".into(), json!(crate::i18n::fmt(tl!(template), &[("n", &n.to_string())])));
+    }
+    Ok(id)
+}
+
 /// Layer › Quick Export as PNG.
 pub fn quick_export_layer_png(app: &mut PhotocraftApp, layer: photocraft_doc::LayerId) -> Result<Value, String> {
     let mut f = Map::new();
@@ -96,10 +156,13 @@ fn export_name(name: &str) -> String {
     if name.is_empty() { "layer".into() } else { name.into() }
 }
 
+/// The files a multi-layer export writes: the chosen path, then numbered siblings named after
+/// each layer, in the chosen path's format.
 fn batch_paths(path: &str, docs: &[Document]) -> Vec<String> {
     let first = std::path::Path::new(path);
     let parent = first.parent().unwrap_or_else(|| std::path::Path::new(""));
     let stem = first.file_stem().and_then(|s| s.to_str()).unwrap_or("layers");
+    let ext = first.extension().and_then(|e| e.to_str()).unwrap_or("png");
     docs.iter()
         .enumerate()
         .map(|(i, doc)| {
@@ -107,7 +170,7 @@ fn batch_paths(path: &str, docs: &[Document]) -> Vec<String> {
                 return path.to_string();
             }
             let name = export_name(&doc.name);
-            let candidate = parent.join(format!("{stem}-{}-{name}.png", i + 1));
+            let candidate = parent.join(format!("{stem}-{}-{name}.{ext}", i + 1));
             // The first file's overwrite is handled by the Save dialog; never overwrite sibling
             // files silently on desktop. Downloads on the web are named by the browser.
             #[cfg(not(target_arch = "wasm32"))]
@@ -115,7 +178,7 @@ fn batch_paths(path: &str, docs: &[Document]) -> Vec<String> {
                 let mut candidate = candidate;
                 let mut suffix = 1u64;
                 while candidate.exists() {
-                    candidate = parent.join(format!("{stem}-{}-{name}-{suffix}.png", i + 1));
+                    candidate = parent.join(format!("{stem}-{}-{name}-{suffix}.{ext}", i + 1));
                     suffix = suffix.saturating_add(1);
                 }
                 candidate
@@ -126,14 +189,17 @@ fn batch_paths(path: &str, docs: &[Document]) -> Vec<String> {
 }
 
 /// The document a dialog exports: the whole image, or one layer (`__layer`).
-fn source_document(app: &PhotocraftApp, f: &Map<String, Value>) -> Result<Arc<Document>, String> {
-    let st = app.session.active().ok_or("no document")?;
+fn source_document_from(doc: Arc<Document>, f: &Map<String, Value>) -> Result<Arc<Document>, String> {
     match f.get("__layer").and_then(Value::as_u64) {
-        Some(id) => photocraft_engine::layer_menu_cmds::layer_document(&st.doc, photocraft_doc::LayerId(id)).map(Arc::new).map_err(|e| e.to_string()),
-        None => Ok(st.doc.clone()),
+        Some(id) => photocraft_engine::layer_menu_cmds::layer_document(&doc, photocraft_doc::LayerId(id)).map(Arc::new).map_err(|e| e.to_string()),
+        None => Ok(doc),
     }
 }
 
+fn source_document(app: &PhotocraftApp, f: &Map<String, Value>) -> Result<Arc<Document>, String> {
+    source_document_from(app.session.active().ok_or("no document")?.doc.clone(), f)
+}
+
 fn s(f: &Map<String, Value>, k: &str) -> String {
     f.get(k).and_then(Value::as_str).unwrap_or_default().to_string()
 }
@@ -156,6 +222,9 @@ fn export_document(doc: &Document, f: &Map<String, Value>, max_side: Option<u32>
     // Both dimensions are sent: a scale can leave a 1 px width unchanged while halving the
     // height, and the engine would otherwise keep the aspect ratio from the width alone.
     let (w, h) = scaled_size(doc.size.width as f64, doc.size.height as f64, scale);
+    if s_fmt(f) == "ico" && (w > 256.0 || h > 256.0) && max_side.is_none() {
+        return Err("ICO export is limited to 256 × 256 pixels; reduce the export scale".into());
+    }
     if (w - doc.size.width as f64).abs() >= 1.0 || (h - doc.size.height as f64).abs() >= 1.0 {
         s.execute("image.imageSize", json!({"width": w, "height": h, "resample": if max_side.is_some() { "bilinear" } else { "bicubic" }}))
             .map_err(|e| e.to_string())?;
@@ -217,15 +286,142 @@ fn settings(f: &Map<String, Value>) -> ExportSettings {
     }
 }
 
-/// Estimated size (bytes) from a ≤512 px proxy encode, scaled by pixel count.
-fn estimate(app: &PhotocraftApp, doc: &Document, f: &Map<String, Value>) -> Option<u64> {
-    let export = app.services.export.as_ref()?;
-    let proxy = export_document(doc, f, Some(512)).ok()?;
-    let (bytes, _) = export(&proxy, &format!("estimate.{}", s_fmt(f)), &settings(f)).ok()?;
+/// The preview and size estimate share a single reduced document. Resizing every layer twice is
+/// especially expensive for layered PSDs, even when the canvas itself is small.
+fn preview_proxy(doc: &Document, f: &Map<String, Value>) -> Result<Document, String> {
+    export_document(doc, f, Some(if s_fmt(f) == "ico" { 256 } else { 512 }))
+}
+
+fn scaled_estimate(bytes: usize, doc: &Document, proxy: &Document, f: &Map<String, Value>) -> u64 {
     let scale = n(f, "scale", 100.0) / 100.0;
     let full = doc.size.width as f64 * scale * doc.size.height as f64 * scale;
     let small = (proxy.size.width as f64 * proxy.size.height as f64).max(1.0);
-    Some((bytes.len() as f64 * full / small) as u64)
+    (bytes as f64 * full / small) as u64
+}
+
+/// Estimated size (bytes) from the already prepared proxy encode, scaled by pixel count.
+fn estimate(app: &PhotocraftApp, doc: &Document, proxy: &Document, f: &Map<String, Value>) -> Option<u64> {
+    let export = app.services.export.as_ref()?;
+    let (bytes, _) = export(proxy, &format!("estimate.{}", s_fmt(f)), &settings(f)).ok()?;
+    Some(scaled_estimate(bytes.len(), doc, proxy, f))
+}
+
+struct PreviewPixels {
+    estimate: Option<u64>,
+    width: usize,
+    height: usize,
+    rgba: Vec<u8>,
+}
+
+fn preview_pixels(proxy: &Document, estimate: Option<u64>) -> PreviewPixels {
+    let img = photocraft_compose::thumbnail(proxy, 360);
+    PreviewPixels { estimate, width: img.width as usize, height: img.height as usize, rgba: img.pixels }
+}
+
+fn preview_sync(app: &PhotocraftApp, doc: &Document, f: &Map<String, Value>) -> Result<PreviewPixels, String> {
+    let proxy = preview_proxy(doc, f)?;
+    Ok(preview_pixels(&proxy, estimate(app, doc, &proxy, f)))
+}
+
+#[derive(Clone)]
+struct CachedPreview {
+    signature: String,
+    estimate: Option<u64>,
+    texture: Option<Arc<egui::TextureHandle>>,
+}
+
+fn cache_preview(ui: &mut egui::Ui, key: egui::Id, signature: String, result: Result<PreviewPixels, String>) -> CachedPreview {
+    let preview = match result {
+        Ok(pixels) => {
+            let image = egui::ColorImage::from_rgba_unmultiplied([pixels.width, pixels.height], &pixels.rgba);
+            let texture = Arc::new(ui.ctx().load_texture("export-preview", image, egui::TextureOptions::LINEAR));
+            CachedPreview { signature, estimate: pixels.estimate, texture: Some(texture) }
+        }
+        Err(error) => {
+            log::warn!("Export As preview failed: {error}");
+            CachedPreview { signature, estimate: None, texture: None }
+        }
+    };
+    ui.data_mut(|d| d.insert_temp(key, preview.clone()));
+    preview
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Clone)]
+struct PendingPreview {
+    key: egui::Id,
+    signature: String,
+    result: Arc<Mutex<Option<Result<PreviewPixels, String>>>>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn background_preview_needed(doc: &Document) -> bool {
+    doc.walk().len() > 32 || doc.size.area() > 16_000_000
+}
+
+/// Native app: keep the UI responsive while a many-layer document is reduced and encoded.
+/// A single pending job per document also avoids starting a worker for every slider tick.
+#[cfg(not(target_arch = "wasm32"))]
+fn poll_or_start_preview(
+    ui: &mut egui::Ui,
+    key: egui::Id,
+    signature: &str,
+    doc: Arc<Document>,
+    fields: &Map<String, Value>,
+) -> Option<Result<PreviewPixels, String>> {
+    let pending_key = egui::Id::new(("export-preview-pending", doc.id.0));
+    let pending: Option<PendingPreview> = ui.data(|d| d.get_temp(pending_key));
+    if let Some(pending) = pending {
+        let result = pending.result.lock().unwrap_or_else(std::sync::PoisonError::into_inner).take()?;
+        ui.data_mut(|d| d.remove::<PendingPreview>(pending_key));
+        if pending.key == key && pending.signature == signature {
+            return Some(result);
+        }
+    }
+
+    let result = Arc::new(Mutex::new(None));
+    let shared = result.clone();
+    let ctx = ui.ctx().clone();
+    let fields = fields.clone();
+    let started = std::thread::Builder::new().name("export-preview".into()).spawn(move || {
+        let prepared = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            let source = source_document_from(doc.clone(), &fields).unwrap_or(doc);
+            let proxy = preview_proxy(&source, &fields)?;
+            let estimate = estimate_native(&source, &proxy, &fields);
+            Ok::<_, String>(preview_pixels(&proxy, estimate))
+        }))
+        .unwrap_or_else(|_| Err("preview worker panicked".into()));
+        *shared.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(prepared);
+        ctx.request_repaint();
+    });
+    match started {
+        Ok(_) => {
+            ui.data_mut(|d| d.insert_temp(pending_key, PendingPreview { key, signature: signature.to_string(), result }));
+            None
+        }
+        Err(error) => Some(Err(format!("could not start preview worker: {error}"))),
+    }
+}
+
+/// The native exporter uses this same IO encoder. Keep the entire estimate off the UI thread.
+#[cfg(not(target_arch = "wasm32"))]
+fn estimate_native(doc: &Document, proxy: &Document, f: &Map<String, Value>) -> Option<u64> {
+    let settings = settings(f);
+    let mut options = photocraft_io::ExportOptions::default();
+    if let Some(quality) = settings.jpeg_quality {
+        options.encode.jpeg_quality = quality;
+    }
+    options.encode.webp_lossless = settings.webp_lossless;
+    if let Some(quality) = settings.webp_quality {
+        options.encode.webp_quality = quality;
+    }
+    options.tiff_layers = settings.tiff_layers;
+    options.xmp = if settings.xmp_all { photocraft_io::XmpEmbed::All } else { photocraft_io::XmpEmbed::None };
+    options.tga_bits = settings.tga_bits;
+    options.image_previews = settings.image_previews;
+    options.psd_maximize_compatibility = settings.psd_maximize_compatibility;
+    let bytes = photocraft_io::export(proxy, &format!("estimate.{}", s_fmt(f)), &options).ok()?.bytes;
+    Some(scaled_estimate(bytes.len(), doc, proxy, f))
 }
 
 pub fn body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Value>) {
@@ -290,6 +486,9 @@ pub fn body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Valu
             let (bw, bh) = (n(f, "__w", f64::from(doc.size.width)), n(f, "__h", f64::from(doc.size.height)));
             let (w, h) = scaled_size(bw, bh, f64::from(sc) / 100.0);
             ui.label(egui::RichText::new(format!("{w} × {h} px")).color(t.text_dim).size(11.5));
+            if fmt == "ico" && (w > 256.0 || h > 256.0) {
+                ui.label(egui::RichText::new(tl!("ICO is limited to 256 × 256 pixels")).color(t.warning));
+            }
         });
         ui.add_space(12.0);
         // Right: preview + estimated size.
@@ -306,28 +505,40 @@ pub fn body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Valu
                 s(f, "metadata"),
                 s(f, "tgaBits")
             );
-            let cached: Option<(String, Option<u64>, Arc<egui::TextureHandle>)> = ui.data(|d| d.get_temp(key));
-            let (size, tex) = match cached.filter(|c| c.0 == sig) {
-                Some((_, size, tex)) => (size, tex),
+            let cached: Option<CachedPreview> = ui.data(|d| d.get_temp(key));
+            let preview = match cached.filter(|cached| cached.signature == sig) {
+                Some(cached) => Some(cached),
                 None => {
-                    let src = source_document(app, f).unwrap_or_else(|_| doc.clone());
-                    let size = estimate(app, &src, f);
-                    let img = photocraft_compose::thumbnail(&export_document(&src, f, Some(360)).unwrap_or_else(|_| (*src).clone()), 360);
-                    let color = egui::ColorImage::from_rgba_unmultiplied([img.width as usize, img.height as usize], &img.pixels);
-                    let tex = Arc::new(ui.ctx().load_texture("export-preview", color, egui::TextureOptions::LINEAR));
-                    ui.data_mut(|d| d.insert_temp(key, (sig, size, tex.clone())));
-                    (size, tex)
+                    #[cfg(not(target_arch = "wasm32"))]
+                    let result = if background_preview_needed(&doc) {
+                        poll_or_start_preview(ui, key, &sig, doc.clone(), f)
+                    } else {
+                        let source = source_document(app, f).unwrap_or_else(|_| doc.clone());
+                        Some(preview_sync(app, &source, f))
+                    };
+                    #[cfg(target_arch = "wasm32")]
+                    let result = {
+                        let source = source_document(app, f).unwrap_or_else(|_| doc.clone());
+                        Some(preview_sync(app, &source, f))
+                    };
+                    result.map(|result| cache_preview(ui, key, sig, result))
                 }
             };
             let side = 300.0;
             let (r, _) = ui.allocate_exact_size(egui::vec2(side, side), egui::Sense::hover());
             crate::widgets::checker(ui.painter(), r, 8.0);
-            let ts = tex.size_vec2();
-            let k = (side / ts.x.max(ts.y)).min(1.0e3);
-            let ir = egui::Rect::from_center_size(r.center(), ts * k);
-            ui.painter().image(tex.id(), ir, egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)), egui::Color32::WHITE);
+            if let Some(tex) = preview.as_ref().and_then(|preview| preview.texture.as_ref()) {
+                let ts = tex.size_vec2();
+                let k = (side / ts.x.max(ts.y)).min(1.0e3);
+                let ir = egui::Rect::from_center_size(r.center(), ts * k);
+                ui.painter().image(tex.id(), ir, egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)), egui::Color32::WHITE);
+            } else if preview.is_none() {
+                ui.put(egui::Rect::from_center_size(r.center(), egui::vec2(24.0, 24.0)), egui::Spinner::new());
+            } else {
+                ui.painter().text(r.center(), egui::Align2::CENTER_CENTER, tl!("Preview"), egui::FontId::proportional(12.0), t.text_dim);
+            }
             ui.painter().rect_stroke(r, 0.0, egui::Stroke::new(1.0, t.separator), egui::StrokeKind::Outside);
-            let est = size.map_or("—".to_string(), |b| crate::sizing::human_bytes(b as f64));
+            let est = preview.as_ref().and_then(|preview| preview.estimate).map_or("—".to_string(), |b| crate::sizing::human_bytes(b as f64));
             ui.label(egui::RichText::new(format!("{}  ≈ {est}", s_fmt(f).to_uppercase())).color(t.text_dim).size(11.5));
         });
     });
@@ -335,6 +546,11 @@ pub fn body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Valu
 
 /// Export with the dialog's settings: choose a path, render, encode, write.
 pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value, String> {
+    remember(app, f);
+    if let Some(layers) = f.get("__layers").and_then(Value::as_array) {
+        let ids: Vec<_> = layers.iter().filter_map(Value::as_u64).map(photocraft_doc::LayerId).collect();
+        return confirm_layers(app, f, &ids);
+    }
     let doc = source_document(app, f)?;
     let stem = doc.name.rsplit_once('.').map_or(doc.name.as_str(), |(a, _)| a).to_string();
     let ext = s_fmt(f);
@@ -356,6 +572,39 @@ pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value,
     })
 }
 
+/// [`confirm`] for several layers: one destination prompt, then each layer exported with the
+/// dialog's settings and named as Quick Export names a selection's files. The layers are captured
+/// when asked, so changing the selection or document meanwhile can't change what is exported.
+fn confirm_layers(app: &mut PhotocraftApp, f: &Map<String, Value>, ids: &[photocraft_doc::LayerId]) -> Result<Value, String> {
+    let st = app.session.active().ok_or("no document")?;
+    let docs: Vec<Document> =
+        ids.iter().map(|id| photocraft_engine::layer_menu_cmds::layer_document(&st.doc, *id).map_err(|e| e.to_string())).collect::<Result<_, _>>()?;
+    if docs.is_empty() {
+        return Err("no selected layers".into());
+    }
+    let stem = st.doc.name.rsplit_once('.').map_or(st.doc.name.as_str(), |(a, _)| a);
+    let suggested = format!("{}.{}", export_name(stem), s_fmt(f));
+    let (f, settings) = (f.clone(), settings(f));
+    app.pick_save(&suggested, move |app, path| {
+        let mut exported = Vec::new();
+        for (doc, path) in docs.iter().zip(batch_paths(&path, &docs)) {
+            let out = export_document(doc, &f, None)?;
+            let export = app.services.export.as_ref().ok_or("no exporter configured")?;
+            let (bytes, warnings) = export(&out, &path, &settings)?;
+            let write = app.services.write.as_mut().ok_or("no writer configured")?;
+            write(&path, &bytes)?;
+            let template = "Exported {path}";
+            let what = crate::i18n::fmt(tl!(template), &[("path", &crate::file_open::display_name(&path))]);
+            crate::notices::io_warnings(app, &what, &warnings);
+            exported.push(json!({"path": path, "bytes": bytes.len(), "warnings": warnings}));
+        }
+        let template = "Exported {n} files";
+        app.ui.status = crate::i18n::fmt(tl!(template), &[("n", &exported.len().to_string())]);
+        app.ui.status_error = false;
+        Ok(json!({"files": exported}))
+    })
+}
+
 /// File › Export › Quick Export as PNG: the format, quality, metadata, colour space and location
 /// from File › Export › Export Preferences (engine `file.export.quickExport`). On the web (no
 /// file system) it falls back to a PNG download through the export service.
@@ -393,8 +642,71 @@ fn quick_export(app: &mut PhotocraftApp, p: Value) -> Result<Value, String> {
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn ico_export_is_available_and_rejects_oversize_output() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 300, "height": 200})).unwrap();
+        let mut f = Map::new();
+        f.insert("format".into(), json!("ico"));
+        f.insert("scale".into(), json!(100));
+        assert!(FORMATS.iter().any(|(ext, _)| *ext == "ico"));
+        assert!(export_document(&app.session.active().unwrap().doc, &f, None).err().is_some_and(|e| e.contains("256")));
+        f.insert("scale".into(), json!(50));
+        let resized = export_document(&app.session.active().unwrap().doc, &f, None).unwrap();
+        assert_eq!((resized.size.width, resized.size.height), (150, 100));
+    }
+
     use super::*;
 
+    /// Export As reopens with the settings it was used with last (Preferences ▸ remembered
+    /// dialog settings), and a value no control accepts keeps its default.
+    #[test]
+    fn export_as_opens_with_the_settings_used_last() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 20, "height": 10})).unwrap();
+        app.session.prefs.edit(|p| {
+            p.dialogs.insert(
+                COMMAND.into(),
+                json!({"format": "jpg", "quality": 88, "scale": 37, "transparency": false, "metadata": "all", "tgaBits": "24", "lossless": true}),
+            );
+        });
+        let id = open(&mut app).unwrap();
+        let f = &app.ui.dialog_mut(id).unwrap().fields;
+        assert_eq!(f["format"], "jpg");
+        assert_eq!(f["quality"], json!(88.0));
+        assert_eq!(f["scale"], json!(37.0));
+        assert_eq!(f["transparency"], false);
+        assert_eq!(f["metadata"], "all");
+        assert_eq!(f["tgaBits"], "24");
+
+        app.session.prefs.edit(|p| {
+            p.dialogs.insert(COMMAND.into(), json!({"format": "nope", "scale": 0, "metadata": "sometimes"}));
+        });
+        let id = open(&mut app).unwrap();
+        let f = &app.ui.dialog_mut(id).unwrap().fields;
+        assert_eq!(f["format"], "png");
+        assert_eq!(f["scale"], 100);
+        assert_eq!(f["metadata"], "none");
+    }
+
+    /// Only the dialog's own settings are remembered: not the destination, the document size or
+    /// the layer the dialog was opened with.
+    #[test]
+    fn remembering_keeps_only_the_dialog_settings() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let mut f = Map::new();
+        f.insert("format".into(), json!("webp"));
+        f.insert("scale".into(), json!(50));
+        f.insert("path".into(), json!("/tmp/x.webp"));
+        f.insert("__w".into(), json!(1200));
+        f.insert("__layer".into(), json!(3));
+        remember(&mut app, &f);
+        let saved = app.session.prefs().dialogs.get(COMMAND).cloned().unwrap();
+        assert_eq!(saved["format"], "webp");
+        assert_eq!(saved["scale"], 50);
+        assert!(saved.get("path").is_none() && saved.get("__w").is_none() && saved.get("__layer").is_none());
+    }
+
     #[test]
     fn export_document_scales_height_when_rounded_width_is_unchanged() {
         use photocraft_doc::{Color, ColorMode, SampleType, Size};
@@ -487,6 +799,54 @@ mod tests {
         assert_eq!(scaled_size(10.0, 300.0, 0.01), (1.0, 3.0));
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn layered_preview_runs_outside_the_ui_frame() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 32, "height": 16})).unwrap();
+        for _ in 0..33 {
+            app.run("layer.new.layer", json!({})).unwrap();
+        }
+        let doc = app.session.active().unwrap().doc.clone();
+        assert!(background_preview_needed(&doc));
+        let fields = Map::from_iter([("format".into(), json!("png")), ("scale".into(), json!(100))]);
+        let ctx = egui::Context::default();
+        let key = egui::Id::new("layered-preview-test");
+        let mut result = None;
+        let mut output = ctx.run_ui(Default::default(), |ctx| {
+            egui::CentralPanel::default().show(ctx, |ui| {
+                result = poll_or_start_preview(ui, key, "png100", doc.clone(), &fields);
+            });
+        });
+        output.textures_delta.clear();
+        assert!(result.is_none(), "the first UI frame must only start the worker");
+
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+        loop {
+            let mut output = ctx.run_ui(Default::default(), |ctx| {
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    result = poll_or_start_preview(ui, key, "png100", doc.clone(), &fields);
+                });
+            });
+            output.textures_delta.clear();
+            if let Some(preview) = result {
+                let preview = preview.unwrap();
+                assert_eq!((preview.width, preview.height), (32, 16));
+                assert_eq!(preview.rgba.len(), 32 * 16 * 4);
+                assert!(preview.estimate.is_some_and(|bytes| bytes > 0));
+                break;
+            }
+            assert!(std::time::Instant::now() < deadline, "background preview did not complete");
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+
+        let tiff_fields = Map::from_iter([("format".into(), json!("tif")), ("scale".into(), json!(100))]);
+        let proxy = preview_proxy(&doc, &tiff_fields).unwrap();
+        let options = photocraft_io::ExportOptions { tiff_layers: true, xmp: photocraft_io::XmpEmbed::None, ..Default::default() };
+        let actual_bytes = photocraft_io::export(&proxy, "estimate.tif", &options).unwrap().bytes.len();
+        assert_eq!(estimate_native(&doc, &proxy, &tiff_fields), Some(scaled_estimate(actual_bytes, &doc, &proxy, &tiff_fields)));
+    }
+
     #[test]
     fn switching_export_formats_uses_independent_quality_preferences() {
         let prefs = photocraft_engine::prefs::Export { jpeg_quality: 43, webp_quality: 72, webp_lossless: false, ..Default::default() };
diff --git a/crates/ui-egui/src/file_dialog.rs b/crates/ui-egui/src/file_dialog.rs
index a1f6e5240b..7cdff50af9 100644
--- a/crates/ui-egui/src/file_dialog.rs
+++ b/crates/ui-egui/src/file_dialog.rs
@@ -21,12 +21,14 @@ use serde_json::{Value, json};
 use crate::PhotocraftApp;
 use crate::file_open::display_name;
 
-/// What a file dialog asks the user for.
+/// What a file or folder dialog asks the user for.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum FileDialogRequest {
     /// Files to read: several for File › Open, one for a command that reads a file (Place,
     /// scripts, notes, presets). Starts in `initial_dir` (the last-used folder, UI-217-3).
     Open { multiple: bool, initial_dir: Option<String>, extensions: Option<Vec<String>> },
+    /// Which folder to read from. Starts in `initial_dir` when available.
+    Folder { initial_dir: Option<String> },
     /// Where to write, starting from `suggested` (a file name, or the document's own path).
     Save { suggested: String },
 }
@@ -42,6 +44,8 @@ pub enum FileDialogAnswer {
     ContentsMany(Vec<(String, Vec<u8>)>),
     /// The path to save to (desktop), or the download's name (web).
     SaveTo(String),
+    /// The selected folder's path (desktop).
+    FolderTo(String),
     /// No dialog could be shown (on Linux: no desktop portal and no zenity, #3354); the message
     /// says what to install. Reported as an error rather than taken for Cancel.
     Unavailable(String),
@@ -88,7 +92,7 @@ impl PhotocraftApp {
     }
 
     /// Show a file dialog; `then` continues with the user's choice on a later frame (see the
-    /// module docs). Returns at once with `{"fileDialog": "open" | "save"}`; `Err` without a
+    /// module docs). Returns at once with `{"fileDialog": "open" | "folder" | "save"}`; `Err` without a
     /// dialog service ("cancelled", as before there were async dialogs) or while one is open.
     pub(crate) fn ask_file(
         &mut self,
@@ -103,6 +107,7 @@ impl PhotocraftApp {
         }
         let kind = match request {
             FileDialogRequest::Open { .. } => "open",
+            FileDialogRequest::Folder { .. } => "folder",
             FileDialogRequest::Save { .. } => "save",
         };
         let then: Then = Box::new(move |app, answer| match answer {
@@ -114,6 +119,16 @@ impl PhotocraftApp {
         Ok(json!({ "fileDialog": kind }))
     }
 
+    /// Ask the user to choose a folder, starting in the folder of the most recent file when known.
+    /// `then` receives the selected path when the dialog is answered.
+    pub(crate) fn ask_folder(&mut self, then: impl FnOnce(&mut Self, String) -> Result<Value, String> + 'static) -> Result<Value, String> {
+        let initial_dir = last_used_dir(&self.ui.recent_files);
+        self.ask_file(FileDialogRequest::Folder { initial_dir }, move |app, answer| match answer {
+            FileDialogAnswer::FolderTo(path) => then(app, path),
+            _ => Err(UNEXPECTED.into()),
+        })
+    }
+
     /// Ask where to save: `then` gets the chosen path, with a lowercase extension when
     /// Preferences ▸ File Handling › Lowercase Extension is on (its default).
     ///
@@ -134,9 +149,17 @@ impl PhotocraftApp {
         {
             suggested = dir.join(suggested);
         }
+        // The format comes from the extension, so a name typed without one (common where file
+        // extensions are hidden, #5039) gets the suggested file's extension, as Photoshop's
+        // Save As appends the extension of the chosen file type.
+        let suggested_ext = suggested.extension().and_then(|e| e.to_str()).map(|e| e.to_ascii_lowercase());
         self.ask_file(FileDialogRequest::Save { suggested: suggested.to_string_lossy().into_owned() }, move |app, answer| match answer {
             FileDialogAnswer::SaveTo(path) => {
                 let path = Self::lowercased_extension(app, path);
+                let path = match &suggested_ext {
+                    Some(ext) if Path::new(&path).extension().is_none() => Path::new(&path).with_extension(ext).to_string_lossy().into_owned(),
+                    _ => path,
+                };
                 // The web answers a download name, which has no folder to remember.
                 if let Some(doc) = doc
                     && let Some(dir) = Path::new(&path).parent().filter(|p| !p.as_os_str().is_empty())
@@ -193,6 +216,7 @@ impl PhotocraftApp {
                 }
                 FileDialogAnswer::Contents(name, bytes) => app.open_contents(vec![(name, bytes)]),
                 FileDialogAnswer::ContentsMany(files) => app.open_contents(files),
+                FileDialogAnswer::FolderTo(_) => return Err(UNEXPECTED.into()),
                 FileDialogAnswer::SaveTo(_) | FileDialogAnswer::Unavailable(_) => return Err(UNEXPECTED.into()),
             }
             Ok(Value::Null)
@@ -275,7 +299,7 @@ impl PhotocraftApp {
 }
 
 /// The folder an open dialog starts in: the directory of the most recent file (UI-217-3).
-fn last_used_dir(recent: &[String]) -> Option<String> {
+pub(crate) fn last_used_dir(recent: &[String]) -> Option<String> {
     let dir = std::path::Path::new(recent.first()?).parent()?;
     (!dir.as_os_str().is_empty()).then(|| dir.to_string_lossy().into_owned())
 }
@@ -290,6 +314,7 @@ fn read_picked(answer: FileDialogAnswer) -> Result<(String, Vec<u8>), String> {
             let bytes = photocraft_format::read_file(std::path::Path::new(&path)).map_err(|e| format!("{}: {e}", display_name(&path)))?;
             Ok((path, bytes))
         }
+        FileDialogAnswer::FolderTo(_) => Err(UNEXPECTED.into()),
         FileDialogAnswer::SaveTo(_) | FileDialogAnswer::Unavailable(_) => Err(UNEXPECTED.into()),
     }
 }
diff --git a/crates/ui-egui/src/file_dialog/tests.rs b/crates/ui-egui/src/file_dialog/tests.rs
index 59c8c49731..5f7dfc5c98 100644
--- a/crates/ui-egui/src/file_dialog/tests.rs
+++ b/crates/ui-egui/src/file_dialog/tests.rs
@@ -175,6 +175,30 @@ fn open_starts_in_the_last_used_folder() {
     );
 }
 
+#[test]
+fn ask_folder_uses_the_async_dialog_and_returns_the_selected_path() {
+    let (mut app, open, _) = app();
+    let ctx = egui::Context::default();
+    app.ui.recent_files = vec!["/pics/cat.psd".into()];
+    let selected = Rc::new(RefCell::new(None));
+    let result = selected.clone();
+
+    assert_eq!(
+        app.ask_folder(move |_, path| {
+            *result.borrow_mut() = Some(path);
+            Ok(Value::Null)
+        })
+        .unwrap(),
+        json!({"fileDialog": "folder"})
+    );
+    app.poll_file_dialog(&ctx, None);
+    assert!(matches!(open.borrow().as_slice(), [(FileDialogRequest::Folder { initial_dir: Some(dir) }, _)] if dir == "/pics"));
+
+    answer(&open, Some(FileDialogAnswer::FolderTo("/pics/frames".into())));
+    app.poll_file_dialog(&ctx, None);
+    assert_eq!(selected.borrow().as_deref(), Some("/pics/frames"));
+}
+
 #[test]
 fn filtered_picker_requests_only_the_given_extensions() {
     let (mut app, open, _) = app();
@@ -266,6 +290,26 @@ fn save_paths_get_a_lowercase_extension_when_the_preference_is_on() {
     assert_eq!(*written.borrow(), ["/pics/CAT.PSD"], "off keeps the user's spelling");
 }
 
+/// #5039: a name typed without an extension (where file extensions are hidden) gets the
+/// suggested file's extension, so the save picks its format instead of failing.
+#[test]
+fn save_paths_without_an_extension_get_the_suggested_one() {
+    let (mut app, open, written) = app();
+    let ctx = egui::Context::default();
+    menus::invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap();
+    app.poll_file_dialog(&ctx, None);
+    answer(&open, Some(FileDialogAnswer::SaveTo("/pics/cat".into())));
+    app.poll_file_dialog(&ctx, None);
+    assert_eq!(*written.borrow(), ["/pics/cat.psd"]);
+    assert_eq!(app.session.active().unwrap().path.as_deref(), Some("/pics/cat.psd"));
+    // A name that already has an extension is left alone.
+    menus::invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap();
+    app.poll_file_dialog(&ctx, None);
+    answer(&open, Some(FileDialogAnswer::SaveTo("/pics/dog.png".into())));
+    app.poll_file_dialog(&ctx, None);
+    assert_eq!(*written.borrow(), ["/pics/cat.psd", "/pics/dog.png"]);
+}
+
 #[test]
 fn save_and_export_dialogs_start_beside_the_document() {
     let (mut app, open, _) = app();
@@ -661,3 +705,92 @@ fn an_unavailable_dialog_is_reported_and_a_cancelled_one_is_not() {
     assert_eq!(app.ui.status, "No file dialog can open");
     assert!(!app.file_dialog_open(), "the pending dialog is over");
 }
+
+/// #3629: Layer › Export As with several artboards selected exports one file per board, at each
+/// board's size and with the dialog's settings, after one destination prompt.
+#[test]
+fn export_as_with_several_artboards_selected_writes_one_file_each() {
+    let (mut app, open, written) = app();
+    let a = app.run("layer.new.artboard", json!({"rect": [0, 0, 40, 30], "name": "Header"})).unwrap()["layer"].as_u64().unwrap();
+    let b = app.run("layer.new.artboard", json!({"rect": [60, 0, 20, 50], "name": "Capsule"})).unwrap()["layer"].as_u64().unwrap();
+    app.run("layer.select", json!({"layer": a})).unwrap();
+    app.run("layer.select", json!({"layer": b, "mode": "add"})).unwrap();
+    assert_eq!(app.session.active().unwrap().selected_layers().len(), 2);
+    let sizes = Rc::new(RefCell::new(Vec::new()));
+    let capture = sizes.clone();
+    app.services.export = Some(Box::new(move |doc: &photocraft_doc::Document, _: &str, _: &crate::ExportSettings| {
+        capture.borrow_mut().push((doc.name.clone(), doc.size.width, doc.size.height));
+        Ok((b"out".to_vec(), Vec::new()))
+    }));
+    assert!(!crate::layer_menu_ui::single_layer_only("layer.exportAs"), "the menu offers it for a selection");
+    let ctx = egui::Context::default();
+    let r = menus::invoke(&mut app, &ctx, "layer.exportAs", Value::Null).unwrap();
+    let id = r["dialog"].as_u64().unwrap();
+    let mut fields = app.ui.dialogs.iter().find(|d| d.id == id).unwrap().fields.clone();
+    assert_eq!(fields["__label"], "Export As: 2 layers");
+    // The dialog's settings apply to every file: JPG at 50 %.
+    fields.insert("format".into(), json!("jpg"));
+    fields.insert("scale".into(), json!(50));
+    crate::export_dialog::confirm(&mut app, &fields).unwrap();
+    app.poll_file_dialog(&ctx, None);
+    assert_eq!(open.borrow().len(), 1, "one destination for every board");
+    answer(&open, Some(FileDialogAnswer::SaveTo("/out/boards.jpg".into())));
+    app.poll_file_dialog(&ctx, None);
+    assert!(!app.ui.status_error, "{}", app.ui.status);
+    assert_eq!(written.borrow().len(), 2);
+    assert_eq!(written.borrow()[0], "/out/boards.jpg");
+    // The sibling path is built with `Path::join`, so Windows turns the separator into `\`.
+    let second = written.borrow()[1].replace('\\', "/");
+    assert!(second.starts_with("/out/boards-2-") && second.ends_with(".jpg"), "{:?}", written.borrow());
+    let mut got = sizes.borrow().iter().map(|(_, w, h)| (*w, *h)).collect::<Vec<_>>();
+    got.sort_unstable();
+    assert_eq!(got, [(10, 25), (20, 15)], "each board at its own size, scaled to 50 %");
+}
+
+/// #3806: File › Save on an OpenRaster file that can't hold the document (here an adjustment
+/// layer) doesn't overwrite it: Save As opens on a PSD with a notice saying what the .ora would
+/// drop, and the PSD becomes the document's file. A plain document still saves back to its .ora.
+#[test]
+fn openraster_save_never_overwrites_what_it_cannot_hold() {
+    let (mut app, open, written) = app();
+    app.run("layer.new.layer", json!({})).unwrap();
+    app.session.active_mut().unwrap().path = Some("/pics/art.ora".into());
+    let ctx = egui::Context::default();
+    menus::invoke(&mut app, &ctx, "file.save", json!({})).unwrap();
+    assert_eq!(*written.borrow(), ["/pics/art.ora"], "a plain document saves in place");
+    app.run("layer.newAdjustmentLayer.invert", json!({})).unwrap();
+    let notices = app.ui.notices.len();
+    menus::invoke(&mut app, &ctx, "file.save", json!({})).unwrap();
+    app.poll_file_dialog(&ctx, None);
+    assert_eq!(written.borrow().len(), 1, "the .ora is not overwritten");
+    assert!(matches!(open.borrow().as_slice(), [(FileDialogRequest::Save { suggested }, _)] if suggested == "/pics/art.psd"), "Save As offers PSD");
+    assert_eq!(app.ui.notices.len(), notices + 1);
+    assert!(app.ui.notices.last().unwrap().lines.iter().any(|l| l.contains("adjustment layers")), "{:?}", app.ui.notices.last().unwrap().lines);
+    assert!(app.session.active().unwrap().is_dirty(), "the edits are still unsaved");
+    answer(&open, Some(FileDialogAnswer::SaveTo("/pics/art.psd".into())));
+    app.poll_file_dialog(&ctx, None);
+    assert_eq!(written.borrow().last().map(String::as_str), Some("/pics/art.psd"));
+    let st = app.session.active().unwrap();
+    assert_eq!(st.path.as_deref(), Some("/pics/art.psd"));
+    assert!(!st.is_dirty());
+}
+
+/// Save As to OpenRaster of a document it can't hold writes a copy, as Photoshop does for formats
+/// that can't keep everything: the document keeps its file and its unsaved state. An automation
+/// save without a path won't overwrite such an .ora either.
+#[test]
+fn save_as_openraster_of_what_it_cannot_hold_is_a_copy() {
+    let (mut app, _open, written) = app();
+    app.run("layer.newAdjustmentLayer.invert", json!({})).unwrap();
+    app.session.active_mut().unwrap().path = Some("/pics/art.psd".into());
+    let ctx = egui::Context::default();
+    menus::invoke(&mut app, &ctx, "file.saveAs", json!({"path": "/pics/copy.ora"})).unwrap();
+    assert_eq!(*written.borrow(), ["/pics/copy.ora"]);
+    let st = app.session.active().unwrap();
+    assert_eq!(st.path.as_deref(), Some("/pics/art.psd"), "the document keeps its file");
+    assert!(st.is_dirty());
+    app.session.active_mut().unwrap().path = Some("/pics/art.ora".into());
+    let err = app.save_automation(None).unwrap_err();
+    assert!(err.contains("OpenRaster"), "{err}");
+    assert_eq!(written.borrow().len(), 1);
+}
diff --git a/crates/ui-egui/src/file_open.rs b/crates/ui-egui/src/file_open.rs
index 785d234d02..d67e56dbf0 100644
--- a/crates/ui-egui/src/file_open.rs
+++ b/crates/ui-egui/src/file_open.rs
@@ -33,6 +33,27 @@ pub enum DropTarget {
     Elsewhere,
 }
 
+/// `warnings` from an import, plus one for each font family the active document's type uses that
+/// isn't installed (#4559): Photoshop warns about missing fonts as a file opens, and the CLI and
+/// automation already report them; the type would otherwise silently render in a fallback face.
+pub(crate) fn with_missing_fonts(app: &PhotocraftApp, warnings: Vec<String>) -> Vec<String> {
+    match app.session.active() {
+        Some(st) => with_missing_fonts_of(&st.doc, warnings),
+        None => warnings,
+    }
+}
+
+/// [`with_missing_fonts`] for `doc` itself: a file held back for its profile prompt
+/// (`open_prompt`) isn't the active document yet.
+pub(crate) fn with_missing_fonts_of(doc: &photocraft_doc::Document, mut warnings: Vec<String>) -> Vec<String> {
+    for w in photocraft_engine::type_extra_cmds::missing_font_warnings(doc) {
+        if !warnings.contains(&w) {
+            warnings.push(w);
+        }
+    }
+    warnings
+}
+
 /// A dropped file's name ("dropped" when it has none).
 fn dropped_name(f: &egui::DroppedFileHandle) -> String {
     f.path().file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped".into())
@@ -57,9 +78,7 @@ impl PhotocraftApp {
             crate::jobs_ui::start_open(self, &display_name(path), Some(path.to_string()), crate::jobs_ui::bytes(bytes))?;
             return Ok(Vec::new());
         }
-        let warnings = self.open_bytes(&display_name(path), bytes)?;
-        self.opened_from(path);
-        Ok(warnings)
+        self.open_bytes_from(&display_name(path), bytes, Some(path))
     }
 
     /// Record that the active document was just opened from `path`: File › Save writes back to it
@@ -154,6 +173,12 @@ impl PhotocraftApp {
             DropTarget::Tabs(slot) => Some(slot),
             DropTarget::Canvas | DropTarget::Elsewhere => None,
         };
+        // A box still open from an earlier drop (or any Free Transform) is applied first (#4833):
+        // the queue below places the next file only once no box is open, so a separate drop
+        // would otherwise wait unseen for ↩. Files dropped together still go one by one.
+        if target == DropTarget::Canvas && self.ui.transform.is_some() && files.iter().any(|f| !crate::preset_files_ui::is_preset_file(&dropped_name(f))) {
+            crate::transform_tool::commit(self);
+        }
         for f in files {
             let name = dropped_name(&f);
             if target == DropTarget::Canvas && !crate::preset_files_ui::is_preset_file(&name) {
diff --git a/crates/ui-egui/src/file_open/tests.rs b/crates/ui-egui/src/file_open/tests.rs
index 3e6bde28b2..bdefab6229 100644
--- a/crates/ui-egui/src/file_open/tests.rs
+++ b/crates/ui-egui/src/file_open/tests.rs
@@ -464,6 +464,29 @@ fn files_dropped_onto_the_canvas_are_placed_in_free_transform_one_by_one() {
     let _ = std::fs::remove_dir_all(&dir);
 }
 
+/// #4833: a file dropped on the canvas on its own while the previous one is still in Free
+/// Transform applies that box and is placed at once, instead of waiting unseen for ↩.
+#[test]
+fn a_separate_drop_applies_the_open_transform_and_places_at_once() {
+    let ctx = egui::Context::default();
+    let mut app = app_with_canvas();
+    let (layers, steps) = (layer_count(&app), history_steps(&app));
+    let at = Some(egui::pos2(400.0, 300.0));
+    app.open_dropped(&ctx, vec![dropped("first.png", Ok(png_bytes(4, 4)))], at);
+    app.place_next_dropped(&ctx);
+    assert!(app.ui.transform.is_some(), "the first file is in Free Transform");
+    app.open_dropped(&ctx, vec![dropped("second.png", Ok(png_bytes(2, 2)))], at);
+    app.place_next_dropped(&ctx);
+    let st = app.session.active().unwrap();
+    assert_eq!(st.doc.layer(st.active_layer.unwrap()).unwrap().name, "second", "placed without waiting for ↩");
+    assert_eq!(app.ui.transform.as_ref().and_then(|t| t.made), Some(crate::state::MadeLayer::Place));
+    // The first place was applied, not taken back: both layers, one Place Embedded step each.
+    assert_eq!(layer_count(&app), layers + 2);
+    assert!(app.drop_places.is_empty());
+    crate::transform_tool::commit(&mut app);
+    assert_eq!(history_steps(&app), steps + 2);
+}
+
 /// #1099: switching tabs after an actual canvas drop cancels the place in its source document.
 #[test]
 fn switching_documents_after_a_canvas_drop_undoes_only_the_place() {
@@ -616,7 +639,8 @@ fn views_and_windows_stay_with_their_documents() {
     for (i, v) in app.ui.views.iter_mut().enumerate() {
         v.zoom = i as f32 + 1.0;
     }
-    app.ui.windows = (0..4).map(|document| crate::state::DocWindow { id: document as u64, document, view: Default::default(), open: true }).collect();
+    app.ui.windows =
+        (0..4).map(|document| crate::state::DocWindow { id: document as u64, document, view: Default::default(), open: true, position: None }).collect();
     let zooms = |app: &PhotocraftApp| app.ui.views.iter().map(|v| v.zoom).collect::<Vec<_>>();
     let windows = |app: &PhotocraftApp| app.ui.windows.iter().map(|w| (w.id, w.document)).collect::<Vec<_>>();
     assert_eq!(app.run("document.move", json!({"document": 0, "to": 3})).unwrap(), json!({"document": 3}));
@@ -775,3 +799,87 @@ fn a_set_of_background_opens_keeps_its_order_however_they_finish() {
     jobs_ui::finish_open_tab(&mut app, &late, &json!({"document": index})).unwrap();
     assert_eq!(doc_names(&app), ["dropped.psd", "existing.psd", "f0.psd", "f1.psd", "f2.psd", "f3.psd", "late.psd"]);
 }
+
+/// #4373: Save a Copy is recorded in an action, like Save and Save As, and played back as a copy:
+/// the document keeps its own file and unsaved changes.
+#[test]
+fn save_a_copy_is_recorded_and_replayed_as_a_copy() {
+    let (mut app, written) = app_with(vec![Some(FileDialogAnswer::SaveTo("/pics/copy.png".into()))]);
+    let ctx = egui::Context::default();
+    app.open_file("/pics/work.pcraft", b"x").unwrap();
+    app.run("layer.new.layer", json!({})).unwrap();
+    app.run("actions.record", json!({})).unwrap();
+    app.run("edit.fill", json!({"color": "#ff0000"})).unwrap();
+    menus::invoke(&mut app, &ctx, "file.saveACopy", json!({})).unwrap();
+    answer(&mut app);
+    app.run("actions.stop", json!({})).unwrap();
+    assert_eq!(app.session.actions.list[0].steps.last(), Some(&("file.saveACopy".to_string(), json!({"path": "/pics/copy.png"}))));
+    assert_eq!(crate::actions::label_of("file.saveACopy"), "Save a Copy");
+    written.borrow_mut().clear();
+    let played = app.run("actions.play", json!({"action": 0})).unwrap();
+    assert!(played.get("failed").is_none(), "{played}");
+    assert_eq!(written.borrow().iter().map(|(p, _)| p.as_str()).collect::<Vec<_>>(), ["/pics/copy.png"]);
+    let st = app.session.active().unwrap();
+    assert_eq!(st.path.as_deref(), Some("/pics/work.pcraft"), "the document keeps its file");
+    assert!(st.is_dirty(), "and its unsaved changes");
+}
+
+/// #4400: a new document saved under a name is listed in Open Recent (and on the Home screen),
+/// as opening it is; a Save a Copy isn't, since the document doesn't live there.
+#[test]
+fn saving_a_new_document_lists_it_in_recent_files() {
+    let (mut app, _written) = app_with(vec![Some(FileDialogAnswer::SaveTo("/pics/new.psd".into())), Some(FileDialogAnswer::SaveTo("/pics/copy.png".into()))]);
+    let ctx = egui::Context::default();
+    app.run("file.new", json!({"width": 4, "height": 4})).unwrap();
+    assert!(app.ui.recent_files.is_empty());
+    menus::invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap();
+    answer(&mut app);
+    assert_eq!(app.ui.recent_files, ["/pics/new.psd"]);
+    assert_eq!(app.session.prefs().file_handling.recent_files, ["/pics/new.psd"], "kept for the next launch");
+    menus::invoke(&mut app, &ctx, "file.saveACopy", json!({})).unwrap();
+    answer(&mut app);
+    assert_eq!(app.ui.recent_files, ["/pics/new.psd"], "a copy isn't the document's file");
+}
+
+/// #4559: a file whose type uses a font that isn't installed opens with a notice naming it, as
+/// Photoshop warns on open (the CLI and automation already did); the file still opens. Type in
+/// an installed face adds nothing, and a font the importer already warned about isn't repeated.
+#[test]
+fn opening_type_in_a_missing_font_warns() {
+    fn doc_with_type(font: Option<&str>) -> Document {
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 40, "height": 20})).unwrap();
+        let mut p = json!({"text": "Hi", "x": 2, "y": 12, "size": 10});
+        if let Some(f) = font {
+            p["font"] = json!(f);
+        }
+        s.execute("type.create", p).unwrap();
+        (*s.active().unwrap().doc).clone()
+    }
+    const MISSING: &str = "NoSuchFamily4559";
+    let warning = format!("font '{MISSING}' is not installed; text may render using a fallback face");
+    let (with_missing, installed) = (doc_with_type(Some(MISSING)), doc_with_type(None));
+    let already = warning.clone();
+    let services = Services {
+        import: Some(Box::new(move |name: &str, _bytes: &[u8], _depth: usize| {
+            Ok(match name {
+                "installed.psd" => (installed.clone(), Vec::new()),
+                "warned.psd" => (with_missing.clone(), vec![already.clone()]),
+                _ => (with_missing.clone(), Vec::new()),
+            })
+        })),
+        ..Default::default()
+    };
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), services);
+    let warnings = app.open_bytes("poster.psd", b"x").unwrap();
+    assert_eq!(warnings, vec![warning.clone()]);
+    assert!(app.ui.status.contains(MISSING), "{}", app.ui.status);
+    assert_eq!(app.ui.notices.len(), 1);
+    assert_eq!(app.ui.notices[0].lines, vec![warning.clone()]);
+    assert_eq!(app.session.documents().len(), 1, "the file still opens");
+    // Type in an installed face: no notice.
+    assert!(app.open_bytes("installed.psd", b"x").unwrap().is_empty());
+    assert_eq!(app.ui.notices.len(), 1);
+    // The importer's own warning for the same font isn't doubled.
+    assert_eq!(app.open_bytes("warned.psd", b"x").unwrap(), vec![warning]);
+}
diff --git a/crates/ui-egui/src/file_ui.rs b/crates/ui-egui/src/file_ui.rs
index 8481ab6174..4b708fa1c0 100644
--- a/crates/ui-egui/src/file_ui.rs
+++ b/crates/ui-egui/src/file_ui.rs
@@ -22,6 +22,22 @@ fn default_dir(app: &PhotocraftApp) -> String {
     app.session.active().and_then(|d| d.path.as_deref()).and_then(|p| p.rfind(['/', '\\']).map(|i| p[..i].to_string())).unwrap_or_else(|| ".".into())
 }
 
+/// A packaged macOS app does not start in a useful writable working directory. A saved
+/// document keeps its own folder; otherwise prefer the user's Documents folder.
+fn droplet_default_dir(app: &PhotocraftApp) -> String {
+    let dir = default_dir(app);
+    if dir != "." {
+        return dir;
+    }
+    #[cfg(target_os = "macos")]
+    if let Some(home) = std::env::var_os("HOME") {
+        let home = std::path::PathBuf::from(home);
+        let documents = home.join("Documents");
+        return if documents.is_dir() { documents } else { home }.to_string_lossy().into_owned();
+    }
+    dir
+}
+
 fn doc_stem(app: &PhotocraftApp) -> String {
     app.session.active().map(|d| d.doc.name.rsplit_once('.').map_or(d.doc.name.clone(), |(a, _)| a.to_string())).unwrap_or_else(|| tl!("Untitled").into())
 }
@@ -71,6 +87,7 @@ pub fn invoke(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, params: &V
             json!({"units": ["inches", "cm", "pixels"], "mode": ["rgb", "gray", "cmyk", "lab"]}),
         ),
         "file.automate.createDroplet" => {
+            let dir = droplet_default_dir(app);
             let Some(action) = crate::actions::selected_action(app) else {
                 return Some(Err("record an action in the Actions panel first".into()));
             };
@@ -84,10 +101,7 @@ pub fn invoke(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, params: &V
                 json!({"format": ["same", "png", "jpg", "psd", "tiff"]}),
             )
         }
-        "file.scripts.statistics" => {
-            let modes: Vec<&str> = photocraft_doc::StackMode::ALL.iter().map(|m| m.id()).collect();
-            form(app, id, "Image Statistics", json!({"mode": "median", "input": dir, "align": false}), json!({"mode": modes}))
-        }
+        "file.scripts.statistics" => json!({"dialog": crate::stack_dialog::open_statistics(app)}),
         "file.scripts.browse" => {
             return Some(app.pick_file_bytes_filtered(SCRIPT_EXTENSIONS, |app, name, bytes| {
                 let r = app.run("file.scripts.browse", json!({"script": String::from_utf8_lossy(&bytes)}));
@@ -180,6 +194,9 @@ fn b(f: &Map<String, Value>, k: &str, d: bool) -> bool {
 
 // ---------- Save for Web ----------
 
+#[path = "file_ui/web_preview.rs"]
+mod web_preview;
+
 const WEB_FORMATS: [(&str, &str); 5] = [("gif", "GIF"), ("png8", "PNG-8"), ("png24", "PNG-24"), ("jpeg", "JPEG"), ("wbmp", "WBMP")];
 const WEB_COMMAND: &str = "file.export.saveForWebLegacy";
 
@@ -189,11 +206,19 @@ pub fn open_web(app: &mut PhotocraftApp) -> u64 {
     f.insert("__command".into(), json!(WEB_COMMAND));
     f.insert("__label".into(), json!("Save for Web (Legacy)"));
     f.insert("__view".into(), json!("2up"));
-    // Remember encoding choices, but each document starts at its own full size.
-    let last = app.session.file_menu.last_web.clone().unwrap_or_else(|| json!({"format": "jpeg", "quality": 60}));
+    // Remember encoding choices, but each document starts at its own full size. This session's
+    // last export lives in `file_menu`; the last one before a restart comes from the
+    // preferences' remembered dialog settings (`web_cmds::remember_web_settings`).
+    let last = app
+        .session
+        .file_menu
+        .last_web
+        .clone()
+        .or_else(|| app.session.prefs().dialogs.get(WEB_COMMAND).cloned())
+        .unwrap_or_else(|| json!({"format": "jpeg", "quality": 60}));
     if let Value::Object(m) = last {
         for (k, v) in m {
-            if !matches!(k.as_str(), "path" | "dir" | "width" | "height" | "percent") {
+            if !matches!(k.as_str(), "path" | "dir" | "width" | "height" | "percent" | "colorTable" | "colorTableEdits") {
                 f.insert(k, v);
             }
         }
@@ -227,6 +252,10 @@ fn variants(p: &Value) -> Vec<Value> {
     let fmt = p["format"].as_str().unwrap_or("jpeg");
     for k in [2.0, 4.0] {
         let mut v = p.clone();
+        if let Some(m) = v.as_object_mut() {
+            m.remove("colorTable");
+            m.remove("colorTableEdits");
+        }
         if fmt == "jpeg" {
             v["quality"] = json!((p["quality"].as_f64().unwrap_or(60.0) / k).round().max(1.0));
         } else if fmt == "gif" || fmt == "png8" {
@@ -241,51 +270,66 @@ fn variants(p: &Value) -> Vec<Value> {
 }
 
 /// The flattened preview image: pixels, width, height, full-size / proxy pixel ratio.
-type WebProxy = (Arc<Vec<[f32; 4]>>, u32, u32, f64);
+type WebProxy = (Arc<Vec<[f32; 4]>>, u32, u32, f64, egui::Vec2);
 type WebCache = (String, Arc<egui::TextureHandle>, Option<(usize, Option<usize>, &'static str)>);
 
 /// Renders one preview pane: the original (`None`) or an optimised variant.
-fn web_pane(app: &PhotocraftApp, ui: &mut egui::Ui, size: egui::Vec2, p: Option<&Value>, full_px: f64) {
+fn web_pane(app: &PhotocraftApp, ui: &mut egui::Ui, size: egui::Vec2, p: Option<&Value>, f: &mut Map<String, Value>, pane: usize, frame: Option<usize>) {
     let t = Tokens::get(ui.ctx());
     let Some(st) = app.session.active() else { return };
     let doc = st.doc.clone();
     let rev = st.revision;
-    // The proxy: the export size, at most 640 px on the long side.
+    // A bounded proxy; navigation never recomposites or re-encodes it.
     let base = p.cloned().unwrap_or_else(|| json!({}));
-    let size_sig = format!("{}|{}|{}", base["percent"], base["width"], base["height"]);
-    let wkey = egui::Id::new(("web-proxy", doc.id.0, rev, size_sig.clone()));
-    let proxy: Option<WebProxy> = ui.data(|d| d.get_temp(wkey));
-    let (px, w, h, ratio) = match proxy {
+    let size_sig = format!("{}|{}|{}|{}", base["percent"], base["width"], base["height"], base["convertToSrgb"]);
+    let wkey = egui::Id::new(("web-proxy", doc.id.0, pane));
+    let proxy_sig = format!("{rev}|{frame:?}|{size_sig}");
+    let cached_proxy: Option<(String, WebProxy)> = ui.data(|d| d.get_temp(wkey));
+    let proxy = cached_proxy.filter(|(sig, _)| sig == &proxy_sig).map(|(_, proxy)| proxy);
+    let (px, w, h, ratio, source_size) = match proxy {
         Some(v) => v,
         None => {
-            let pct = base["percent"].as_f64().unwrap_or(100.0).max(1.0) / 100.0;
-            let (fw, fh) = (f64::from(doc.size.width) * pct, f64::from(doc.size.height) * pct);
-            let k = (640.0 / fw.max(fh)).min(1.0);
-            let st = WebSettings::default();
+            let (fw, fh) = match web_preview::dimensions(&doc, &base) {
+                Ok(size) => size,
+                Err(error) => {
+                    ui.label(error);
+                    return;
+                }
+            };
+            let k = (2048.0 / fw.max(fh)).min(1.0);
+            let st = WebSettings::from_params(&base, "preview").unwrap_or_default();
+            let Ok(doc) = web_frame_document(&doc, frame) else { return };
             let Ok((wd, _, _)) =
                 web_cmds::web_document(&doc, &json!({"width": (fw * k).round().max(1.0), "height": (fh * k).round().max(1.0), "resample": "bilinear"}), &st)
             else {
                 return;
             };
             let buf = photocraft_compose::flatten(&wd);
-            let v = (Arc::new(buf.px), wd.size.width, wd.size.height, (fw * fh) / (f64::from(wd.size.width) * f64::from(wd.size.height)).max(1.0));
-            ui.data_mut(|d| d.insert_temp(wkey, v.clone()));
+            let v = (
+                Arc::new(buf.px),
+                wd.size.width,
+                wd.size.height,
+                (fw * fh) / (f64::from(wd.size.width) * f64::from(wd.size.height)).max(1.0),
+                egui::vec2(fw as f32, fh as f32),
+            );
+            ui.data_mut(|d| d.insert_temp(wkey, (proxy_sig, v.clone())));
             v
         }
     };
-    let sig = format!("{}{}", size_sig, p.map(|v| v.to_string()).unwrap_or_else(|| "original".into()));
-    let key = egui::Id::new(("web-pane", doc.id.0, rev, sig.clone()));
+    let sig = format!("{}|{rev}|{frame:?}|{size_sig}|{}", doc.id.0, p.map(|v| v.to_string()).unwrap_or_else(|| "original".into()));
+    let key = egui::Id::new(("web-pane", doc.id.0, pane));
     let cached: Option<WebCache> = ui.data(|d| d.get_temp(key));
     let (tex, info) = match cached.filter(|c| c.0 == sig) {
         Some((_, tex, info)) => (tex, info),
         None => {
             let (rgba, info) = match p {
                 None => (px.iter().flat_map(|q| q.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8)).collect::<Vec<u8>>(), None),
-                Some(p) => match WebSettings::from_params(p, "preview")
-                    .and_then(|st| web_cmds::optimize(&px, w as usize, photocraft_geom::Rect::new(0, 0, w as i32, h as i32), &st, None, None, 72.0, true))
-                {
-                    Ok(Optimized { preview, bytes, colors, ext, .. }) => (preview, Some(((bytes.len() as f64 * ratio) as usize, colors, ext))),
-                    Err(_) => (vec![0; (w * h * 4) as usize], None),
+                Some(p) => match web_preview::optimized(ui, key, &format!("{}|{rev}|{frame:?}|{size_sig}", doc.id.0), p, &px, w, h) {
+                    Ok((preview, bytes, colors, ext)) => (preview, Some(((bytes as f64 * ratio) as usize, colors, ext))),
+                    Err(error) => {
+                        ui.label(error);
+                        (vec![0; (w * h * 4) as usize], None)
+                    }
                 },
             };
             let img = egui::ColorImage::from_rgba_unmultiplied([w as usize, h as usize], &rgba);
@@ -295,14 +339,15 @@ fn web_pane(app: &PhotocraftApp, ui: &mut egui::Ui, size: egui::Vec2, p: Option<
         }
     };
     ui.vertical(|ui| {
-        let (r, _) = ui.allocate_exact_size(size - egui::vec2(0.0, 34.0), egui::Sense::hover());
+        ui.set_width(size.x);
+        let (r, response) = ui.allocate_exact_size((size - egui::vec2(0.0, 42.0)).max(egui::vec2(1.0, 1.0)), egui::Sense::drag());
+        let response = response.on_hover_cursor(egui::CursorIcon::Grab);
+        if let Some(rects) = f.get_mut("__previewRects").and_then(Value::as_array_mut) {
+            rects.push(json!([r.left(), r.top(), r.right(), r.bottom()]));
+        }
         crate::widgets::checker(ui.painter(), r, 8.0);
-        let ts = tex.size_vec2();
-        let k = (r.width() / ts.x).min(r.height() / ts.y).min(1.0);
-        let ir = egui::Rect::from_center_size(r.center(), ts * k);
-        ui.painter().image(tex.id(), ir, egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)), egui::Color32::WHITE);
-        ui.painter().rect_stroke(r, 0.0, egui::Stroke::new(1.0, t.separator), egui::StrokeKind::Outside);
-        let _ = full_px;
+        web_preview::paint(ui, r, &response, &tex, source_size, f);
+        ui.painter().rect_stroke(r, 0.0, egui::Stroke::new(1.0, t.separator), egui::StrokeKind::Inside);
         let (l1, l2) = match (p, info) {
             (None, _) => ("Original".to_string(), format!("{}  ·  {} × {} px", doc.name, doc.size.width, doc.size.height)),
             (Some(_), Some((bytes, colors, ext))) => {
@@ -315,11 +360,33 @@ fn web_pane(app: &PhotocraftApp, ui: &mut egui::Ui, size: egui::Vec2, p: Option<
             }
             (Some(_), None) => ("—".into(), String::new()),
         };
-        ui.label(egui::RichText::new(l1).color(t.text).size(11.5));
-        ui.label(egui::RichText::new(l2).color(t.text_dim).size(11.0));
+        let l1 = if ratio > 1.001 { format!("{l1}  ·  Proxy preview") } else { l1 };
+        ui.add(egui::Label::new(egui::RichText::new(l1).color(t.text).size(11.5)).truncate());
+        ui.add(egui::Label::new(egui::RichText::new(l2).color(t.text_dim).size(11.0)).truncate());
     });
 }
 
+/// Print's Printer menu: the default printer (value ""), then every printer `file.printers`
+/// listed. A saved name the spooler no longer lists stays selectable rather than vanishing.
+/// CUPS queue names stand in for spaces with `_`; the labels show the spaces.
+fn printer_options(list: Option<&Value>, current: &str) -> Vec<(String, String)> {
+    let printers: Vec<(&str, bool)> = list
+        .and_then(Value::as_array)
+        .map(|a| a.iter().filter_map(|p| Some((p.get("name")?.as_str()?, p.get("default").and_then(Value::as_bool).unwrap_or(false)))).collect())
+        .unwrap_or_default();
+    let pretty = |n: &str| n.replace('_', " ");
+    let default = match printers.iter().find(|p| p.1) {
+        Some((n, _)) => format!("{} ({})", tl!("Default printer"), pretty(n)),
+        None => tl!("Default printer").to_string(),
+    };
+    let mut opts = vec![(String::new(), default)];
+    opts.extend(printers.iter().map(|(n, _)| (n.to_string(), pretty(n))));
+    if !current.is_empty() && !printers.iter().any(|p| p.0 == current) {
+        opts.push((current.to_string(), pretty(current)));
+    }
+    opts
+}
+
 fn dropdown_str(ui: &mut egui::Ui, id: &str, f: &mut Map<String, Value>, key: &str, opts: &[(&str, &str)], w: f32) {
     let mut v = s(f, key, opts.first().map_or("", |o| o.0));
     let o: Vec<(String, &str)> = opts.iter().map(|(k, l)| (k.to_string(), *l)).collect();
@@ -344,6 +411,70 @@ fn number(ui: &mut egui::Ui, f: &mut Map<String, Value>, key: &str, label: &str,
     });
 }
 
+/// Advance a preview clock by whole elapsed frames, retaining fractional time.
+/// The caller resets `last` on Play so paused wall time never advances the preview.
+fn advance_preview(frame: usize, duration: usize, fps: f32, last: f64, now: f64) -> (usize, f64) {
+    let duration = duration.max(1);
+    let frame = frame.min(duration - 1);
+    if !now.is_finite() {
+        return (frame, last);
+    }
+    if !last.is_finite() || now < last {
+        return (frame, now);
+    }
+    let fps = if fps.is_finite() && fps > 0.0 { f64::from(fps) } else { 30.0 };
+    let elapsed_frames = (now - last) * fps;
+    if !elapsed_frames.is_finite() {
+        return (frame, now);
+    }
+    let steps = elapsed_frames.floor();
+    if steps < 1.0 {
+        return (frame, last);
+    }
+    let delta = (steps % duration as f64) as usize % duration;
+    let remaining = duration - frame;
+    let next = if delta >= remaining { delta - remaining } else { frame + delta };
+    (next, now - (elapsed_frames - steps) / fps)
+}
+
+fn web_playback(ui: &mut egui::Ui, f: &mut Map<String, Value>, doc: &photocraft_doc::Document) -> Option<usize> {
+    let mut timeline = doc.timeline.clone()?;
+    timeline.clamp();
+    if timeline.duration < 2 {
+        return None;
+    }
+    let now = ui.input(|i| i.time);
+    let mut frame = f.get("__web_frame").and_then(Value::as_u64).and_then(|v| usize::try_from(v).ok()).unwrap_or(timeline.current).min(timeline.duration - 1);
+    let mut last = n(f, "__web_time", now);
+    let mut playing = b(f, "__web_playing", false);
+    if playing {
+        (frame, last) = advance_preview(frame, timeline.duration, timeline.fps, last, now);
+    }
+    ui.horizontal(|ui| {
+        if crate::icons::button(ui, if playing { "pause" } else { "play" }, 22.0, playing, if playing { tl!("Pause") } else { tl!("Play") }).clicked() {
+            playing = !playing;
+            last = now;
+        }
+        ui.label(format!("{} / {}", frame + 1, timeline.duration));
+    });
+    f.insert("__web_frame".into(), json!(frame));
+    f.insert("__web_time".into(), json!(last));
+    f.insert("__web_playing".into(), json!(playing));
+    if playing {
+        let remaining = (1.0 / f64::from(timeline.fps) - (now - last)).clamp(0.0, 1.0);
+        ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(remaining));
+    }
+    Some(frame)
+}
+
+/// Seek a preview copy, preserving any edits to the source's currently displayed frame.
+fn web_frame_document(doc: &photocraft_doc::Document, frame: Option<usize>) -> Result<photocraft_doc::Document, photocraft_engine::EngineError> {
+    let Some(frame) = frame else { return Ok(doc.clone()) };
+    let mut preview = photocraft_engine::Session::new();
+    preview.add_document(doc.clone(), None);
+    preview.execute("timeline.setFrame", json!({"frame": frame}))?;
+    Ok((*preview.active().ok_or(photocraft_engine::EngineError::NoDocument)?.doc).clone())
+}
 fn web_body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Value>) {
     let t = Tokens::get(ui.ctx());
     let Some(doc) = app.session.active().map(|d| d.doc.clone()) else { return };
@@ -357,158 +488,186 @@ fn web_body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Valu
         f.insert("__view".into(), json!(view));
     });
     ui.add_space(4.0);
+    let frame = web_playback(ui, f, &doc);
+    web_preview::controls(ui, f);
+    if let Err(error) = web_preview::prepare_table(app, f) {
+        ui.colored_label(t.text_dim, error);
+    }
     let p = params(f);
-    let full_px = f64::from(doc.size.width) * f64::from(doc.size.height);
+    f.insert("__previewRects".into(), json!([]));
+    let area = egui::vec2((ui.available_width() - 270.0 - ui.spacing().item_spacing.x).max(260.0), (ui.available_height() - 48.0).max(180.0));
     ui.horizontal_top(|ui| {
-        // Previews.
-        let area = egui::vec2(600.0, 470.0);
+        // Previews grow with the dialog; settings retain their compact width.
         ui.vertical(|ui| {
             ui.set_width(area.x);
             match s(f, "__view", "2up").as_str() {
-                "original" => web_pane(app, ui, area, None, full_px),
-                "optimized" => web_pane(app, ui, area, Some(&p), full_px),
+                "original" => web_pane(app, ui, area, None, f, 0, frame),
+                "optimized" => web_pane(app, ui, area, Some(&p), f, 1, frame),
                 "2up" => {
                     ui.horizontal(|ui| {
-                        web_pane(app, ui, egui::vec2(area.x / 2.0 - 4.0, area.y), None, full_px);
-                        web_pane(app, ui, egui::vec2(area.x / 2.0 - 4.0, area.y), Some(&p), full_px);
+                        web_pane(app, ui, egui::vec2(area.x / 2.0 - 4.0, area.y), None, f, 0, frame);
+                        web_pane(app, ui, egui::vec2(area.x / 2.0 - 4.0, area.y), Some(&p), f, 1, frame);
                     });
                 }
                 _ => {
                     let v = variants(&p);
-                    let cell = egui::vec2(area.x / 2.0 - 4.0, area.y / 2.0 - 2.0);
+                    let cell = egui::vec2(area.x / 2.0 - 4.0, area.y / 2.0 - 4.0);
                     ui.horizontal(|ui| {
-                        web_pane(app, ui, cell, None, full_px);
-                        web_pane(app, ui, cell, Some(&v[0]), full_px);
+                        web_pane(app, ui, cell, None, f, 0, frame);
+                        web_pane(app, ui, cell, Some(&v[0]), f, 1, frame);
                     });
                     ui.horizontal(|ui| {
-                        web_pane(app, ui, cell, Some(&v[1]), full_px);
-                        web_pane(app, ui, cell, Some(&v[2]), full_px);
+                        web_pane(app, ui, cell, Some(&v[1]), f, 2, frame);
+                        web_pane(app, ui, cell, Some(&v[2]), f, 3, frame);
                     });
                 }
             }
         });
         ui.add_space(10.0);
-        // Settings.
+        // Settings scroll independently on smaller windows.
         ui.vertical(|ui| {
             ui.set_width(250.0);
-            ui.label(egui::RichText::new(tl!("Preset")).color(t.text_dim));
-            let mut preset = s(f, "__preset", "");
-            let mut opts: Vec<(String, &str)> = vec![("".into(), "[Unnamed]")];
-            opts.extend(web_cmds::PRESETS.iter().map(|p| (p.to_string(), *p)));
-            if crate::widgets::dropdown(ui, "web-preset", &mut preset, &opts, 230.0) && !preset.is_empty() {
-                if let Some(Value::Object(m)) = web_cmds::preset_settings(&preset).map(|st| st.to_params()) {
-                    f.extend(m);
-                }
-                f.insert("__preset".into(), json!(preset));
-            }
-            ui.add_space(4.0);
-            dropdown_str(ui, "web-format", f, "format", &WEB_FORMATS, 230.0);
-            ui.add_space(4.0);
-            let fmt = s(f, "format", "jpeg");
-            match fmt.as_str() {
-                "gif" | "png8" => {
-                    dropdown_str(
-                        ui,
-                        "web-palette",
-                        f,
-                        "palette",
-                        &[
-                            ("perceptual", tl!("Perceptual")),
-                            ("selective", tl!("Selective")),
-                            ("adaptive", tl!("Adaptive")),
-                            ("restrictive", tl!("Restrictive (Web)")),
-                            ("exact", tl!("Exact")),
-                        ],
-                        150.0,
-                    );
-                    number(ui, f, "colors", tl!("Colors"), 2.0..=256.0, "", 128.0);
-                    dropdown_str(
-                        ui,
-                        "web-dither",
-                        f,
-                        "dither",
-                        &[("none", tl!("No Dither")), ("diffusion", tl!("Diffusion")), ("pattern", tl!("Pattern")), ("noise", tl!("Noise"))],
-                        150.0,
-                    );
-                    number(ui, f, "ditherAmount", tl!("Dither"), 0.0..=100.0, "%", 88.0);
-                    check(ui, f, "transparency", tl!("Transparency"), true);
-                    check(ui, f, "interlaced", tl!("Interlaced"), false);
-                    number(ui, f, "webSnap", tl!("Web Snap"), 0.0..=100.0, "%", 0.0);
-                }
-                "jpeg" => {
-                    number(ui, f, "quality", tl!("Quality"), 0.0..=100.0, "", 60.0);
-                    check(ui, f, "progressive", tl!("Progressive"), false);
-                    check(ui, f, "optimized", tl!("Optimized"), true);
-                    check(ui, f, "embedIcc", tl!("Embed Color Profile"), false);
-                }
-                "wbmp" => {
-                    dropdown_str(
-                        ui,
-                        "web-dither",
-                        f,
-                        "dither",
-                        &[("none", tl!("No Dither")), ("diffusion", tl!("Diffusion")), ("pattern", tl!("Pattern"))],
-                        150.0,
-                    );
-                }
-                _ => {
-                    check(ui, f, "transparency", tl!("Transparency"), true);
-                    check(ui, f, "interlaced", tl!("Interlaced"), false);
-                }
-            }
-            if fmt != "png24" || !b(f, "transparency", true) {
-                ui.horizontal(|ui| {
-                    ui.label(egui::RichText::new(tl!("Matte")).color(t.text_dim));
-                    let mut m = s(f, "matte", "#ffffff");
-                    if ui.add(egui::TextEdit::singleline(&mut m).desired_width(80.0)).changed() {
-                        f.insert("matte".into(), json!(m));
+            egui::ScrollArea::vertical().id_salt("web-settings").max_height(area.y).show(ui, |ui| {
+                ui.label(egui::RichText::new(tl!("Preset")).color(t.text_dim));
+                let mut preset = s(f, "__preset", "");
+                let mut opts: Vec<(String, &str)> = vec![("".into(), "[Unnamed]")];
+                opts.extend(web_cmds::PRESETS.iter().map(|p| (p.to_string(), *p)));
+                if crate::widgets::dropdown(ui, "web-preset", &mut preset, &opts, 230.0) && !preset.is_empty() {
+                    if let Some(Value::Object(m)) = web_cmds::preset_settings(&preset).map(|st| st.to_params()) {
+                        f.extend(m);
                     }
-                });
-            }
-            ui.add_space(6.0);
-            check(ui, f, "convertToSrgb", tl!("Convert to sRGB"), true);
-            ui.horizontal(|ui| {
-                ui.label(egui::RichText::new(tl!("Metadata")).color(t.text_dim));
-                dropdown_str(
-                    ui,
-                    "web-meta",
-                    f,
-                    "metadata",
-                    &[("none", tl!("None")), ("copyright", tl!("Copyright")), ("copyrightAndContact", tl!("Copyright and Contact Info")), ("all", tl!("All"))],
-                    160.0,
-                );
-            });
-            ui.add_space(8.0);
-            ui.label(egui::RichText::new(tl!("Image Size")).font(crate::theme::semibold(12.0)).color(t.text));
-            number(ui, f, "percent", tl!("Percent"), 1.0..=1000.0, "%", 100.0);
-            let pct = n(f, "percent", 100.0) / 100.0;
-            ui.label(
-                egui::RichText::new(format!("W: {} px   H: {} px", (f64::from(doc.size.width) * pct).round(), (f64::from(doc.size.height) * pct).round()))
-                    .color(t.text_dim)
-                    .size(11.5),
-            );
-            let nslices = photocraft_doc::slices::resolve(&doc).len();
-            if !doc.slices.is_empty() {
+                    f.insert("__preset".into(), json!(preset));
+                }
+                ui.add_space(4.0);
+                dropdown_str(ui, "web-format", f, "format", &WEB_FORMATS, 230.0);
+                ui.add_space(4.0);
+                let fmt = s(f, "format", "jpeg");
+                match fmt.as_str() {
+                    "gif" | "png8" => {
+                        dropdown_str(
+                            ui,
+                            "web-palette",
+                            f,
+                            "palette",
+                            &[
+                                ("perceptual", tl!("Perceptual")),
+                                ("selective", tl!("Selective")),
+                                ("adaptive", tl!("Adaptive")),
+                                ("restrictive", tl!("Restrictive (Web)")),
+                                ("exact", tl!("Exact")),
+                            ],
+                            150.0,
+                        );
+                        number(ui, f, "colors", tl!("Colors"), 2.0..=256.0, "", 128.0);
+                        dropdown_str(
+                            ui,
+                            "web-dither",
+                            f,
+                            "dither",
+                            &[("none", tl!("No Dither")), ("diffusion", tl!("Diffusion")), ("pattern", tl!("Pattern")), ("noise", tl!("Noise"))],
+                            150.0,
+                        );
+                        number(ui, f, "ditherAmount", tl!("Dither"), 0.0..=100.0, "%", 88.0);
+                        check(ui, f, "transparency", tl!("Transparency"), true);
+                        check(ui, f, "interlaced", tl!("Interlaced"), false);
+                        number(ui, f, "webSnap", tl!("Web Snap"), 0.0..=100.0, "%", 0.0);
+                    }
+                    "jpeg" => {
+                        number(ui, f, "quality", tl!("Quality"), 0.0..=100.0, "", 60.0);
+                        check(ui, f, "progressive", tl!("Progressive"), false);
+                        check(ui, f, "optimized", tl!("Optimized"), true);
+                        check(ui, f, "embedIcc", tl!("Embed Color Profile"), false);
+                    }
+                    "wbmp" => {
+                        dropdown_str(
+                            ui,
+                            "web-dither",
+                            f,
+                            "dither",
+                            &[("none", tl!("No Dither")), ("diffusion", tl!("Diffusion")), ("pattern", tl!("Pattern"))],
+                            150.0,
+                        );
+                    }
+                    _ => {
+                        check(ui, f, "transparency", tl!("Transparency"), true);
+                        check(ui, f, "interlaced", tl!("Interlaced"), false);
+                    }
+                }
+                if fmt != "png24" || !b(f, "transparency", true) {
+                    ui.horizontal(|ui| {
+                        ui.label(egui::RichText::new(tl!("Matte")).color(t.text_dim));
+                        let mut m = s(f, "matte", "#ffffff");
+                        if ui.add(egui::TextEdit::singleline(&mut m).desired_width(80.0)).changed() {
+                            f.insert("matte".into(), json!(m));
+                        }
+                    });
+                }
                 ui.add_space(6.0);
-                ui.label(egui::RichText::new(crate::i18n::trn(crate::i18n::current(), nslices as u64, "{n} slice", "{n} slices")).color(t.text_dim));
-                check(ui, f, "html", tl!("Save HTML and Images"), true);
-                dropdown_str(ui, "web-slices", f, "slices", &[("all", tl!("All Slices")), ("user", tl!("All User Slices"))], 150.0);
-            }
+                check(ui, f, "convertToSrgb", tl!("Convert to sRGB"), true);
+                ui.horizontal(|ui| {
+                    ui.label(egui::RichText::new(tl!("Metadata")).color(t.text_dim));
+                    dropdown_str(
+                        ui,
+                        "web-meta",
+                        f,
+                        "metadata",
+                        &[
+                            ("none", tl!("None")),
+                            ("copyright", tl!("Copyright")),
+                            ("copyrightAndContact", tl!("Copyright and Contact Info")),
+                            ("all", tl!("All")),
+                        ],
+                        160.0,
+                    );
+                });
+                if matches!(fmt.as_str(), "gif" | "png8") {
+                    web_preview::table(ui, f);
+                }
+                ui.add_space(8.0);
+                ui.label(egui::RichText::new(tl!("Image Size")).font(crate::theme::semibold(12.0)).color(t.text));
+                number(ui, f, "percent", tl!("Percent"), 1.0..=1000.0, "%", 100.0);
+                let pct = n(f, "percent", 100.0) / 100.0;
+                ui.label(
+                    egui::RichText::new(format!("W: {} px   H: {} px", (f64::from(doc.size.width) * pct).round(), (f64::from(doc.size.height) * pct).round()))
+                        .color(t.text_dim)
+                        .size(11.5),
+                );
+                let nslices = photocraft_doc::slices::resolve(&doc).len();
+                if !doc.slices.is_empty() {
+                    ui.add_space(6.0);
+                    ui.label(egui::RichText::new(crate::i18n::trn(crate::i18n::current(), nslices as u64, "{n} slice", "{n} slices")).color(t.text_dim));
+                    check(ui, f, "html", tl!("Save HTML and Images"), true);
+                    dropdown_str(ui, "web-slices", f, "slices", &[("all", tl!("All Slices")), ("user", tl!("All User Slices"))], 150.0);
+                }
+            });
         });
     });
 }
 
 fn web_confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value, String> {
-    let mut p = params(f);
     // Check while the control/input policy is still installed, before an asynchronous picker
     // can outlive the request. A browser download uses the interactive platform writer.
-    if let Some(authorize) = app.session.authorize.or(if app.automation_input { app.services.automation_authorize } else { None }) {
-        authorize(WEB_COMMAND, &p).map_err(|e| e.to_string())?;
-    }
-    if app.automation_input
-        && let Some(authorize) = app.services.automation_command.as_ref()
-    {
-        authorize(WEB_COMMAND, &p)?;
+    let authorize = |p: &Value| -> Result<(), String> {
+        if let Some(authorize) = app.session.authorize.or(if app.automation_input { app.services.automation_authorize } else { None }) {
+            authorize(WEB_COMMAND, p).map_err(|e| e.to_string())?;
+        }
+        if app.automation_input
+            && let Some(authorize) = app.services.automation_command.as_ref()
+        {
+            authorize(WEB_COMMAND, p)?;
+        }
+        Ok(())
+    };
+    let mut p = params(f);
+    authorize(&p)?;
+    // Confirmation may follow a field edit without an intervening frame (Enter or automation).
+    let mut fields = f.clone();
+    web_preview::prepare_table(app, &mut fields)?;
+    let prepared = params(&fields);
+    if prepared != p {
+        // The policy must also approve the actual palette-bearing export parameters.
+        authorize(&prepared)?;
+        p = prepared;
     }
     if p.get("path").is_some() || p.get("dir").is_some() {
         return save_for_web(app, p);
@@ -565,6 +724,9 @@ pub fn open_print(app: &mut PhotocraftApp) -> u64 {
     let mut f = Map::new();
     f.insert("__print".into(), json!(true));
     f.insert("__label".into(), json!("PhotoCraft Print Settings"));
+    // Asked once per opening: the Printer menu lists what the spooler knows now.
+    let printers = app.session.execute("file.printers", json!({})).unwrap_or_default();
+    f.insert("__printers".into(), printers["printers"].clone());
     if let Some(Value::Object(m)) = app.session.file_menu.last_print.clone() {
         f.extend(m);
     }
@@ -607,6 +769,10 @@ fn unit_pt(units: &str) -> f64 {
 
 /// A number field in `units` for a value kept in points; true when edited.
 fn length_field(ui: &mut egui::Ui, label: &str, pt: &mut f64, units: &str) -> bool {
+    length_field_prec(ui, label, pt, units, 0)
+}
+
+fn length_field_prec(ui: &mut egui::Ui, label: &str, pt: &mut f64, units: &str, decimals: u32) -> bool {
     let t = Tokens::get(ui.ctx());
     let k = unit_pt(units);
     let mut v = (*pt / k) as f32;
@@ -614,7 +780,7 @@ fn length_field(ui: &mut egui::Ui, label: &str, pt: &mut f64, units: &str) -> bo
     ui.horizontal(|ui| {
         ui.label(egui::RichText::new(label).color(t.text_dim));
         let before = v;
-        crate::widgets::value_field(ui, &mut v, 0.0..=10000.0, units, 70.0);
+        crate::widgets::value_field_prec(ui, &mut v, 0.0..=10000.0, units, 70.0, decimals);
         if (v - before).abs() > 1e-4 && v.is_finite() {
             *pt = f64::from(v) * k;
             changed = true;
@@ -623,6 +789,53 @@ fn length_field(ui: &mut egui::Ui, label: &str, pt: &mut f64, units: &str) -> bo
     changed
 }
 
+/// Unrotated paper dimensions in points, for either the current preset or a custom array.
+fn print_paper_size(value: Option<&Value>) -> (f64, f64) {
+    let default = (612.0, 792.0);
+    match value {
+        Some(Value::Array(a)) => (a.first().and_then(Value::as_f64).unwrap_or(default.0), a.get(1).and_then(Value::as_f64).unwrap_or(default.1)),
+        Some(Value::String(name)) => photocraft_engine::print_cmds::PAPERS.iter().find(|p| p.0.eq_ignore_ascii_case(name)).map_or(default, |p| (p.1, p.2)),
+        _ => default,
+    }
+}
+
+fn print_paper_controls(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
+    let previous = f.get("paper").cloned();
+    let mut selected = if previous.as_ref().is_some_and(Value::is_array) { "custom".to_string() } else { s(f, "paper", "letter") };
+    ui.horizontal(|ui| {
+        let mut papers: Vec<_> = photocraft_engine::print_cmds::PAPERS.iter().map(|p| (p.0.to_string(), p.0)).collect();
+        papers.push(("custom".to_string(), tl!("Custom")));
+        if crate::widgets::dropdown(ui, "print-paper", &mut selected, &papers, 110.0) {
+            if selected == "custom" {
+                let (w, h) = print_paper_size(f.get("__customPaper").or(previous.as_ref()));
+                f.insert("paper".into(), json!([w, h]));
+            } else {
+                if let Some(paper @ Value::Array(_)) = previous {
+                    f.insert("__customPaper".into(), paper);
+                }
+                f.insert("paper".into(), json!(selected));
+            }
+        }
+        dropdown_str(ui, "print-orient", f, "orientation", &[("portrait", tl!("Portrait")), ("landscape", tl!("Landscape"))], 110.0);
+    });
+    if f.get("paper").is_some_and(Value::is_array) {
+        let (mut w, mut h) = print_paper_size(f.get("paper"));
+        let units = s(f, "units", "cm");
+        let changed = ui
+            .horizontal(|ui| {
+                let wc = length_field_prec(ui, tl!("Paper Width"), &mut w, &units, 2);
+                let hc = length_field_prec(ui, tl!("Paper Height"), &mut h, &units, 2);
+                wc || hc
+            })
+            .inner;
+        if changed {
+            // Keep points in the command, and let the engine apply orientation and validation.
+            f.insert("paper".into(), json!([w, h]));
+            f.insert("__customPaper".into(), json!([w, h]));
+        }
+    }
+}
+
 fn print_body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Value>) {
     let t = Tokens::get(ui.ctx());
     let Some(doc) = app.session.active().map(|d| d.doc.clone()) else { return };
@@ -705,16 +918,14 @@ fn print_body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Va
             ui.horizontal(|ui| {
                 ui.label(egui::RichText::new(tl!("Printer")).color(t.text_dim));
                 let mut pr = s(f, "printer", "");
-                if ui.add(egui::TextEdit::singleline(&mut pr).hint_text(tl!("Default printer")).desired_width(180.0)).changed() {
+                let opts = printer_options(f.get("__printers"), &pr);
+                let o: Vec<(String, &str)> = opts.iter().map(|(k, l)| (k.clone(), l.as_str())).collect();
+                if crate::widgets::dropdown(ui, "print-printer", &mut pr, &o, 240.0) {
                     f.insert("printer".into(), json!(pr));
                 }
             });
             number(ui, f, "copies", tl!("Copies"), 1.0..=999.0, "", 1.0);
-            ui.horizontal(|ui| {
-                let papers: Vec<(&str, &str)> = photocraft_engine::print_cmds::PAPERS.iter().map(|p| (p.0, p.0)).collect();
-                dropdown_str(ui, "print-paper", f, "paper", &papers, 110.0);
-                dropdown_str(ui, "print-orient", f, "orientation", &[("portrait", tl!("Portrait")), ("landscape", tl!("Landscape"))], 110.0);
-            });
+            print_paper_controls(ui, f);
             head(ui, tl!("Color Management"));
             dropdown_str(
                 ui,
@@ -840,6 +1051,13 @@ fn print_body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Va
 
 fn print_confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value, String> {
     let r = app.run("file.print", params(f))?;
+    if r["pending"] != json!(true) {
+        print_status(app, &r);
+    }
+    Ok(r)
+}
+
+pub(crate) fn print_status(app: &mut PhotocraftApp, r: &Value) {
     app.ui.status = if r["sent"] == json!(true) {
         let template = "Sent to the printer ({spooler})";
         crate::i18n::fmt(tl!(template), &[("spooler", r["spooler"].as_str().unwrap_or(""))])
@@ -847,7 +1065,7 @@ fn print_confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Valu
         let template = "Printed to {path}";
         crate::i18n::fmt(tl!(template), &[("path", r["pdf"].as_str().unwrap_or(""))])
     };
-    Ok(r)
+    app.ui.status_error = false;
 }
 
 #[cfg(test)]
@@ -860,6 +1078,20 @@ mod tests {
         (app, egui::Context::default())
     }
 
+    #[test]
+    fn droplet_folder_follows_the_document_or_uses_a_safe_fallback() {
+        let (mut app, _) = app();
+        let fallback = droplet_default_dir(&app);
+        #[cfg(target_os = "macos")]
+        if std::env::var_os("HOME").is_some() {
+            assert!(std::path::Path::new(&fallback).is_absolute());
+        }
+        #[cfg(not(target_os = "macos"))]
+        assert_eq!(fallback, ".");
+        app.session.active_mut().unwrap().path = Some("/tmp/photocraft/drawing.pcraft".into());
+        assert_eq!(droplet_default_dir(&app), "/tmp/photocraft");
+    }
+
     #[test]
     fn save_for_web_dialog_runs_the_command() {
         let (mut app, ctx) = app();
@@ -880,6 +1112,20 @@ mod tests {
         assert!(!d.fields.contains_key("path"));
     }
 
+    /// A fresh session's dialog seeds from the preferences: the last export before a restart is
+    /// remembered there (`web_cmds::remember_web_settings`), as `file_menu` is not saved.
+    #[test]
+    fn the_save_for_web_dialog_seeds_from_the_remembered_preferences() {
+        let (mut app, _) = app();
+        app.session.prefs.edit(|p| {
+            p.dialogs.insert(WEB_COMMAND.into(), json!({"format": "png8", "colors": 64}));
+        });
+        let id = open_web(&mut app);
+        let f = &app.ui.dialog_mut(id).unwrap().fields;
+        assert_eq!(f["format"], "png8");
+        assert_eq!(f["colors"], 64);
+    }
+
     #[test]
     fn save_for_web_starts_at_the_current_document_size() {
         let (mut app, _) = app();
@@ -957,6 +1203,118 @@ mod tests {
         }
     }
 
+    #[test]
+    fn save_for_web_authorizes_generated_palette_before_opening_a_picker() {
+        fn deny_palette(_: &str, p: &Value) -> photocraft_engine::Result<()> {
+            if p.get("colorTable").is_some() { Err(photocraft_engine::EngineError::Other("palette denied".into())) } else { Ok(()) }
+        }
+        for synthetic_input in [false, true] {
+            let (mut app, _) = app();
+            let id = open_web(&mut app);
+            let fields = &mut app.ui.dialog_mut(id).unwrap().fields;
+            fields.insert("format".into(), json!("gif"));
+            assert!(!fields.contains_key("colorTable"));
+            if synthetic_input {
+                app.automation_input = true;
+                app.services.automation_command = Some(Box::new(|cmd, p| deny_palette(cmd, p).map_err(|e| e.to_string())));
+            } else {
+                app.session.authorize = Some(deny_palette);
+            }
+            app.services.file_dialog = Some(Box::new(|_, _, _| panic!("denied palette must not show a picker")));
+            app.services.write = Some(Box::new(|_, _| panic!("denied palette must not write")));
+            assert_eq!(crate::dialogs::confirm(&mut app, id).unwrap_err(), "palette denied");
+            assert!(!app.file_dialog_open());
+        }
+    }
+
+    #[test]
+    fn web_preview_grows_with_resize_and_accepts_zoom_and_pan() {
+        let (mut app, _) = app();
+        let id = open_web(&mut app);
+        let revision = app.session.active().unwrap().revision;
+        app.ui.dialog_mut(id).unwrap().fields.insert("__view".into(), json!("optimized"));
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1600.0, 1100.0)).build_ui_state(
+            |ui, app| {
+                if ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("semibold".into()))) {
+                    crate::dialogs::show(app, ui.ctx());
+                }
+            },
+            app,
+        );
+        PhotocraftApp::setup_context(&h.ctx, Default::default());
+        h.run_steps(5);
+        let pane = |h: &egui_kittest::Harness<'_, PhotocraftApp>| {
+            let r = &h.state().ui.dialogs[0].fields["__previewRects"][0];
+            egui::Rect::from_min_max(
+                egui::pos2(r[0].as_f64().unwrap() as f32, r[1].as_f64().unwrap() as f32),
+                egui::pos2(r[2].as_f64().unwrap() as f32, r[3].as_f64().unwrap() as f32),
+            )
+        };
+        let before = pane(&h);
+        let rects: Vec<egui::Rect> = h.ctx.data(|m| m.get_temp(egui::Id::new("pc-dialog-rects"))).unwrap();
+        let corner = rects[0].max - egui::vec2(14.0, 14.0);
+        h.event(egui::Event::PointerMoved(corner));
+        h.step();
+        h.event(egui::Event::PointerButton { pos: corner, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE });
+        h.step();
+        let end = corner + egui::vec2(180.0, 100.0);
+        h.event(egui::Event::PointerMoved(end));
+        h.step();
+        h.event(egui::Event::PointerButton { pos: end, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE });
+        h.run_steps(4);
+        let after = pane(&h);
+        assert!(after.width() > before.width() + 100.0, "before {before:?}, after {after:?}, corner {corner:?}");
+        assert!(after.height() > before.height() + 50.0);
+        // Zoom in enough that the small fixture can pan, then drag the real pane.
+        h.state_mut().ui.dialogs[0].fields.insert("__zoom".into(), json!(16.0));
+        h.run_steps(3);
+        let at = pane(&h).center();
+        h.event(egui::Event::PointerMoved(at));
+        h.step();
+        h.event(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE });
+        h.step();
+        let end = at + egui::vec2(35.0, 20.0);
+        h.event(egui::Event::PointerMoved(end));
+        h.step();
+        h.event(egui::Event::PointerButton { pos: end, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE });
+        h.run_steps(3);
+        assert_ne!(h.state().ui.dialogs[0].fields["__center"], json!([0.5, 0.5]));
+        assert_eq!(h.state().session.active().unwrap().revision, revision);
+        // Enter while editing a swatch must not export and close the parent dialog.
+        h.state_mut().ui.dialogs[0].fields.insert("format".into(), json!("gif"));
+        h.run_steps(4);
+        use egui_kittest::kittest::Queryable;
+        h.get_by_role(egui::accesskit::Role::ColorWell).click();
+        h.run_steps(3);
+        assert!(egui::Popup::is_any_open(&h.ctx));
+        h.key_press(egui::Key::Enter);
+        h.run_steps(3);
+        assert_eq!(h.state().ui.dialogs.len(), 1);
+    }
+
+    #[test]
+    fn palette_draft_survives_navigation_and_resets_when_colors_change() {
+        let (app, _) = app();
+        let mut f = serde_json::from_value::<Map<String, Value>>(json!({"format": "gif", "colors": 16})).unwrap();
+        web_preview::prepare_table(&app, &mut f).unwrap();
+        let table = f["colorTable"].clone();
+        f.insert("colorTableEdits".into(), json!({"0": "#12ab34"}));
+        f.insert("__zoom".into(), json!(2.0));
+        f.insert("__center".into(), json!([0.25, 0.75]));
+        web_preview::prepare_table(&app, &mut f).unwrap();
+        assert_eq!(f["colorTable"], table);
+        assert_eq!(f["colorTableEdits"]["0"], "#12ab34");
+        f.insert("metadata".into(), json!("none"));
+        f.insert("interlaced".into(), json!(true));
+        f.insert("dither".into(), json!("pattern"));
+        web_preview::prepare_table(&app, &mut f).unwrap();
+        assert_eq!(f["colorTableEdits"]["0"], "#12ab34", "non-palette settings must retain edits");
+        f.insert("colors".into(), json!(8));
+        web_preview::prepare_table(&app, &mut f).unwrap();
+        assert!(!f.contains_key("colorTableEdits"));
+        assert!(f["colorTable"].as_array().unwrap().len() <= 8);
+    }
+
     #[test]
     fn print_dialog_and_toggles() {
         let (mut app, ctx) = app();
@@ -979,6 +1337,26 @@ mod tests {
         }
     }
 
+    #[test]
+    fn printer_menu_lists_the_spooler_printers_after_the_default() {
+        let list = json!([{"name": "HP_OfficeJet_3830_series", "default": true}, {"name": "DNP_DP_DS620", "default": false}]);
+        let o = printer_options(Some(&list), "");
+        let keys: Vec<&str> = o.iter().map(|p| p.0.as_str()).collect();
+        assert_eq!(keys, ["", "HP_OfficeJet_3830_series", "DNP_DP_DS620"]);
+        assert!(o[0].1.ends_with("(HP OfficeJet 3830 series)"), "{}", o[0].1);
+        assert_eq!(o[2].1, "DNP DP DS620");
+        // A remembered printer that's gone stays selectable; no list still offers the default.
+        let o = printer_options(Some(&list), "Old_Queue");
+        assert_eq!(o.last().unwrap().0, "Old_Queue");
+        assert_eq!(printer_options(None, "").len(), 1);
+        // The dialog asks the engine, and the list never reaches file.print's params.
+        let (mut app, ctx) = app();
+        let id = crate::menus::invoke(&mut app, &ctx, "file.print", json!({})).unwrap()["dialog"].as_u64().unwrap();
+        let f = &app.ui.dialog_mut(id).unwrap().fields;
+        assert!(f.get("__printers").is_some_and(Value::is_array));
+        assert!(params(f).get("__printers").is_none());
+    }
+
     #[test]
     fn print_dialog_does_not_inherit_scripted_send_override() {
         for send in [false, true] {
@@ -993,3 +1371,232 @@ mod tests {
         }
     }
 }
+
+#[cfg(test)]
+mod web_playback_tests {
+    use super::*;
+    use egui_kittest::{Harness, kittest::Queryable};
+
+    fn animated_app(depth: u32) -> PhotocraftApp {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 32, "height": 24, "depth": depth})).unwrap();
+        app.run("timeline.create", json!({"duration": 3, "fps": 2})).unwrap();
+        app.run("layer.videoLayers.newBlankVideoLayer", json!({})).unwrap();
+        for (frame, color) in ["#ff0000", "#00ff00", "#0000ff"].iter().enumerate() {
+            app.run("timeline.setFrame", json!({"frame":frame})).unwrap();
+            app.run("edit.fill", json!({"color":color})).unwrap();
+        }
+        app.run("timeline.setFrame", json!({"frame":0})).unwrap();
+        app
+    }
+
+    fn harness(app: PhotocraftApp, fields: Map<String, Value>) -> Harness<'static, (PhotocraftApp, Map<String, Value>)> {
+        let mut h = Harness::builder().with_size(egui::vec2(1000.0, 800.0)).with_step_dt(0.1).build_ui_state(
+            |ui, state: &mut (PhotocraftApp, Map<String, Value>)| {
+                if !ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                    return;
+                }
+                web_body(&mut state.0, ui, &mut state.1);
+            },
+            (app, fields),
+        );
+        PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+        h.run_steps(3);
+        h
+    }
+
+    #[test]
+    fn animated_save_for_web_offers_playback() {
+        let mut app = animated_app(8);
+        let id = open_web(&mut app);
+        let mut fields = app.ui.dialog_mut(id).unwrap().fields.clone();
+        fields.insert("__view".into(), json!("original"));
+        fields.insert("format".into(), json!("gif"));
+        let mut h = harness(app, fields);
+        assert!(h.query_by_label("Play").is_some(), "an animated document needs a preview playback control");
+        let original = h.state().0.session.active().unwrap().doc.clone();
+        let revision = h.state().0.session.active().unwrap().revision;
+        let history = h.state().0.session.active().unwrap().history.past_len();
+        h.get_by_label("Play").click();
+        h.run_steps(2);
+        assert_eq!(h.state().1["__web_playing"], true);
+        h.run_steps(6);
+        assert_ne!(h.state().1["__web_frame"], 0);
+        h.get_by_label("Pause").click();
+        h.run_steps(2);
+        assert_eq!(h.state().1["__web_playing"], false);
+        let paused = h.state().1["__web_frame"].clone();
+        h.run_steps(20);
+        assert_eq!(h.state().1["__web_frame"], paused);
+        h.get_by_label("Play").click();
+        h.run_steps(2);
+        assert_eq!(h.state().1["__web_playing"], true);
+        assert_eq!(h.state().1["__web_frame"], paused, "resuming must not count time spent paused");
+        h.run_steps(6);
+        assert_ne!(h.state().1["__web_frame"], paused, "resuming must advance the preview again");
+        let st = h.state().0.session.active().unwrap();
+        assert!(Arc::ptr_eq(&st.doc, &original));
+        assert_eq!(st.revision, revision);
+        assert_eq!(st.history.past_len(), history);
+        assert!(params(&h.state().1).as_object().unwrap().keys().all(|k| !k.starts_with("__")));
+        crate::dialogs::cancel(&mut h.state_mut().0, id).unwrap();
+        let next = open_web(&mut h.state_mut().0);
+        let fields = &h.state_mut().0.ui.dialog_mut(next).unwrap().fields;
+        assert!(!fields.contains_key("__web_playing"));
+        assert!(!fields.contains_key("__web_frame"));
+    }
+
+    #[test]
+    fn frame_previews_preserve_source_and_match_colors_across_depths() {
+        for depth in [8, 16, 32] {
+            let app = animated_app(depth);
+            let source = app.session.active().unwrap().doc.clone();
+            for (frame, expected) in [[1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0]].iter().enumerate() {
+                let preview = web_frame_document(&source, Some(frame)).unwrap();
+                let (proxy, _, _) = web_cmds::web_document(&preview, &json!({"width":16,"height":12}), &WebSettings::default()).unwrap();
+                let pixels = photocraft_compose::flatten(&proxy);
+                for (actual, expected) in pixels.px[0].iter().zip(expected) {
+                    assert!((actual - expected).abs() < 0.002, "depth={depth} frame={frame}");
+                }
+            }
+            assert_eq!(source.timeline.as_ref().unwrap().current, 0);
+            assert_eq!(photocraft_compose::flatten(&source).px[0], [1.0, 0.0, 0.0, 1.0]);
+        }
+    }
+
+    #[test]
+    fn four_up_caches_follow_the_local_frame() {
+        let mut app = animated_app(8);
+        let doc_id = app.session.active().unwrap().doc.id.0;
+        let id = open_web(&mut app);
+        let mut fields = app.ui.dialog_mut(id).unwrap().fields.clone();
+        fields.insert("__view".into(), json!("4up"));
+        fields.insert("format".into(), json!("gif"));
+        let mut h = harness(app, fields);
+        for frame in [1, 2, 0] {
+            h.state_mut().1.insert("__web_frame".into(), json!(frame));
+            h.run_steps(2);
+            for pane in 0usize..4 {
+                let proxy: (String, WebProxy) = h.ctx.data(|d| d.get_temp(egui::Id::new(("web-proxy", doc_id, pane)))).unwrap();
+                assert!(proxy.1.0[0][frame] > 0.99, "pane {pane} must show frame {frame}");
+                let cache: WebCache = h.ctx.data(|d| d.get_temp(egui::Id::new(("web-pane", doc_id, pane)))).unwrap();
+                assert!(cache.0.contains(&format!("Some({frame})")));
+            }
+        }
+    }
+    #[test]
+    fn playback_refreshes_indexed_frames_without_resetting_palette_or_navigation() {
+        let mut app = animated_app(8);
+        let doc_id = app.session.active().unwrap().doc.id.0;
+        let id = open_web(&mut app);
+        let mut fields = app.ui.dialog_mut(id).unwrap().fields.clone();
+        fields.insert("__view".into(), json!("optimized"));
+        fields.insert("format".into(), json!("gif"));
+        fields.insert("__zoom".into(), json!(2.0));
+        let mut h = harness(app, fields);
+        // Set the custom palette after the dialog has initialized its format defaults.
+        let expected_palette = json!(["#ff0000", "#00ff00", "#0000ff"]);
+        h.state_mut().1.insert("colorTable".into(), expected_palette.clone());
+        h.run_steps(2);
+        assert_eq!(h.state().1["colorTable"], expected_palette);
+        let key = egui::Id::new(("web-pane", doc_id, 1usize)).with("indexed-source");
+        let encoded = |ctx: &egui::Context| ctx.data(|d| d.get_temp::<(String, Arc<Optimized>)>(key)).unwrap().1;
+        let first = encoded(&h.ctx);
+        h.state_mut().1.insert("colorTableEdits".into(), json!({"0":"#ffff00"}));
+        h.run_steps(2);
+        assert!(Arc::ptr_eq(&first, &encoded(&h.ctx)), "palette edits reuse the current frame's indices");
+        let palette = h.state().1["colorTable"].clone();
+        let center = h.state().1["__center"].clone();
+        let mut previous = first;
+        for (frame, rgba) in [(1, [0, 255, 0, 255]), (2, [0, 0, 255, 255]), (0, [255, 0, 0, 255])] {
+            h.state_mut().1.insert("__web_frame".into(), json!(frame));
+            h.run_steps(2);
+            let next = encoded(&h.ctx);
+            assert!(!Arc::ptr_eq(&previous, &next), "a changed frame needs fresh indexed pixels");
+            assert_eq!(&next.preview[..4], &rgba);
+            assert_eq!(h.state().1["colorTable"], palette);
+            assert_eq!(h.state().1["colorTableEdits"], json!({"0":"#ffff00"}));
+            assert_eq!(h.state().1["__zoom"], 2.0);
+            assert_eq!(h.state().1["__center"], center);
+            assert_eq!(h.state().0.session.active().unwrap().doc.timeline.as_ref().unwrap().current, 0);
+            previous = next;
+        }
+    }
+
+    #[test]
+    fn still_documents_have_no_playback_controls() {
+        for duration in [None, Some(1)] {
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            app.run("file.new", json!({"width":32,"height":24})).unwrap();
+            if let Some(duration) = duration {
+                app.run("timeline.create", json!({"duration":duration,"fps":2})).unwrap();
+            }
+            let id = open_web(&mut app);
+            let fields = app.ui.dialog_mut(id).unwrap().fields.clone();
+            let h = harness(app, fields);
+            assert!(h.query_by_label("Play").is_none());
+            assert!(!h.state().1.contains_key("__web_playing"));
+        }
+    }
+
+    #[test]
+    fn preview_keeps_current_frame_edits_without_storing_into_source() {
+        let mut app = animated_app(8);
+        app.run("edit.fill", json!({"color":"#ffff00"})).unwrap();
+        let source = app.session.active().unwrap().doc.clone();
+        let edited = web_frame_document(&source, Some(0)).unwrap();
+        let other = web_frame_document(&source, Some(1)).unwrap();
+        assert_eq!(photocraft_compose::flatten(&edited).px[0], [1.0, 1.0, 0.0, 1.0]);
+        assert_eq!(photocraft_compose::flatten(&other).px[0], [0.0, 1.0, 0.0, 1.0]);
+        assert!(Arc::ptr_eq(&source, &app.session.active().unwrap().doc));
+        assert_eq!(source.timeline.as_ref().unwrap().current, 0);
+    }
+
+    #[test]
+    fn optimized_gif_preview_matches_each_frame_at_every_depth() {
+        let settings = WebSettings::from_params(&json!({"format":"gif","colors":16}), "preview").unwrap();
+        for depth in [8, 16, 32] {
+            let app = animated_app(depth);
+            for (frame, expected) in [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255]].iter().enumerate() {
+                let doc = web_frame_document(&app.session.active().unwrap().doc, Some(frame)).unwrap();
+                let (proxy, _, _) = web_cmds::web_document(&doc, &json!({"width":16,"height":12}), &settings).unwrap();
+                let pixels = photocraft_compose::flatten(&proxy);
+                let optimized = web_cmds::optimize(&pixels.px, 16, photocraft_geom::Rect::new(0, 0, 16, 12), &settings, None, None, 72.0, true).unwrap();
+                assert_eq!(&optimized.preview[..4], expected, "depth={depth} frame={frame}");
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod web_clock_tests {
+    use super::*;
+    #[test]
+    fn frames_follow_elapsed_time_and_keep_fraction() {
+        assert_eq!(advance_preview(0, 3, 2.0, 0.0, 0.49), (0, 0.0));
+        assert_eq!(advance_preview(0, 3, 2.0, 0.0, 0.75), (1, 0.5));
+        assert_eq!(advance_preview(1, 3, 2.0, 0.5, 1.0), (2, 1.0));
+    }
+    #[test]
+    fn slow_frames_catch_up_and_loop() {
+        assert_eq!(advance_preview(2, 3, 2.0, 0.0, 1.0), (1, 1.0));
+        let (frame, last) = advance_preview(0, 3, 2.0, 0.0, 6.2);
+        assert_eq!(frame, 0);
+        assert!((last - 6.0).abs() < 1e-10);
+    }
+    #[test]
+    fn resumed_clock_excludes_pause_time() {
+        assert_eq!(advance_preview(1, 3, 2.0, 20.0, 20.25), (1, 20.0));
+        assert_eq!(advance_preview(1, 3, 2.0, 20.0, 20.5), (2, 20.5));
+    }
+    #[test]
+    fn fractional_frame_rates_work() {
+        assert_eq!(advance_preview(0, 3, 0.5, 0.0, 2.0), (1, 2.0));
+    }
+    #[test]
+    fn malformed_or_changed_timeline_is_bounded() {
+        assert_eq!(advance_preview(usize::MAX, 0, f32::NAN, 0.0, 1.0), (0, 1.0));
+        assert_eq!(advance_preview(usize::MAX - 2, usize::MAX, 2.0, 0.0, 1.0), (0, 1.0));
+        assert_eq!(advance_preview(2, 3, 2.0, 10.0, 9.0), (2, 9.0));
+    }
+}
diff --git a/crates/ui-egui/src/file_ui/web_preview.rs b/crates/ui-egui/src/file_ui/web_preview.rs
new file mode 100644
index 0000000000..a9ee7a933c
--- /dev/null
+++ b/crates/ui-egui/src/file_ui/web_preview.rs
@@ -0,0 +1,323 @@
+//! Save for Web navigation and indexed palette UI. Draft state is serialized in dialog fields.
+use super::*;
+
+/// Export dimensions, using the same percent/width/height precedence as web_document.
+pub fn dimensions(doc: &photocraft_doc::Document, p: &Value) -> Result<(f64, f64), String> {
+    let (w0, h0) = (f64::from(doc.size.width).max(1.0), f64::from(doc.size.height).max(1.0));
+    let positive = |k: &str| p.get(k).and_then(Value::as_f64).filter(|v| v.is_finite() && *v > 0.0);
+    let (w, h) = match (positive("percent"), positive("width"), positive("height")) {
+        (Some(pct), _, _) => (w0 * pct / 100.0, h0 * pct / 100.0),
+        (_, Some(w), Some(h)) => (w, h),
+        (_, Some(w), None) => (w, h0 * w / w0),
+        (_, None, Some(h)) => (w0 * h / h0, h),
+        _ => (w0, h0),
+    };
+    if !w.is_finite() || !h.is_finite() || w > 300_000.0 || h > 300_000.0 {
+        return Err("export dimensions exceed the 300,000 px per-side limit".into());
+    }
+    Ok((w.round().max(1.0), h.round().max(1.0)))
+}
+
+pub fn prepare_table(app: &PhotocraftApp, f: &mut Map<String, Value>) -> Result<(), String> {
+    if !matches!(s(f, "format", "jpeg").as_str(), "gif" | "png8") {
+        return Ok(());
+    }
+    let st = app.session.active().ok_or("no document")?;
+    let mut source = params(f);
+    let Some(m) = source.as_object_mut() else { return Err("invalid web settings".into()) };
+    // Only palette-affecting options invalidate index-based edits. Metadata, interlacing,
+    // dithering and output paths must not discard the user's replacement colours.
+    m.retain(|k, _| {
+        matches!(
+            k.as_str(),
+            "preset" | "format" | "palette" | "colors" | "transparency" | "matte" | "webSnap" | "convertToSrgb" | "width" | "height" | "percent" | "resample"
+        )
+    });
+    let signature = format!("{}|{}|{}", st.doc.id.0, st.revision, source);
+    if f.get("__tableSignature").and_then(Value::as_str) == Some(&signature) {
+        return Ok(());
+    }
+    // A regenerated palette invalidates index-based edits. Explicit tables supplied through
+    // ui.dialog.set remain usable until a palette/size setting changes.
+    if f.contains_key("__tableSignature") {
+        f.remove("colorTable");
+        f.remove("colorTableEdits");
+        f.remove("__selectedColor");
+    }
+    if !f.contains_key("colorTable") {
+        let settings = WebSettings::from_params(&source, "preview").map_err(|e| e.to_string())?;
+        // Bound palette preparation as well as the displayed image. The fixed table is then
+        // passed unchanged to full-resolution export, so the swatches are the file's colours.
+        let (w, h) = dimensions(&st.doc, &source)?;
+        let scale = (2048.0 / w.max(h)).min(1.0);
+        let mut proxy = source.clone();
+        if let Some(m) = proxy.as_object_mut() {
+            m.remove("percent");
+            m.insert("width".into(), json!((w * scale).round().max(1.0)));
+            m.insert("height".into(), json!((h * scale).round().max(1.0)));
+            m.insert("resample".into(), json!("bilinear"));
+        }
+        let (doc, _, _) = web_cmds::web_document(&st.doc, &proxy, &settings).map_err(|e| e.to_string())?;
+        f.insert("__paletteApproximate".into(), json!(scale < 1.0));
+        let buf = photocraft_compose::flatten(&doc);
+        let mut optimized =
+            web_cmds::optimize(&buf.px, doc.size.width as usize, doc.bounds(), &settings, None, None, doc.resolution_dpi, false).map_err(|e| e.to_string())?;
+        // Tiny transparent features may disappear in the proxy; keep room for their index.
+        if settings.transparency {
+            optimized.color_table.truncate(255);
+        }
+        f.insert("colorTable".into(), json!(optimized.color_table.iter().map(|c| web_cmds::rgb_hex(*c)).collect::<Vec<_>>()));
+        f.insert("__transparentIndex".into(), json!(optimized.transparent_index));
+    }
+    f.insert("__tableSignature".into(), json!(signature));
+    Ok(())
+}
+
+pub fn table(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
+    let p = params(f);
+    let Ok(settings) = WebSettings::from_params(&p, "preview") else { return };
+    let Some(table) = settings.color_table else { return };
+    ui.add_space(8.0);
+    ui.label(egui::RichText::new(tl!("Color Table…").trim_end_matches('…')).font(crate::theme::semibold(12.0)));
+    ui.scope(|ui| {
+        ui.spacing_mut().interact_size = egui::vec2(14.0, 14.0);
+        ui.spacing_mut().item_spacing = egui::vec2(1.0, 1.0);
+        egui::Grid::new("web-color-table").spacing(egui::vec2(1.0, 1.0)).show(ui, |ui| {
+            for (i, source) in table.iter().enumerate() {
+                let mut color = settings.color_table_edits.get(&i).copied().unwrap_or(*source);
+                let response = ui.push_id(i, |ui| crate::widgets::color_edit_button_srgb(ui, &mut color)).inner;
+                response.clone().on_hover_text(format!("Index {i}: {}", web_cmds::rgb_hex(color)));
+                if response.clicked() {
+                    f.insert("__selectedColor".into(), json!(i));
+                }
+                if f.get("__selectedColor").and_then(Value::as_u64) == Some(i as u64) {
+                    let t = Tokens::get(ui.ctx());
+                    ui.painter().rect_stroke(response.rect, t.radius_sm, egui::Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);
+                }
+                if response.changed() {
+                    let edits = f.entry("colorTableEdits").or_insert_with(|| json!({}));
+                    if let Some(edits) = edits.as_object_mut() {
+                        edits.insert(i.to_string(), json!(web_cmds::rgb_hex(color)));
+                    }
+                }
+                if i % 16 == 15 {
+                    ui.end_row();
+                }
+            }
+            if f.get("__transparentIndex").and_then(Value::as_u64).is_some() {
+                let (rect, response) = ui.allocate_exact_size(egui::vec2(14.0, 14.0), egui::Sense::hover());
+                crate::widgets::checker(ui.painter(), rect, 4.0);
+                response.on_hover_text(tl!("Transparency"));
+            }
+        });
+    });
+    ui.horizontal(|ui| {
+        ui.weak(format!("{}: {}", tl!("Colors"), table.len()));
+        if ui.small_button(tl!("Reset")).clicked() {
+            f.remove("colorTableEdits");
+        }
+    });
+}
+
+type EncodedPreview = (Vec<u8>, usize, Option<usize>, &'static str);
+
+/// Palette replacements reuse the cached index buffer; picker drags do not re-quantize or
+/// re-encode the proxy. The GIF payload length is unchanged by RGB table replacements.
+pub fn optimized(ui: &mut egui::Ui, key: egui::Id, signature: &str, p: &Value, px: &[[f32; 4]], w: u32, h: u32) -> Result<EncodedPreview, String> {
+    let settings = WebSettings::from_params(p, "preview").map_err(|e| e.to_string())?;
+    let mut base = p.clone();
+    if let Some(m) = base.as_object_mut() {
+        m.remove("colorTableEdits");
+    }
+    let signature = format!("{signature}|{base}");
+    let key = key.with("indexed-source");
+    let cached: Option<(String, Arc<Optimized>)> = ui.data(|d| d.get_temp(key));
+    let encoded = if let Some((_, encoded)) = cached.filter(|(sig, _)| sig == &signature) {
+        encoded
+    } else {
+        let settings = WebSettings::from_params(&base, "preview").map_err(|e| e.to_string())?;
+        let encoded = Arc::new(
+            web_cmds::optimize(px, w as usize, photocraft_geom::Rect::new(0, 0, w as i32, h as i32), &settings, None, None, 72.0, true)
+                .map_err(|e| e.to_string())?,
+        );
+        ui.data_mut(|d| d.insert_temp(key, (signature, encoded.clone())));
+        encoded
+    };
+    let rgba = if settings.color_table_edits.is_empty() || !settings.format.indexed() {
+        encoded.preview.clone()
+    } else {
+        encoded
+            .indices
+            .iter()
+            .flat_map(|index| {
+                let index = usize::from(*index);
+                let color = settings.color_table_edits.get(&index).copied().or_else(|| encoded.color_table.get(index).copied()).unwrap_or([0; 3]);
+                [color[0], color[1], color[2], if Some(index) == encoded.transparent_index { 0 } else { 255 }]
+            })
+            .collect()
+    };
+    Ok((rgba, encoded.bytes.len(), encoded.colors, encoded.ext))
+}
+
+#[derive(Clone, Copy, Debug)]
+struct Navigation {
+    zoom: Option<f32>,
+    center: egui::Vec2,
+}
+impl Navigation {
+    fn read(f: &Map<String, Value>) -> Self {
+        let zoom = f.get("__zoom").and_then(Value::as_f64).filter(|z| z.is_finite() && *z > 0.0).map(|z| (z as f32).clamp(0.0001, 32.0));
+        let center = f
+            .get("__center")
+            .and_then(Value::as_array)
+            .and_then(|a| Some(egui::vec2(a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32)))
+            .filter(|c| c.is_finite())
+            .unwrap_or(egui::vec2(0.5, 0.5));
+        Self { zoom, center }
+    }
+    fn write(self, f: &mut Map<String, Value>) {
+        f.insert("__zoom".into(), json!(self.zoom));
+        f.insert("__center".into(), json!([self.center.x, self.center.y]));
+    }
+    fn scale(self, viewport: egui::Vec2, source: egui::Vec2, ppp: f32) -> f32 {
+        self.zoom.map_or((viewport.x / source.x).min(viewport.y / source.y), |z| z / ppp)
+    }
+    fn clamp(&mut self, viewport: egui::Vec2, image: egui::Vec2) {
+        let half = (viewport / image * 0.5).min(egui::vec2(0.5, 0.5));
+        self.center = self.center.clamp(half, egui::Vec2::splat(1.0) - half);
+    }
+    fn zoom_at(&mut self, factor: f32, at: egui::Vec2, viewport: egui::Vec2, source: egui::Vec2, ppp: f32) {
+        if !factor.is_finite() || factor <= 0.0 {
+            return;
+        }
+        let old = self.scale(viewport, source, ppp);
+        self.zoom = Some((old * ppp * factor).clamp(0.0001, 32.0));
+        let new = self.scale(viewport, source, ppp);
+        self.center += at / source * (1.0 / old - 1.0 / new);
+        self.clamp(viewport, source * new);
+    }
+}
+
+pub fn controls(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
+    let mut nav = Navigation::read(f);
+    let effective = n(f, "__effectiveZoom", 1.0) as f32;
+    ui.horizontal(|ui| {
+        if ui.small_button(tl!("Fit")).clicked() {
+            nav.zoom = None;
+            nav.center = egui::vec2(0.5, 0.5);
+        }
+        if ui.small_button("−").clicked() {
+            nav.zoom = Some((nav.zoom.unwrap_or(effective) / 1.25).max(0.0001));
+        }
+        if ui.small_button("+").clicked() {
+            nav.zoom = Some((nav.zoom.unwrap_or(effective) * 1.25).min(32.0));
+        }
+        let mut percent = nav.zoom.unwrap_or(effective) * 100.0;
+        if ui.add(egui::DragValue::new(&mut percent).range(0.01..=3200.0).suffix("%").speed(10.0)).changed() {
+            nav.zoom = Some(percent / 100.0);
+        }
+        if ui.small_button(tl!("100%")).clicked() {
+            nav.zoom = Some(1.0);
+        }
+        ui.add(egui::Label::new(egui::RichText::new(tl!("Drag to pan · Scroll to zoom · Double-click to fit")).weak()).truncate());
+    });
+    nav.write(f);
+}
+
+pub fn paint(ui: &mut egui::Ui, rect: egui::Rect, response: &egui::Response, tex: &egui::TextureHandle, source: egui::Vec2, f: &mut Map<String, Value>) {
+    let mut nav = Navigation::read(f);
+    let ppp = ui.ctx().pixels_per_point();
+    if response.double_clicked() {
+        nav.zoom = None;
+        nav.center = egui::Vec2::splat(0.5);
+    }
+    let mut scale = nav.scale(rect.size(), source, ppp);
+    if response.dragged() {
+        nav.zoom = Some(scale * ppp);
+        nav.center -= response.drag_delta() / (source * scale);
+    }
+    if response.hovered() {
+        let (scroll, pinch) = ui.input(|i| (i.smooth_scroll_delta.y, i.zoom_delta()));
+        let factor = if pinch != 1.0 { pinch } else { (scroll * 0.005).exp() };
+        if factor != 1.0 {
+            let at = response.hover_pos().unwrap_or(rect.center()) - rect.center();
+            nav.zoom_at(factor, at, rect.size(), source, ppp);
+            scale = nav.scale(rect.size(), source, ppp);
+            ui.ctx().request_repaint();
+        }
+    }
+    nav.clamp(rect.size(), source * scale);
+    let image = egui::Rect::from_min_size(rect.center() - nav.center * source * scale, source * scale);
+    ui.painter().with_clip_rect(rect.intersect(ui.clip_rect())).image(
+        tex.id(),
+        image,
+        egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)),
+        egui::Color32::WHITE,
+    );
+    // Fit follows resizing; explicit zoom/pan shares the same normalized centre in every pane.
+    if nav.zoom.is_some() {
+        f.insert("__effectiveZoom".into(), json!(nav.zoom));
+    } else {
+        f.insert("__effectiveZoom".into(), json!(scale * ppp));
+    }
+    nav.write(f);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn anchored_zoom_keeps_pixel_under_pointer_and_pan_is_bounded() {
+        let mut nav = Navigation { zoom: Some(1.0), center: egui::Vec2::splat(0.5) };
+        let viewport = egui::vec2(200.0, 100.0);
+        let source = egui::vec2(800.0, 400.0);
+        let at = egui::vec2(30.0, 20.0);
+        let before = nav.center + at / source;
+        nav.zoom_at(2.0, at, viewport, source, 1.0);
+        let after = nav.center + at / (source * 2.0);
+        assert!((before - after).length() < 0.00001);
+        nav.center = egui::vec2(-5.0, 50.0);
+        nav.clamp(viewport, source * 2.0);
+        assert_eq!(nav.center, egui::vec2(0.0625, 0.9375));
+        nav.zoom = None;
+        assert_eq!(nav.scale(viewport, source, 1.0), 0.25);
+        assert_eq!(nav.scale(viewport * 2.0, source, 1.0), 0.5);
+    }
+
+    #[test]
+    fn palette_picker_reuses_indices_and_updates_preview_pixels() {
+        let key = egui::Id::new("test-web-preview");
+        let p = json!({"format": "gif", "colorTable": ["#ff0000", "#0000ff"], "dither": "none"});
+        let mut h = egui_kittest::Harness::builder().build_ui_state(
+            move |ui, state: &mut (Value, Vec<u8>)| {
+                state.1 = optimized(ui, key, "fixture", &state.0, &[[1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0]], 2, 1).unwrap().0;
+            },
+            (p, Vec::new()),
+        );
+        let cached = |ctx: &egui::Context| ctx.data(|d| d.get_temp::<(String, Arc<Optimized>)>(key.with("indexed-source"))).unwrap().1;
+        let before = cached(&h.ctx);
+        assert_eq!(h.state().1, [255, 0, 0, 255, 0, 0, 255, 255]);
+        h.state_mut().0["colorTableEdits"] = json!({"0": "#00ff00"});
+        h.run_steps(3);
+        assert!(Arc::ptr_eq(&before, &cached(&h.ctx)), "picker drag must not re-encode");
+        assert_eq!(h.state().1, [0, 255, 0, 255, 0, 0, 255, 255]);
+    }
+
+    #[test]
+    fn absurd_dimensions_and_navigation_fields_are_safe() {
+        let doc =
+            photocraft_doc::Document::new("fixture", photocraft_geom::Size::new(100, 50), photocraft_color::ColorMode::Rgb, photocraft_color::SampleType::U8);
+        assert!(dimensions(&doc, &json!({"percent": 1e308})).is_err());
+        assert!(dimensions(&doc, &json!({"width": 1e300})).is_err());
+        let f = serde_json::from_value::<Map<String, Value>>(json!({"__zoom": 1e300, "__center": [1e300, -1e300]})).unwrap();
+        let nav = Navigation::read(&f);
+        assert_eq!(nav.zoom, Some(32.0));
+        assert_eq!(nav.center, egui::Vec2::splat(0.5));
+        let mut nav = nav;
+        for factor in [f32::NAN, f32::INFINITY, 0.0, -1.0] {
+            nav.zoom_at(factor, egui::Vec2::ZERO, egui::vec2(200.0, 100.0), egui::vec2(400.0, 200.0), 1.0);
+            assert_eq!(nav.zoom, Some(32.0));
+            assert!(nav.center.is_finite());
+        }
+    }
+}
diff --git a/crates/ui-egui/src/fill_ui.rs b/crates/ui-egui/src/fill_ui.rs
index c44c4b5774..faa917f039 100644
--- a/crates/ui-egui/src/fill_ui.rs
+++ b/crates/ui-egui/src/fill_ui.rs
@@ -53,8 +53,8 @@ fn valid(app: &PhotocraftApp, key: &str, v: &Value) -> bool {
     }
 }
 
-/// The dialog's fields: Photoshop's defaults, overridden by the last choices.
-pub fn fields(app: &PhotocraftApp) -> Map<String, Value> {
+/// Photoshop's Fill defaults (no last-used prefs). Used by open and Alt+Reset.
+pub fn default_fields(app: &PhotocraftApp) -> Map<String, Value> {
     let mut f = Map::new();
     f.insert(MARK.into(), json!(true));
     f.insert("__command".into(), json!(COMMAND));
@@ -68,6 +68,12 @@ pub fn fields(app: &PhotocraftApp) -> Map<String, Value> {
     f.insert("mode".into(), json!("normal"));
     f.insert("opacity".into(), json!(100.0));
     f.insert("preserveTransparency".into(), json!(false));
+    f
+}
+
+/// The dialog's fields: Photoshop's defaults, overridden by the last choices.
+pub fn fields(app: &PhotocraftApp) -> Map<String, Value> {
+    let mut f = default_fields(app);
     if let Some(Value::Object(saved)) = app.session.prefs().dialogs.get(COMMAND) {
         for k in KEYS {
             if let Some(v) = saved.get(k).filter(|v| valid(app, k, v)) {
@@ -78,6 +84,19 @@ pub fn fields(app: &PhotocraftApp) -> Map<String, Value> {
     f
 }
 
+/// Alt+Cancel (Reset): Photoshop Fill defaults, not last-used prefs. Dialog stays open.
+pub fn reset(app: &PhotocraftApp, fields: &mut Map<String, Value>) {
+    if !owns(fields) {
+        return;
+    }
+    let defaults = default_fields(app);
+    for k in KEYS {
+        if let Some(v) = defaults.get(k) {
+            fields.insert(k.into(), v.clone());
+        }
+    }
+}
+
 /// Open the Fill dialog; returns its id.
 pub fn open(app: &mut PhotocraftApp) -> u64 {
     let f = fields(app);
diff --git a/crates/ui-egui/src/fill_ui_tests.rs b/crates/ui-egui/src/fill_ui_tests.rs
index aa5f2772eb..5d353127f8 100644
--- a/crates/ui-egui/src/fill_ui_tests.rs
+++ b/crates/ui-egui/src/fill_ui_tests.rs
@@ -74,6 +74,22 @@ fn mode_opacity_and_preserve_transparency() {
     assert!(close(px(&app, 5, 5), [0.5, 0.5, 0.5, 1.0]));
 }
 
+#[test]
+fn alt_reset_restores_photoshop_defaults_not_last_used() {
+    let mut app = app();
+    // Remember a non-default choice, then open (which restores it) and Reset.
+    fill(&mut app, json!({"contents": "white", "opacity": 40})).unwrap();
+    let id = open(&mut app);
+    assert_eq!(app.ui.dialog_mut(id).unwrap().fields["opacity"].as_f64(), Some(40.0));
+    let mut fields = app.ui.dialog_mut(id).unwrap().fields.clone();
+    reset(&app, &mut fields);
+    app.ui.dialog_mut(id).unwrap().fields = fields;
+    let f = &app.ui.dialog_mut(id).unwrap().fields;
+    assert_eq!(f["opacity"].as_f64(), Some(100.0));
+    assert_eq!(f["contents"], json!("foreground"));
+    assert!(app.ui.dialogs.iter().any(|d| d.id == id));
+}
+
 #[test]
 fn choices_persist_across_restarts() {
     let mut app = app();
diff --git a/crates/ui-egui/src/filter_dialog.rs b/crates/ui-egui/src/filter_dialog.rs
index 13ded76048..f4dacbc575 100644
--- a/crates/ui-egui/src/filter_dialog.rs
+++ b/crates/ui-egui/src/filter_dialog.rs
@@ -1,4 +1,5 @@
-//! Filter dialogs generated from engine command parameter specs, with live on-canvas preview.
+//! Filter dialogs generated from engine command parameter specs, with live on-canvas preview and an
+//! in-dialog preview window (#3769).
 //!
 //! The preview runs the *same engine command* on the downsampled proxy document (pixel-sized
 //! parameters scaled by the proxy factor), so what you preview is what you get.
@@ -195,6 +196,10 @@ fn is_pixel_param_of(command: &str, key: &str) -> bool {
 /// interval) and Tree, whose branches are built from 6 px segments. On a reduced proxy those
 /// features come out k times too large (or a different tree grows), so these preview at full
 /// resolution: what the preview shows is what OK applies, as in Photoshop (#2063).
+///
+/// Sharpen, Sharpen More, Sharpen Edges, Find Edges, Emboss and Despeckle use fixed one-pixel
+/// kernels with no size parameter, so a proxy changes their look: edges average away, making
+/// the sharpening and edge detection invisible. These must preview at full resolution (#3929).
 const FULL_RESOLUTION_PREVIEW: &[&str] = &[
     "filter.distort.ripple",
     "filter.stylize.diffuse",
@@ -211,6 +216,12 @@ const FULL_RESOLUTION_PREVIEW: &[&str] = &[
     "filter.stylize.wind",
     "filter.stylize.extrude",
     "filter.render.tree",
+    "filter.sharpen.sharpen",
+    "filter.sharpen.sharpenMore",
+    "filter.sharpen.sharpenEdges",
+    "filter.stylize.findEdges",
+    "filter.stylize.emboss",
+    "filter.noise.despeckle",
 ];
 
 /// Whether `command` with `params` previews at full resolution: [`FULL_RESOLUTION_PREVIEW`], every
@@ -288,6 +299,7 @@ pub fn has_dialog(command: &str) -> bool {
                 | "layer.layerStyle.globalLight"
                 | "image.mode.colorTable"
                 | "edit.definePattern"
+                | "select.convertToShape"
         ))
         && photocraft_engine::commands::find(command).is_some_and(|c| !parse_spec(c.params).is_empty())
 }
@@ -326,6 +338,109 @@ pub(crate) fn remember(app: &mut PhotocraftApp, command: &str, fields: &Map<Stri
     }
 }
 
+/// Schema-default values for one param of `command` (open and Alt+Reset share this).
+fn default_value(app: &PhotocraftApp, command: &str, p: &Param) -> Option<Value> {
+    Some(match &p.kind {
+        Kind::Range { default, .. } if command == "image.mode.indexedColor" && p.key == "colors" => json!(default.round().clamp(2.0, 256.0) as u32),
+        Kind::Range { default, .. } => json!(default),
+        Kind::Choice { options, default } => {
+            let initial = default.as_deref().or_else(|| options.first().map(String::as_str)).unwrap_or("");
+            json!(initial)
+        }
+        Kind::Bool(default) => json!(default),
+        Kind::Int { default } => json!(default),
+        Kind::Text => json!(""),
+        Kind::Document => json!(-1),
+        // Identity kernel: 1 in the centre.
+        Kind::Grid(n) => json!((0..*n).map(|i| i64::from(i == *n / 2)).collect::<Vec<_>>()),
+        Kind::Color(Some(rgb)) => json!(crate::color_picker_ui::hex(*rgb)),
+        // Replace Color starts from the foreground colour and can sample a new one off the canvas.
+        Kind::Color(None) if command == REPLACE_COLOR => {
+            let fg = app.session.tools.foreground;
+            json!(crate::color_picker_ui::hex([fg[0], fg[1], fg[2]]))
+        }
+        Kind::Color(None) => return None,
+        // Colour inputs come from the current swatches, so the proxy preview matches the result.
+        Kind::Json if p.key == "foreground" => json!(app.session.tools.foreground),
+        Kind::Json if p.key == "background" => json!(app.session.tools.background),
+        Kind::Json => return None,
+    })
+}
+
+/// Command-specific open defaults (ruler straighten, warp from layer, …), not remembered prefs.
+fn apply_command_defaults(app: &PhotocraftApp, command: &str, fields: &mut Map<String, Value>) {
+    if command == "image.rotation.arbitrary" {
+        straighten_defaults(app, fields);
+    }
+    if command == "type.warpText" {
+        warp_defaults(app, fields);
+    }
+    // Photoshop's Pattern Name dialog starts from the name the pattern would get anyway.
+    if command == "edit.definePattern" {
+        fields.insert("name".into(), json!(photocraft_engine::pattern_cmds::default_name(&app.session)));
+    }
+    if command == "layer.layerStyle.globalLight" {
+        global_light_defaults(app, fields);
+    }
+    if command == "view.proofSetup" {
+        proof_setup_defaults(app, fields);
+    }
+    if command == "edit.assignProfile" {
+        assign_profile_defaults(app, fields);
+    }
+}
+
+/// Assign Profile offers only the profiles the document's colour mode can take (#4951): the
+/// command refuses one of another colour space. `__profiles` lists them for the `profile` menu,
+/// and a remembered choice that doesn't fit this document falls back to the working space.
+fn assign_profile_defaults(app: &PhotocraftApp, fields: &mut Map<String, Value>) {
+    let Some(st) = app.session.active() else { return };
+    let Some(spec) = photocraft_engine::commands::find("edit.assignProfile") else { return };
+    let space = photocraft_engine::color_cmds::mode_space(st.doc.mode);
+    let fits = |name: &str| name == "none" || app.session.color.resolve(name, Some(&st.doc), None).is_ok_and(|p| p.color_space == space);
+    let builtin: Vec<String> = parse_spec(spec.params)
+        .into_iter()
+        .filter(|p| p.key == "profile")
+        .flat_map(|p| match p.kind {
+            Kind::Choice { options, .. } => options,
+            _ => Vec::new(),
+        })
+        .collect();
+    let installed: Vec<_> = photocraft_engine::installed_profiles::installed().into_iter().filter(|i| i.is_destination()).collect();
+    let allowed: Vec<String> =
+        builtin.iter().filter(|name| fits(name)).cloned().chain(installed.iter().filter(|i| i.color_space == space).map(|i| i.path.clone())).collect();
+    // A path nobody lists (typed by an agent) is left alone: the command decides about it.
+    let listed = |cur: &str| builtin.iter().any(|name| name == cur) || installed.iter().any(|i| i.path == cur);
+    if fields.get("profile").and_then(Value::as_str).is_some_and(|cur| listed(cur) && !allowed.iter().any(|name| name == cur)) {
+        fields.insert("profile".into(), json!("working"));
+    }
+    fields.insert("__profiles".into(), json!(allowed));
+}
+
+/// Alt+Cancel (Reset): schema defaults + command hooks, without last-used remembered prefs.
+pub fn reset_fields(app: &PhotocraftApp, fields: &mut Map<String, Value>) {
+    if !fields.contains_key("__filter") || fields.contains_key("__adjust") {
+        return;
+    }
+    let Some(command) = fields.get("__command").and_then(Value::as_str).map(str::to_owned) else { return };
+    let spec =
+        fields.get("__spec").and_then(Value::as_str).map(str::to_owned).or_else(|| photocraft_engine::commands::find(&command).map(|c| c.params.to_owned()));
+    let Some(spec) = spec else { return };
+    // Drop user params; keep private `__` chrome (and fixed keys outside the schema for `__spec`).
+    let schema_keys: std::collections::HashSet<String> = parse_spec(&spec).into_iter().map(|p| p.key).collect();
+    fields.retain(|k, _| k.starts_with("__") || !schema_keys.contains(k));
+    for p in parse_spec(&spec) {
+        if let Some(v) = default_value(app, &command, &p) {
+            fields.insert(p.key, v);
+        }
+    }
+    apply_command_defaults(app, &command, fields);
+    // The schema has no default for the Blur Gallery's pins: start again from the opening one.
+    if command == crate::blur_pins::COMMAND {
+        crate::blur_pins::reset(fields);
+    }
+}
+
 pub fn open(app: &mut PhotocraftApp, command: &str) -> Option<u64> {
     let spec = photocraft_engine::commands::find(command)?;
     let mut fields = Map::new();
@@ -337,44 +452,14 @@ pub fn open(app: &mut PhotocraftApp, command: &str) -> Option<u64> {
         fields.insert("__preview".into(), json!(true));
     }
     for p in parse_spec(spec.params) {
-        let v = match &p.kind {
-            Kind::Range { default, .. } if command == "image.mode.indexedColor" && p.key == "colors" => json!(default.round().clamp(2.0, 256.0) as u32),
-            Kind::Range { default, .. } => json!(default),
-            Kind::Choice { options, default } => {
-                let initial = default.as_deref().or_else(|| options.first().map(String::as_str)).unwrap_or("");
-                json!(initial)
-            }
-            Kind::Bool(default) => json!(default),
-            Kind::Int { default } => json!(default),
-            Kind::Text => json!(""),
-            Kind::Document => json!(-1),
-            // Identity kernel: 1 in the centre.
-            Kind::Grid(n) => json!((0..*n).map(|i| i64::from(i == *n / 2)).collect::<Vec<_>>()),
-            Kind::Color(Some(rgb)) => json!(crate::color_picker_ui::hex(*rgb)),
-            Kind::Color(None) => continue,
-            // Colour inputs come from the current swatches, so the proxy preview matches the result.
-            Kind::Json if p.key == "foreground" => json!(app.session.tools.foreground),
-            Kind::Json if p.key == "background" => json!(app.session.tools.background),
-            Kind::Json => continue,
-        };
-        fields.insert(p.key, v);
+        if let Some(v) = default_value(app, command, &p) {
+            fields.insert(p.key, v);
+        }
     }
     restore_remembered(app, command, spec.params, &mut fields);
-    if command == "image.rotation.arbitrary" {
-        straighten_defaults(app, &mut fields);
-    }
-    if command == "type.warpText" {
-        warp_defaults(app, &mut fields);
-    }
-    // Photoshop's Pattern Name dialog starts from the name the pattern would get anyway.
-    if command == "edit.definePattern" {
-        fields.insert("name".into(), json!(photocraft_engine::pattern_cmds::default_name(&app.session)));
-    }
-    if command == "layer.layerStyle.globalLight" {
-        global_light_defaults(app, &mut fields);
-    }
-    if command == "view.proofSetup" {
-        proof_setup_defaults(app, &mut fields);
+    apply_command_defaults(app, command, &mut fields);
+    if command == crate::blur_pins::COMMAND {
+        crate::blur_pins::init(app, &mut fields);
     }
     if parse_spec(spec.params).iter().any(|p| p.kind == Kind::Document) {
         // The document picker lists every open document (params refer to them by index).
@@ -467,6 +552,14 @@ pub(crate) fn label(key: &str) -> String {
 }
 
 pub(crate) fn source_label(key: &str) -> String {
+    // Photoshop's name for the localized colour matching (Replace Color, Color Range).
+    if key == "localized" {
+        return "Localized Color Clusters".into();
+    }
+    // A name that already reads as text ("iPhone 14 Pro Max", "Web 1920") is not camelCase.
+    if key.contains(' ') {
+        return key.to_string();
+    }
     // camelCase → "Camel Case"
     let mut s = String::new();
     for (i, ch) in key.chars().enumerate() {
@@ -510,6 +603,40 @@ fn uses_angle_dial(command: &str, key: &str) -> bool {
     key == "angle" && ANGLE_DIAL.contains(&command)
 }
 
+/// Replace Color (#4143): the dialog's "From" colour, sampled from the image with a canvas
+/// eyedropper like Photoshop's. While armed, the next click on the image writes the merged
+/// composite colour into the `color` field (the same sampler the Color Picker uses).
+const REPLACE_COLOR: &str = "image.adjustments.replaceColor";
+const COLOR_EYEDROPPER: &str = "__colorEyedropper";
+
+fn color_eyedropper_owns(f: &Map<String, Value>) -> bool {
+    f.get("__filter").and_then(Value::as_bool) == Some(true)
+        && f.get("__command").and_then(Value::as_str) == Some(REPLACE_COLOR)
+        && f.get(COLOR_EYEDROPPER).and_then(Value::as_bool) == Some(true)
+}
+
+/// Whether the top dialog is a Replace Color with its canvas eyedropper armed.
+pub(crate) fn color_eyedropper_armed(app: &PhotocraftApp) -> bool {
+    app.ui.dialogs.last().is_some_and(|d| color_eyedropper_owns(&d.fields))
+}
+
+/// Sample the merged image at document point (x, y) into the armed dialog's "From" colour.
+/// Returns true when the click was consumed, even off-image or over transparency, where nothing
+/// changes and the eyedropper stays armed (like the Curves picker).
+pub(crate) fn color_eyedropper_sample(app: &mut PhotocraftApp, x: f64, y: f64) -> bool {
+    let Some(id) = app.ui.dialogs.last().filter(|d| color_eyedropper_owns(&d.fields)).map(|d| d.id) else {
+        return false;
+    };
+    if let Some(rgb) = crate::canvas::composite_color(app, x, y)
+        && let Some(d) = app.ui.dialog_mut(id)
+    {
+        d.fields.insert("color".into(), json!(crate::color_picker_ui::hex(rgb)));
+        // Where it was picked: Localized Color Clusters match the colour near this point (#4457).
+        d.fields.insert("points".into(), json!([[x.floor(), y.floor()]]));
+    }
+    true
+}
+
 /// Dialog body for filter commands.
 pub fn body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
     let t = Tokens::get(ui.ctx());
@@ -535,6 +662,8 @@ pub fn body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
                     f.insert(p.key, json!(count));
                     continue;
                 }
+                // Replace Color's Range only applies with Localized Color Clusters on, as in Photoshop.
+                let enabled = !(cmd == REPLACE_COLOR && p.key == "range") || f.get("localized").and_then(Value::as_bool) == Some(true);
                 let unit = if is_pixel_param_of(&cmd, &p.key) {
                     "px"
                 } else if p.key == "angle" {
@@ -544,28 +673,33 @@ pub fn body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
                 } else {
                     ""
                 };
-                if uses_angle_dial(&cmd, &p.key) {
-                    crate::widgets::angle_dial_row(ui, &label(&p.key), &mut v, min..=max);
-                    ui.add_space(4.0);
-                } else if uses_logarithmic_slider(min, max) {
-                    // Keep one numeric field for direct entry and one log-scaled slider for
-                    // wide ranges. slider_row would add a second, linear slider (#146).
-                    ui.horizontal(|ui| {
-                        ui.label(egui::RichText::new(label(&p.key)).color(t.text_dim));
-                        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                            crate::widgets::value_field(ui, &mut v, min..=max, unit, 74.0);
-                        });
-                    });
-                    let mut lv = v.clamp(min, max).ln();
-                    if crate::widgets::slider(ui, &mut lv, min.ln()..=max.ln(), None).changed() {
-                        v = lv.exp();
+                ui.scope(|ui| {
+                    if !enabled {
+                        ui.disable();
                     }
-                    ui.add_space(4.0);
-                } else {
-                    // A double-click on the slider puts it back to the filter's default.
-                    let gestures = crate::widgets::RowGestures { reset: Some(default), wheel_step: None };
-                    crate::widgets::slider_row_with(ui, &label(&p.key), &mut v, min..=max, unit, None, gestures);
-                }
+                    if uses_angle_dial(&cmd, &p.key) {
+                        crate::widgets::angle_dial_row(ui, &label(&p.key), &mut v, min..=max);
+                        ui.add_space(4.0);
+                    } else if uses_logarithmic_slider(min, max) {
+                        // Keep one numeric field for direct entry and one log-scaled slider for
+                        // wide ranges. slider_row would add a second, linear slider (#146).
+                        ui.horizontal(|ui| {
+                            ui.label(egui::RichText::new(label(&p.key)).color(t.text_dim));
+                            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                                crate::widgets::value_field(ui, &mut v, min..=max, unit, 74.0);
+                            });
+                        });
+                        let mut lv = v.clamp(min, max).ln();
+                        if crate::widgets::slider(ui, &mut lv, min.ln()..=max.ln(), None).changed() {
+                            v = lv.exp();
+                        }
+                        ui.add_space(4.0);
+                    } else {
+                        // A double-click on the slider puts it back to the filter's default.
+                        let gestures = crate::widgets::RowGestures { reset: Some(default), wheel_step: None };
+                        crate::widgets::slider_row_with(ui, &label(&p.key), &mut v, min..=max, unit, None, gestures);
+                    }
+                });
                 // Small ranges (0–1 thresholds and centres) keep the two decimals their field shows.
                 let scale = if max - min <= 10.0 { 100.0 } else { 10.0 };
                 f.insert(p.key, json!((v * scale).round() / scale));
@@ -585,6 +719,12 @@ pub fn body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
                         Vec::new()
                     };
                     opts.extend(installed.iter().map(|i| (i.path.clone(), i.description.as_str())));
+                    // Assign Profile: only what the document's colour mode can take (#4951).
+                    if p.key == "profile"
+                        && let Some(allowed) = f.get("__profiles").and_then(Value::as_array)
+                    {
+                        opts.retain(|(v, _)| allowed.iter().any(|a| a.as_str() == Some(v.as_str())));
+                    }
                     // A profile given by path that isn't listed (typed by an agent, or spelled with
                     // different case) still shows, by its file name, instead of a blank menu.
                     let stem = std::path::Path::new(&cur).file_stem().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
@@ -652,11 +792,18 @@ pub fn body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
                 let bytes = rgb.map(q);
                 let name = label(&p.key);
                 let mut clicked = false;
+                let eyedropper = cmd == REPLACE_COLOR && p.key == "color";
                 ui.horizontal(|ui| {
                     ui.label(egui::RichText::new(&name).color(t.text_dim));
                     ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                         // PhotoCraft's Color Picker, as everywhere else (#2144).
                         clicked = crate::widgets::color_swatch_button(ui, egui::Color32::from_rgb(bytes[0], bytes[1], bytes[2]), &name).clicked();
+                        if eyedropper {
+                            let armed = f.get(COLOR_EYEDROPPER).and_then(Value::as_bool).unwrap_or(false);
+                            if crate::icons::button(ui, "pipette", 24.0, armed, "Pick Color From Image").clicked() {
+                                f.insert(COLOR_EYEDROPPER.into(), json!(!armed));
+                            }
+                        }
                         ui.label(egui::RichText::new(crate::color_picker_ui::hex(rgb)).color(t.text_dim).monospace());
                     });
                 });
@@ -713,6 +860,23 @@ pub fn preview_document_with(
     params: &Value,
     k: u32,
     cancel: Option<&photocraft_engine::jobs::JobCtx>,
+) -> Option<Document> {
+    preview_document_for_target(doc, active, command, params, k, cancel, photocraft_engine::channel_cmds::ChannelTarget::Composite, &[])
+}
+
+/// Run the preview with the same pixel target as the final command, including individual channels.
+/// `documents` are the open documents in session order: document params (Match Color's Source,
+/// Displace's map) index into them.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn preview_document_for_target(
+    doc: &Document,
+    active: Option<photocraft_doc::LayerId>,
+    command: &str,
+    params: &Value,
+    k: u32,
+    cancel: Option<&photocraft_engine::jobs::JobCtx>,
+    target: photocraft_engine::channel_cmds::ChannelTarget,
+    documents: &[Arc<Document>],
 ) -> Option<Document> {
     if command == crate::select_mask_view::COMMAND {
         return crate::select_mask_view::preview_document(doc, active, params, k, cancel);
@@ -723,11 +887,14 @@ pub fn preview_document_with(
     let proxy = crate::proxy::proxy_document(doc, run_k);
     let mut s = photocraft_engine::Session::new();
     s.set_inline_job_ctx(cancel.cloned());
+    let doc_id = proxy.id;
     s.add_document(proxy, None);
+    let mut p = params.clone();
+    add_source_documents(&mut s, doc_id, command, &mut p, documents, run_k);
     if let Some(id) = active {
         s.select_layer(id).ok()?;
     }
-    let mut p = params.clone();
+    s.active_mut()?.channel_view.target = target;
     if run_k > 1
         && let Some(o) = p.as_object_mut()
     {
@@ -750,10 +917,42 @@ pub fn preview_document_with(
             }
         }
     }
+    // Blur Gallery pins carry their blur in document pixels too.
+    if command.starts_with("filter.blurGallery.") {
+        crate::blur_pins::scale_for_proxy(&mut p, run_k);
+    }
     s.execute(command, p).ok()?;
     s.active().map(|d| crate::proxy::proxy_document(&d.doc, reduce_k))
 }
 
+/// The preview session holds only the proxy of the edited document (index 0), so a document param
+/// pointing at another open document found nothing there: Match Color's preview with a Source
+/// document failed, or matched the image to itself (#4851). Add each referenced document (as a
+/// proxy at the same factor) and point the param at its index in the preview session.
+fn add_source_documents(s: &mut photocraft_engine::Session, doc_id: photocraft_doc::DocId, command: &str, p: &mut Value, documents: &[Arc<Document>], k: u32) {
+    let Some(spec) = photocraft_engine::commands::find(command) else { return };
+    let Some(o) = p.as_object_mut() else { return };
+    let mut added: Vec<(usize, usize)> = Vec::new();
+    for param in parse_spec(spec.params).into_iter().filter(|p| p.kind == Kind::Document) {
+        let Some(v) = o.get_mut(&param.key) else { continue };
+        let Some(i) = v.as_u64().and_then(|i| usize::try_from(i).ok()) else { continue };
+        // An index past the open documents stays as given, so the preview fails like OK would.
+        let Some(src) = documents.get(i) else { continue };
+        let at = if src.id == doc_id {
+            0
+        } else if let Some(&(_, at)) = added.iter().find(|(j, _)| *j == i) {
+            at
+        } else {
+            let at = s.add_document(crate::proxy::proxy_document(src, k), None);
+            added.push((i, at));
+            at
+        };
+        *v = json!(at);
+    }
+    // Adding a document makes it active: the command still runs on the edited one.
+    s.set_active(0);
+}
+
 /// Cached preview state on the app.
 pub struct FilterPreview {
     pub key: FilterPreviewKey,
@@ -770,6 +969,7 @@ pub struct FilterPreviewKey {
     pub revision: u64,
     pub dialog: u64,
     pub active: Option<photocraft_doc::LayerId>,
+    pub target: photocraft_engine::channel_cmds::ChannelTarget,
     pub command: String,
     pub params: Value,
     pub k: u32,
@@ -779,6 +979,15 @@ pub struct FilterPreviewKey {
 mod tests {
     use super::*;
 
+    /// Preset names such as "iPhone 14 Pro Max" (the artboard dialog's choices) are text, not
+    /// camelCase keys: they used to read "I Phone 14  Pro  Max".
+    #[test]
+    fn display_names_are_not_split_like_camel_case_keys() {
+        assert_eq!(source_label("iPhone 14 Pro Max"), "iPhone 14 Pro Max");
+        assert_eq!(source_label("Web 1920"), "Web 1920");
+        assert_eq!(source_label("centerX"), "Center X");
+    }
+
     #[test]
     fn only_direction_angles_get_the_dial() {
         // Every listed command still has a degree `angle` range, so the list cannot go stale.
@@ -817,6 +1026,24 @@ mod tests {
         assert_eq!(fields["radius"], json!(2.0));
     }
 
+    #[test]
+    fn alt_reset_restores_schema_defaults_not_remembered() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.session.prefs.edit(|prefs| {
+            prefs.dialogs.insert("filter.blur.gaussianBlur".into(), json!({"radius": 11.0}));
+        });
+        let id = open(&mut app, "filter.blur.gaussianBlur").unwrap();
+        assert_eq!(app.ui.dialog_mut(id).unwrap().fields["radius"], json!(11.0));
+        let mut fields = app.ui.dialog_mut(id).unwrap().fields.clone();
+        reset_fields(&app, &mut fields);
+        app.ui.dialog_mut(id).unwrap().fields = fields;
+        let f = &app.ui.dialog_mut(id).unwrap().fields;
+        // Registry default for gaussian blur radius is 1.
+        assert_eq!(f["radius"], json!(1.0));
+        assert!(f.contains_key("__filter"));
+        assert!(app.ui.dialogs.iter().any(|d| d.id == id));
+    }
+
     #[test]
     fn remembering_dialogs_never_persists_paths_or_document_indices() {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
@@ -1093,12 +1320,12 @@ mod tests {
         assert!(!has_dialog("filter.stylize.findEdges"));
     }
 
-    #[test]
-    fn korean_covers_generated_filter_options_and_gallery_names() {
-        let ko = crate::i18n::lang_from_tag("ko-KR").unwrap();
+    /// Generated filter and adjustment labels (param names, symbolic choices) and gallery
+    /// names that `lang` has no catalog row for.
+    fn missing_generated_filter_labels(lang: crate::i18n::Lang) -> std::collections::BTreeSet<String> {
         let mut missing = std::collections::BTreeSet::new();
         let mut check = |s: String| {
-            if !matches!(s.as_str(), "X" | "Y" | "A" | "B") && !crate::i18n::has(ko, &s) {
+            if !matches!(s.as_str(), "X" | "Y" | "A" | "B") && !crate::i18n::has(lang, &s) {
                 missing.insert(s);
             }
         };
@@ -1125,9 +1352,21 @@ mod tests {
         for cat in photocraft_algo::GALLERY_CATEGORIES {
             check(cat.to_string());
         }
+        missing
+    }
+
+    #[test]
+    fn korean_covers_generated_filter_options_and_gallery_names() {
+        let missing = missing_generated_filter_labels(crate::i18n::lang_from_tag("ko-KR").unwrap());
         assert!(missing.is_empty(), "missing Korean dynamic labels: {missing:#?}");
     }
 
+    #[test]
+    fn italian_covers_generated_filter_options_and_gallery_names() {
+        let missing = missing_generated_filter_labels(crate::i18n::lang_from_tag("it-IT").unwrap());
+        assert!(missing.is_empty(), "missing Italian dynamic labels: {missing:#?}");
+    }
+
     /// The Select menu's generated dialogs (Select and Mask, Modify ▸ …) show their
     /// params, choices and title in every UI language, not just Korean.
     #[test]
@@ -1187,6 +1426,62 @@ mod tests {
         assert_eq!(label("wavelengthMin"), "Wavelength Min");
     }
 
+    /// Match Color's preview reads the Source document from the open documents, as OK does: the
+    /// preview session held only the edited document, so a Source showed no change (#4851).
+    #[test]
+    fn match_color_preview_uses_the_source_document() {
+        use photocraft_doc::{Color, ColorMode, SampleType, Size};
+        let solid = |name: &str, c: [f32; 4]| {
+            let mut d = Document::with_background(name, Size::new(32, 32), ColorMode::Rgb, SampleType::U8, Color::WHITE);
+            d.layers[0].surface_mut().unwrap().fill_rect(photocraft_geom::Rect::new(0, 0, 32, 32), &c);
+            d.layers[0].surface_mut().unwrap().fill_rect(photocraft_geom::Rect::new(0, 0, 16, 32), &[c[0] * 0.5, c[1] * 0.5, c[2] * 0.5, 1.0]);
+            d
+        };
+        // The source document is open before the edited one, so indices differ between sessions.
+        let mut s = photocraft_engine::Session::new();
+        s.add_document(solid("reference", [0.1, 0.3, 0.9, 1.0]), None);
+        s.add_document(solid("texture", [0.9, 0.5, 0.2, 1.0]), None);
+        let doc = s.active().unwrap().doc.clone();
+        let layer = doc.layers[0].id;
+        let documents: Vec<_> = s.documents().iter().map(|d| d.doc.clone()).collect();
+        for (source, label) in [(0, "another document"), (1, "the edited document itself")] {
+            let p = json!({"source": source});
+            let mut applied = photocraft_engine::Session::new();
+            for d in &documents {
+                applied.add_document((**d).clone(), None);
+            }
+            applied.execute("image.adjustments.matchColor", p.clone()).unwrap();
+            let want = applied.active().unwrap().doc.layers[0].surface().unwrap().pixel(24, 16);
+            let preview = preview_document_for_target(
+                &doc,
+                Some(layer),
+                "image.adjustments.matchColor",
+                &p,
+                1,
+                None,
+                photocraft_engine::channel_cmds::ChannelTarget::Composite,
+                &documents,
+            )
+            .unwrap_or_else(|| panic!("{label}: no preview"));
+            let got = preview.layers[0].surface().unwrap().pixel(24, 16);
+            assert!((0..3).all(|c| (got[c] - want[c]).abs() < 1.0 / 255.0 + 1e-4), "{label}: preview {got:?}, OK gives {want:?}");
+        }
+        // The preview is of the matched image: the orange texture took the reference's blue.
+        let preview = preview_document_for_target(
+            &doc,
+            Some(layer),
+            "image.adjustments.matchColor",
+            &json!({"source": 0}),
+            2,
+            None,
+            photocraft_engine::channel_cmds::ChannelTarget::Composite,
+            &documents,
+        )
+        .unwrap();
+        let px = preview.layers[0].surface().unwrap().pixel(12, 8);
+        assert!(px[2] > px[0], "proxy preview matched to the reference: {px:?}");
+    }
+
     #[test]
     fn core_filter_previews_keep_minimum_settings_after_downsampling() {
         use photocraft_doc::{Color, ColorMode, SampleType, Size};
@@ -1443,6 +1738,12 @@ mod tests {
             ("filter.stylize.wind", json!({"method": "blast"})),
             ("filter.stylize.extrude", json!({})),
             ("filter.render.tree", json!({"baseTreeType": 1})),
+            ("filter.sharpen.sharpen", json!({})),
+            ("filter.sharpen.sharpenMore", json!({})),
+            ("filter.sharpen.sharpenEdges", json!({})),
+            ("filter.stylize.findEdges", json!({})),
+            ("filter.stylize.emboss", json!({})),
+            ("filter.noise.despeckle", json!({})),
             ("filter.gallery.graphicPen", json!({})),
             ("filter.gallery.stainedGlass", json!({"cellSize": 10})),
             ("image.mode.indexedColor", json!({"colors": 16})),
@@ -1793,6 +2094,61 @@ mod tests {
         }
     }
 
+    /// The profiles Assign Profile offers for a new document converted with `mode` (if any),
+    /// and which of the command's built-in profiles the command itself accepts for it.
+    fn assign_profile_offers(mode: Option<&str>) -> (Vec<String>, Vec<String>) {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": 8, "height": 8})).unwrap();
+        if let Some(mode) = mode {
+            app.run(mode, json!({})).unwrap();
+        }
+        open(&mut app, "edit.assignProfile").unwrap();
+        let offered: Vec<String> =
+            app.ui.dialogs.last().unwrap().fields["__profiles"].as_array().unwrap().iter().filter_map(|v| v.as_str().map(str::to_owned)).collect();
+        let spec = photocraft_engine::commands::find("edit.assignProfile").unwrap();
+        let builtin = parse_spec(spec.params).into_iter().find(|p| p.key == "profile").unwrap();
+        let Kind::Choice { options, .. } = builtin.kind else { panic!("profile is a menu") };
+        let accepted = options.into_iter().filter(|name| app.session.execute("edit.assignProfile", json!({"profile": name})).is_ok()).collect();
+        (offered, accepted)
+    }
+
+    /// #4951: Assign Profile lists the profiles the command accepts for the document's colour
+    /// mode, and none of the others.
+    #[test]
+    fn assign_profile_offers_only_profiles_of_the_documents_colour_mode() {
+        for mode in [None, Some("image.mode.cmyk"), Some("image.mode.grayscale")] {
+            let (offered, accepted) = assign_profile_offers(mode);
+            for name in &accepted {
+                assert!(offered.contains(name), "{mode:?}: {name} can be assigned, so it is offered");
+            }
+            for name in ["srgb", "coated-cmyk", "sgray"] {
+                assert_eq!(offered.iter().any(|o| o == name), accepted.iter().any(|a| a == name), "{mode:?}: {name}");
+            }
+            assert!(offered.iter().any(|o| o == "working") && offered.iter().any(|o| o == "none"), "{mode:?}: working space and none always fit");
+        }
+        let (rgb, _) = assign_profile_offers(None);
+        assert!(rgb.iter().any(|o| o == "srgb") && !rgb.iter().any(|o| o == "coated-cmyk"), "an RGB document gets RGB profiles");
+        let (cmyk, _) = assign_profile_offers(Some("image.mode.cmyk"));
+        assert!(cmyk.iter().any(|o| o == "coated-cmyk") && !cmyk.iter().any(|o| o == "srgb"), "a CMYK document gets CMYK profiles");
+    }
+
+    /// #4951: a profile remembered from a document of another colour mode isn't preselected.
+    #[test]
+    fn assign_profile_drops_a_remembered_profile_that_does_not_fit() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": 8, "height": 8})).unwrap();
+        app.session.prefs.edit(|prefs| {
+            prefs.dialogs.insert("edit.assignProfile".into(), json!({"profile": "coated-cmyk"}));
+        });
+        open(&mut app, "edit.assignProfile").unwrap();
+        assert_eq!(app.ui.dialogs.last().unwrap().fields["profile"], json!("working"));
+        app.session.prefs.edit(|prefs| {
+            prefs.dialogs.insert("edit.assignProfile".into(), json!({"profile": "display-p3"}));
+        });
+        open(&mut app, "edit.assignProfile").unwrap();
+        assert_eq!(app.ui.dialogs.last().unwrap().fields["profile"], json!("display-p3"), "one that fits is kept");
+    }
+
     #[test]
     fn schema_dialogs_respect_explicit_dropdown_defaults() {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
@@ -1834,4 +2190,85 @@ mod tests {
         let fields = &app.ui.dialogs.last().unwrap().fields;
         assert_eq!(fields["direction"], json!("cw"), "Explicit default matching first option is preserved");
     }
+
+    /// #4143: Replace Color shows the From colour (defaulting to the foreground) and its canvas
+    /// eyedropper samples the merged image into the dialog.
+    #[test]
+    fn replace_color_eyedropper_samples_the_image() {
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 16, "height": 16, "background": "#00ff00"})).unwrap();
+        let mut app = PhotocraftApp::new(s, crate::Services::default());
+        app.run("tools.setColors", json!({"foreground": "#ff0000"})).unwrap();
+        let id = open(&mut app, REPLACE_COLOR).unwrap();
+        assert_eq!(app.ui.dialogs.last().unwrap().fields["color"], json!("#ff0000"), "the dialog starts from the foreground colour");
+        assert!(!color_eyedropper_armed(&app));
+        app.ui.dialog_mut(id).unwrap().fields.insert(COLOR_EYEDROPPER.into(), json!(true));
+        assert!(color_eyedropper_armed(&app));
+        assert!(color_eyedropper_sample(&mut app, 4.0, 4.0));
+        assert_eq!(app.ui.dialogs.last().unwrap().fields["color"], json!("#00ff00"));
+        // #4457: where it was picked, for Localized Color Clusters.
+        assert_eq!(app.ui.dialogs.last().unwrap().fields["points"], json!([[4.0, 4.0]]));
+        // Off-image: the click is consumed, nothing changes and the eyedropper stays armed.
+        assert!(color_eyedropper_sample(&mut app, -1.0, 4.0));
+        assert_eq!(app.ui.dialogs.last().unwrap().fields["color"], json!("#00ff00"));
+        assert!(color_eyedropper_armed(&app));
+        // Disarmed, the dialog never claims the click.
+        app.ui.dialog_mut(id).unwrap().fields.insert(COLOR_EYEDROPPER.into(), json!(false));
+        assert!(!color_eyedropper_armed(&app));
+        assert!(!color_eyedropper_sample(&mut app, 4.0, 4.0));
+    }
+
+    /// #4143: the eyedropper button arms and disarms the canvas picker.
+    #[test]
+    fn replace_color_dialog_arms_the_eyedropper_button() {
+        use egui_kittest::Harness;
+        use egui_kittest::kittest::Queryable;
+
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 16, "height": 16})).unwrap();
+        let mut app = PhotocraftApp::new(s, crate::Services::default());
+        let mut h = Harness::builder().with_size(egui::vec2(900.0, 700.0)).build_ui_state(|ui, app| crate::dialogs::show(app, ui.ctx()), &mut app);
+        PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+        open(h.state_mut(), REPLACE_COLOR).unwrap();
+        h.run_steps(3);
+        h.get_by_label("Pick Color From Image").click();
+        h.run_steps(2);
+        assert!(color_eyedropper_armed(h.state()));
+        h.get_by_label("Pick Color From Image").click();
+        h.run_steps(2);
+        assert!(!color_eyedropper_armed(h.state()));
+    }
+
+    /// #4457: Localized Color Clusters and its Range, as in Photoshop's dialog; the sampled point
+    /// and both settings reach the command.
+    #[test]
+    fn replace_color_localized_color_clusters() {
+        use egui_kittest::Harness;
+        use egui_kittest::kittest::Queryable;
+
+        // Left half red, right half red too: localized on the left point, the right half stays.
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 40, "height": 10, "background": "#ff0000"})).unwrap();
+        let mut app = PhotocraftApp::new(s, crate::Services::default());
+        let mut h = Harness::builder().with_size(egui::vec2(900.0, 800.0)).build_ui_state(|ui, app| crate::dialogs::show(app, ui.ctx()), &mut app);
+        PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+        let id = open(h.state_mut(), REPLACE_COLOR).unwrap();
+        h.run_steps(3);
+        let _ = h.get_by_label("Localized Color Clusters");
+        h.state_mut().ui.dialog_mut(id).unwrap().fields.insert(COLOR_EYEDROPPER.into(), json!(true));
+        assert!(color_eyedropper_sample(h.state_mut(), 2.0, 5.0));
+        h.get_by_label("Localized Color Clusters").click();
+        h.run_steps(2);
+        let f = h.state().ui.dialogs.last().unwrap().fields.clone();
+        assert_eq!((f["localized"].clone(), f["points"].clone()), (json!(true), json!([[2.0, 5.0]])));
+        // The command with the dialog's fields, small range and a hue shift: only near (2, 5).
+        let mut p: Map<String, Value> = f.iter().filter(|(k, _)| !k.starts_with("__")).map(|(k, v)| (k.clone(), v.clone())).collect();
+        p.insert("range".into(), json!(10));
+        p.insert("hue".into(), json!(120));
+        h.state_mut().run(REPLACE_COLOR, Value::Object(p)).unwrap();
+        let doc = &h.state().session.active().unwrap().doc;
+        let px = |x: i32| doc.layers[0].surface().unwrap().read_region(photocraft_geom::Rect::new(x, 5, x + 1, 6));
+        assert!(px(2)[1] > 0.5, "near the point: shifted to green {:?}", px(2));
+        assert!(px(38)[0] > 0.9 && px(38)[1] < 0.1, "far away: still red {:?}", px(38));
+    }
 }
diff --git a/crates/ui-egui/src/filter_preview_ui.rs b/crates/ui-egui/src/filter_preview_ui.rs
new file mode 100644
index 0000000000..90eaf4f6fe
--- /dev/null
+++ b/crates/ui-egui/src/filter_preview_ui.rs
@@ -0,0 +1,504 @@
+//! In-dialog preview window for the generic schema filter dialogs (#3769).
+//!
+//! Photoshop shows a preview of the filtered result *inside* its filter dialogs. This draws one
+//! from the same proxy preview the canvas already shows (`filter_dialog::preview_document`): a
+//! cropped region of the filtered proxy with − / + zoom and a percentage readout, drag to pan, a
+//! click to centre the view on a document point, and press-and-hold to compare with the unfiltered
+//! image. The proxy is drawn scaled by its reduction factor, so 100% is one *document* pixel per
+//! point whatever the proxy factor. The Preview checkbox keeps toggling the on-canvas live result
+//! (`canvas::ensure_filter_preview`), unchanged.
+
+use egui::{Color32, Rect, Sense, Stroke, Vec2, pos2, vec2};
+use photocraft_doc::Document;
+use serde_json::{Map, Value, json};
+
+use crate::PhotocraftApp;
+use crate::filter_dialog::FilterPreviewKey;
+use crate::theme::Tokens;
+
+/// Zoom bounds, as a fraction of document scale: 100% shows one document pixel per point.
+const MIN_ZOOM: f32 = 0.125;
+const MAX_ZOOM: f32 = 8.0;
+const DEFAULT_ZOOM: f32 = 1.0;
+/// The preview region's height in points; its width follows the dialog.
+const PREVIEW_H: f32 = 150.0;
+/// Private dialog fields holding the preview's view (stripped from the command's params).
+const ZOOM_FIELD: &str = "__pvZoom";
+const CENTER_X_FIELD: &str = "__pvCx";
+const CENTER_Y_FIELD: &str = "__pvCy";
+
+/// Draw the filter dialog's in-dialog preview window below its parameters (its `fields` `f`). A
+/// no-op for dialogs without a preview and for Select and Mask, which has its own view.
+pub(crate) fn window(app: &PhotocraftApp, dialog: u64, ui: &mut egui::Ui, f: &mut Map<String, Value>) {
+    if !shows(f) {
+        return;
+    }
+    let Some(cmd) = f.get("__command").and_then(Value::as_str).map(str::to_owned) else { return };
+    let Some(idx) = app.session.active_index() else { return };
+    let Some(st) = app.session.documents().get(idx) else { return };
+    let (doc_id, revision) = (st.doc.id, st.revision);
+
+    // The filtered proxy the canvas already computed for this dialog, when there is one. Matching
+    // the dialog keeps a stacked dialog from showing another's preview; the Preview checkbox still
+    // decides whether the filtered result (rather than the original) is shown.
+    let preview_on = f.get("__preview").and_then(Value::as_bool) == Some(true);
+    let filtered: Option<(FilterPreviewKey, std::sync::Arc<Document>)> = app.filter_preview.as_ref().and_then(|p| {
+        (preview_on && p.key.dialog == dialog && p.key.doc == doc_id && p.key.command == cmd).then(|| p.result.clone().map(|r| (p.key.clone(), r))).flatten()
+    });
+    // The proxy factor the preview runs at (the filtered key's when it exists, else the request's).
+    let base_k = filtered.as_ref().map(|(k, _)| k.k).unwrap_or_else(|| {
+        let params = app.with_mask_target(&cmd, crate::filter_dialog::params_of(f));
+        crate::filter_dialog::preview_factor(&cmd, &params, crate::proxy::preview_factor(&st.doc, crate::proxy::reduced_previews(app)))
+    });
+
+    let t = Tokens::get(ui.ctx());
+    let cache_id = egui::Id::new(("filter-preview-ui", dialog));
+    let mut cache: Cache = ui.ctx().data_mut(|d| std::mem::take(d.get_temp_mut_or_default::<Cache>(cache_id)));
+    // Channel visibility and the active mask can change without a document revision. Both the
+    // original (press-and-hold) and filtered textures must follow the canvas's current view.
+    let view = (st.channel_view.clone(), app.session.prefs().interface.show_channels_in_color, st.active_layer);
+    if cache.view.as_ref() != Some(&view) {
+        cache = Cache { view: Some(view), ..Default::default() };
+    }
+
+    // Unfiltered proxy: built once per document revision and factor (cheap at the proxy factor).
+    let orig_key = TexKey::Original(doc_id, revision, base_k);
+    if cache.original.as_ref().map(|c| &c.key) != Some(&orig_key) {
+        let proxy = crate::proxy::proxy_document(&st.doc, base_k);
+        let tex = upload(ui.ctx(), app, "filter-preview-original", &proxy);
+        cache.original = Some(CachedTex { key: orig_key, tex, size: [proxy.size.width, proxy.size.height] });
+    }
+    // Filtered proxy: rebuilt whenever the worker publishes a new result.
+    match &filtered {
+        Some((key, filtered_doc)) => {
+            let fkey = TexKey::Filtered(key.clone());
+            if cache.filtered.as_ref().map(|c| &c.key) != Some(&fkey) {
+                let tex = upload(ui.ctx(), app, "filter-preview-filtered", filtered_doc);
+                cache.filtered = Some(CachedTex { key: fkey, tex, size: [filtered_doc.size.width, filtered_doc.size.height] });
+            }
+        }
+        None => cache.filtered = None,
+    }
+    let orig = cache.original.as_ref().map(|c| (c.tex.clone(), c.size));
+    let filt = cache.filtered.as_ref().map(|c| (c.tex.clone(), c.size));
+    ui.ctx().data_mut(|d| d.insert_temp(cache_id, cache));
+
+    let Some([img_w, img_h]) = filt.as_ref().map(|(_, s)| *s).or_else(|| orig.as_ref().map(|(_, s)| *s)) else { return };
+    if img_w == 0 || img_h == 0 {
+        return;
+    }
+    // The proxy is the document reduced by `base_k`, so the view works in *document* pixels: at
+    // 100% one document pixel covers one point, whatever the proxy factor (#3769).
+    let doc = document_size([img_w, img_h], base_k);
+
+    // View state, sanitised: a corrupt field must not divide by zero or draw off the texture.
+    let mut zoom = f.get(ZOOM_FIELD).and_then(Value::as_f64).map(|v| v as f32).filter(|z| z.is_finite() && *z > 0.0).unwrap_or(DEFAULT_ZOOM);
+    zoom = zoom.clamp(MIN_ZOOM, MAX_ZOOM);
+    let mut cx = f.get(CENTER_X_FIELD).and_then(Value::as_f64).map(|v| v as f32).filter(|v| v.is_finite()).unwrap_or(doc.x / 2.0);
+    let mut cy = f.get(CENTER_Y_FIELD).and_then(Value::as_f64).map(|v| v as f32).filter(|v| v.is_finite()).unwrap_or(doc.y / 2.0);
+    (cx, cy) = clamp_center(cx, cy, doc.x, doc.y);
+
+    let width = ui.available_width().max(140.0);
+    let (rect, response) = ui.allocate_exact_size(vec2(width, PREVIEW_H), Sense::click_and_drag());
+    let (x0, y0, sw, sh) = source_rect(cx, cy, zoom, rect.size(), doc);
+    let (dest, uv) = placement(rect, (x0, y0, sw, sh), zoom, doc);
+
+    // Press-and-hold shows the unfiltered image, as Photoshop's preview does.
+    let holding = response.is_pointer_button_down_on();
+    let shown = if holding { orig.as_ref() } else { filt.as_ref().or(orig.as_ref()) };
+    let painter = ui.painter_at(rect);
+    painter.rect_filled(rect, t.radius_sm, t.canvas);
+    if let Some((tex, _)) = shown {
+        crate::widgets::checker(&painter, dest, 8.0);
+        painter.image(tex.id(), dest, uv, Color32::WHITE);
+    }
+    painter.rect_stroke(rect, t.radius_sm, Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside);
+
+    // Drag to pan (the image follows the pointer); a plain click centres on the clicked point.
+    if response.dragged() {
+        let d = response.drag_delta();
+        cx -= d.x / zoom;
+        cy -= d.y / zoom;
+    }
+    if response.clicked()
+        && let Some(p) = response.interact_pointer_pos()
+    {
+        (cx, cy) = point_to_source(p - rect.min, x0, y0, zoom, doc);
+    }
+    (cx, cy) = clamp_center(cx, cy, doc.x, doc.y);
+
+    ui.horizontal(|ui| {
+        if crate::icons::button(ui, "minus", 22.0, false, tl!("Zoom out")).clicked() {
+            zoom = step_zoom(zoom, false);
+        }
+        ui.label(egui::RichText::new(format!("{}%", crate::widgets::fmt_num(zoom as f64 * 100.0))).color(t.text_dim));
+        if crate::icons::button(ui, "plus", 22.0, false, tl!("Zoom in")).clicked() {
+            zoom = step_zoom(zoom, true);
+        }
+    });
+
+    f.insert(ZOOM_FIELD.into(), json!(zoom.clamp(MIN_ZOOM, MAX_ZOOM)));
+    f.insert(CENTER_X_FIELD.into(), json!(cx));
+    f.insert(CENTER_Y_FIELD.into(), json!(cy));
+}
+
+/// The zoom levels the − / + buttons step through, like the Filter Gallery's.
+const ZOOM_STEPS: [f32; 7] = [0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0];
+
+/// The vertical space the preview window takes below the parameters: the image, the zoom row and
+/// their spacing. `0` when the dialog has no preview (so the caller reserves nothing).
+pub(crate) fn reserved_height(f: &Map<String, Value>) -> f32 {
+    if shows(f) { PREVIEW_H + 32.0 } else { 0.0 }
+}
+
+/// Whether the dialog with fields `f` gets the preview window: Filter menu dialogs with a Preview
+/// checkbox, as in Photoshop. Image › Rotation › Arbitrary and the adjustment dialogs keep only
+/// the on-canvas preview, and Select and Mask has its own view.
+fn shows(f: &Map<String, Value>) -> bool {
+    f.contains_key("__preview") && !crate::select_mask_view::owns(f) && f.get("__command").and_then(Value::as_str).is_some_and(|c| c.starts_with("filter."))
+}
+
+/// The next zoom level up or down from `zoom`, clamped to [`ZOOM_STEPS`]' ends.
+fn step_zoom(zoom: f32, up: bool) -> f32 {
+    if up {
+        ZOOM_STEPS.iter().copied().find(|s| *s > zoom + 1e-3).unwrap_or(MAX_ZOOM)
+    } else {
+        ZOOM_STEPS.iter().rev().copied().find(|s| *s < zoom - 1e-3).unwrap_or(MIN_ZOOM)
+    }
+}
+
+/// Keep the view centre on the image (so panning never runs off it entirely). A non-finite centre
+/// (corrupt dialog state) falls back to the image's origin.
+fn clamp_center(cx: f32, cy: f32, w: f32, h: f32) -> (f32, f32) {
+    let axis = |v: f32, max: f32| if v.is_finite() { v.clamp(0.0, max.max(0.0)) } else { 0.0 };
+    (axis(cx, w), axis(cy, h))
+}
+
+/// The image rectangle shown in a `region` of points at `zoom`, centred on `(cx, cy)`:
+/// `(x0, y0, width, height)` in document pixels. A region wider than the image is centred on it.
+fn source_rect(cx: f32, cy: f32, zoom: f32, region: Vec2, doc: Vec2) -> (f32, f32, f32, f32) {
+    let zoom = if zoom.is_finite() && zoom > 0.0 { zoom } else { DEFAULT_ZOOM };
+    let sw = (region.x / zoom).max(0.0);
+    let sh = (region.y / zoom).max(0.0);
+    (origin(cx, sw, doc.x), origin(cy, sh, doc.y), sw, sh)
+}
+
+fn origin(centre: f32, size: f32, total: f32) -> f32 {
+    if size >= total { (total - size) / 2.0 } else { (centre - size / 2.0).clamp(0.0, total - size) }
+}
+
+/// Where the image is drawn in `rect` and which part of the texture fills it, for the `source`
+/// rectangle `(x0, y0, width, height)` in document pixels shown at `zoom`. Only the part of the
+/// source that lies on the image is drawn, at its own place in the region: stretching the clamped
+/// texture over the whole region made the pixels non-square whenever the region overhung the image
+/// on one axis (#4640).
+fn placement(rect: Rect, source: (f32, f32, f32, f32), zoom: f32, doc: Vec2) -> (Rect, Rect) {
+    let zoom = if zoom.is_finite() && zoom > 0.0 { zoom } else { DEFAULT_ZOOM };
+    let (x0, y0, sw, sh) = source;
+    let (vx0, vy0) = (x0.max(0.0), y0.max(0.0));
+    let (vx1, vy1) = ((x0 + sw).min(doc.x).max(vx0), (y0 + sh).min(doc.y).max(vy0));
+    let at = |x: f32, y: f32| rect.min + vec2((x - x0) * zoom, (y - y0) * zoom);
+    let uv = Rect::from_min_max(pos2(vx0 / doc.x, vy0 / doc.y), pos2(vx1 / doc.x, vy1 / doc.y));
+    (Rect::from_min_max(at(vx0, vy0), at(vx1, vy1)), uv)
+}
+
+/// The document pixel under a pointer at `local` (relative to the region's top-left) in a view whose
+/// source rectangle starts at `(x0, y0)` and is shown at `zoom`.
+fn point_to_source(local: Vec2, x0: f32, y0: f32, zoom: f32, doc: Vec2) -> (f32, f32) {
+    let zoom = if zoom.is_finite() && zoom > 0.0 { zoom } else { DEFAULT_ZOOM };
+    ((x0 + local.x / zoom).clamp(0.0, doc.x), (y0 + local.y / zoom).clamp(0.0, doc.y))
+}
+
+/// The document-pixel size of a proxy with `k`-reduced dimensions. A hostile/overflowing size falls
+/// back to the proxy's own dimensions (factor 1), which stays finite and positive.
+fn document_size(proxy: [u32; 2], k: u32) -> Vec2 {
+    let scale = k.max(1) as f32;
+    let doc = vec2(proxy[0] as f32 * scale, proxy[1] as f32 * scale);
+    if doc.x.is_finite() && doc.y.is_finite() && doc.x > 0.0 && doc.y > 0.0 { doc } else { vec2(proxy[0] as f32, proxy[1] as f32) }
+}
+
+/// A composite as monitor pixels, matching the canvas (`canvas::display_image`).
+fn upload(ctx: &egui::Context, app: &PhotocraftApp, name: &str, doc: &Document) -> egui::TextureHandle {
+    // Reduce only the display texture when a full-resolution result exceeds the device limit.
+    // The cached document and the window's document-pixel zoom coordinates stay at full size.
+    let factor = texture_factor(doc.size.width, doc.size.height, ctx.input(|i| i.max_texture_side));
+    let (width, height) = (doc.size.width.div_ceil(factor), doc.size.height.div_ceil(factor));
+    if let Some(st) = app.session.active()
+        && let Some(pixels) =
+            crate::channel_view::render(doc, &st.channel_view, doc.bounds(), factor, app.session.prefs().interface.show_channels_in_color, st.active_layer)
+    {
+        let image = egui::ColorImage::new([width as usize, height as usize], pixels);
+        return ctx.load_texture(name, image, egui::TextureOptions::LINEAR);
+    }
+    let buf = if factor == 1 { photocraft_compose::flatten(doc) } else { photocraft_compose::render_reduced(doc, width, height) };
+    let (display, _) = crate::canvas::canvas_display(app, doc, None);
+    let img = crate::canvas::display_image(display.as_deref(), &buf);
+    ctx.load_texture(name, img, egui::TextureOptions::LINEAR)
+}
+
+/// The reduction that fits a `w`×`h` image inside a `max_side` texture (1: it already fits).
+fn texture_factor(w: u32, h: u32, max_side: usize) -> u32 {
+    let max_side = u32::try_from(max_side).unwrap_or(u32::MAX).max(1);
+    w.max(h).div_ceil(max_side).max(1)
+}
+
+/// What a cached texture was built from, so it is rebuilt only when its source changes.
+#[derive(Clone, PartialEq)]
+enum TexKey {
+    Filtered(FilterPreviewKey),
+    Original(photocraft_doc::DocId, u64, u32),
+}
+
+#[derive(Clone)]
+struct CachedTex {
+    key: TexKey,
+    tex: egui::TextureHandle,
+    /// The image's size in pixels.
+    size: [u32; 2],
+}
+
+/// The dialog's live textures: the filtered proxy and the unfiltered proxy.
+#[derive(Clone, Default)]
+struct Cache {
+    filtered: Option<CachedTex>,
+    original: Option<CachedTex>,
+    view: Option<(photocraft_engine::channel_cmds::ChannelView, bool, Option<photocraft_doc::LayerId>)>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn full_resolution_preview_textures_respect_the_device_limit() {
+        let ctx = egui::Context::default();
+        let limit = ctx.input(|i| i.max_texture_side) as u32;
+        let width = limit + 2;
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": width, "height": 2})).unwrap();
+        for alpha in [false, true] {
+            if alpha {
+                app.run("channel.new", json!({"name": "Alpha", "fill": "black"})).unwrap();
+                app.session
+                    .edit("Fixture", |doc, _| {
+                        doc.channels[0].surface.fill_rect(photocraft_geom::Rect::new(0, 0, (width / 2) as i32, 2), &[1.0]);
+                        Ok(())
+                    })
+                    .unwrap();
+            }
+            let doc = &app.session.active().unwrap().doc;
+            let texture = upload(&ctx, &app, "full-resolution-preview", doc);
+            let mut delta = ctx.tex_manager().write().take_delta();
+            let egui::ImageData::Color(image) = &delta.set.get(&texture.id()).unwrap()[0].image;
+            let pixels = image.pixels.clone();
+            delta.clear();
+            assert_eq!(texture.size(), [width.div_ceil(2) as usize, 1]);
+            assert!(texture.size().into_iter().all(|side| side <= limit as usize));
+            assert_eq!(doc.size.width, width, "display reduction must not resize the filter result");
+            assert_eq!(pixels[0], Color32::WHITE);
+            assert_eq!(*pixels.last().unwrap(), if alpha { Color32::BLACK } else { Color32::WHITE });
+        }
+    }
+
+    #[test]
+    fn uploaded_preview_shows_the_filtered_alpha_at_every_depth_and_proxy_scale() {
+        use photocraft_engine::channel_cmds::ChannelTarget;
+        for depth in [8, 16, 32] {
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            app.run("file.new", json!({"width": 16, "height": 16, "depth": depth})).unwrap();
+            app.run("channel.new", json!({"name": "Alpha", "fill": "black"})).unwrap();
+            app.session
+                .edit("Fixture", |doc, _| {
+                    doc.channels[0].surface.fill_rect(photocraft_geom::Rect::new(0, 0, 8, 16), &[1.0]);
+                    Ok(())
+                })
+                .unwrap();
+            let st = app.session.active().unwrap();
+            for k in [1, 2, 4] {
+                let preview = crate::filter_dialog::preview_document_for_target(
+                    &st.doc,
+                    st.active_layer,
+                    "filter.blur.gaussianBlur",
+                    &json!({"radius": 2.0}),
+                    k,
+                    None,
+                    ChannelTarget::Alpha(0),
+                    &[],
+                )
+                .unwrap();
+                let ctx = egui::Context::default();
+                let texture = upload(&ctx, &app, "alpha-preview", &preview);
+                let mut delta = ctx.tex_manager().write().take_delta();
+                let egui::ImageData::Color(image) = &delta.set.get(&texture.id()).unwrap()[0].image;
+                let pixels = image.pixels.clone();
+                delta.clear();
+                let expected = crate::channel_view::render(&preview, &st.channel_view, preview.bounds(), 1, false, st.active_layer).unwrap();
+                assert_eq!(pixels, expected, "depth {depth}, factor {k}");
+                assert_ne!(pixels[0], pixels[pixels.len() - 1], "the alpha edge is visible, not the white RGB layer");
+                assert!(pixels.iter().any(|p| p.r() > 0 && p.r() < 255), "the blurred edge is visible");
+            }
+        }
+    }
+
+    #[test]
+    fn original_texture_refreshes_when_the_channel_view_changes_without_an_edit() {
+        use photocraft_engine::channel_cmds::ChannelTarget;
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 16, "height": 16})).unwrap();
+        app.run("channel.new", json!({"name": "White", "fill": "white"})).unwrap();
+        app.run("channel.new", json!({"name": "Black", "fill": "black"})).unwrap();
+        app.session.active_mut().unwrap().channel_view.target = ChannelTarget::Alpha(0);
+        let revision = app.session.active().unwrap().revision;
+        let id = crate::filter_dialog::open(&mut app, "filter.blur.gaussianBlur").unwrap();
+        let mut fields = app.ui.dialogs.last().unwrap().fields.clone();
+        let ctx = egui::Context::default();
+        let cache_id = egui::Id::new(("filter-preview-ui", id));
+        ctx.run_ui(Default::default(), |ui| window(&app, id, ui, &mut fields)).textures_delta.clear();
+        let before = ctx.data(|d| d.get_temp::<Cache>(cache_id).unwrap().original.unwrap().tex.id());
+        app.session.active_mut().unwrap().channel_view.target = ChannelTarget::Alpha(1);
+        assert_eq!(app.session.active().unwrap().revision, revision);
+        let mut output = ctx.run_ui(Default::default(), |ui| window(&app, id, ui, &mut fields));
+        let after = ctx.data(|d| d.get_temp::<Cache>(cache_id).unwrap().original.unwrap().tex.id());
+        let pixels = output.textures_delta.set.get(&after).map(|delta| {
+            let egui::ImageData::Color(image) = &delta[0].image;
+            image.pixels.clone()
+        });
+        output.textures_delta.clear();
+        assert_ne!(before, after, "press-and-hold must not reuse the old channel");
+        assert!(pixels.unwrap().iter().all(|p| *p == Color32::BLACK));
+    }
+
+    #[test]
+    fn zoom_steps_walk_the_levels_and_stay_in_bounds() {
+        assert_eq!(step_zoom(1.0, true), 2.0);
+        assert_eq!(step_zoom(1.0, false), 0.5);
+        assert_eq!(step_zoom(0.9, true), 1.0);
+        assert_eq!(step_zoom(1.1, false), 1.0);
+        assert_eq!(step_zoom(MAX_ZOOM, true), MAX_ZOOM, "clamped at the top");
+        assert_eq!(step_zoom(MIN_ZOOM, false), MIN_ZOOM, "clamped at the bottom");
+        assert_eq!(step_zoom(0.0, true), MIN_ZOOM, "a corrupt zoom recovers upward");
+        assert_eq!(step_zoom(f32::NAN, false), MIN_ZOOM);
+    }
+
+    #[test]
+    fn only_filter_dialogs_get_the_preview_window() {
+        let fields = |cmd: &str| json!({"__preview": true, "__command": cmd}).as_object().cloned().unwrap();
+        assert!(shows(&fields("filter.blur.gaussianBlur")));
+        assert!(reserved_height(&fields("filter.blur.gaussianBlur")) > 0.0);
+        // Photoshop's Rotate Canvas and adjustment dialogs have no preview window.
+        assert!(!shows(&fields("image.rotation.arbitrary")));
+        assert_eq!(reserved_height(&fields("image.rotation.arbitrary")), 0.0);
+        assert!(!shows(&fields("adjust.levels")));
+        // No Preview checkbox or no command: no window.
+        assert!(!shows(json!({"__command": "filter.blur.gaussianBlur"}).as_object().unwrap()));
+        assert!(!shows(json!({"__preview": true}).as_object().unwrap()));
+    }
+
+    #[test]
+    fn textures_are_reduced_to_fit_the_gpu() {
+        assert_eq!(texture_factor(3000, 2000, 2048), 2);
+        assert_eq!(texture_factor(2048, 100, 2048), 1);
+        assert_eq!(texture_factor(9000, 9000, 2048), 5);
+        // A zero or absurd limit never divides by zero.
+        assert_eq!(texture_factor(3000, 2000, 0), 3000);
+        assert_eq!(texture_factor(0, 0, 2048), 1);
+    }
+
+    #[test]
+    fn the_centre_is_clamped_to_the_document() {
+        assert_eq!(clamp_center(-5.0, 99.0, 100.0, 50.0), (0.0, 50.0));
+        assert_eq!(clamp_center(40.0, 25.0, 100.0, 50.0), (40.0, 25.0));
+        // A corrupt (non-finite) centre falls back to the origin, not a panic or a NaN.
+        assert_eq!(clamp_center(f32::NAN, f32::INFINITY, 100.0, 50.0), (0.0, 0.0));
+    }
+
+    #[test]
+    fn the_source_rect_follows_the_centre_and_zoom() {
+        let doc = vec2(1000.0, 500.0);
+        let region = vec2(200.0, 100.0);
+        // 100%: a 200×100 document-pixel crop centred at (500, 250) sits in the middle.
+        assert_eq!(source_rect(500.0, 250.0, 1.0, region, doc), (400.0, 200.0, 200.0, 100.0));
+        // 200%: the crop is half as large, still centred.
+        assert_eq!(source_rect(500.0, 250.0, 2.0, region, doc), (450.0, 225.0, 100.0, 50.0));
+        // Near an edge the crop stops at it instead of running off.
+        let (x0, _, sw, _) = source_rect(0.0, 250.0, 1.0, region, doc);
+        assert_eq!((x0, sw), (0.0, 200.0));
+        let (x0, _, sw, _) = source_rect(1000.0, 250.0, 1.0, region, doc);
+        assert_eq!((x0, sw), (800.0, 200.0));
+    }
+
+    #[test]
+    fn a_zoomed_out_region_centres_the_whole_image() {
+        let doc = vec2(100.0, 50.0);
+        let region = vec2(200.0, 100.0);
+        let (x0, y0, sw, sh) = source_rect(50.0, 25.0, 0.5, region, doc);
+        // The region is wider than the image: it is centred (a negative origin) and covers all of
+        // it, so the UV clamps to 0..1 rather than reading outside the texture.
+        assert_eq!((x0, y0, sw, sh), (-150.0, -75.0, 400.0, 200.0));
+        assert!(x0 / doc.x < 0.0 && (x0 + sw) / doc.x > 1.0);
+    }
+
+    #[test]
+    fn the_image_keeps_square_pixels_when_the_region_overhangs_it() {
+        // #4640: a 370×240 document in a 650×150 region at 100% is wider than the image but shorter
+        // than it, and at 50% it fits inside on both axes. Either way one document pixel must cover
+        // the same number of points across and down, and the image is centred, not stretched.
+        let rect = Rect::from_min_size(pos2(10.0, 20.0), vec2(650.0, 150.0));
+        let doc = vec2(370.0, 240.0);
+        for zoom in [1.0, 0.5] {
+            let (dest, uv) = placement(rect, source_rect(185.0, 120.0, zoom, rect.size(), doc), zoom, doc);
+            let across = dest.width() / (uv.width() * doc.x);
+            let down = dest.height() / (uv.height() * doc.y);
+            assert!((across - zoom).abs() < 1e-4 && (down - zoom).abs() < 1e-4, "zoom {zoom}: {across} × {down} points per pixel");
+            assert!((dest.center().x - rect.center().x).abs() < 1e-3, "zoom {zoom}: centred across");
+            assert!(rect.contains_rect(dest), "zoom {zoom}: drawn inside the region");
+            assert!(Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)).contains_rect(uv), "zoom {zoom}: {uv:?} stays on the texture");
+        }
+    }
+
+    #[test]
+    fn a_click_maps_to_the_document_point_under_it() {
+        let doc = vec2(1000.0, 500.0);
+        // The top-left of a crop starting at (400, 200) shown at 100% is that point.
+        assert_eq!(point_to_source(vec2(0.0, 0.0), 400.0, 200.0, 1.0, doc), (400.0, 200.0));
+        // At 200%, 50 points in is 25 document pixels in.
+        assert_eq!(point_to_source(vec2(50.0, 50.0), 400.0, 200.0, 2.0, doc), (425.0, 225.0));
+        // Clicking outside the image clamps to it.
+        assert_eq!(point_to_source(vec2(-10_000.0, 0.0), 400.0, 200.0, 1.0, doc), (0.0, 200.0));
+    }
+
+    #[test]
+    fn a_hundred_percent_is_one_document_pixel_per_point() {
+        // A 4×-reduced proxy of a 4000×3000 document: 100% must span 200 document pixels across a
+        // 200-point region, not 200 proxy pixels (which would be a quarter of the document scale).
+        let doc = document_size([1000, 750], 4);
+        assert_eq!(doc, vec2(4000.0, 3000.0));
+        let (_, _, sw, sh) = source_rect(2000.0, 1500.0, 1.0, vec2(200.0, 100.0), doc);
+        assert_eq!((sw, sh), (200.0, 100.0), "one document pixel per point at 100%");
+        // The same region covers 50 proxy pixels: the stored UV is a 200/4000 fraction.
+        let (x0, _, _, _) = source_rect(2000.0, 1500.0, 1.0, vec2(200.0, 100.0), doc);
+        assert_eq!(x0 / doc.x, 0.475);
+        assert!(document_size([0, 0], 4) == vec2(0.0, 0.0), "degenerate size stays finite");
+        assert_eq!(document_size([10, 20], 0), vec2(10.0, 20.0), "a zero factor means 1×");
+    }
+
+    #[test]
+    fn the_window_defaults_its_view_and_never_panics() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
+        let id = crate::filter_dialog::open(&mut app, "filter.stylize.emboss").expect("Emboss opens a dialog");
+        let mut f = app.ui.dialogs.iter().find(|d| d.id == id).expect("the dialog is open").fields.clone();
+        assert!(f.contains_key("__preview"), "Emboss previews");
+        egui::Context::default().run_ui(Default::default(), |ui| window(&app, id, ui, &mut f)).textures_delta.clear();
+        assert_eq!(f.get(ZOOM_FIELD), Some(&json!(1.0)), "100% by default");
+        assert_eq!(f.get(CENTER_X_FIELD), Some(&json!(32.0)), "centred on the document");
+        assert_eq!(f.get(CENTER_Y_FIELD), Some(&json!(24.0)));
+        // Corrupt state is recovered, not panicked on.
+        f.insert(ZOOM_FIELD.into(), json!(0.0));
+        f.insert(CENTER_X_FIELD.into(), json!(f64::NAN));
+        f.insert(CENTER_Y_FIELD.into(), json!(-999.0));
+        egui::Context::default().run_ui(Default::default(), |ui| window(&app, id, ui, &mut f)).textures_delta.clear();
+        assert_eq!(f.get(ZOOM_FIELD), Some(&json!(1.0)));
+        assert_eq!(f.get(CENTER_Y_FIELD), Some(&json!(0.0)));
+    }
+}
diff --git a/crates/ui-egui/src/filter_preview_worker.rs b/crates/ui-egui/src/filter_preview_worker.rs
index 2704f8a6ac..48f29400fb 100644
--- a/crates/ui-egui/src/filter_preview_worker.rs
+++ b/crates/ui-egui/src/filter_preview_worker.rs
@@ -116,6 +116,7 @@ mod tests {
             revision,
             dialog,
             active: None,
+            target: Default::default(),
             command: "image.mode.indexedColor".into(),
             params: json!({"colors": colors}),
             k: 1,
diff --git a/crates/ui-egui/src/font_preview.rs b/crates/ui-egui/src/font_preview.rs
index 1568abf655..74c334d682 100644
--- a/crates/ui-egui/src/font_preview.rs
+++ b/crates/ui-egui/src/font_preview.rs
@@ -49,9 +49,12 @@ pub(crate) fn sample(preview: FontPreview) -> Option<(f32, [f32; 2])> {
     Some((size, box_for(size)))
 }
 
-/// Family, display scale, the font database generations (so a family installed or fetched
-/// (served fonts) after its first miss gets a sample once it is available) and the point size.
-type Key = (String, u32, (u64, u64), u32);
+/// Family, display scale, the shared font database's generation (so a family installed or
+/// fetched (served fonts) after its first miss gets a sample once it is available) and the point
+/// size. Not the served catalog's generation: a listed family has no sample until its fonts are
+/// registered, which moves the database's generation, and keying on the catalog re-rendered
+/// every sample whenever it changed.
+type Key = (String, u32, u64, u32);
 #[derive(Clone)]
 struct Samples {
     latin: TextureHandle,
@@ -111,7 +114,7 @@ fn images(engine: &mut photocraft_text::TextEngine, family: &str, scale: u32, si
 
 fn key(ctx: &egui::Context, family: &str, size: f32) -> Key {
     let scale = ctx.pixels_per_point().ceil().clamp(1.0, 4.0) as u32;
-    (family.to_owned(), scale, (photocraft_text::fonts::generation(), photocraft_text::served::generation()), size as u32)
+    (family.to_owned(), scale, photocraft_text::fonts::shared_generation(), size as u32)
 }
 
 /// Width a row reserves for its samples: wider once a painted row showed the family covers
diff --git a/crates/ui-egui/src/gallery_ui.rs b/crates/ui-egui/src/gallery_ui.rs
index ed1597deb1..83928e29b4 100644
--- a/crates/ui-egui/src/gallery_ui.rs
+++ b/crates/ui-egui/src/gallery_ui.rs
@@ -21,6 +21,7 @@ use photocraft_raster::{Interrupt, Surface};
 use serde_json::{Map, Value, json};
 
 use crate::PhotocraftApp;
+use crate::edit_history::{EditHistory, Step};
 use crate::filter_dialog::{Kind, parse_spec};
 use crate::theme::Tokens;
 use crate::widgets;
@@ -91,6 +92,7 @@ pub struct GalleryDialog {
     thumb_src: Surface,
     thumbs: Vec<Option<TextureHandle>>,
     pub preview_ms: f64,
+    history: EditHistory<Vec<EffectLayer>>,
 }
 
 impl GalleryDialog {
@@ -145,6 +147,12 @@ impl GalleryDialog {
         }
     }
 
+    pub(crate) fn step(&mut self, step: Step) {
+        if self.history.step(&mut self.effects, step) {
+            self.selected = self.selected.min(self.effects.len().saturating_sub(1));
+        }
+    }
+
     fn move_to(&mut self, from: usize, to: usize) {
         if from < self.effects.len() && to < self.effects.len() && from != to {
             let e = self.effects.remove(from);
@@ -295,6 +303,7 @@ pub fn open(app: &mut PhotocraftApp) -> Result<(), String> {
     let thumb_src = sample(&src, Rect::new(cx - tw / 2, cy - th / 2, cx - tw / 2 + tw, cy - th / 2 + th), k);
     let sel = effects.len() - 1;
     let open_cats = std::array::from_fn(|i| effects[sel].filter.category() == GALLERY_CATEGORIES[i]);
+    let history = EditHistory::new(&effects);
     app.distort.gallery = Some(GalleryDialog {
         layer,
         layer_name,
@@ -316,6 +325,7 @@ pub fn open(app: &mut PhotocraftApp) -> Result<(), String> {
         thumb_src,
         thumbs: vec![None; GalleryFilter::ALL.len()],
         preview_ms: 0.0,
+        history,
     });
     Ok(())
 }
@@ -370,6 +380,7 @@ pub fn control(app: &mut PhotocraftApp, ui: &Value) -> Result<Value, String> {
     if let Some(Value::Object(m)) = ui.get("params") {
         d.cur().params.extend(m.clone());
     }
+    d.history.settle(&d.effects, false);
     match ui.get("zoom") {
         Some(Value::String(s)) if s == "fit" => d.zoom = 0.0,
         // The gallery's own preview zoom, not the canvas (`zoom_levels` doesn't apply): its − / +
@@ -545,6 +556,7 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
     let background = app.background_jobs;
     egui::Area::new(egui::Id::new("gallery-dialog")).order(egui::Order::Foreground).fixed_pos(screen.min).show(ctx, |ui| {
         let Some(d) = app.distort.gallery.as_mut() else { return };
+        d.history.settle(&d.effects, ctx.input(|i| i.pointer.any_down()));
         let (full, _) = ui.allocate_exact_size(screen.size(), Sense::hover());
         let painter = ui.painter().clone();
         painter.rect_filled(full, 0.0, t.chrome);
@@ -609,7 +621,8 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
                 let r = ui.horizontal(|ui| {
                     let (ir, _) = ui.allocate_exact_size(vec2(16.0, 16.0), Sense::hover());
                     crate::icons::paint(ui, ir, icon, 14.0, t.icon);
-                    ui.add(egui::Label::new(egui::RichText::new(tl!(*cat)).color(t.text)).sense(Sense::click()))
+                    ui.add(egui::Label::new(egui::RichText::new(tl!(*cat)).color(t.text)).selectable(false).sense(Sense::click()))
+                        .on_hover_cursor(egui::CursorIcon::PointingHand)
                 });
                 if r.inner.clicked() {
                     d.open[ci] = !d.open[ci];
diff --git a/crates/ui-egui/src/gpu_canvas.rs b/crates/ui-egui/src/gpu_canvas.rs
index e73c59985a..046d4ac2a7 100644
--- a/crates/ui-egui/src/gpu_canvas.rs
+++ b/crates/ui-egui/src/gpu_canvas.rs
@@ -527,6 +527,20 @@ impl GpuCanvas {
         doc: &photocraft_doc::Document,
         damage: Option<photocraft_geom::Rect>,
         display: Option<&photocraft_engine::display_color::CanvasDisplay>,
+    ) -> Refresh {
+        self.refresh_with(key, doc, damage, display, false)
+    }
+
+    /// [`GpuCanvas::refresh`], except that with `defer`, a refresh of at least [`DEFER_PX`] the
+    /// CPU compositor would draw is left to the caller (`background_redraw`): the texture is made
+    /// ready (keeping what it shows when it already fits) and the kind is [`REFRESH_DEFERRED`].
+    pub fn refresh_with(
+        &self,
+        key: u64,
+        doc: &photocraft_doc::Document,
+        damage: Option<photocraft_geom::Rect>,
+        display: Option<&photocraft_engine::display_color::CanvasDisplay>,
+        defer: bool,
     ) -> Refresh {
         if let Some(f) = self.fault() {
             // Nothing reaches the GPU any more; the app switches to the CPU canvas.
@@ -564,6 +578,12 @@ impl GpuCanvas {
             }
             Err(e) => out.fallback = Some(e.0),
         }
+        let px = region.width() as u64 * region.height() as u64;
+        if defer && px >= DEFER_PX && self.prepare_texture(key, doc).is_some() {
+            out.kind = REFRESH_DEFERRED;
+            out.px = px;
+            return out;
+        }
         if let Some(r) = damage {
             if r.is_empty() {
                 out.kind = "rect";
@@ -591,22 +611,8 @@ impl GpuCanvas {
     /// never needs a full-size float composite or texture-format copy in memory.
     pub fn upload_composite(&self, key: u64, doc: &photocraft_doc::Document, display: Option<&photocraft_engine::display_color::CanvasDisplay>) {
         let size = [doc.size.width, doc.size.height];
-        if size[0] == 0 || size[1] == 0 || !self.health.is_ok() {
-            return;
-        }
-        let format = self.format_for(doc.depth, size);
+        let Some(format) = self.prepare_texture(key, doc) else { return };
         let (device, queue) = (&self.rs.device, &self.rs.queue);
-        {
-            let mut renderer = self.rs.renderer.write();
-            let Some(res) = renderer.callback_resources.get_mut::<Resources>() else { return };
-            if res.docs.get(&key).is_none_or(|d| d.size != size || d.format != format) {
-                let Some(tex) = DocTextures::new(device, res, size, self.tile, format) else {
-                    res.docs.remove(&key);
-                    return;
-                };
-                res.docs.insert(key, tex);
-            }
-        }
         let mut rgba = Vec::new();
         let _ = photocraft_compose::render_bands(doc, doc.bounds(), 0, |band| -> Result<(), ()> {
             if !self.health.is_ok() {
@@ -633,19 +639,39 @@ impl GpuCanvas {
         }
     }
 
+    /// Make sure document `key` has a display texture of `doc`'s size and format, keeping the one
+    /// it has when that fits. Returns its format, or `None` when it can't be created.
+    pub fn prepare_texture(&self, key: u64, doc: &photocraft_doc::Document) -> Option<wgpu::TextureFormat> {
+        let size = [doc.size.width, doc.size.height];
+        if size[0] == 0 || size[1] == 0 || !self.health.is_ok() {
+            return None;
+        }
+        let format = self.format_for(doc.depth, size);
+        let mut renderer = self.rs.renderer.write();
+        let res = renderer.callback_resources.get_mut::<Resources>()?;
+        if res.docs.get(&key).is_none_or(|d| d.size != size || d.format != format) {
+            let Some(tex) = DocTextures::new(&self.rs.device, res, size, self.tile, format) else {
+                res.docs.remove(&key);
+                return None;
+            };
+            res.docs.insert(key, tex);
+        }
+        Some(format)
+    }
+
     /// Free textures, display LUTs and their signatures for documents not in `live`.
     pub fn retain(&self, live: &[u64]) {
         let mut renderer = self.rs.renderer.write();
         let Some(res) = renderer.callback_resources.get_mut::<Resources>() else { return };
         if res.docs.keys().any(|k| !live.contains(k)) {
-            let gone: Vec<u64> = res.docs.keys().filter(|k| !live.contains(k)).copied().collect();
-            if let Some(c) = res.compositor.as_mut() {
-                for k in &gone {
-                    c.forget_doc(photocraft_doc::DocId(*k));
-                }
-            }
             res.docs.retain(|k, _| live.contains(k));
         }
+        // Everything the compositor holds for documents that aren't open, also when their
+        // texture entry was dropped earlier (over budget, a failed render), which used to leave
+        // their pages and effect maps resident after closing (#4529).
+        if let Some(c) = res.compositor.as_mut() {
+            c.retain_docs(|d| live.contains(&d.0));
+        }
         // LUTs and identity-transform signatures can outlive document textures. Prune both,
         // or a preserved-ID reopen can skip rebuilding a missing LUT.
         res.luts.retain(|k, _| live.contains(&k.0));
@@ -764,6 +790,16 @@ fn texture_buffer<'a>(
     }
 }
 
+/// A CPU composite `buf` as texels of a `format` canvas texture, in `display`'s encoding: what
+/// [`GpuCanvas::upload_rect`] takes. Runs anywhere (a redraw's worker converts its own pieces).
+pub fn display_texels(
+    format: wgpu::TextureFormat,
+    display: Option<&photocraft_engine::display_color::CanvasDisplay>,
+    buf: &photocraft_compose::Buffer,
+) -> Vec<u8> {
+    texels(format, &texture_buffer(display, buf).px)
+}
+
 /// What a [`GpuCanvas::refresh`] did.
 #[derive(Clone, Debug, Default)]
 pub struct Refresh {
@@ -1151,6 +1187,13 @@ pub const OVER_CANVAS_BUDGET: &str = "the canvas exceeds the GPU texture budget;
 /// was created, and the caller draws the CPU canvas instead.
 pub const REFRESH_OVER_BUDGET: &str = "over-budget";
 
+/// [`Refresh::kind`] of a CPU refresh left to the caller ([`GpuCanvas::refresh_with`]).
+pub const REFRESH_DEFERRED: &str = "deferred";
+
+/// The smallest CPU refresh (pixels) [`GpuCanvas::refresh_with`] defers: below it, the
+/// synchronous composite takes a fraction of a second even with many layers.
+pub const DEFER_PX: u64 = 1 << 22;
+
 /// GPU bytes one document's display texture set (every tile and mip level) may take: a quarter
 /// of physical memory (`ram`; 16 GB assumed when unknown), at least [`MIN_GPU_BUDGET`]. The set
 /// covers the whole canvas at full resolution, so its size follows the declared canvas, not the
diff --git a/crates/ui-egui/src/gradient_ui.rs b/crates/ui-egui/src/gradient_ui.rs
index 5fd87393d3..be35f66028 100644
--- a/crates/ui-egui/src/gradient_ui.rs
+++ b/crates/ui-egui/src/gradient_ui.rs
@@ -13,6 +13,7 @@
 
 use std::sync::Arc;
 
+use egui::emath::GuiRounding;
 use egui::{Color32, Pos2, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
 use photocraft_compose::gradient_fill as gf;
 use photocraft_doc::{Document, Fill, GradientStyle, Layer, LayerContent, LayerId};
@@ -508,6 +509,9 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
 
 /// A ramp of RGBA stops over a checkerboard in `r`.
 fn paint_ramp(p: &egui::Painter, r: Rect, sample: impl Fn(f32) -> [f32; 4]) {
+    // The tessellator snaps the checker's rects to pixels but not the mesh: snap both alike, or a
+    // half-pixel offset leaves a row of checker showing under the ramp (#4577).
+    let r = r.round_to_pixels(p.pixels_per_point());
     widgets::checker(p, r, 5.0);
     let n = 64;
     let mut mesh = egui::Mesh::default();
@@ -674,6 +678,25 @@ pub fn options_changed(app: &mut PhotocraftApp, before: &crate::state::ToolOptio
     let _ = app.run(cmds::SET, p);
 }
 
+/// Live mode: the options bar's Opacity sets a selected gradient fill layer's opacity, as a
+/// drag's `opacity` does, live while it is scrubbed; `drag` numbers the scrub so it is one undo
+/// step, as in the Layers panel (#5012).
+pub fn opacity_changed(app: &mut PhotocraftApp, drag: Option<u64>) {
+    let o = &app.ui.tool_options;
+    if app.ui.tool != Tool::Gradient || o.gradient_classic {
+        return;
+    }
+    let opacity = o.fill_opacity / 100.0;
+    let Some((l, ..)) = active_gradient(app) else { return };
+    if (l.opacity - opacity).abs() > 1e-6 {
+        let mut p = json!({"layer": l.id.0, "opacity": opacity});
+        if let Some(n) = drag {
+            p["coalesce"] = json!(format!("gradient-tool-opacity:{n}"));
+        }
+        let _ = app.run("layer.setProps", p);
+    }
+}
+
 // ---------------------------------------------------------------- Properties panel
 
 /// Properties panel for a live gradient. Every change uses the existing gradient commands.
@@ -1253,6 +1276,27 @@ mod tests {
         assert_eq!(layer.blend, BlendMode::Difference);
     }
 
+    #[test]
+    fn changing_live_gradient_opacity_updates_selected_fill_layer() {
+        let mut app = app_with_gradient("linear");
+        drag(&mut app, [20.0, 60.0], [180.0, 60.0]);
+        let past = app.session.active().unwrap().history.past_len();
+        // A scrub is live on every frame and one undo step.
+        for pct in [70.0, 55.0, 40.0] {
+            app.ui.tool_options.fill_opacity = pct;
+            opacity_changed(&mut app, Some(7));
+        }
+        opacity_changed(&mut app, None);
+        let st = app.session.active().unwrap();
+        assert!((st.doc.layers.last().unwrap().opacity - 0.4).abs() < 1e-6);
+        assert_eq!(st.history.past_len(), past + 1, "one undo step, none for an unchanged value");
+        // Classic mode paints pixels: the options bar leaves the layer alone.
+        app.ui.tool_options.gradient_classic = true;
+        app.ui.tool_options.fill_opacity = 80.0;
+        opacity_changed(&mut app, None);
+        assert!((app.session.active().unwrap().doc.layers.last().unwrap().opacity - 0.4).abs() < 1e-6);
+    }
+
     #[test]
     fn preview_shows_the_drag_before_commit() {
         let mut app = app_with_gradient("radial");
@@ -1390,4 +1434,42 @@ mod tests {
         assert!(active_gradient(&app).is_none(), "the canvas widget skips a hidden layer");
         assert!(selected_gradient(&app).is_some(), "the editor still edits it");
     }
+
+    /// #4577: the tessellator snaps the checkerboard's rects to whole pixels but leaves the ramp's
+    /// mesh where it was laid out, so at a half-pixel offset the ramp stopped a pixel short of the
+    /// checker and a row of it showed under the gradient. The ramp must cover the checker exactly.
+    #[test]
+    fn the_ramp_covers_its_checkerboard_at_half_pixel_offsets() {
+        let ctx = egui::Context::default();
+        for ppp in [1.0, 2.0] {
+            ctx.set_pixels_per_point(ppp);
+            let r = Rect::from_min_size(pos2(10.0 + 0.5 / ppp, 7.0 + 0.5 / ppp), vec2(96.0, 20.0));
+            // The new scale applies from the next frame.
+            ctx.run_ui(egui::RawInput::default(), |_| {}).textures_delta.clear();
+            let mut painted_at = 0.0;
+            let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
+                painted_at = ui.ctx().pixels_per_point();
+                paint_ramp(ui.painter(), r, |u| [u, u, u, 1.0]);
+            });
+            out.textures_delta.clear();
+            assert_eq!(painted_at, ppp);
+            let checker = out
+                .shapes
+                .iter()
+                .find_map(|s| match &s.shape {
+                    egui::Shape::Rect(rs) if rs.fill == Color32::from_gray(250) => Some(rs.rect),
+                    _ => None,
+                })
+                .expect("the checkerboard's base rect");
+            let ramp = out
+                .shapes
+                .iter()
+                .find_map(|s| match &s.shape {
+                    egui::Shape::Mesh(m) => Some(m.calc_bounds()),
+                    _ => None,
+                })
+                .expect("the ramp mesh");
+            assert_eq!(ramp, checker.round_to_pixels(ppp), "{ppp}x: the ramp covers every pixel of the checker");
+        }
+    }
 }
diff --git a/crates/ui-egui/src/guide_layout_ui.rs b/crates/ui-egui/src/guide_layout_ui.rs
index d6c5c9fdbe..8d47e628c8 100644
--- a/crates/ui-egui/src/guide_layout_ui.rs
+++ b/crates/ui-egui/src/guide_layout_ui.rs
@@ -31,6 +31,33 @@ pub fn owns(f: &Map<String, Value>) -> bool {
     f.contains_key(MARK)
 }
 
+/// Alt+Cancel (Reset): factory New Guide Layout values, not the last-used remembered layout.
+pub fn reset(app: &PhotocraftApp, f: &mut Map<String, Value>) {
+    if !owns(f) {
+        return;
+    }
+    let Value::Object(defaults) = crate::view_cmds::default_guide_layout() else { return };
+    // Drop layout params and interactive toggles; keep dialog chrome (`__command`, …).
+    f.retain(|k, _| {
+        k.starts_with("__")
+            && !matches!(
+                k.as_str(),
+                "__preset" | "__columnsEnabled" | "__rowsEnabled" | "__marginEnabled" | "__previewGuides" | "__previewParams" | "__previewSource"
+            )
+    });
+    f.extend(defaults);
+    f.insert("color".into(), json!(app.session.prefs().guides_grid_and_slices.guide_color));
+    f.insert("target".into(), json!("document"));
+    f.insert("__preset".into(), json!("custom"));
+    f.insert("width".into(), Value::Null);
+    f.insert("height".into(), Value::Null);
+    let margin = f.get("margin").cloned().unwrap_or(json!(0));
+    if !margin.is_array() {
+        f.insert("margin".into(), json!([margin.clone(), margin.clone(), margin.clone(), margin]));
+    }
+    f.insert("__preview".into(), json!(true));
+}
+
 fn on(f: &Map<String, Value>, key: &str, fallback: bool) -> bool {
     f.get(key).and_then(Value::as_bool).unwrap_or(fallback)
 }
@@ -130,6 +157,10 @@ pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value,
     let color = rgb(color).ok_or("invalid guide color")?;
     let hex = format!("#{:02x}{:02x}{:02x}", color.r(), color.g(), color.b());
     let result = app.run(COMMAND, params(f))?;
+    // The preview is visible even when guides were hidden. Keep a committed layout visible too.
+    app.ui.view.extras = true;
+    app.ui.view.show.canvas_guides = true;
+    app.ui.extras.guides = true;
     app.session.prefs.edit(|prefs| prefs.guides_grid_and_slices.guide_color = hex);
     let mut remembered = f.clone();
     for key in [MARK, "__command", "__label", "__document", "__previewGuides", "__previewParams", "__previewSource"] {
diff --git a/crates/ui-egui/src/guide_layout_ui/tests.rs b/crates/ui-egui/src/guide_layout_ui/tests.rs
index 17abf3e381..299b3fb83e 100644
--- a/crates/ui-egui/src/guide_layout_ui/tests.rs
+++ b/crates/ui-egui/src/guide_layout_ui/tests.rs
@@ -1,5 +1,56 @@
 use super::*;
 
+#[test]
+fn applying_a_previewed_layout_reveals_hidden_guides() {
+    for hidden in ["extras", "canvas", "guides"] {
+        let mut app = app();
+        match hidden {
+            "extras" => app.ui.view.extras = false,
+            "canvas" => app.ui.view.show.canvas_guides = false,
+            _ => app.ui.extras.guides = false,
+        }
+        let id = open(&mut app);
+        let doc = &app.session.active().unwrap().doc;
+        assert!(preview(&app, doc).is_some(), "the dialog shows a preview despite hidden {hidden}");
+        crate::dialogs::confirm(&mut app, id).unwrap();
+        let doc = &app.session.active().unwrap().doc;
+        assert!(!doc.guides.vertical.is_empty(), "the layout was actually created");
+        assert!(preview(&app, doc).is_none(), "the temporary preview is gone");
+        assert!(app.ui.view.shows(app.ui.view.show.canvas_guides) && app.ui.extras.guides, "applied guides must remain visible when {hidden} was hidden");
+    }
+}
+
+#[test]
+fn cancelling_invalid_and_empty_layouts_keep_guides_hidden() {
+    for action in ["cancel", "invalid", "empty"] {
+        let mut app = app();
+        app.ui.view.extras = false;
+        app.ui.view.show.canvas_guides = false;
+        app.ui.extras.guides = false;
+        let id = open(&mut app);
+        match action {
+            "cancel" => {
+                crate::dialogs::cancel(&mut app, id).unwrap();
+            }
+            "invalid" => {
+                app.ui.dialog_mut(id).unwrap().fields.insert("color".into(), json!("invalid"));
+                assert!(crate::dialogs::confirm(&mut app, id).is_err());
+            }
+            _ => {
+                let f = &mut app.ui.dialog_mut(id).unwrap().fields;
+                for key in ["__columnsEnabled", "__rowsEnabled", "__marginEnabled"] {
+                    f.insert(key.into(), json!(false));
+                }
+                f.insert("clearExisting".into(), json!(true));
+                assert!(crate::dialogs::confirm(&mut app, id).is_err(), "an empty layout is rejected");
+            }
+        }
+        let guides = &app.session.active().unwrap().doc.guides;
+        assert!(guides.vertical.is_empty() && guides.horizontal.is_empty(), "{action}");
+        assert!(!app.ui.view.extras && !app.ui.view.show.canvas_guides && !app.ui.extras.guides, "{action} must not change visibility");
+    }
+}
+
 #[test]
 fn tab_includes_optional_sizes_and_shift_tab_selects_their_text() {
     let mut app = app();
@@ -84,6 +135,23 @@ fn app() -> PhotocraftApp {
     PhotocraftApp::new(session, crate::Services::default())
 }
 
+#[test]
+fn alt_reset_restores_factory_layout() {
+    let mut app = app();
+    let id = open(&mut app);
+    let mut fields = app.ui.dialog_mut(id).unwrap().fields.clone();
+    fields.insert("columns".into(), json!(3));
+    fields.insert("gutter".into(), json!(99));
+    fields.insert("__preset".into(), json!("twoColumn"));
+    reset(&app, &mut fields);
+    app.ui.dialog_mut(id).unwrap().fields = fields;
+    let f = &app.ui.dialog_mut(id).unwrap().fields;
+    assert_eq!(f["columns"], json!(8));
+    assert_eq!(f["gutter"], json!(20));
+    assert_eq!(f["__preset"], json!("custom"));
+    assert!(app.ui.dialogs.iter().any(|d| d.id == id));
+}
+
 fn draw(app: &mut PhotocraftApp, id: u64) {
     let mut f = app.ui.dialog_mut(id).unwrap().fields.clone();
     let ctx = egui::Context::default();
diff --git a/crates/ui-egui/src/history_panel_select_tests.rs b/crates/ui-egui/src/history_panel_select_tests.rs
new file mode 100644
index 0000000000..92c458e37f
--- /dev/null
+++ b/crates/ui-egui/src/history_panel_select_tests.rs
@@ -0,0 +1,60 @@
+//! #2966: a click on a History panel state returns the document there with one command
+//! (`history.selectState`), not one Undo / Redo per state, so the canvas refreshes once and only
+//! where the jump changed pixels.
+
+use egui::vec2;
+use egui_kittest::Harness;
+use egui_kittest::kittest::Queryable;
+use serde_json::json;
+
+use super::*;
+
+/// Open, then New Layer, Fill, New Layer, Fill.
+fn harness() -> Harness<'static, PhotocraftApp> {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+    app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
+    for (cmd, p) in
+        [("layer.new.layer", json!({})), ("edit.fill", json!({"color": "#ff0000"})), ("layer.new.layer", json!({})), ("edit.fill", json!({"color": "#00ff00"}))]
+    {
+        app.run(cmd, p).unwrap();
+    }
+    let mut ready = false;
+    let mut h = Harness::builder().with_size(vec2(300.0, 400.0)).build_ui_state(
+        move |ui, app: &mut PhotocraftApp| {
+            if !ready {
+                PhotocraftApp::setup_context(ui.ctx(), theme::ThemeKind::ProMedium);
+                ready = true;
+                return;
+            }
+            history(app, ui);
+        },
+        app,
+    );
+    h.run_steps(3);
+    h
+}
+
+fn state(h: &Harness<'_, PhotocraftApp>) -> (usize, usize, u64) {
+    let st = h.state().session.active().unwrap();
+    (st.history.past_len(), st.history.redo_labels().count(), st.revision)
+}
+
+#[test]
+fn clicking_a_state_jumps_there_with_one_command() {
+    let mut h = harness();
+    let (past, redo, rev) = state(&h);
+    assert_eq!((past, redo), (4, 0));
+    // Back three states: one command, one revision (the canvas sees one change).
+    h.get_all_by_label("New Layer").next().expect("the first New Layer row").click();
+    h.run_steps(2);
+    assert_eq!(state(&h), (1, 3, rev + 1));
+    assert_eq!(h.state().perf.last_command, "history.selectState");
+    // Forward to the last (dimmed) state, again in one step.
+    h.get_all_by_label("Fill").last().expect("the last Fill row").click();
+    h.run_steps(2);
+    assert_eq!(state(&h), (4, 0, rev + 2));
+    // The current state: nothing to do.
+    h.get_all_by_label("Fill").last().expect("the last Fill row").click();
+    h.run_steps(2);
+    assert_eq!(state(&h), (4, 0, rev + 2));
+}
diff --git a/crates/ui-egui/src/hold_keys.rs b/crates/ui-egui/src/hold_keys.rs
index c182247bfd..3f2845cae8 100644
--- a/crates/ui-egui/src/hold_keys.rs
+++ b/crates/ui-egui/src/hold_keys.rs
@@ -147,9 +147,10 @@ fn held(i: &InputState, sc: &KeyboardShortcut) -> bool {
 }
 
 /// The temporary tool whose key is held now, the most specific binding first (⌘Space before
-/// Space). Never while a text field has the keyboard.
+/// Space). Never while a text field has the keyboard, or while editing type on the canvas
+/// (Space must insert a space, not grab the Hand tool).
 pub fn held_tool(app: &PhotocraftApp, ctx: &egui::Context) -> Option<Temporary> {
-    if ctx.text_edit_focused() {
+    if ctx.text_edit_focused() || app.ui.text_edit.is_some() {
         return None;
     }
     let count = |sc: &KeyboardShortcut| {
@@ -194,7 +195,7 @@ pub fn erase_held(app: &PhotocraftApp, ctx: &egui::Context) -> bool {
 
 /// Is the reposition key (the Hand key, any modifiers) down?
 pub fn reposition_held(app: &PhotocraftApp, ctx: &egui::Context) -> bool {
-    !ctx.text_edit_focused() && binding(app, Temporary::Hand).is_some_and(|sc| ctx.input(|i| i.key_down(sc.logical_key)))
+    !ctx.text_edit_focused() && app.ui.text_edit.is_none() && binding(app, Temporary::Hand).is_some_and(|sc| ctx.input(|i| i.key_down(sc.logical_key)))
 }
 
 /// Tools whose in-progress drag the reposition key moves.
diff --git a/crates/ui-egui/src/hold_keys/tests.rs b/crates/ui-egui/src/hold_keys/tests.rs
index 45e806c64d..cfe89d4642 100644
--- a/crates/ui-egui/src/hold_keys/tests.rs
+++ b/crates/ui-egui/src/hold_keys/tests.rs
@@ -72,9 +72,15 @@ fn key(h: &mut Harness<'static, PhotocraftApp>, k: Key, pressed: bool, m: Modifi
     h.run_steps(1);
 }
 
+/// A quick press and release in one frame (a tool letter held across frames springs, #2672).
 fn tap(h: &mut Harness<'static, PhotocraftApp>, k: Key, m: Modifiers) {
-    key(h, k, true, m);
-    key(h, k, false, m);
+    let m = platform(m);
+    h.input_mut().events.extend([
+        Event::ModifiersChanged(m),
+        Event::Key { key: k, physical_key: None, pressed: true, repeat: false, modifiers: m },
+        Event::Key { key: k, physical_key: None, pressed: false, repeat: false, modifiers: m },
+    ]);
+    h.run_steps(1);
     h.event(Event::ModifiersChanged(Modifiers::NONE));
     h.run_steps(1);
 }
@@ -174,6 +180,28 @@ fn space_is_a_temporary_hand_and_gives_the_tool_back() {
     assert!(!st.session.active().unwrap().history.can_undo(), "nothing was painted");
 }
 
+#[test]
+fn space_while_editing_type_is_not_the_hand_tool() {
+    let mut h = harness(Tool::Type);
+    let id = h.state_mut().run("type.create", json!({"text": "ئا", "size": 20, "x": 100, "y": 100})).unwrap()["layer"].as_u64().unwrap();
+    h.state_mut().ui.text_edit = Some(crate::state::TextEdit {
+        layer: id,
+        caret: 2,
+        anchor: 2,
+        session: "t".into(),
+        created: false,
+        mask: false,
+        dragging: false,
+        resize: None,
+        preedit: None,
+    });
+    key(&mut h, Key::Space, true, Modifiers::NONE);
+    assert!(h.state().ui.text_edit.is_some(), "type session stays open");
+    assert_eq!(held_tool(h.state(), &h.ctx), None, "Space types a space while editing");
+    assert!(!reposition_held(h.state(), &h.ctx));
+    key(&mut h, Key::Space, false, Modifiers::NONE);
+}
+
 #[test]
 fn temporary_zoom_in_and_out_restore_the_tool() {
     let mut h = harness(Tool::RectMarquee);
diff --git a/crates/ui-egui/src/i18n/LICENSE-translations.txt b/crates/ui-egui/src/i18n/LICENSE-translations.txt
index bf2f8caaae..c33e7a21e9 100644
--- a/crates/ui-egui/src/i18n/LICENSE-translations.txt
+++ b/crates/ui-egui/src/i18n/LICENSE-translations.txt
@@ -1,6 +1,6 @@
-PhotoCraft's Korean, German, Brazilian Portuguese, Italian, Ukrainian, Dutch and Czech UI translation catalogs are
-licensed under MIT OR Apache-2.0, at your option. The full license texts are in ../../../../LICENSE-MIT
-and ../../../../LICENSE-APACHE.
+PhotoCraft's Korean, German, Brazilian Portuguese, Italian, Ukrainian, Dutch, Czech, Turkish,
+Hungarian and Serbian UI translation catalogs are licensed under MIT OR Apache-2.0, at your option.
+The full license texts are in ../../../../LICENSE-MIT and ../../../../LICENSE-APACHE.
 
 Korean translations: PhotoCraft contributors, original translations of
 PhotoCraft's English labels; no proprietary translation resources were used.
@@ -22,3 +22,12 @@ PhotoCraft's English labels; no proprietary translation resources were used.
 
 Czech translations: PhotoCraft contributors, original translations of
 PhotoCraft's English labels; no proprietary translation resources were used.
+
+Turkish translations: PhotoCraft contributors, original translations of
+PhotoCraft's English labels; no proprietary translation resources were used.
+
+Hungarian translations: PhotoCraft contributors, original translations of
+PhotoCraft's English labels; no proprietary translation resources were used.
+
+Serbian translations: PhotoCraft contributors, original translations of
+PhotoCraft's English labels; no proprietary translation resources were used.
diff --git a/crates/ui-egui/src/i18n/cs.tsv b/crates/ui-egui/src/i18n/cs.tsv
index bb7f34d11d..805c20f76a 100644
--- a/crates/ui-egui/src/i18n/cs.tsv
+++ b/crates/ui-egui/src/i18n/cs.tsv
@@ -19,7 +19,17 @@
 # (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...) stay in Latin letters; the trailing "…" of
 # dialog commands is kept.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Barva kanálu
+	Color Indicates:	Barva označuje:
+	Solidity:	Plnost:
+	Ink Characteristics	Vlastnosti inkoustu
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Šířka papíru
+	Paper Height	Výška papíru
 	Columns	Sloupce
 	Rows	Řádky
 	Number	Počet
@@ -77,6 +87,8 @@
 	Save	Uložit
 	Save As…	Uložit jako…
 	Save a Copy…	Uložit kopii…
+	{name} can't keep everything in this document	{name} nedokáže uchovat vše z tohoto dokumentu
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Zvolte formát, který vše zachová, například Photoshop (PSD), nebo uložte kopii.
 	Revert	Vrátit k uložené verzi
 	Export	Export
 	Quick Export as PNG	Rychlý export do PNG
@@ -114,6 +126,13 @@
 	Script Events Manager…	Správce událostí skriptů…
 	Import	Import
 	Browse…	Procházet…
+	Source Files	Zdrojové soubory
+	Use:	Použít:
+	Files	Soubory
+	Add Open Files	Přidat otevřené soubory
+	Sort By Name	Seřadit podle názvu
+	Attempt to Automatically Align Source Images	Pokusit se automaticky zarovnat zdrojové obrazy
+	Create Smart Object after Loading Layers	Po načtení vrstev vytvořit chytrý objekt
 	Reveal in Finder	Zobrazit ve Finderu
 	Show in Explorer	Zobrazit v Průzkumníkovi
 	Show in Folder	Zobrazit ve složce
@@ -138,6 +157,8 @@
 	Search…	Hledat…
 	Check Spelling…	Kontrola pravopisu…
 	Find and Replace Text…	Najít a nahradit text…
+	Add to Dictionary	Přidat do slovníku
+	No Spelling Suggestions	Žádné návrhy pravopisu
 	Fill…	Vyplnit…
 	Stroke…	Tah…
 	Content-Aware Fill…	Výplň s ohledem na obsah…
@@ -152,6 +173,8 @@
 	Transform Again on a Copy	Duplikovat a opakovat transformaci
 	Scale	Měřítko
 	Rotate	Otočit
+	Set horizontal skew	Nastavit vodorovné zkosení
+	Set vertical skew	Nastavit svislé zkosení
 	Skew	Zkosit
 	Distort	Zkreslit
 	Perspective	Perspektiva
@@ -364,6 +387,7 @@
 	Update Modified Content	Aktualizovat změněný obsah
 	Update All Modified Content	Aktualizovat veškerý změněný obsah
 	Stack Mode	Režim zásobníku
+	Choose Stack Mode:	Vyberte režim zásobníku:
 	Entropy	Entropie
 	Kurtosis	Špičatost
 	Maximum	Maximum
@@ -398,6 +422,7 @@
 	Select Linked Layers	Vybrat propojené vrstvy
 	Merge Layers	Sloučit vrstvy
 	Merge Down	Sloučit dolů
+	Merge Group	Sloučit skupinu
 	Merge Visible	Sloučit viditelné
 	Stamp Visible	Otisknout viditelné
 	Select Layer Above	Vybrat vrstvu nad
@@ -534,6 +559,9 @@
 	Blur	Rozostření
 	Blur Gallery	Galerie rozostření
 	Field Blur…	Rozostření pole…
+# Field Blur pins (#3373)
+	No pin selected	Není vybrán žádný špendlík
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Kliknutím do obrazu přidáte špendlík; tažením špendlík přesunete, tažením jeho prstence změníte rozostření. Delete odstraní vybraný špendlík.
 	Iris Blur…	Rozostření clonou…
 	Tilt-Shift…	Tilt-shift…
 	Path Blur…	Rozostření podél cesty…
@@ -732,6 +760,10 @@
 	Breeze Dark Theme	Tmavý motiv Breeze
 	Breeze light	Breeze světlý
 	Breeze Light Theme	Světlý motiv Breeze
+	Soft dark	Jemný tmavý
+	Soft light	Jemný světlý
+	Soft Dark Theme	Jemné tmavé téma
+	Soft Light Theme	Jemné světlé téma
 	Next Theme	Další motiv
 	Actions	Akce
 	Brush Settings	Nastavení štětce
@@ -839,6 +871,9 @@
 	Appearance	Vzhled
 	Appearance (Layer Style)	Vzhled (styl vrstvy)
 	Apply Layer Mask	Použít masku vrstvy
+	Add Mask to Selection	Přidat masku do výběru
+	Subtract Mask from Selection	Odečíst masku od výběru
+	Intersect Mask with Selection	Průnik masky s výběrem
 	Apply Per Tip	Použít pro každý hrot
 	Apply next selected layer comp	Použít další vybranou kompozici vrstev
 	Apply previous selected layer comp	Použít předchozí vybranou kompozici vrstev
@@ -854,11 +889,18 @@
 	Background	Pozadí
 	Background Color	Barva pozadí
 	Background Contents	Obsah pozadí
+	Custom background color	Vlastní barva pozadí
 	Balance	Vyvážení
 	Baseline	Účaří
 	Baseline shift	Posun účaří
 	Basic	Základní
 	Before (Y)	Před (Y)
+	Save Settings…	Uložit nastavení…
+	Load Settings…	Načíst nastavení…
+	Save these settings as a Camera Raw .xmp file	Uložit toto nastavení jako soubor Camera Raw .xmp
+	Load settings from a Camera Raw .xmp file	Načíst nastavení ze souboru Camera Raw .xmp
+	Loaded Camera Raw settings from {file}	Nastavení Camera Raw načteno ze souboru {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Nastavení Camera Raw načteno ze souboru {file} (nepodporováno: {n})
 	Begin recording	Zahájit záznam
 	Bend:	Ohyb:
 	Bicubic	Bikubická
@@ -889,6 +931,7 @@
 	Camera Raw isn't open	Camera Raw není otevřen
 	Cancel	Zrušit
 	Cancel (Esc)	Zrušit (Esc)
+	Manage submitted jobs in the system print queue	Spravovat odeslané úlohy v systémové tiskové frontě
 	Cancel any current edits (Esc)	Zrušit aktuální úpravy (Esc)
 	Cancel current crop operation  (Esc)	Zrušit aktuální oříznutí  (Esc)
 	Cancel transform (Esc)	Zrušit transformaci (Esc)
@@ -1160,6 +1203,9 @@
 	Ignore All	Ignorovat vše
 	Image Size	Velikost obrazu
 	Import Brushes…	Importovat štětce…
+	Gradient Preset Options	Možnosti předvoleb přechodu
+	Import .GRD	Importovat .GRD
+	Choose a gradient file (.grd).	Vyberte soubor přechodů (.grd).
 	Import brushes (.abr)	Importovat štětce (.abr)
 	Import Presets	Importovat přednastavení
 	Imported	Importováno
@@ -2100,6 +2146,11 @@
 	Rename Brush…	Přejmenovat štětec…
 	Delete Brush	Odstranit štětec
 	New Brush Preset…	Nová předvolba štětce…
+	Capture Brush Size in Preset	Zachytit velikost štětce v předvolbě
+	Include Tool Settings	Zahrnout nastavení nástroje
+	Include Color	Zahrnout barvu
+	Enter a name for the brush preset	Zadejte název předvolby štětce
+	A brush preset with this name already exists	Předvolba štětce s tímto názvem již existuje
 	Brush Preset Options	Možnosti přednastavení štětců
 	Group name	Název skupiny
 	Brush name	Název štětce
@@ -2161,6 +2212,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Není k dispozici žádná cesta, ze které by šlo vytvořit výběr: nakreslete ji nástrojem Pero nebo ji vyberte na panelu Cesty.
 	Cancel opening	Zrušit otevírání
 	Cancelled opening {name}	Otevírání {name} zrušeno
+	The document “{name}” does not have an embedded {mode} profile.	Dokument „{name}“ nemá vložený profil {mode}.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Dokument „{name}“ má vložený barevný profil, který neodpovídá aktuálnímu pracovnímu prostoru barev {mode}.
+	Embedded: {embedded}	Vložený: {embedded}
+	Working: {working}	Pracovní: {working}
 	Developing {name}	Vyvolávání {name}
 	Cancelled {label}	Zrušeno: {label}
 	Esc to cancel	Esc pro zrušení
@@ -2321,6 +2376,7 @@ cameraRaw	Color	Barvy
 	Click to pick · Esc to cancel	Kliknutí vybere · Esc zruší
 	Pick a screen pixel or press Esc to cancel	Vyberte pixel obrazovky nebo stiskněte Esc pro zrušení
 	Scroll to zoom	Rolováním přibližujte
+	Drag to pan · Scroll to zoom · Double-click to fit	Tažením posouvejte · Rolováním přibližujte · Dvojklikem přizpůsobte
 	Show/Hide All Panels	Zobrazit/skrýt všechny panely
 	Show/Hide Panels	Zobrazit/skrýt panely
 	Could not open	Nelze otevřít
@@ -2379,6 +2435,7 @@ cameraRaw	Color	Barvy
 	Violet	Fialová
 	Reset	Obnovit
 	Large document: redrawing on the CPU	Velký dokument: překreslování na CPU
+	Redrawing	Překreslování
 	This redraw took {seconds} s on the CPU.	Toto překreslení na CPU trvalo {seconds} s.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Úpravy, které mění celý dokument, například režim prolnutí, krytí nebo viditelnost vrstvy, jej překreslí celý.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Vrstvy se nevejdou do rozpočtu paměti GPU. Zvýšením hodnoty Využití paměti v Předvolbách › Výkon se rozpočet zvětší, nejvýše na čtvrtinu paměti tohoto počítače.
@@ -2665,7 +2722,6 @@ cameraData	Lens	Objektiv
 	Brush Type	Typ štětce
 	Bulge	Vyboulení
 	Burlap	Pytlovina
-	Burn	Ztmavení
 	Calculations	Výpočty
 	Camera Calibration	Kalibrace fotoaparátu
 	Camera Raw	Camera Raw
@@ -2695,7 +2751,6 @@ cameraData	Lens	Objektiv
 	Clear Selection	Zrušit výběr
 	Clipping Path	Ořezová cesta
 	Clone	Klonovat
-	Clone Stamp	Klonovací razítko
 	Close Window	Zavřít okno
 	Clumped	Shlukované
 	Coarse Dots	Hrubé tečky
@@ -2792,7 +2847,6 @@ cameraData	Lens	Objektiv
 	Distribution	Rozložení
 	Documentation	Dokumentace
 	Documents	Dokumenty
-	Dodge	Zesvětlení
 	Dot	Tečka
 	Double Line	Dvojitá čára
 	Draft	Koncept
@@ -2933,7 +2987,6 @@ cameraData	Lens	Objektiv
 	Highlight Radius	Poloměr světel
 	Highlight Strength	Síla odlesku
 	Highlight Tone	Tón světel
-	History Brush	Štětec historie
 	Horizontal Only	Pouze vodorovně
 	Hotspot	Jádro světla
 	Hsb	HSB
@@ -3278,7 +3331,6 @@ cameraData	Lens	Objektiv
 	Spherize	Sférická deformace
 	Spin	Rotace
 	Spin Blur	Rotační rozostření
-	Sponge	Houba
 	Spot	Reflektor
 	Spot Color	Přímá barva
 	Spot Healing	Bodové retušování
@@ -3336,7 +3388,6 @@ cameraData	Lens	Objektiv
 	Tiny Lens	Drobné čočky
 	To Center	Ke středu
 	Tone Curve	Tónová křivka
-	Tool	Nástroj
 	Tool Options	Možnosti nástroje
 	Toolbars	Panely nástrojů
 	Torn Edges	Roztřepené okraje
@@ -3467,6 +3518,7 @@ curves	Smooth	Vyhladit
 	Paint over hair or fur on the image; Alt paints the other mode	Malujte přes vlasy nebo srst v obraze; Alt maluje v opačném režimu
 	Clear Brush Strokes	Vymazat tahy štětce
 	Show rulers	Zobrazit pravítka
+	Presentation	Prezentace
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Kliknutím umístíte · Alt-kliknutím nebo přetažením mimo plátno odeberete
@@ -3622,13 +3674,12 @@ curves	Smooth	Vyhladit
 	fallback	náhradní
 
 # Composed labels and Navigator zoom context
-	The document does not have an embedded colour profile. Working space: {working}.	Dokument nemá vložený barevný profil. Pracovní prostor barev: {working}.
-	The document has an embedded colour profile that does not match the working space.\nEmbedded: {embedded}\nWorking: {working}	Dokument má vložený barevný profil, který neodpovídá pracovnímu prostoru barev.\nVložený: {embedded}\nPracovní: {working}
 	Importing {what} from {file}…	Importují se {what} ze souboru {file}…
 	brushes	štětce
 	gradients	přechody
 @plural	Imported {n} brush from {file}|Imported {n} brushes from {file}	Importován {n} štětec ze souboru {file}|Importovány {n} štětce ze souboru {file}|Importováno {n} štětců ze souboru {file}
 @plural	Imported {n} gradient from {file}|Imported {n} gradients from {file}	Importován {n} přechod ze souboru {file}|Importovány {n} přechody ze souboru {file}|Importováno {n} přechodů ze souboru {file}
+@plural	Imported {n} pattern from {file}|Imported {n} patterns from {file}	Importován {n} vzorek ze souboru {file}|Importovány {n} vzorky ze souboru {file}|Importováno {n} vzorků ze souboru {file}
 	Data Set: {name}  ({index}/{total})	Datová sada: {name}  ({index}/{total})
 	(none)	(žádná)
 navigator	Zoom	Zvětšení
@@ -3661,3 +3712,36 @@ navigator	Zoom	Zvětšení
 	Light Blue	Světle modrá
 	Light Red	Světle červená
 	Medium Blue	Středně modrá
+	Object Finder	Hledání objektů
+	No object found there — drag a rectangle around it	Nebyl tam nalezen žádný objekt — přetáhněte kolem něj obdélník
+	Remove after each stroke	Odstranit po každém tahu
+	Apply the removal ({key})	Použít odstranění ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Tahy k odstranění: {n} (Enter použije, Esc zruší)
+	Clear Brush Controls	Obnovit ovládací prvky stopy
+	Reset All Locked Settings	Obnovit všechna zamknutá nastavení
+	Copy Texture to Other Tools	Kopírovat texturu do jiných nástrojů
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Načíst akce…
+	Save Actions…	Uložit akce…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Načtena {n} akce ze souboru {file}|Načteny {n} akce ze souboru {file}|Načteno {n} akcí ze souboru {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} krok zatím nemá v PhotoCraftu obdobu|{n} kroky zatím nemají v PhotoCraftu obdobu|{n} kroků zatím nemá v PhotoCraftu obdobu
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Uložena {n} akce do souboru {file}|Uloženy {n} akce do souboru {file}|Uloženo {n} akcí do souboru {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Vynechán {n} krok bez obdoby v Photoshopu|Vynechány {n} kroky bez obdoby v Photoshopu|Vynecháno {n} kroků bez obdoby v Photoshopu
+
+	File Naming	Pojmenování souborů
+	Starting serial	Počáteční pořadové číslo
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Vložit zastavení…
+	Save Set…	Uložit sadu…
+	Message:	Zpráva:
+	Allow Continue	Povolit pokračování
+	Show dialog during playback	Zobrazit dialog při přehrávání
+	Select an action first	Nejprve vyberte akci
+	Action playback stopped	Přehrávání akce zastaveno
+	Step {step} is waiting for its dialog	Krok {step} čeká na svůj dialog
+@plural	{n} action|{n} actions	{n} akce|{n} akce|{n} akcí
+	Auto Add/Delete	Automaticky přidat/odstranit
+	ICO is limited to 256 × 256 pixels	ICO je omezen na 256 × 256 pixelů
diff --git a/crates/ui-egui/src/i18n/de.tsv b/crates/ui-egui/src/i18n/de.tsv
index 6836a381dc..88ef957675 100644
--- a/crates/ui-egui/src/i18n/de.tsv
+++ b/crates/ui-egui/src/i18n/de.tsv
@@ -15,7 +15,19 @@
 # way. Product and technology names (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...) stay in Latin
 # letters; the trailing "…" of dialog commands is kept. Plural rule: one|other (n != 1 -> other).
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Kanalfarbe
+	Color Indicates:	Farbe kennzeichnet:
+	Solidity:	Solidität:
+	Masked Areas	Maskierte Bereiche
+	Selected Areas	Ausgewählte Bereiche
+	Ink Characteristics	Farbeigenschaften
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Papierbreite
+	Paper Height	Papierhöhe
 	Columns	Spalten
 	Rows	Zeilen
 	Number	Anzahl
@@ -73,6 +85,8 @@
 	Save	Speichern
 	Save As…	Speichern unter…
 	Save a Copy…	Kopie speichern…
+	{name} can't keep everything in this document	{name} kann nicht alles in diesem Dokument erhalten
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Wählen Sie ein Format, das alles erhält, etwa Photoshop (PSD), oder speichern Sie eine Kopie.
 	Revert	Zurücksetzen
 	Export	Exportieren
 	Quick Export as PNG	Schnellexport als PNG
@@ -110,6 +124,14 @@
 	Script Events Manager…	Skriptereignis-Manager…
 	Import	Importieren
 	Browse…	Durchsuchen…
+	Source Files	Quelldateien
+	Use:	Verwenden:
+	Files	Dateien
+	Folder	Ordner
+	Add Open Files	Geöffnete Dateien hinzufügen
+	Sort By Name	Nach Namen sortieren
+	Attempt to Automatically Align Source Images	Quellbilder nach Möglichkeit automatisch ausrichten
+	Create Smart Object after Loading Layers	Nach dem Laden der Ebenen Smart-Objekt erstellen
 	Reveal in Finder	Im Finder anzeigen
 	Show in Explorer	Im Explorer anzeigen
 	Show in Folder	Im Ordner anzeigen
@@ -134,6 +156,8 @@
 	Search…	Suchen…
 	Check Spelling…	Rechtschreibung prüfen…
 	Find and Replace Text…	Text suchen und ersetzen…
+	Add to Dictionary	Zum Wörterbuch hinzufügen
+	No Spelling Suggestions	Keine Rechtschreibvorschläge
 	Fill…	Füllen…
 	Stroke…	Nachziehen…
 	Content-Aware Fill…	Inhaltsbasiert füllen…
@@ -148,6 +172,8 @@
 	Transform Again on a Copy	Erneut auf Kopie transformieren
 	Scale	Skalieren
 	Rotate	Drehen
+	Set horizontal skew	Horizontale Neigung festlegen
+	Set vertical skew	Vertikale Neigung festlegen
 	Skew	Neigen
 	Distort	Verzerren
 	Perspective	Perspektive
@@ -360,6 +386,7 @@
 	Update Modified Content	Geänderten Inhalt aktualisieren
 	Update All Modified Content	Alle geänderten Inhalte aktualisieren
 	Stack Mode	Stapelmodus
+	Choose Stack Mode:	Stapelmodus auswählen:
 	Entropy	Entropie
 	Kurtosis	Kurtosis
 	Maximum	Maximum
@@ -394,6 +421,7 @@
 	Select Linked Layers	Verknüpfte Ebenen auswählen
 	Merge Layers	Ebenen zusammenfügen
 	Merge Down	Nach unten zusammenfügen
+	Merge Group	Gruppe zusammenfügen
 	Merge Visible	Sichtbare zusammenfügen
 	Stamp Visible	Sichtbare Ebenen stempeln
 	Select Layer Above	Ebene darüber auswählen
@@ -530,6 +558,9 @@
 	Blur	Weichzeichnen
 	Blur Gallery	Weichzeichnen-Galerie
 	Field Blur…	Feldweichzeichner…
+# Field Blur pins (#3373)
+	No pin selected	Kein Pin ausgewählt
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Klicken Sie ins Bild, um einen Pin hinzuzufügen; ziehen Sie einen Pin, um ihn zu verschieben, oder seinen Ring, um die Unschärfe zu ändern. Entf entfernt den ausgewählten Pin.
 	Iris Blur…	Irisweichzeichner…
 	Tilt-Shift…	Tilt-Shift…
 	Path Blur…	Pfadweichzeichner…
@@ -718,6 +749,10 @@
 	Breeze Dark Theme	Breeze-Design (Dunkel)
 	Breeze light	Breeze hell
 	Breeze Light Theme	Breeze-Design (Hell)
+	Soft dark	Weich dunkel
+	Soft light	Weich hell
+	Soft Dark Theme	Weiches Design (Dunkel)
+	Soft Light Theme	Weiches Design (Hell)
 	Next Theme	Nächstes Design
 	Actions	Aktionen
 	Brush Settings	Pinseleinstellungen
@@ -816,6 +851,9 @@
 	Appearance	Erscheinungsbild
 	Appearance (Layer Style)	Erscheinungsbild (Ebenenstil)
 	Apply Layer Mask	Ebenenmaske anwenden
+	Add Mask to Selection	Maske zur Auswahl hinzufügen
+	Subtract Mask from Selection	Maske von Auswahl subtrahieren
+	Intersect Mask with Selection	Schnittmenge von Maske und Auswahl
 	Apply Per Tip	Pro Pinselspitze anwenden
 	Apply next selected layer comp	Nächste ausgewählte Ebenenkomposition anwenden
 	Apply previous selected layer comp	Vorherige ausgewählte Ebenenkomposition anwenden
@@ -831,11 +869,18 @@
 	Background	Hintergrund
 	Background Color	Hintergrundfarbe
 	Background Contents	Hintergrundinhalte
+	Custom background color	Benutzerdefinierte Hintergrundfarbe
 	Balance	Balance
 	Baseline	Grundlinie
 	Baseline shift	Grundlinienverschiebung
 	Basic	Grundeinstellungen
 	Before (Y)	Davor (Y)
+	Save Settings…	Einstellungen speichern…
+	Load Settings…	Einstellungen laden…
+	Save these settings as a Camera Raw .xmp file	Diese Einstellungen als Camera-Raw-.xmp-Datei speichern
+	Load settings from a Camera Raw .xmp file	Einstellungen aus einer Camera-Raw-.xmp-Datei laden
+	Loaded Camera Raw settings from {file}	Camera-Raw-Einstellungen aus {file} geladen
+	Loaded Camera Raw settings from {file} ({n} not supported)	Camera-Raw-Einstellungen aus {file} geladen ({n} nicht unterstützt)
 	Begin recording	Aufnahme starten
 	Bend:	Biegung:
 	Bicubic	Bikubisch
@@ -867,6 +912,7 @@
 	Cancel	Abbrechen
 	Reset	Zurücksetzen
 	Cancel (Esc)	Abbrechen (Esc)
+	Manage submitted jobs in the system print queue	Übermittelte Aufträge in der Druckwarteschlange des Systems verwalten
 	Cancel any current edits (Esc)	Aktuelle Bearbeitungen abbrechen (Esc)
 	Cancel current crop operation  (Esc)	Aktuelle Freistellung abbrechen  (Esc)
 	Cancel transform (Esc)	Transformation abbrechen (Esc)
@@ -1140,6 +1186,9 @@
 	Ignore All	Alle ignorieren
 	Image Size	Bildgröße
 	Import Brushes…	Pinsel importieren…
+	Gradient Preset Options	Verlaufsvorgabenoptionen
+	Import .GRD	.GRD importieren
+	Choose a gradient file (.grd).	Wählen Sie eine Verlaufsdatei (.grd).
 	Import brushes (.abr)	Pinsel (.abr) importieren
 	Import Presets	Vorgaben importieren
 	Imported	Importiert
@@ -1662,7 +1711,7 @@
 	Layer Knocks Out Drop Shadow	Ebene stanzt den Schlagschatten aus
 	Legal	Legal
 	Letter	Letter
-	Light	Light
+	Light	Hell
 	Line Tool	Linien-Werkzeug
 	Linear	Linear
 	Linear Burn	Linear nachbelichten
@@ -2067,6 +2116,11 @@
 	Rename Brush…	Pinsel umbenennen…
 	Delete Brush	Pinsel löschen
 	New Brush Preset…	Neue Pinselvorgabe…
+	Capture Brush Size in Preset	Pinselgröße in Vorgabe erfassen
+	Include Tool Settings	Werkzeugeinstellungen einschließen
+	Include Color	Farbe einschließen
+	Enter a name for the brush preset	Geben Sie einen Namen für die Pinselvorgabe ein
+	A brush preset with this name already exists	Eine Pinselvorgabe mit diesem Namen ist bereits vorhanden
 	Brush Preset Options	Pinselvorgaben-Optionen
 	Group name	Gruppenname
 	Brush name	Pinselname
@@ -2128,6 +2182,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Kein Pfad für eine Auswahl vorhanden: zeichne einen mit dem Stift-Werkzeug oder wähle einen im Pfade-Bedienfeld.
 	Cancel opening	Öffnen abbrechen
 	Cancelled opening {name}	Öffnen von {name} abgebrochen
+	The document “{name}” does not have an embedded {mode} profile.	Das Dokument „{name}“ hat kein eingebettetes {mode}-Profil.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Das Dokument „{name}“ hat ein eingebettetes Farbprofil, das nicht zum aktuellen {mode}-Arbeitsfarbraum passt.
+	Embedded: {embedded}	Eingebettet: {embedded}
+	Working: {working}	Arbeitsfarbraum: {working}
 	Developing {name}	{name} wird entwickelt
 	Cancelled {label}	{label} abgebrochen
 	Esc to cancel	Esc zum Abbrechen
@@ -2358,6 +2416,7 @@
 	Click to pick · Esc to cancel	Klicken zum Auswählen · Esc zum Abbrechen
 	Pick a screen pixel or press Esc to cancel	Ein Bildschirmpixel auswählen oder mit Esc abbrechen
 	Scroll to zoom	Zum Zoomen scrollen
+	Drag to pan · Scroll to zoom · Double-click to fit	Ziehen zum Verschieben · Scrollen zum Zoomen · Doppelklick zum Einpassen
 	Show/Hide All Panels	Alle Bedienfelder ein-/ausblenden
 	Show/Hide Panels	Bedienfelder ein-/ausblenden
 	Could not open	Öffnen nicht möglich
@@ -2415,6 +2474,7 @@ layerLabel	No Color	Keine Farbe
 	Fuchsia	Fuchsia
 	Violet	Violett
 	Large document: redrawing on the CPU	Großes Dokument: Neuzeichnen auf der CPU
+	Redrawing	Neuzeichnen
 	This redraw took {seconds} s on the CPU.	Dieses Neuzeichnen auf der CPU dauerte {seconds} s.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Änderungen, die das ganze Dokument betreffen, etwa Füllmethode, Deckkraft oder Sichtbarkeit einer Ebene, zeichnen es vollständig neu.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Die Ebenen passen nicht in das GPU-Speicherbudget. Eine höhere Speichernutzung unter Voreinstellungen › Leistung erhöht das Budget, bis zu einem Viertel des Arbeitsspeichers dieses Computers.
@@ -2650,6 +2710,7 @@ curves	Smooth	Glätten
 	Paint over hair or fur on the image; Alt paints the other mode	Über Haare oder Fell im Bild malen; Alt malt im anderen Modus
 	Clear Brush Strokes	Pinselstriche löschen
 	Show rulers	Lineale anzeigen
+	Presentation	Präsentation
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Klicken zum Platzieren · Alt-Klick oder Ziehen außerhalb der Arbeitsfläche zum Entfernen
@@ -2687,3 +2748,390 @@ curves	Smooth	Glätten
 	Light Red	Hellrot
 	Medium Blue	Mittelblau
 	Light Gray	Hellgrau
+# Status messages, system info and tool names
+	Join the ArtCraft Discord ({url})	Dem ArtCraft-Discord beitreten ({url})
+	Nothing to paste: the clipboard holds no image	Nichts einzufügen: Die Zwischenablage enthält kein Bild
+	Graphics adapter: {adapter}	Grafikadapter: {adapter}
+	Backend: {backend} ({type})	Backend: {backend} ({type})
+	Driver: {driver}	Treiber: {driver}
+	GPU backend preference: {backend}	Bevorzugtes GPU-Backend: {backend}
+	Selected at launch: {backend}	Beim Start gewählt: {backend}
+	Image compositor: {processor}	Bildkompositor: {processor}
+	Window renderer: {renderer}	Fensterdarstellung: {renderer}
+	Graphics adapter	Grafikadapter
+	Platform: {os} {arch}	Plattform: {os} {arch}
+	Monitor profile: {profile}	Monitorprofil: {profile}
+	Opened {url}	{url} geöffnet
+	{index} of {total}	{index} von {total}
+	Export As: {name}	Exportieren als: {name}
+	Color Sampler Tool	Farbaufnahme-Werkzeug
+	Vertical Type Tool	Vertikales Text-Werkzeug
+	Patch Tool	Ausbessern-Werkzeug
+	Grid view	Rasteransicht
+	List view	Listenansicht
+	Proof Setup…	Proof einrichten…
+	32-bit Preview Options	32-Bit-Vorschauoptionen
+# Shortcut editor commands without a menu item
+	Toggle Layer Mask Overlay	Ebenenmasken-Überlagerung umschalten
+	Increase Type Size	Schriftgröße erhöhen
+	Decrease Type Size	Schriftgröße verringern
+	Increase Type Size by 10	Schriftgröße um 10 erhöhen
+	Decrease Type Size by 10	Schriftgröße um 10 verringern
+	Make Selection from Path	Auswahl aus Pfad erstellen
+	Target Composite Channel	Gesamtkanal als Ziel festlegen
+	Target Channel 3	Kanal 3 als Ziel festlegen
+	Target Channel 4	Kanal 4 als Ziel festlegen
+	Target Channel 5	Kanal 5 als Ziel festlegen
+	Target Channel 6	Kanal 6 als Ziel festlegen
+	Target Channel 7	Kanal 7 als Ziel festlegen
+	Target Channel 8	Kanal 8 als Ziel festlegen
+	Target Channel 9	Kanal 9 als Ziel festlegen
+	Switch Foreground and Background Colors	Vorder- und Hintergrundfarbe vertauschen
+	Default Foreground and Background Colors	Standardfarben für Vorder- und Hintergrund
+	Fill with Foreground Color	Mit Vordergrundfarbe füllen
+	Fill with Background Color	Mit Hintergrundfarbe füllen
+	Fill with Foreground Color, Preserve Transparency	Mit Vordergrundfarbe füllen, Transparenz erhalten
+	Fill with Background Color, Preserve Transparency	Mit Hintergrundfarbe füllen, Transparenz erhalten
+	Decrease Brush Size	Pinselgröße verringern
+	Increase Brush Size	Pinselgröße erhöhen
+	Decrease Brush Hardness	Pinselhärte verringern
+	Increase Brush Hardness	Pinselhärte erhöhen
+	Temporary	Vorübergehend
+	Space	Leertaste
+	Hand Tool (hold)	Hand-Werkzeug (gedrückt halten)
+	Zoom In (hold, drag to scrub)	Vergrößern (gedrückt halten, zum Zoomen ziehen)
+	Zoom Out (hold)	Verkleinern (gedrückt halten)
+	Erase with Brush or Pencil (hold)	Mit Pinsel oder Buntstift radieren (gedrückt halten)
+# Document Info and color profiles
+	Author Title	Position des Urhebers
+	Copyright Status	Urheberrechtsstatus
+	Unknown	Unbekannt
+	Copyrighted	Urheberrechtlich geschützt
+	Public Domain	Gemeinfrei
+	Copyright Url	Urheberrechts-URL
+	Keywords	Stichwörter
+	Title	Titel
+	Profile	Profil
+	Working	Arbeitsfarbraum
+	Working-cmyk	Arbeits-CMYK
+	Coated-cmyk	CMYK (gestrichen)
+	Linear-srgb	Lineares sRGB
+	Gray-gamma-2.2	Grau (Gamma 2,2)
+	Adobe-rgb-compat	Adobe-RGB-kompatibel
+	Prophoto-compat	ProPhoto-kompatibel
+	Display-p3	Display P3
+	Intent	Renderpriorität
+	Bpc	Schwarzpunktkompensierung
+	Simulate Paper	Papierfarbe simulieren
+# Color Lookup, Shadows/Highlights, channels and Calculations
+	Warming Filter (85)	Wärmefilter (85)
+	Lut	LUT
+	Cool	Kühl
+	Teal Orange	Türkis-Orange
+	Faded Film	Verblasster Film
+	Day For Night	Tag für Nacht
+	Mono Contrast	Mono-Kontrast
+	Cross Process	Kreuzentwicklung
+	Shadow Amount	Stärke der Tiefen
+	Shadow Tone	Tonbreite der Tiefen
+	Shadow Radius	Radius der Tiefen
+	Highlight Amount	Stärke der Lichter
+	Highlight Tone	Tonbreite der Lichter
+	Highlight Radius	Radius der Lichter
+	Midtone	Mitteltöne
+	Black Clip	Schwarz beschneiden
+	White Clip	Weiß beschneiden
+	Strength	Stärke
+	Shadow	Schatten
+	Highlight	Lichter
+	Intensity	Intensität
+	Neutralize	Neutralisieren
+	Use Selection In Source	Auswahl in der Quelle verwenden
+	Use Selection In Target	Auswahl im Ziel verwenden
+	Cw	Im Uhrzeigersinn
+	Ccw	Gegen den Uhrzeigersinn
+	Nearest	Nächster Nachbar
+	Linear Dodge	Linear abwedeln
+	Mask Channel	Maskenkanal
+	R G B	RGB
+	Source Channel	Quellkanal
+	Source Invert	Quelle invertieren
+	Result	Ergebnis
+	Source1 Channel	Kanal der Quelle 1
+	Source1 Invert	Quelle 1 invertieren
+	Source2 Channel	Kanal der Quelle 2
+	Source2 Invert	Quelle 2 invertieren
+	Channel1	Kanal 1
+	Channel2	Kanal 2
+	Channel3	Kanal 3
+	Channel4	Kanal 4
+# Measurement log
+	Label	Beschriftung
+	Date and Time	Datum und Uhrzeit
+	Scale Units	Maßstabseinheiten
+	Scale Factor	Maßstabsfaktor
+	Area	Fläche
+	Perimeter	Umfang
+	Circularity	Kreisförmigkeit
+	Gray Value (Minimum)	Grauwert (Minimum)
+	Gray Value (Maximum)	Grauwert (Maximum)
+	Gray Value (Mean)	Grauwert (Mittelwert)
+	Gray Value (Median)	Grauwert (Median)
+	Integrated Density	Integrierte Dichte
+	Length	Länge
+	W:	B:
+	A:	Wi:
+# Lens Correction, Blur Gallery and distortion filters
+	Pattern Fill…	Musterfüllung…
+	Generic	Allgemein
+	Correct Distortion	Verzerrung korrigieren
+	Correct Vignette	Vignette korrigieren
+	Correct C A	Chromatische Aberration korrigieren
+	Auto Scale	Automatisch skalieren
+	Distortion	Verzerrung
+	Red Cyan	Rot/Cyan
+	Blue Yellow	Blau/Gelb
+	Vignette Amount	Stärke der Vignette
+	Vignette Midpoint	Mittelpunkt der Vignette
+	Edge Extension	Kantenerweiterung
+	Hexagon	Sechseck
+	Pentagon	Fünfeck
+	Heptagon	Siebeneck
+	Octagon	Achteck
+	Blade Curvature	Krümmung der Blendenlamellen
+	Depth Map	Tiefenkarte
+	Focal Distance	Fokusabstand
+	Distribution	Verteilung
+	Uniform	Gleichmäßig
+	Monochromatic	Monochrom
+	Seed	Startwert
+	Spin	Drehen
+	Draft	Entwurf
+	Good	Gut
+	Best	Beste
+	Center X	Mitte X
+	Center Y	Mitte Y
+	Circle	Kreis
+	Star	Stern
+	Cross	Kreuz
+	High	Hoch
+	Low	Niedrig
+	Edge Only	Nur Kanten
+	Overlay Edge	Kante überlagern
+	Focus	Fokus
+	Transition	Übergang
+	Speed	Geschwindigkeit
+	Taper	Verjüngung
+	End X	Ende X
+	End Y	Ende Y
+	Blur Angle	Weichzeichnungswinkel
+	Rectangular To Polar	Rechteckig zu Polar
+	Polar To Rectangular	Polar zu Rechteckig
+	Undefined Areas	Undefinierte Bereiche
+	Wrap	Umbrechen
+	Repeat	Wiederholen
+	Horizontal Only	Nur horizontal
+	Vertical Only	Nur vertikal
+	Generators	Generatoren
+	Wavelength Min	Wellenlänge min.
+	Wavelength Max	Wellenlänge max.
+	Amplitude Min	Amplitude min.
+	Amplitude Max	Amplitude max.
+	Sine	Sinus
+	Ridges	Grate
+	Pond Ripples	Teichwellen
+	Out From Center	Von der Mitte nach außen
+	Around Center	Um die Mitte
+	Reduce Color Noise	Farbrauschen reduzieren
+	Sharpen Details	Details schärfen
+	Remove Jpeg Artifact	JPEG-Artefakte entfernen
+	Max Radius	Maximaler Radius
+	Cell Size	Zellengröße
+	Fine Dots	Feine Punkte
+	Medium Dots	Mittlere Punkte
+	Grainy Dots	Körnige Punkte
+	Coarse Dots	Grobe Punkte
+	Short Lines	Kurze Linien
+	Medium Lines	Mittlere Linien
+	Long Lines	Lange Linien
+	Short Strokes	Kurze Striche
+	Medium Strokes	Mittlere Striche
+	Long Strokes	Lange Striche
+# Render filters: Flame, Picture Frame, Tree
+	Flame Type	Flammentyp
+	One Flame Along Path	Eine Flamme entlang des Pfads
+	Multiple Flames Along Path	Mehrere Flammen entlang des Pfads
+	Multiple Flames Path Directions	Mehrere Flammen, Pfadrichtungen
+	Multiple Flames Various Length	Mehrere Flammen, unterschiedliche Längen
+	Candle Light	Kerzenlicht
+	Multiple Flames One Direction	Mehrere Flammen, eine Richtung
+	Randomize Length	Länge zufällig variieren
+	Interval	Abstand
+	Adjust Interval For Loops	Abstand für Schleifen anpassen
+	Use Custom Color	Eigene Farbe verwenden
+	Jag	Zacken
+	Flame Lines	Flammenlinien
+	Flame Bottom Alignment	Ausrichtung des Flammenfußes
+	Flame Style	Flammenstil
+	Violent	Heftig
+	Flat	Flach
+	Flame Shape	Flammenform
+	To Center	Zur Mitte
+	Pointed	Spitz
+	Randomize Shapes	Formen zufällig variieren
+	Fine	Fein
+	Frame	Rahmen
+	Vine With Flowers	Ranke mit Blumen
+	Vine With Leaves	Ranke mit Blättern
+	Ivy	Efeu
+	Roses	Rosen
+	Daisies	Gänseblümchen
+	Berries	Beeren
+	Bamboo	Bambus
+	Waves	Wellen
+	Zigzag	Zickzack
+	Rope	Seil
+	Scallops	Muschelrand
+	Double Line	Doppellinie
+	Snowflakes	Schneeflocken
+	Stars	Sterne
+	Hearts	Herzen
+	Arrangement	Anordnung
+	Thickness	Dicke
+	Vine Color	Rankenfarbe
+	Flower Color	Blütenfarbe
+	Leaf Color	Blattfarbe
+	Base Tree Type	Baumtyp
+	Light Direction	Lichtrichtung
+	Leaves Amount	Blattmenge
+	Leaves Size	Blattgröße
+	Branches Height	Asthöhe
+	Branches Thickness	Aststärke
+	Default Leaves	Standardblätter
+	Leaves Color	Blattfarbe
+	Custom Branch Color	Eigene Astfarbe
+	Branches Color	Astfarbe
+	Flat Shading	Flächige Schattierung
+# Lens, Lighting Effects, depth and mosaic filters
+	Lens	Objektiv
+	Prime35	Festbrennweite 35
+	Prime105	Festbrennweite 105
+	Movie Prime	Film-Festbrennweite
+	Light Type	Lichttyp
+	Point	Punkt
+	Infinite	Unendlich
+	Light X	Licht X
+	Light Y	Licht Y
+	Light Z	Licht Z
+	Target X	Ziel X
+	Target Y	Ziel Y
+	Elevation	Höhe
+	Gloss	Glanz
+	Metallic	Metallisch
+	Ambience	Umgebungslicht
+	White Is High	Weiß ist hoch
+	Ambient	Umgebung
+	Warmth	Wärme
+	Softness	Weichheit
+	Reduce Noise	Rauschen reduzieren
+	Darken Only	Nur abdunkeln
+	Lighten Only	Nur aufhellen
+	Anisotropic	Anisotrop
+	Blocks	Blöcke
+	Pyramids	Pyramiden
+	Depth Mode	Tiefenmodus
+	Random	Zufällig
+	Level Based	Stufenbasiert
+	Solid Front Faces	Einfarbige Vorderseiten
+	Mask Incomplete Blocks	Unvollständige Blöcke maskieren
+	Stylization	Stilisierung
+	Cleanliness	Sauberkeit
+	Bristle Detail	Borstendetail
+	Lighting	Beleuchtung
+	Shine	Glanz
+	Max Offset	Maximaler Versatz
+	Unaltered	Unverändert
+	Lower	Untere
+	Upper	Obere
+	Blast	Böe
+	Stagger	Versetzt
+	From Right	Von rechts
+	From Left	Von links
+	Eliminate	Entfernen
+	Odd Fields	Ungerade Halbbilder
+	Even Fields	Gerade Halbbilder
+	Create By	Erzeugen durch
+	Duplication	Duplizieren
+	Kernel	Kern
+	Input Mode	Eingabemodus
+	Rgb	RGB
+	Hsb	HSB
+	Hsl	HSL
+	Row Order	Zeilenreihenfolge
+	Preserve	Erhalten
+	Squareness	Rechteckigkeit
+# Find and Replace, image size, Warp and Layer Style blending options
+	Any	Beliebig
+	Cmyk	CMYK
+	To	Nach
+	Dont Enlarge	Nicht vergrößern
+	Find	Suchen
+	Replace	Ersetzen
+	Change Find	Ersetzen und suchen
+	Case Sensitive	Groß-/Kleinschreibung beachten
+	Whole Word	Ganzes Wort
+	Forward	Vorwärts
+	Based On	Basierend auf
+	General Blending	Allgemeine Füllmethode
+	Advanced Blending	Erweiterte Füllmethode
+	Blend Interior Effects as Group	Innere Effekte als Gruppe überblenden
+	Blend Clipped Layers as Group	Ebenen der Schnittmaske als Gruppe überblenden
+	Transparency Shapes Layer	Transparenz bestimmt die Ebenenform
+	Layer Mask Hides Effects	Ebenenmaske blendet Effekte aus
+	Vector Mask Hides Effects	Vektormaske blendet Effekte aus
+	This Layer:	Diese Ebene:
+	Underlying Layer:	Darunterliegende Ebene:
+	Up	Nach oben
+	Checkerboard	Schachbrett
+	Arc Lower	Bogen unten
+	Arc Upper	Bogen oben
+	Bend	Biegen
+	Horizontal Distortion	Horizontale Verzerrung
+	Vertical Distortion	Vertikale Verzerrung
+	Stretch	Strecken
+	Map Document	Dokument zuordnen
+	Map Path	Pfad zuordnen
+	Fuzziness	Toleranz
+	Object Finder	Objektsucher
+	No object found there — drag a rectangle around it	Dort wurde kein Objekt gefunden — ziehen Sie ein Rechteck darum
+	Remove after each stroke	Nach jedem Strich entfernen
+	Apply the removal ({key})	Entfernen anwenden ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Striche zum Entfernen: {n} (Eingabe wendet an, Esc bricht ab)
+	Clear Brush Controls	Pinselsteuerungen löschen
+	Reset All Locked Settings	Alle gesperrten Einstellungen zurücksetzen
+	Copy Texture to Other Tools	Struktur auf andere Werkzeuge kopieren
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Aktionen laden…
+	Save Actions…	Aktionen speichern…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{n} Aktion aus {file} geladen|{n} Aktionen aus {file} geladen
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} Schritt hat noch keine Entsprechung in PhotoCraft|{n} Schritte haben noch keine Entsprechung in PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{n} Aktion in {file} gespeichert|{n} Aktionen in {file} gespeichert
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	{n} Schritt ohne Photoshop-Entsprechung ausgelassen|{n} Schritte ohne Photoshop-Entsprechung ausgelassen
+
+	File Naming	Dateibenennung
+	Starting serial	Startnummer
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Stopp einfügen…
+	Save Set…	Set speichern…
+	Message:	Meldung:
+	Allow Continue	Fortsetzen erlauben
+	Show dialog during playback	Dialog bei der Wiedergabe anzeigen
+	Select an action first	Wählen Sie zuerst eine Aktion aus
+	Action playback stopped	Aktionswiedergabe angehalten
+	Step {step} is waiting for its dialog	Schritt {step} wartet auf seinen Dialog
+@plural	{n} action|{n} actions	{n} Aktion|{n} Aktionen
+	Auto Add/Delete	Autom. hinzuf./löschen
+	ICO is limited to 256 × 256 pixels	ICO ist auf 256 × 256 Pixel begrenzt
diff --git a/crates/ui-egui/src/i18n/el.tsv b/crates/ui-egui/src/i18n/el.tsv
index e994a26bd5..e8889313cb 100644
--- a/crates/ui-egui/src/i18n/el.tsv
+++ b/crates/ui-egui/src/i18n/el.tsv
@@ -3,7 +3,17 @@
 # Original translations based on general Greek graphics/computing terminology.
 # Covers every source label the i18n coverage check lists.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Χρώμα καναλιού
+	Color Indicates:	Το χρώμα υποδεικνύει:
+	Solidity:	Συμπαγότητα:
+	Ink Characteristics	Χαρακτηριστικά μελανιού
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Πλάτος χαρτιού
+	Paper Height	Ύψος χαρτιού
 	Rows	Γραμμές
 	Number	Πλήθος
 	Top:	Επάνω:
@@ -54,6 +64,8 @@
 	Save	Αποθήκευση
 	Save As…	Αποθήκευση ως…
 	Save a Copy…	Αποθήκευση αντιγράφου…
+	{name} can't keep everything in this document	Το {name} δεν μπορεί να κρατήσει όλο το περιεχόμενο αυτού του εγγράφου
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Επιλέξτε μια μορφή που τα κρατά όλα, όπως Photoshop (PSD), ή αποθηκεύστε ένα αντίγραφο.
 	Revert	Επαναφορά αποθηκευμένης έκδοσης
 	Export	Εξαγωγή
 	Quick Export as PNG	Γρήγορη εξαγωγή σε PNG
@@ -91,6 +103,13 @@
 	Script Events Manager…	Διαχείριση συμβάντων δεσμών ενεργειών…
 	Import	Εισαγωγή
 	Browse…	Περιήγηση…
+	Source Files	Αρχεία προέλευσης
+	Use:	Χρήση:
+	Files	Αρχεία
+	Add Open Files	Προσθήκη ανοιχτών αρχείων
+	Sort By Name	Ταξινόμηση κατά όνομα
+	Attempt to Automatically Align Source Images	Απόπειρα αυτόματης στοίχισης εικόνων προέλευσης
+	Create Smart Object after Loading Layers	Δημιουργία έξυπνου αντικειμένου μετά τη φόρτωση επιπέδων
 	Reveal in Finder	Εμφάνιση στο Finder
 	Show in Explorer	Εμφάνιση στην Εξερεύνηση αρχείων
 	Show in Folder	Εμφάνιση στον φάκελο
@@ -115,6 +134,8 @@
 	Search…	Αναζήτηση…
 	Check Spelling…	Ορθογραφικός έλεγχος…
 	Find and Replace Text…	Εύρεση και αντικατάσταση κειμένου…
+	Add to Dictionary	Προσθήκη στο λεξικό
+	No Spelling Suggestions	Δεν υπάρχουν ορθογραφικές προτάσεις
 	Fill…	Γέμισμα…
 	Stroke…	Περίγραμμα…
 	Preferences…	Προτιμήσεις…
@@ -164,6 +185,8 @@
 	Transform	Μετασχηματισμός
 	Free Transform	Ελεύθερος μετασχηματισμός
 	Rotate	Περιστροφή
+	Set horizontal skew	Ορισμός οριζόντιας λοξής παραμόρφωσης
+	Set vertical skew	Ορισμός κατακόρυφης λοξής παραμόρφωσης
 	Flip Horizontal	Οριζόντια αναστροφή
 	Flip Vertical	Κατακόρυφη αναστροφή
 	Crop	Περικοπή
@@ -247,6 +270,9 @@
 	Add Layer Mask	Προσθήκη μάσκας επιπέδου
 	Always use pressure for opacity	Πάντα χρήση πίεσης για την αδιαφάνεια
 	Apply Layer Mask	Εφαρμογή μάσκας επιπέδου
+	Add Mask to Selection	Προσθήκη μάσκας στην επιλογή
+	Subtract Mask from Selection	Αφαίρεση μάσκας από την επιλογή
+	Intersect Mask with Selection	Τομή μάσκας με την επιλογή
 	Brush Preset picker	Επιλογή προεπιλογής πινέλου
 	Brush Reconstruct Options	Επιλογές πινέλου επαναφοράς
 	Brush Tool Options	Επιλογές πινέλου (Brush Tool)
@@ -273,6 +299,9 @@
 	Filter for shape layers	Φιλτράρισμα επιπέδων σχημάτων
 	Filter for type layers	Φιλτράρισμα επιπέδων κειμένου
 	Import Brushes…	Εισαγωγή πινέλων…
+	Gradient Preset Options	Επιλογές προεπιλογών ντεγκραντέ
+	Import .GRD	Εισαγωγή .GRD
+	Choose a gradient file (.grd).	Επιλέξτε αρχείο ντεγκραντέ (.grd).
 	Import brushes (.abr)	Εισαγωγή πινέλων (.abr)
 	Mask All	Απόκρυψη όλων με μάσκα
 	Mask Options	Επιλογές μάσκας
@@ -998,7 +1027,6 @@
 	Choose…	Επιλογή…
 	Select Folder…	Επιλογή φακέλου…
 	Override Action "Save" Commands	Παράκαμψη εντολών αποθήκευσης της ενέργειας
-	File Naming	Ονομασία αρχείων
 	Compatibility	Συμβατότητα
 	Include ICC Profile	Συμπερίληψη προφίλ ICC
 	Error File	Αρχείο σφαλμάτων
@@ -1462,6 +1490,11 @@
 	Developing {name}	Επεξεργασία του {name}
 	Camera Raw ({name})	Επεξεργασία RAW ({name})
 	New Brush Preset…	Νέα προεπιλογή πινέλου…
+	Capture Brush Size in Preset	Αποθήκευση μεγέθους πινέλου στην προεπιλογή
+	Include Tool Settings	Συμπερίληψη ρυθμίσεων εργαλείου
+	Include Color	Συμπερίληψη χρώματος
+	Enter a name for the brush preset	Εισαγάγετε όνομα για την προεπιλογή πινέλου
+	A brush preset with this name already exists	Υπάρχει ήδη προεπιλογή πινέλου με αυτό το όνομα
 	Brush Preset Options	Επιλογές προεπιλογής πινέλου
 	Show font names in english	Εμφάνιση ονομάτων γραμματοσειρών στα αγγλικά
 	Show menu colors	Εμφάνιση χρωμάτων μενού
@@ -1577,6 +1610,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Δεν υπάρχει διαδρομή για δημιουργία επιλογής: σχεδιάστε μία με το εργαλείο Πένα (Pen Tool) ή επιλέξτε μία στο πλαίσιο Διαδρομές.
 	Cancel opening	Ακύρωση ανοίγματος
 	Cancelled opening {name}	Ακυρώθηκε το άνοιγμα του {name}
+	The document “{name}” does not have an embedded {mode} profile.	Το έγγραφο «{name}» δεν έχει ενσωματωμένο προφίλ {mode}.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Το έγγραφο «{name}» έχει ενσωματωμένο χρωματικό προφίλ που δεν ταιριάζει με τον τρέχοντα χώρο εργασίας {mode}.
+	Embedded: {embedded}	Ενσωματωμένο: {embedded}
+	Working: {working}	Χώρος εργασίας: {working}
 	Cancelled {label}	Ακυρώθηκε: {label}
 	Esc to cancel	Esc για ακύρωση
 	Opened {name}	Άνοιξε το {name}
@@ -1813,6 +1850,7 @@
 	Update Modified Content	Ενημέρωση τροποποιημένου περιεχομένου
 	Update All Modified Content	Ενημέρωση όλων των τροποποιημένων περιεχομένων
 	Stack Mode	Λειτουργία στοίβας
+	Choose Stack Mode:	Επιλογή λειτουργίας στοίβας:
 	Entropy	Εντροπία
 	Kurtosis	Κύρτωση
 	Maximum	Μέγιστο
@@ -1838,6 +1876,7 @@
 	New Guide Layout…	Νέα διάταξη οδηγών…
 	New Guides From Shape	Νέοι οδηγοί από σχήμα
 	Merge Down	Συγχώνευση με το υποκείμενο επίπεδο
+	Merge Group	Συγχώνευση ομάδας
 	Stamp Visible	Συνένωση ορατών σε νέο επίπεδο
 	Select Layer Above	Επιλογή επάνω επιπέδου
 	Select Layer Below	Επιλογή κάτω επιπέδου
@@ -1895,6 +1934,12 @@
 	Aqua	Κυανό
 	Balance	Ισορροπία
 	Before (Y)	Πριν (Y)
+	Save Settings…	Αποθήκευση ρυθμίσεων…
+	Load Settings…	Φόρτωση ρυθμίσεων…
+	Save these settings as a Camera Raw .xmp file	Αποθήκευση αυτών των ρυθμίσεων ως αρχείο Camera Raw .xmp
+	Load settings from a Camera Raw .xmp file	Φόρτωση ρυθμίσεων από αρχείο Camera Raw .xmp
+	Loaded Camera Raw settings from {file}	Φορτώθηκαν ρυθμίσεις Camera Raw από το {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Φορτώθηκαν ρυθμίσεις Camera Raw από το {file} ({n} δεν υποστηρίζονται)
 	Blending	Ανάμειξη
 	Camera Raw Filter ({layer})	Φίλτρο Camera Raw ({layer})
 	Camera Raw isn't open	Το Camera Raw δεν είναι ανοιχτό
@@ -2044,6 +2089,7 @@
 	Avoid Widows/Orphans	Αποφυγή μονών γραμμών στην αρχή ή στο τέλος σελίδας
 	BLANK DOCUMENT PRESETS ({n})	ΠΡΟΕΠΙΛΟΓΕΣ ΚΕΝΟΥ ΕΓΓΡΑΦΟΥ ({n})
 	Background Contents	Περιεχόμενα φόντου
+	Custom background color	Προσαρμοσμένο χρώμα φόντου
 	Background from Layer	Φόντο από επίπεδο
 	Baseline	Γραμμή βάσης
 	Baseline shift	Μετατόπιση γραμμής βάσης
@@ -2084,6 +2130,7 @@
 	Camera Raw Filter…	Φίλτρο επεξεργασίας ακατέργαστης εικόνας…
 	Camera Raw…	Επεξεργασία ακατέργαστης εικόνας…
 	Cancel (Esc)	Ακύρωση (Esc)
+	Manage submitted jobs in the system print queue	Διαχειριστείτε τις υποβληθείσες εργασίες στην ουρά εκτύπωσης του συστήματος
 	Cancel any current edits (Esc)	Ακύρωση τρεχουσών αλλαγών (Esc)
 	Cancel transform (Esc)	Ακύρωση μετασχηματισμού (Esc)
 	Cancel warp (Esc)	Ακύρωση παραμόρφωσης (Esc)
@@ -2119,6 +2166,10 @@
 	Breeze Dark Theme	Σκούρο θέμα Breeze
 	Breeze light	Breeze φωτεινό
 	Breeze Light Theme	Φωτεινό θέμα Breeze
+	Soft dark	Απαλό σκούρο
+	Soft light	Απαλό ανοιχτό
+	Soft Dark Theme	Απαλό σκούρο θέμα
+	Soft Light Theme	Απαλό ανοιχτό θέμα
 	Clear Canvas Guides	Απαλοιφή οδηγών καμβά
 	Clear Override	Απαλοιφή παράκαμψης
 	Clear Samples	Απαλοιφή δειγμάτων
@@ -2347,6 +2398,9 @@
 	Fibers…	Ίνες…
 	Field Blur	Θόλωση πεδίου
 	Field Blur…	Θόλωση πεδίου…
+# Field Blur pins (#3373)
+	No pin selected	Δεν έχει επιλεγεί καρφίτσα
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Κάντε κλικ στην εικόνα για να προσθέσετε καρφίτσα· σύρετε μια καρφίτσα για να τη μετακινήσετε ή τον δακτύλιό της για να αλλάξετε τη θόλωση. Το Delete αφαιρεί την επιλεγμένη καρφίτσα.
 	File Info	Πληροφορίες αρχείου
 	File Settings	Ρυθμίσεις αρχείου
 	Fill Path	Γέμισμα διαδρομής
@@ -3384,6 +3438,7 @@ cameraRaw	Yellow	Κίτρινο
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Τα επίπεδά του δεν χωρούν στο όριο μνήμης της GPU. Αυξάνοντας τη Χρήση μνήμης στις Προτιμήσεις › Επιδόσεις αυξάνεται το όριο, έως το ένα τέταρτο της μνήμης αυτού του υπολογιστή.
 	Knockout	Διάτρηση
 	Large document: redrawing on the CPU	Μεγάλο έγγραφο: επανασχεδίαση στη CPU
+	Redrawing	Επανασχεδίαση
 	Median…	Διάμεσος…
 	Move	Μετακίνηση
 	New Swatch Group…	Νέα ομάδα δειγμάτων χρωμάτων…
@@ -3501,6 +3556,7 @@ fontWeight	Thin	Πολύ λεπτά
 	Sample a pixel anywhere on the screen	Δειγματοληψία ενός pixel οπουδήποτε στην οθόνη
 	Click to pick · Esc to cancel	Κλικ για επιλογή · Esc για ακύρωση
 	Scroll to zoom	Κύλιση για μεγέθυνση
+	Drag to pan · Scroll to zoom · Double-click to fit	Σύρετε για μετακίνηση · Κυλήστε για μεγέθυνση · Διπλό κλικ για προσαρμογή
 
 # Saved New Document presets (#1516)
 	Preset Name	Όνομα προεπιλογής
@@ -3709,6 +3765,7 @@ curves	Smooth	Εξομάλυνση
 	Paint over hair or fur on the image; Alt paints the other mode	Βάψτε πάνω σε μαλλιά ή γούνα στην εικόνα· το Alt βάφει με την άλλη λειτουργία
 	Clear Brush Strokes	Απαλοιφή πινελιών
 	Show rulers	Εμφάνιση χαράκων
+	Presentation	Παρουσίαση
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Κλικ για τοποθέτηση · Alt-κλικ ή σύρσιμο εκτός καμβά για αφαίρεση
@@ -3745,3 +3802,36 @@ curves	Smooth	Εξομάλυνση
 	Light Red	Ανοιχτό κόκκινο
 	Medium Blue	Μεσαίο μπλε
 	Light Gray	Ανοιχτό γκρι
+	Object Finder	Εύρεση αντικειμένων
+	No object found there — drag a rectangle around it	Δεν βρέθηκε αντικείμενο εκεί — σύρετε ένα ορθογώνιο γύρω του
+	Remove after each stroke	Αφαίρεση μετά από κάθε πινελιά
+	Apply the removal ({key})	Εφαρμογή της αφαίρεσης ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Πινελιές προς αφαίρεση: {n} (Enter εφαρμόζει, Esc ακυρώνει)
+	Clear Brush Controls	Απαλοιφή στοιχείων ελέγχου πινέλου
+	Reset All Locked Settings	Επαναφορά όλων των κλειδωμένων ρυθμίσεων
+	Copy Texture to Other Tools	Αντιγραφή υφής σε άλλα εργαλεία
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Φόρτωση ενεργειών…
+	Save Actions…	Αποθήκευση ενεργειών…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Φορτώθηκε {n} ενέργεια από το {file}|Φορτώθηκαν {n} ενέργειες από το {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} βήμα δεν έχει ακόμη αντίστοιχο στο PhotoCraft|{n} βήματα δεν έχουν ακόμη αντίστοιχο στο PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Αποθηκεύτηκε {n} ενέργεια στο {file}|Αποθηκεύτηκαν {n} ενέργειες στο {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Παραλείφθηκε {n} βήμα χωρίς αντίστοιχο στο Photoshop|Παραλείφθηκαν {n} βήματα χωρίς αντίστοιχο στο Photoshop
+
+	File Naming	Ονομασία αρχείων
+	Starting serial	Αρχικός αριθμός σειράς
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Εισαγωγή διακοπής…
+	Save Set…	Αποθήκευση συνόλου…
+	Message:	Μήνυμα:
+	Allow Continue	Να επιτρέπεται η συνέχεια
+	Show dialog during playback	Εμφάνιση του παραθύρου διαλόγου κατά την αναπαραγωγή
+	Select an action first	Επιλέξτε πρώτα μια ενέργεια
+	Action playback stopped	Η αναπαραγωγή της ενέργειας σταμάτησε
+	Step {step} is waiting for its dialog	Το βήμα {step} περιμένει το παράθυρο διαλόγου του
+@plural	{n} action|{n} actions	{n} ενέργεια|{n} ενέργειες
+	Auto Add/Delete	Αυτόματη προσθήκη/διαγραφή
+	ICO is limited to 256 × 256 pixels	Το ICO περιορίζεται σε 256 × 256 εικονοστοιχεία
diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv
index f9cfe73f89..37f88f4294 100644
--- a/crates/ui-egui/src/i18n/es.tsv
+++ b/crates/ui-egui/src/i18n/es.tsv
@@ -12,7 +12,19 @@
 # Product and technology names (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...) stay in Latin
 # letters; the trailing "…" of dialog commands is kept.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Color del canal
+	Color Indicates:	El color indica:
+	Solidity:	Solidez:
+	Masked Areas	Áreas enmascaradas
+	Selected Areas	Áreas seleccionadas
+	Ink Characteristics	Características de la tinta
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Ancho del papel
+	Paper Height	Altura del papel
 	Columns	Columnas
 	Rows	Filas
 	Number	Número
@@ -70,6 +82,8 @@
 	Save	Guardar
 	Save As…	Guardar como…
 	Save a Copy…	Guardar una copia…
+	{name} can't keep everything in this document	{name} no puede conservar todo lo que tiene este documento
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Elija un formato que lo conserve todo, como Photoshop (PSD), o guarde una copia.
 	Revert	Volver
 	Export	Exportar
 	Quick Export as PNG	Exportación rápida como PNG
@@ -107,6 +121,14 @@
 	Script Events Manager…	Administrador de eventos de secuencias de comandos…
 	Import	Importar
 	Browse…	Examinar…
+	Source Files	Archivos de origen
+	Use:	Usar:
+	Files	Archivos
+	Folder	Carpeta
+	Add Open Files	Añadir archivos abiertos
+	Sort By Name	Ordenar por nombre
+	Attempt to Automatically Align Source Images	Intentar alinear automáticamente las imágenes de origen
+	Create Smart Object after Loading Layers	Crear objeto inteligente tras cargar las capas
 	Reveal in Finder	Mostrar en Finder
 	Show in Explorer	Mostrar en el Explorador
 	Show in Folder	Mostrar en la carpeta
@@ -131,6 +153,8 @@
 	Search…	Buscar…
 	Check Spelling…	Revisar ortografía…
 	Find and Replace Text…	Buscar y reemplazar texto…
+	Add to Dictionary	Añadir al diccionario
+	No Spelling Suggestions	Sin sugerencias ortográficas
 	Fill…	Rellenar…
 	Stroke…	Contornear…
 	Content-Aware Fill…	Relleno según el contenido…
@@ -145,6 +169,8 @@
 	Transform Again on a Copy	Transformar de nuevo una copia
 	Scale	Escalar
 	Rotate	Rotar
+	Set horizontal skew	Definir sesgado horizontal
+	Set vertical skew	Definir sesgado vertical
 	Skew	Sesgar
 	Distort	Distorsionar
 	Perspective	Perspectiva
@@ -357,6 +383,7 @@
 	Update Modified Content	Actualizar contenido modificado
 	Update All Modified Content	Actualizar todo el contenido modificado
 	Stack Mode	Modo de apilamiento
+	Choose Stack Mode:	Elegir modo de apilamiento:
 	Entropy	Entropía
 	Kurtosis	Curtosis
 	Maximum	Máximo
@@ -391,6 +418,7 @@
 	Select Linked Layers	Seleccionar capas vinculadas
 	Merge Layers	Combinar capas
 	Merge Down	Combinar hacia abajo
+	Merge Group	Combinar grupo
 	Merge Visible	Combinar visibles
 	Stamp Visible	Sellar visibles
 	Select Layer Above	Seleccionar la capa de arriba
@@ -527,6 +555,9 @@
 	Blur	Desenfocar
 	Blur Gallery	Galería de desenfoque
 	Field Blur…	Desenfoque de campo…
+# Field Blur pins (#3373)
+	No pin selected	Ningún pin seleccionado
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Haga clic en la imagen para añadir un pin; arrastre un pin para moverlo o su anillo para cambiar el desenfoque. Suprimir elimina el pin seleccionado.
 	Iris Blur…	Desenfoque de iris…
 	Tilt-Shift…	Cambio de inclinación…
 	Path Blur…	Desenfoque de trazado…
@@ -725,6 +756,10 @@
 	Breeze Dark Theme	Tema Breeze oscuro
 	Breeze light	Breeze claro
 	Breeze Light Theme	Tema Breeze claro
+	Soft dark	Suave oscuro
+	Soft light	Suave claro
+	Soft Dark Theme	Tema suave oscuro
+	Soft Light Theme	Tema suave claro
 	Next Theme	Tema siguiente
 	Actions	Acciones
 	Brush Settings	Ajustes del pincel
@@ -825,6 +860,9 @@
 	Appearance	Apariencia
 	Appearance (Layer Style)	Apariencia (estilo de capa)
 	Apply Layer Mask	Aplicar máscara de capa
+	Add Mask to Selection	Añadir máscara a la selección
+	Subtract Mask from Selection	Restar máscara de la selección
+	Intersect Mask with Selection	Intersecar máscara con la selección
 	Apply Per Tip	Aplicar por punta
 	Apply next selected layer comp	Aplicar la composición de capa seleccionada siguiente
 	Apply previous selected layer comp	Aplicar la composición de capa seleccionada anterior
@@ -840,11 +878,18 @@
 	Background	Fondo
 	Background Color	Color de fondo
 	Background Contents	Contenido del fondo
+	Custom background color	Color de fondo personalizado
 	Balance	Balance
 	Baseline	Línea de base
 	Baseline shift	Desplazamiento de línea de base
 	Basic	Básico
 	Before (Y)	Antes (Y)
+	Save Settings…	Guardar ajustes…
+	Load Settings…	Cargar ajustes…
+	Save these settings as a Camera Raw .xmp file	Guardar estos ajustes como archivo .xmp de Camera Raw
+	Load settings from a Camera Raw .xmp file	Cargar ajustes desde un archivo .xmp de Camera Raw
+	Loaded Camera Raw settings from {file}	Ajustes de Camera Raw cargados desde {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Ajustes de Camera Raw cargados desde {file} ({n} no compatibles)
 	Begin recording	Iniciar grabación
 	Bend:	Curvatura:
 	Bicubic	Bicúbica
@@ -875,6 +920,7 @@
 	Camera Raw isn't open	Camera Raw no está abierto
 	Cancel	Cancelar
 	Cancel (Esc)	Cancelar (Esc)
+	Manage submitted jobs in the system print queue	Gestionar los trabajos enviados en la cola de impresión del sistema
 	Cancel any current edits (Esc)	Cancelar las ediciones actuales (Esc)
 	Cancel current crop operation  (Esc)	Cancelar la operación de recorte actual  (Esc)
 	Cancel transform (Esc)	Cancelar transformación (Esc)
@@ -1146,6 +1192,9 @@
 	Ignore All	Ignorar todo
 	Image Size	Tamaño de imagen
 	Import Brushes…	Importar pinceles…
+	Gradient Preset Options	Opciones de ajustes preestablecidos de degradado
+	Import .GRD	Importar .GRD
+	Choose a gradient file (.grd).	Seleccione un archivo de degradados (.grd).
 	Import brushes (.abr)	Importar pinceles (.abr)
 	Import Presets	Importar ajustes preestablecidos
 	Imported	Importado
@@ -2084,6 +2133,11 @@
 	Rename Brush…	Cambiar el nombre del pincel…
 	Delete Brush	Eliminar pincel
 	New Brush Preset…	Nuevo ajuste preestablecido de pincel…
+	Capture Brush Size in Preset	Capturar tamaño del pincel en el ajuste preestablecido
+	Include Tool Settings	Incluir ajustes de herramienta
+	Include Color	Incluir color
+	Enter a name for the brush preset	Escriba un nombre para el ajuste preestablecido de pincel
+	A brush preset with this name already exists	Ya existe un ajuste preestablecido de pincel con este nombre
 	Brush Preset Options	Opciones de ajustes preestablecidos de pincel
 	Group name	Nombre del grupo
 	Brush name	Nombre del pincel
@@ -2144,6 +2198,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	No hay ningún trazado para crear una selección: dibuje uno con la herramienta Pluma o seleccione uno en el panel Trazados.
 	Cancel opening	Cancelar apertura
 	Cancelled opening {name}	Se canceló la apertura de {name}
+	The document “{name}” does not have an embedded {mode} profile.	El documento «{name}» no tiene un perfil {mode} incrustado.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	El documento «{name}» tiene un perfil de color incrustado que no coincide con el espacio de trabajo {mode} actual.
+	Embedded: {embedded}	Incrustado: {embedded}
+	Working: {working}	Espacio de trabajo: {working}
 	Developing {name}	Revelando {name}
 	Cancelled {label}	Se canceló {label}
 	Esc to cancel	Esc para cancelar
@@ -2389,6 +2447,7 @@ cameraRaw	Amount	Cantidad
 	Click to pick · Esc to cancel	Clic para elegir · Esc para cancelar
 	Pick a screen pixel or press Esc to cancel	Elija un píxel de la pantalla o pulse Esc para cancelar
 	Scroll to zoom	Desplace para ampliar
+	Drag to pan · Scroll to zoom · Double-click to fit	Arrastre para desplazar · Desplace para ampliar · Doble clic para ajustar
 	Show/Hide All Panels	Mostrar/ocultar todos los paneles
 	Show/Hide Panels	Mostrar/ocultar paneles
 	Could not open	No se pudo abrir
@@ -2445,6 +2504,7 @@ cameraRaw	Amount	Cantidad
 	Violet	Violeta
 	Reset	Restaurar
 	Large document: redrawing on the CPU	Documento grande: redibujando en la CPU
+	Redrawing	Redibujando
 	This redraw took {seconds} s on the CPU.	Este redibujado en la CPU tardó {seconds} s.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Las ediciones que cambian todo el documento, como el modo de fusión, la opacidad o la visibilidad de una capa, lo redibujan por completo.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Las capas no caben en el presupuesto de memoria de la GPU. Aumentar Uso de memoria en Preferencias › Rendimiento amplía el presupuesto, hasta una cuarta parte de la memoria de este equipo.
@@ -2691,6 +2751,7 @@ curves	Smooth	Suavizar
 	Paint over hair or fur on the image; Alt paints the other mode	Pinte sobre el pelo o el pelaje de la imagen; Alt pinta en el otro modo
 	Clear Brush Strokes	Borrar trazos de pincel
 	Show rulers	Mostrar reglas
+	Presentation	Presentación
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Clic para colocar · Alt-clic o arrastrar fuera del lienzo para quitar
@@ -2728,3 +2789,36 @@ curves	Smooth	Suavizar
 	Light Red	Rojo claro
 	Medium Blue	Azul medio
 	Light Gray	Gris claro
+	Object Finder	Buscador de objetos
+	No object found there — drag a rectangle around it	No se encontró ningún objeto ahí; arrastra un rectángulo a su alrededor
+	Remove after each stroke	Eliminar después de cada trazo
+	Apply the removal ({key})	Aplicar la eliminación ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Trazos por eliminar: {n} (Intro aplica, Esc cancela)
+	Clear Brush Controls	Borrar controles de pincel
+	Reset All Locked Settings	Restaurar todos los ajustes bloqueados
+	Copy Texture to Other Tools	Copiar textura en otras herramientas
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Cargar acciones…
+	Save Actions…	Guardar acciones…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Se cargó {n} acción de {file}|Se cargaron {n} acciones de {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} paso aún no tiene equivalente en PhotoCraft|{n} pasos aún no tienen equivalente en PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Se guardó {n} acción en {file}|Se guardaron {n} acciones en {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	{n} paso sin equivalente en Photoshop omitido|{n} pasos sin equivalente en Photoshop omitidos
+
+	File Naming	Nombres de archivo
+	Starting serial	Número de serie inicial
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Insertar detención…
+	Save Set…	Guardar conjunto…
+	Message:	Mensaje:
+	Allow Continue	Permitir continuar
+	Show dialog during playback	Mostrar el cuadro de diálogo durante la reproducción
+	Select an action first	Seleccione primero una acción
+	Action playback stopped	Reproducción de la acción detenida
+	Step {step} is waiting for its dialog	El paso {step} está esperando su cuadro de diálogo
+@plural	{n} action|{n} actions	{n} acción|{n} acciones
+	Auto Add/Delete	Añadir/eliminar automáticamente
+	ICO is limited to 256 × 256 pixels	ICO está limitado a 256 × 256 píxeles
diff --git a/crates/ui-egui/src/i18n/fr.tsv b/crates/ui-egui/src/i18n/fr.tsv
index 90c075c426..f7d508fb5c 100644
--- a/crates/ui-egui/src/i18n/fr.tsv
+++ b/crates/ui-egui/src/i18n/fr.tsv
@@ -19,7 +19,17 @@
 # ArtCraft, OpenType, Lab ...) stay as they are; RGB/CMYK read RVB/CMJN; the trailing "…" of
 # dialog commands is kept.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Couleur de la couche
+	Color Indicates:	La couleur indique :
+	Solidity:	Solidité :
+	Ink Characteristics	Caractéristiques de l’encre
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Largeur du papier
+	Paper Height	Hauteur du papier
 	Rows	Lignes
 	Number	Nombre
 	Margin	Marge
@@ -75,6 +85,8 @@
 	Save	Enregistrer
 	Save As…	Enregistrer sous…
 	Save a Copy…	Enregistrer une copie…
+	{name} can't keep everything in this document	{name} ne peut pas conserver tout le contenu de ce document
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Choisissez un format qui conserve tout, comme Photoshop (PSD), ou enregistrez une copie.
 	Revert	Revenir à la version enregistrée
 	Export	Exporter
 	Quick Export as PNG	Exportation rapide au format PNG
@@ -112,6 +124,14 @@
 	Script Events Manager…	Gestionnaire d'événements de script…
 	Import	Importer
 	Browse…	Parcourir…
+	Source Files	Fichiers source
+	Use:	Utiliser :
+	Files	Fichiers
+	Folder	Dossier
+	Add Open Files	Ajouter les fichiers ouverts
+	Sort By Name	Trier par nom
+	Attempt to Automatically Align Source Images	Tenter d'aligner automatiquement les images source
+	Create Smart Object after Loading Layers	Créer un objet intelligent après le chargement des calques
 	Reveal in Finder	Afficher dans le Finder
 	Show in Explorer	Afficher dans l'Explorateur
 	Show in Folder	Afficher dans le dossier
@@ -136,6 +156,8 @@
 	Search…	Rechercher…
 	Check Spelling…	Vérifier l'orthographe…
 	Find and Replace Text…	Rechercher et remplacer du texte…
+	Add to Dictionary	Ajouter au dictionnaire
+	No Spelling Suggestions	Aucune suggestion orthographique
 	Fill…	Remplir…
 	Stroke…	Contourner…
 	Content-Aware Fill…	Remplissage d'après le contenu…
@@ -148,6 +170,8 @@
 	Again	Répéter
 	Scale	Mise à l'échelle
 	Rotate	Rotation
+	Set horizontal skew	Définir l'inclinaison horizontale
+	Set vertical skew	Définir l'inclinaison verticale
 	Skew	Inclinaison
 	Distort	Déformation
 	Perspective	Perspective
@@ -353,6 +377,7 @@
 	Update Modified Content	Mettre à jour le contenu modifié
 	Update All Modified Content	Mettre à jour tout le contenu modifié
 	Stack Mode	Mode de pile
+	Choose Stack Mode:	Choisir le mode de pile :
 	Entropy	Entropie
 	Kurtosis	Kurtosis
 	Maximum	Maximum
@@ -387,6 +412,7 @@
 	Select Linked Layers	Sélectionner les calques liés
 	Merge Layers	Fusionner les calques
 	Merge Down	Fusionner avec le calque inférieur
+	Merge Group	Fusionner le groupe
 	Merge Visible	Fusionner les calques visibles
 	Stamp Visible	Tamponner les calques visibles
 	Stamp Down	Tamponner sur le calque inférieur
@@ -517,6 +543,9 @@
 	Blur	Flou
 	Blur Gallery	Galerie de flous
 	Field Blur…	Flou de champ…
+# Field Blur pins (#3373)
+	No pin selected	Aucune épingle sélectionnée
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Cliquez dans l’image pour ajouter une épingle ; faites glisser une épingle pour la déplacer, ou son anneau pour modifier le flou. Suppr supprime l’épingle sélectionnée.
 	Iris Blur…	Flou d'iris…
 	Tilt-Shift…	Inclinaison-décalage…
 	Path Blur…	Flou de tracé…
@@ -715,6 +744,10 @@
 	Breeze Dark Theme	Thème Breeze sombre
 	Breeze light	Breeze clair
 	Breeze Light Theme	Thème Breeze clair
+	Soft dark	Doux sombre
+	Soft light	Doux clair
+	Soft Dark Theme	Thème doux sombre
+	Soft Light Theme	Thème doux clair
 	Next Theme	Thème suivant
 	Actions	Actions
 	Brush Settings	Paramètres du pinceau
@@ -813,6 +846,9 @@
 	Appearance	Apparence
 	Appearance (Layer Style)	Apparence (style de calque)
 	Apply Layer Mask	Appliquer le masque de calque
+	Add Mask to Selection	Ajouter le masque à la sélection
+	Subtract Mask from Selection	Soustraire le masque de la sélection
+	Intersect Mask with Selection	Intersection du masque et de la sélection
 	Apply Per Tip	Appliquer par pointe
 	Apply next selected layer comp	Appliquer la composition de calques sélectionnée suivante
 	Apply previous selected layer comp	Appliquer la composition de calques sélectionnée précédente
@@ -828,11 +864,18 @@
 	Background	Arrière-plan
 	Background Color	Couleur d'arrière-plan
 	Background Contents	Contenu de l'arrière-plan
+	Custom background color	Couleur d'arrière-plan personnalisée
 	Balance	Balance
 	Baseline	Ligne de base
 	Baseline shift	Décalage de la ligne de base
 	Basic	De base
 	Before (Y)	Avant (Y)
+	Save Settings…	Enregistrer les paramètres…
+	Load Settings…	Charger les paramètres…
+	Save these settings as a Camera Raw .xmp file	Enregistrer ces paramètres dans un fichier .xmp Camera Raw
+	Load settings from a Camera Raw .xmp file	Charger les paramètres d’un fichier .xmp Camera Raw
+	Loaded Camera Raw settings from {file}	Paramètres Camera Raw chargés depuis {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Paramètres Camera Raw chargés depuis {file} ({n} non pris en charge)
 	Begin recording	Démarrer l'enregistrement
 	Bend:	Courbure :
 	Bicubic	Bicubique
@@ -863,6 +906,7 @@
 	Camera Raw isn't open	Camera Raw n'est pas ouvert
 	Cancel	Annuler
 	Cancel (Esc)	Annuler (Échap)
+	Manage submitted jobs in the system print queue	Gérer les tâches soumises dans la file d’impression du système
 	Cancel any current edits (Esc)	Annuler les modifications en cours (Échap)
 	Cancel current crop operation  (Esc)	Annuler le recadrage en cours  (Échap)
 	Cancel transform (Esc)	Annuler la transformation (Échap)
@@ -1128,6 +1172,9 @@
 	Ignore All	Tout ignorer
 	Image Size	Taille de l'image
 	Import Brushes…	Importer des pinceaux…
+	Gradient Preset Options	Options des paramètres prédéfinis de dégradé
+	Import .GRD	Importer .GRD
+	Choose a gradient file (.grd).	Choisissez un fichier de dégradés (.grd).
 	Import brushes (.abr)	Importer des pinceaux (.abr)
 	Import Presets	Importer des préréglages
 	Imported	Importé
@@ -2049,6 +2096,11 @@
 	Rename Brush…	Renommer le pinceau…
 	Delete Brush	Supprimer le pinceau
 	New Brush Preset…	Nouveau préréglage de pinceau…
+	Capture Brush Size in Preset	Capturer la taille du pinceau dans le préréglage
+	Include Tool Settings	Inclure les paramètres de l'outil
+	Include Color	Inclure la couleur
+	Enter a name for the brush preset	Saisissez un nom pour le préréglage de pinceau
+	A brush preset with this name already exists	Un préréglage de pinceau porte déjà ce nom
 	Brush Preset Options	Options des préréglages de pinceau
 	Group name	Nom du groupe
 	Brush name	Nom du pinceau
@@ -2106,6 +2158,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Aucun tracé à partir duquel créer une sélection : dessinez-en un avec l'outil Plume ou sélectionnez-en un dans le panneau Tracés.
 	Cancel opening	Annuler l'ouverture
 	Cancelled opening {name}	Ouverture de {name} annulée
+	The document “{name}” does not have an embedded {mode} profile.	Le document « {name} » n'a pas de profil {mode} incorporé.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Le document « {name} » a un profil colorimétrique incorporé qui ne correspond pas à l'espace de travail {mode} actuel.
+	Embedded: {embedded}	Incorporé : {embedded}
+	Working: {working}	Espace de travail : {working}
 	Developing {name}	Développement de {name}
 	Cancelled {label}	{label} : annulé
 	Esc to cancel	Échap pour annuler
@@ -2421,7 +2477,6 @@
 	Choose…	Choisir…
 	Select Folder…	Sélectionner un dossier…
 	Override Action "Save" Commands	Ignorer les commandes « Enregistrer » de l'action
-	File Naming	Dénomination des fichiers
 	Compatibility	Compatibilité
 	Mac OS	Mac OS
 	Unix	Unix
@@ -2743,6 +2798,7 @@ cameraRaw	Blending	Fusion
 	Click to pick · Esc to cancel	Cliquer pour choisir · Échap pour annuler
 	Pick a screen pixel or press Esc to cancel	Choisissez un pixel à l’écran ou appuyez sur Échap pour annuler
 	Scroll to zoom	Défiler pour zoomer
+	Drag to pan · Scroll to zoom · Double-click to fit	Glisser pour déplacer · Défiler pour zoomer · Double-cliquer pour ajuster
 	Show/Hide All Panels	Afficher/masquer tous les panneaux
 	Show/Hide Panels	Afficher/masquer les panneaux
 	Could not open	Impossible d’ouvrir
@@ -2798,6 +2854,7 @@ cameraRaw	Blending	Fusion
 	Fuchsia	Fuchsia
 	Violet	Violet
 	Large document: redrawing on the CPU	Document volumineux : redessin sur le CPU
+	Redrawing	Redessin
 	This redraw took {seconds} s on the CPU.	Ce redessin sur le CPU a pris {seconds} s.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Les modifications qui touchent tout le document, comme le mode de fusion, l'opacité ou la visibilité d'un calque, le redessinent entièrement.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Les calques dépassent le budget de mémoire GPU. Augmenter Utilisation de la mémoire dans Préférences › Performances relève ce budget, jusqu'au quart de la mémoire de cet ordinateur.
@@ -3026,6 +3083,7 @@ curves	Smooth	Lisser
 	Paint over hair or fur on the image; Alt paints the other mode	Peignez sur les cheveux ou la fourrure dans l'image ; Alt peint dans l'autre mode
 	Clear Brush Strokes	Effacer les traits de pinceau
 	Show rulers	Afficher les règles
+	Presentation	Présentation
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Cliquez pour placer · Alt-clic ou glisser hors du canevas pour supprimer
@@ -3048,3 +3106,36 @@ curves	Smooth	Lisser
 	Light Red	Rouge clair
 	Medium Blue	Bleu moyen
 	Light Gray	Gris clair
+	Object Finder	Outil de recherche d’objets
+	No object found there — drag a rectangle around it	Aucun objet trouvé ici — tracez un rectangle autour
+	Remove after each stroke	Supprimer après chaque trait
+	Apply the removal ({key})	Appliquer la suppression ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Traits à supprimer : {n} (Entrée applique, Échap annule)
+	Clear Brush Controls	Effacer les commandes de pinceau
+	Reset All Locked Settings	Réinitialiser tous les paramètres verrouillés
+	Copy Texture to Other Tools	Copier la texture dans d'autres outils
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Charger des actions…
+	Save Actions…	Enregistrer les actions…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{n} action chargée depuis {file}|{n} actions chargées depuis {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} étape n’a pas encore d’équivalent dans PhotoCraft|{n} étapes n’ont pas encore d’équivalent dans PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{n} action enregistrée dans {file}|{n} actions enregistrées dans {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	{n} étape sans équivalent Photoshop omise|{n} étapes sans équivalent Photoshop omises
+
+	File Naming	Dénomination des fichiers
+	Starting serial	Numéro de série initial
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Insérer un arrêt…
+	Save Set…	Enregistrer l’ensemble…
+	Message:	Message :
+	Allow Continue	Autoriser la poursuite
+	Show dialog during playback	Afficher la boîte de dialogue pendant l’exécution
+	Select an action first	Sélectionnez d’abord une action
+	Action playback stopped	Exécution de l’action arrêtée
+	Step {step} is waiting for its dialog	L’étape {step} attend sa boîte de dialogue
+@plural	{n} action|{n} actions	{n} action|{n} actions
+	Auto Add/Delete	Ajout/suppr. auto
+	ICO is limited to 256 × 256 pixels	Le format ICO est limité à 256 × 256 pixels
diff --git a/crates/ui-egui/src/i18n/hu.tsv b/crates/ui-egui/src/i18n/hu.tsv
new file mode 100644
index 0000000000..70c2294205
--- /dev/null
+++ b/crates/ui-egui/src/i18n/hu.tsv
@@ -0,0 +1,4060 @@
+# Hungarian (hu) catalog. Columns, separated by a TAB:  context <TAB> source <TAB> translation
+#
+#   context  empty                a plain UI string; `source` is the English text in the code
+#            @id                  a command id (e.g. file.saveAs): wins over the English text for
+#                                 that menu item, so one id can read differently from its twin
+#            @plural              `source` is "one|other" (English forms); the translation lists the
+#                                 language's forms separated by "|" (see `plural` in i18n/mod.rs)
+#            anything else        a disambiguating context passed to `tr_ctx`
+#   escapes  \n  \t  \\  inside a column. `{name}` placeholders must appear in both columns.
+#   lines starting with # and blank lines are ignored.
+#
+# Clean-room: every entry was written from the plain meaning of the English label using ordinary
+# Hungarian image-editing vocabulary (réteg, maszk, kijelölés ...). No proprietary localisation
+# resource, string table or product UI was consulted or copied; add entries the same way.
+# Product and technology names (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...) stay in Latin
+# letters; the trailing "…" of dialog commands is kept. Plural rule: a count is followed by the
+# singular noun in Hungarian, so every @plural entry has a single form.
+
+# Plural messages and command id overrides
+# Custom paper dimensions in Print Settings.
+	Paper Width	Papír szélessége
+	Paper Height	Papír magassága
+
+@id	edit.purge.undo	Visszavonási adatok
+@id	edit.stroke	Körvonalazás…
+@id	edit.transform.scale	Méretezés
+@id	filter.sharpen.sharpen	Egyszerű élesítés
+@id	select.all	Mind
+@plural	Exported {n} swatch to {file}|Exported {n} swatches to {file}	{n} színminta exportálva. Cél: {file}
+@plural	Group · {n} layer|Group · {n} layers	Csoport · {n} réteg
+@plural	Imported {n} brush from {file}|Imported {n} brushes from {file}	{n} ecset importálva. Forrás: {file}
+@plural	Imported {n} brush from {group}|Imported {n} brushes from {group}	{n} ecset importálva. Csoport: {group}
+@plural	Imported {n} gradient from {file}|Imported {n} gradients from {file}	{n} színátmenet importálva. Forrás: {file}
+@plural	Imported {n} pattern from {file}|Imported {n} patterns from {file}	{n} mintázat importálva. Forrás: {file}
+@plural	Imported {n} swatch from {file}|Imported {n} swatches from {file}	{n} színminta importálva. Forrás: {file}
+@plural	Played {n} step|Played {n} steps	{n} lépés lejátszva
+@plural	Saved for Web: {n} file|Saved for Web: {n} files	Mentés webre: {n} fájl
+@plural	Updated {n} linked smart object changed on disk|Updated {n} linked smart objects changed on disk	{n} csatolt intelligens objektum frissítve (a lemezen módosult)
+@plural	{n} item|{n} items	{n} elem
+@plural	{n} layer recorded by this comp was deleted. Update the comp, or clear the warning.|{n} layers recorded by this comp were deleted. Update the comp, or clear the warning.	A rétegkompozícióban rögzített rétegek közül {n} törlődött. Frissítsd a rétegkompozíciót, vagy töröld a figyelmeztetést.
+@plural	{n} Layer|{n} Layers	{n} réteg
+@plural	{n} layer|{n} layers	{n} réteg
+@plural	{n} plane|{n} planes	{n} sík
+@plural	{n} preset|{n} presets	{n} előbeállítás
+@plural	{n} sample point removed|{n} sample points removed	{n} mintavételi pont eltávolítva
+@plural	{n} sample|{n} samples	{n} minta
+@plural	{n} slice|{n} slices	{n} szelet
+@plural	{n} step|{n} steps	{n} lépés
+@plural	{warning} (+{n} more brush preset warning)|{warning} (+{n} more brush preset warnings)	{warning} (+{n} további figyelmeztetés az ecset-előbeállításokról)
+@plural	{what} with {n} warning|{what} with {n} warnings	{what} ({n} figyelmeztetés)
+@id	file.close	Bezárás
+@id	layer.layerMask.apply	Alkalmazás
+@id	edit.clear	Kiürítés
+
+# Menus: File, Edit, Image
+	16 Bits/Channel	16 bit/csatorna
+	180°	180°
+	32 Bits/Channel	32 bit/csatorna
+	8 Bits/Channel	8 bit/csatorna
+	90° Clockwise	90° az óramutató járása szerint
+	90° Counter Clockwise	90° az óramutató járásával szemben
+	Adjustments	Korrekciók
+	Again	Ismétlés
+	AI Integrations…	MI-integrációk…
+	Analysis	Elemzés
+	Apply Data Set…	Adatkészlet alkalmazása…
+	Apply Image…	Kép alkalmazása…
+	Arbitrary…	Tetszőleges…
+	Artboards to Files…	Rajztáblák fájlokba…
+	Artboards to PDF…	Rajztáblák PDF-be…
+	Assign Profile…	Profil hozzárendelése…
+	Auto Color	Automatikus szín
+	Auto Contrast	Automatikus kontraszt
+	Auto Tone	Automatikus tónus
+	Auto-Align Layers…	Rétegek automatikus igazítása…
+	Auto-Blend Layers…	Rétegek automatikus keverése…
+	Automate	Automatizálás
+	Batch…	Kötegelt feldolgozás…
+	Bitmap	Bittérkép
+	Black & White…	Fekete-fehér…
+	Brightness/Contrast…	Fényerő/kontraszt…
+	Browse…	Tallózás…
+	Source Files	Forrásfájlok
+	Use:	Használat:
+	Files	Fájlok
+	Add Open Files	Megnyitott fájlok hozzáadása
+	Sort By Name	Rendezés név szerint
+	Attempt to Automatically Align Source Images	Forrásképek automatikus igazításának megkísérlése
+	Create Smart Object after Loading Layers	Intelligens objektum létrehozása a rétegek betöltése után
+	Calculations…	Számítások…
+	Canvas Size…	Vászonméret…
+	Channel Mixer…	Csatornakeverő…
+	Check Spelling…	Helyesírás-ellenőrzés…
+	Clipboard	Vágólap
+	Close All	Összes bezárása
+	Close Others	Többi bezárása
+	Color Balance…	Színegyensúly…
+	Color Lookup Tables…	Színleképezési táblák…
+	Color Lookup…	Színleképezés…
+	Color Settings…	Színbeállítások…
+	Color Table…	Színtábla…
+	Conditional Mode Change…	Feltételes módváltás…
+	Contact Sheet II…	Kontaktlap II…
+	Content-Aware Fill…	Tartalomérzékeny kitöltés…
+	Content-Aware Scale	Tartalomérzékeny méretezés
+	Convert to Profile…	Átalakítás profilra…
+	Copy	Másolás
+	Copy Merged	Egyesített másolás
+	Create Droplet…	Droplet létrehozása…
+	Crop	Körbevágás
+	Crop and Straighten Photos	Fotók körbevágása és kiegyenesítése
+	Cursors…	Kurzorok…
+	Curves…	Görbék…
+	Cut	Kivágás
+	Data Sets as Files…	Adatkészletek fájlokként…
+	Data Sets…	Adatkészletek…
+	Define Brush Preset…	Ecset-előbeállítás megadása…
+	Define Custom Shape…	Egyéni alakzat megadása…
+	Define Pattern…	Mintázat megadása…
+	Define…	Megadás…
+	Delete All Empty Layers	Összes üres réteg törlése
+	Desaturate	Színtelenítés
+	Distort	Torzítás
+	Duotone	Kéttónusú
+	Duplicate…	Kettőzés…
+	Edit	Szerkesztés
+	Enhanced Controls…	Bővített vezérlők…
+	Equalize	Kiegyenlítés
+	Exit	Kilépés
+	Export As…	Exportálás másként…
+	Export Preferences…	Beállítások exportálása…
+	Export/Import Presets…	Előbeállítások exportálása/importálása…
+	Export…	Exportálás…
+	Exposure…	Expozíció…
+	Fade…	Halványítás…
+	File	Fájl
+	File Handling…	Fájlkezelés…
+	File Info…	Fájladatok…
+	Fill…	Kitöltés…
+	Find and Replace Text…	Szöveg keresése és cseréje…
+	Add to Dictionary	Hozzáadás a szótárhoz
+	No Spelling Suggestions	Nincs helyesírási javaslat
+	Fit Image…	Kép méretre igazítása…
+	Flatten All Layer Effects	Összes rétegeffektus egybesimítása
+	Flatten All Masks	Összes maszk egybesimítása
+	Flip Canvas Horizontal	Vászon vízszintes tükrözése
+	Flip Canvas Vertical	Vászon függőleges tükrözése
+	Flip Horizontal	Vízszintes tükrözés
+	Flip Vertical	Függőleges tükrözés
+	Free Transform	Szabad alakítás
+	Generate	Létrehozás
+	Gradient Map…	Színátmenet-leképezés…
+	Guides, Grid & Slices…	Segédvonalak, rács és szeletek…
+	HDR Toning…	HDR-tónusozás…
+	Histories	Előzmények
+	History Log…	Előzménynapló…
+	Hue/Saturation…	Színárnyalat/telítettség…
+	Image	Kép
+	Image Assets	Képelemek
+	Image Processor…	Képfeldolgozó…
+	Image Rotation	Képforgatás
+	Indexed Color	Indexelt szín
+	Interface…	Felület…
+	Keyboard Shortcuts…	Billentyűparancsok…
+	Layer Comps to Files…	Rétegkompozíciók fájlokba…
+	Layers to Files…	Rétegek fájlokba…
+	Lens Correction…	Objektívkorrekció…
+	Levels…	Szintek…
+	Load Files into Stack…	Fájlok betöltése halomba…
+	Match Color…	Színillesztés…
+	Menus…	Menük…
+	Merge to HDR Pro…	HDR Pro-egyesítés…
+	Migrate Presets	Előbeállítások átvétele
+	Multichannel	Többcsatornás
+	New…	Új…
+	Notes…	Jegyzetek…
+	Open As…	Megnyitás mint…
+	Open EXR Parts…	EXR-részek megnyitása…
+	Open…	Megnyitás…
+	Package…	Csomagolás…
+	Paste	Beillesztés
+	Paste in Place	Beillesztés a helyére
+	Paste Into	Beillesztés belülre
+	Paste Outside	Beillesztés kívülre
+	Paste Special	Speciális beillesztés
+	Paths to Illustrator…	Útvonalak Illustrator-fájlba…
+	Performance…	Teljesítmény…
+	Perspective	Perspektíva
+	Perspective Warp	Perspektivikus torzítás
+	Photo Filter…	Fotószűrő…
+	Photomerge…	Fotóegyesítés…
+	Place Embedded…	Beágyazott elhelyezése…
+	Place Linked…	Csatolt elhelyezése…
+	Place Scale Marker…	Méretarány-jelölő elhelyezése…
+	Plug-ins…	Bővítmények…
+	Posterize…	Poszterizálás…
+	Preferences	Beállítások
+	Preset Manager…	Előbeállítás-kezelő…
+	Presets	Előbeállítások
+	Print One Copy	Egy példány nyomtatása
+	Print…	Nyomtatás…
+	Puppet Warp	Bábtorzítás
+	Purge	Memória ürítése
+	Quick Export as PNG	Gyors exportálás PNG-be
+	Raw Defaults…	Raw-alapértékek…
+	Record Measurements	Mérések rögzítése
+	Redo	Újra
+	Remove Warp Split	Hajlításfelosztás eltávolítása
+	Render Video…	Videó renderelése…
+	Replace Color…	Színcsere…
+	Reveal All	Minden megjelenítése
+	Revert	Visszaállítás
+	Rotate	Forgatás
+	Set horizontal skew	Vízszintes döntés beállítása
+	Set vertical skew	Függőleges döntés beállítása
+	Rotate 180°	Forgatás 180°-kal
+	Rotate 90° Clockwise	Forgatás 90°-kal az óramutató járása szerint
+	Rotate 90° Counter Clockwise	Forgatás 90°-kal az óramutató járásával szemben
+	Save	Mentés
+	Save a Copy…	Másolat mentése…
+	{name} can't keep everything in this document	Nem őrizhető meg minden a dokumentumból ebben a formátumban: {name}
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Válassz olyan formátumot, amely mindent megőriz, például Photoshop (PSD), vagy ments másolatot.
+	Save As…	Mentés másként…
+	Save for Web (Legacy)…	Mentés webre (régi)…
+	Scale	Méretarány
+	Scratch Disks…	Lapozólemezek…
+	Script Events Manager…	Parancsfájl-eseménykezelő…
+	Scripts	Parancsfájlok
+	Search…	Keresés…
+	Select Data Points…	Adatpontok kiválasztása…
+	Selective Color…	Szelektív szín…
+	Set Measurement Scale…	Mérési méretarány beállítása…
+	Settings…	Beállítások…
+	Shadows/Highlights…	Árnyékok/csúcsfények…
+	Skew	Döntés
+	Split Warp Crosswise	Hajlítás felosztása keresztben
+	Split Warp Horizontally	Hajlítás felosztása vízszintesen
+	Split Warp Vertically	Hajlítás felosztása függőlegesen
+	Statistics…	Statisztika…
+	Stroke…	Körvonal…
+	Threshold…	Küszöb…
+	Toggle Last State	Utolsó állapot váltása
+	Toolbar…	Eszköztár…
+	Tools…	Eszközök…
+	Transform	Alakítás
+	Transparency & Gamut…	Átlátszóság és színtartomány…
+	Trap…	Ráfutás…
+	Trim…	Levágás…
+	Type…	Szöveg…
+	Undo	Visszavonás
+	Units & Rulers…	Mértékegységek és vonalzók…
+	Variable Data Sets…	Változó adatkészletek…
+	Variables	Változók
+	Vibrance…	Élénkség…
+	Video Cache	Videogyorsítótár
+	Video Frames to Layers…	Videókockák rétegekbe…
+	Warp	Hajlítás
+	WIA Support…	WIA-támogatás…
+	Workspace…	Munkaterület…
+
+# Menus: Layer, Select
+	Align	Igazítás
+	Apply	Alkalmaz
+	Arrange	Elrendezés
+	Artboard from Group…	Rajztábla csoportból…
+	Artboard from Layers…	Rajztábla rétegekből…
+	Artboard…	Rajztábla…
+	Background from Layer	Háttér a rétegből
+	Bevel & Emboss…	Fazetta és domborítás…
+	Blending Options…	Keverési beállítások…
+	Border…	Szegély…
+	Bottom Edges	Alsó szélek
+	Bring Forward	Előrébb hozás
+	Bring to Front	Előrehozás legfelülre
+	Clear Layer Style	Rétegstílus törlése
+	Clear Smart Filters	Intelligens szűrők törlése
+	Color Decontaminate…	Színszennyeződés eltávolítása…
+	Color Overlay…	Színfedés…
+	Color Range…	Színtartomány…
+	Combine Shapes	Alakzatok kombinálása
+	Contract…	Szűkítés…
+	Convert to Embedded	Átalakítás beágyazottá
+	Convert to Layers	Átalakítás rétegekké
+	Convert to Linked…	Átalakítás csatolttá…
+	Convert to Smart Object	Átalakítás intelligens objektummá
+	Copy Layer Style	Rétegstílus másolása
+	Create Clipping Mask	Vágómaszk létrehozása
+	Create Layer	Réteg létrehozása
+	Current Path	Aktuális útvonal
+	Defringe…	Szegélyjavítás…
+	Delete Filter Mask	Szűrőmaszk törlése
+	Delete Frame	Képkocka törlése
+	Deselect	Kijelölés megszüntetése
+	Deselect Layers	Rétegek kijelölésének megszüntetése
+	Disable Filter Mask	Szűrőmaszk letiltása
+	Disable Smart Filters	Intelligens szűrők letiltása
+	Distribute	Elosztás
+	Drop Shadow…	Vetett árnyék…
+	Duplicate Frame	Képkocka kettőzése
+	Duplicate Layer…	Réteg kettőzése…
+	Edit Contents	Tartalom szerkesztése
+	Edit in Quick Mask Mode	Szerkesztés gyorsmaszk módban
+	Enable Layer Mask	Rétegmaszk engedélyezése
+	Enable Vector Mask	Vektormaszk engedélyezése
+	Entropy	Entrópia
+	Exclude Overlapping Shapes	Átfedő alakzatok kizárása
+	Expand…	Bővítés…
+	Export Contents…	Tartalom exportálása…
+	Feather…	Elmosott szél…
+	Fill Content	Kitöltés tartalma
+	Find Layers	Rétegek keresése
+	Flatten Image	Kép egybesimítása
+	Focus Area…	Fókuszterület…
+	Frame from Layers	Keret rétegekből
+	From Transparency	Átlátszóságból
+	Global Light…	Globális fény…
+	Gradient Overlay…	Színátmenet-fedés…
+	Gradient…	Színátmenet…
+	Group from Layers…	Csoport rétegekből…
+	Group Layers	Rétegek csoportosítása
+	Group…	Csoport…
+	Grow	Növelés
+	Hidden Layers	Rejtett rétegek
+	Hide All	Minden elrejtése
+	Hide All Effects	Összes effektus elrejtése
+	Hide Layers	Rétegek elrejtése
+	Hide Selection	Kijelölés elrejtése
+	Horizontal Centers	Vízszintes középvonalak
+	Inner Glow…	Belső ragyogás…
+	Inner Shadow…	Belső árnyék…
+	Insert Blank Frame	Üres képkocka beszúrása
+	Interpret Footage…	Videoanyag értelmezése…
+	Intersect Shape Areas	Alakzatterületek metszete
+	Inverse Selection	Kijelölés megfordítása
+	Invert…	Invertálás…
+	Isolate Layers	Rétegek elkülönítése
+	Kurtosis	Csúcsosság
+	Layer	Réteg
+	Layer Content Options…	Rétegtartalom beállításai…
+	Layer from Background…	Réteg a háttérből…
+	Layer Style	Rétegstílus
+	Layer via Copy	Réteg másolással
+	Layer via Cut	Réteg kivágással
+	Layer…	Réteg…
+	Left Edges	Bal szélek
+	Link Layer Mask	Rétegmaszk összekapcsolása
+	Link Layers	Rétegek összekapcsolása
+	Link Vector Mask	Vektormaszk összekapcsolása
+	Load Selection…	Kijelölés betöltése…
+	Lock Layers…	Rétegek zárolása…
+	Mask All Objects	Összes objektum maszkolása
+	Matting	Szegélykezelés
+	Maximum	Maximum
+	Mean	Átlag
+	Median	Medián
+	Merge Layers	Rétegek egyesítése
+	Merge Shape Components	Alakzatösszetevők egyesítése
+	Merge Visible	Láthatók egyesítése
+	Modify	Módosítás
+	New Adjustment Layer	Új korrekciós réteg
+	New Blank Video Layer	Új üres videoréteg
+	New Fill Layer	Új kitöltőréteg
+	New Layer Based Slice	Új rétegalapú szelet
+	New Smart Object via Copy	Új intelligens objektum másolással
+	New Video Layer from File…	Új videoréteg fájlból…
+	Outer Glow…	Külső ragyogás…
+	Paste Layer Style	Rétegstílus beillesztése
+	Pattern Overlay…	Mintázatfedés…
+	Pattern…	Mintázat…
+	Range	Terjedelem
+	Rasterize	Raszterizálás
+	Relink to File…	Újracsatolás fájlhoz…
+	Reload Frame	Képkocka újratöltése
+	Remove Black Matte	Fekete szegély eltávolítása
+	Remove White Matte	Fehér szegély eltávolítása
+	Rename Layer	Réteg átnevezése
+	Replace Contents…	Tartalom cseréje…
+	Replace Footage…	Videoanyag cseréje…
+	Reselect	Újbóli kijelölés
+	Restore All Frames	Összes képkocka visszaállítása
+	Restore Frame	Képkocka visszaállítása
+	Reveal in Finder	Megjelenítés a Finderben
+	Reveal Selection	Kijelölés megjelenítése
+	Right Edges	Jobb szélek
+	Satin…	Szatén…
+	Save Selection…	Kijelölés mentése…
+	Scale Effects…	Effektusok méretezése…
+	Select	Kijelölés
+	Select and Mask…	Kijelölés és maszk…
+	Select Linked Layers	Összekapcsolt rétegek kijelölése
+	Send Backward	Hátrébb küldés
+	Send to Back	Hátraküldés legalulra
+	Show Altered Video	Módosított videó megjelenítése
+	Similar	Hasonló
+	Skewness	Ferdeség
+	Sky	Égbolt
+	Smart Filter	Intelligens szűrő
+	Smart Object	Intelligens objektum
+	Smart Objects	Intelligens objektumok
+	Smooth…	Simítás…
+	Solid Color…	Egyszínű kitöltés…
+	Stack Mode	Halommód
+	Choose Stack Mode:	Halommód kiválasztása:
+	Standard Deviation	Szórás
+	Subject	Fő téma
+	Subtract Front Shape	Elülső alakzat kivonása
+	Summation	Összegzés
+	Top Edges	Felső szélek
+	Transform Selection	Kijelölés alakítása
+	Type	Szöveg
+	Ungroup Layers	Csoport bontása
+	Unite Shapes	Alakzatok egyesítése
+	Update All Modified Content	Összes módosult tartalom frissítése
+	Update Modified Content	Módosult tartalom frissítése
+	Variance	Variancia
+	Vector Mask	Vektormaszk
+	Vertical Centers	Függőleges középvonalak
+	Video	Videó
+	Video Layers	Videorétegek
+
+# Menus: Type, Filter, View, Window; UI and engine commands
+	(coming soon)	(hamarosan)
+	100%	100%
+	2-up Horizontal	2 nézet vízszintesen
+	2-up Vertical	2 nézet függőlegesen
+	200%	200%
+	3-up Horizontal	3 nézet vízszintesen
+	3-up Stacked	3 nézet egymás alatt
+	3-up Vertical	3 nézet függőlegesen
+	32-bit Preview Options…	32 bites előnézet beállításai…
+	4-up	4 nézet
+	6-up	6 nézet
+	About PhotoCraft	A PhotoCraft névjegye
+	About {app}	Névjegy: {app}
+	Actions	Műveletsorok
+	Activate Panel	Panel aktiválása
+	Actual Pixels	Tényleges méret
+	Adaptive Wide Angle…	Adaptív nagy látószög…
+	Add Layer Mask	Rétegmaszk hozzáadása
+	Add Noise…	Zaj hozzáadása…
+	Add Vector Mask	Vektormaszk hozzáadása
+	Adwaita Dark Theme	Adwaita sötét téma
+	Adwaita Light Theme	Adwaita világos téma
+	AI Integrations	MI-integrációk
+	Anamorphic 2:1 (2)	Anamorfikus 2:1 (2)
+	Anti-Alias	Élsimítás
+	Appearance	Megjelenés
+	Apply Data Set	Adatkészlet alkalmazása
+	Apply Layer Mask	Rétegmaszk alkalmazása
+	Add Mask to Selection	Maszk hozzáadása a kijelöléshez
+	Subtract Mask from Selection	Maszk kivonása a kijelölésből
+	Intersect Mask with Selection	Maszk metszése a kijelöléssel
+	Artboard Guides	Rajztábla-segédvonalak
+	Artboards to Files	Rajztáblák fájlokba
+	Artboards to PDF	Rajztáblák PDF-be
+	ArtCraft Website	ArtCraft-weboldal
+	Average	Átlag
+	Background From Layer	Háttér a rétegből
+	Bitmap…	Bittérkép…
+	Blur	Elmosás
+	Blur Gallery	Elmosásgaléria
+	Blur More	Erősebb elmosás
+	Box Blur…	Dobozelmosás…
+	Breeze Dark Theme	Breeze sötét téma
+	Breeze Light Theme	Breeze világos téma
+	Soft dark	Lágy sötét
+	Soft light	Lágy világos
+	Soft Dark Theme	Lágy sötét téma
+	Soft Light Theme	Lágy világos téma
+	Brush Preview	Ecset előnézete
+	Brush Settings	Ecsetbeállítások
+	Brushes	Ecsetek
+	brushes	ecsetek
+	Camera Raw Filter…	Camera Raw szűrő…
+	Canvas Guides	Vászon-segédvonalak
+	Cascade	Lépcsőzetes
+	Change Panel Group	Panelcsoport váltása
+	Change Panel Layout	Panelelrendezés váltása
+	Change…	Módosítás…
+	Channels	Csatornák
+	Character Panel	Karakter panel
+	Character Styles	Karakterstílusok
+	Character Styles Panel	Karakterstílusok panel
+	Classic Theme	Klasszikus téma
+	Clear Canvas Guides	Vászon-segédvonalak törlése
+	Clear Guides	Segédvonalak törlése
+	Clear Recent Files	Legutóbbi fájlok listájának törlése
+	Clear Selected Artboard Guides	Kijelölt rajztábla segédvonalainak törlése
+	Clear Slices	Szeletek törlése
+	Clipping Mask	Vágómaszk
+	Clipping Path…	Vágóútvonal…
+	Clone Source	Klónozási forrás
+	Close Panel	Panel bezárása
+	Close Window	Ablak bezárása
+	Clouds	Felhők
+	Color Blindness — Deuteranopia-type	Színtévesztés — deuteranópia típusú
+	Color Blindness — Protanopia-type	Színtévesztés — protanópia típusú
+	Color Halftone…	Színes féltónus…
+	Color Lookup Tables	Színleképezési táblák
+	Color Picker (Custom Canvas Color)	Színválasztó (egyéni vászonszín)
+	Color to Alpha…	Szín átalakítása átlátszóvá…
+	Consolidate All to Tabs	Összes lapfülre
+	Contextual Alternates	Környezetfüggő változatok
+	Convert for Smart Filters	Átalakítás intelligens szűrőkhöz
+	Convert to Paragraph Text	Átalakítás bekezdésszöveggé
+	Convert to Point Text	Átalakítás pontszöveggé
+	Convert to Shape	Átalakítás alakzattá
+	Copy Complete Stroke	Teljes körvonal másolása
+	Copy Fill	Kitöltés másolása
+	Count	Darabszám
+	Create Vector Mask	Vektormaszk létrehozása
+	Create Work Path	Munkaútvonal létrehozása
+	Crisp	Tiszta
+	Crosswise	Keresztben
+	Crystallize…	Kristályosítás…
+	Custom Pixel Aspect Ratio	Egyéni pixelarány
+	Custom Pixel Aspect Ratio…	Egyéni pixelarány…
+	Custom…	Egyéni…
+	Cycle Screen Mode	Képernyőmód váltása
+	D1/DV NTSC (0.91)	D1/DV NTSC (0,91)
+	D1/DV NTSC Widescreen (1.21)	D1/DV NTSC szélesvásznú (1,21)
+	D1/DV PAL (1.09)	D1/DV PAL (1,09)
+	D1/DV PAL Widescreen (1.46)	D1/DV PAL szélesvásznú (1,46)
+	Dark gray	Sötétszürke
+	Dark Gray	Sötétszürke
+	Data Sets as Files	Adatkészletek fájlokként
+	De-Interlace…	Váltott soros megjelenítés megszüntetése…
+	Default Features	Alapértelmezett funkciók
+	Define Brush Preset	Ecset-előbeállítás megadása
+	Define Custom Shape	Egyéni alakzat megadása
+	Define Pattern	Mintázat megadása
+	Delete and Fill Selection	Kijelölés törlése és kitöltése
+	Delete Layer	Réteg törlése
+	Delete Layer Mask	Rétegmaszk törlése
+	Delete Layers	Rétegek törlése
+	Delete Vector Mask	Vektormaszk törlése
+	Delete Workspace…	Munkaterület törlése…
+	Despeckle	Szemcsék eltávolítása
+	Difference Clouds	Különbségfelhők
+	Diffuse…	Diffúzió…
+	Disable Layer Mask	Rétegmaszk letiltása
+	Disable Symmetry Path	Szimmetriaútvonal letiltása
+	Discretionary Ligatures	Választható ligatúrák
+	Displace…	Elmozdítás…
+	Dock Panel	Panel dokkolása
+	Document Bounds	Dokumentum határai
+	Duotone…	Kéttónusú…
+	Duplicate Layers…	Rétegek kettőzése…
+	Dust & Scratches…	Por és karcolások…
+	DVCPRO HD 1080/HDV 1080 (1.5)	DVCPRO HD 1080/HDV 1080 (1,5)
+	East Asian Features	Kelet-ázsiai funkciók
+	Edit Pins	Tűk szerkesztése
+	Edit Type	Szöveg szerkesztése
+	Effects	Effektusok
+	Emboss…	Domborítás…
+	Essentials	Alapok
+	Extra Large	Nagyon nagy
+	Extras	Segédelemek
+	Extrude…	Kihúzás…
+	F	F
+	Facet	Lapolás
+	Fibers…	Szálak…
+	Field Blur…	Mezőelmosás…
+	No pin selected	Nincs kijelölt tű
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Kattints a képre tű hozzáadásához; húzd a tűt az áthelyezéséhez, vagy a gyűrűjét az elmosás módosításához. A Delete törli a kijelölt tűt.
+	Fill Path…	Útvonal kitöltése…
+	Fill Screen	Képernyő kitöltése
+	Filter	Szűrő
+	Filter Gallery…	Szűrőgaléria…
+	Find and Replace Text	Szöveg keresése és cseréje
+	Fit Artboard on Screen	Rajztábla képernyőhöz igazítása
+	Fit Layer(s) on Screen	Réteg(ek) képernyőhöz igazítása
+	Fit on Screen	Képernyőhöz igazítás
+	Flame…	Láng…
+	Float All in Windows	Összes lebegő ablakban
+	Float in Window	Lebegő ablakban
+	Float Panel	Panel lebegtetése
+	Font Preview Size	Betűtípus-előnézet mérete
+	Fractions	Törtek
+	Fragment	Töredezés
+	Frame from Layers…	Keret rétegekből…
+	Free Transform a Copy	Másolat szabad alakítása
+	Free Transform Path	Útvonal szabad alakítása
+	Full Screen	Teljes képernyő
+	Full Screen Mode	Teljes képernyős mód
+	Full Screen Mode With Menu Bar	Teljes képernyős mód menüsorral
+	Gamut Warning	Színtartomány-figyelmeztetés
+	Gaussian Blur…	Gauss-elmosás…
+	Glyphs	Glifák
+	Glyphs Panel	Glifák panel
+	Gradients	Színátmenetek
+	Graphic and Web	Grafika és web
+	Graphic and web	Grafika és web
+	Grid	Rács
+	Group from Layers	Csoport rétegekből
+	Guides	Segédvonalak
+	HDV 1080/DVCPRO HD 720 (1.33)	HDV 1080/DVCPRO HD 720 (1,33)
+	Help	Súgó
+	Hide	Elrejtés
+	Hide Others	Többi elrejtése
+	Hide {app}	Elrejtés: {app}
+	High Pass…	Felüláteresztő…
+	Histogram	Hisztogram
+	History	Előzmények
+	Horizontal	Vízszintes
+	HSB/HSL	HSB/HSL
+	Huge	Óriási
+	Image Processor	Képfeldolgozó
+	Indexed Color…	Indexelt szín…
+	Info	Információ
+	Install Plug-in	Bővítmény telepítése
+	Install Plug-in…	Bővítmény telepítése…
+	Internet Standard RGB	Internetes szabványos RGB
+	Inverse	Megfordítás
+	Iris Blur…	Íriszelmosás…
+	Join the ArtCraft Discord	Csatlakozás az ArtCraft Discordhoz
+	Join the ArtCraft Discord…	Csatlakozás az ArtCraft Discordhoz…
+	Language	Nyelv
+	Language Options	Nyelvi beállítások
+	Large	Nagy
+	Last Filter	Utolsó szűrő
+	Layer Comps	Rétegkompozíciók
+	Layer Comps to Files	Rétegkompozíciók fájlokba
+	Layer Content Options	Rétegtartalom beállításai
+	Layer Edges	Rétegszélek
+	Layer from Background	Réteg a háttérből
+	Layer From Background…	Réteg a háttérből…
+	Layers	Rétegek
+	Layers to Files	Rétegek fájlokba
+	Legacy Macintosh RGB	Régi Macintosh RGB
+	Lens Blur…	Objektívelmosás…
+	Lens Flare…	Lencsecsillanás…
+	Light gray	Világosszürke
+	Light Gray	Világosszürke
+	Lighting Effects…	Fényhatások…
+	Liquify…	Képlékenyítés…
+	Load Default Type Styles	Alapértelmezett szövegstílusok betöltése
+	Load Files into Stack	Fájlok betöltése halomba
+	Lock Guides	Segédvonalak zárolása
+	Lock Slices	Szeletek zárolása
+	Lock Workspace	Munkaterület zárolása
+	Make Selection…	Kijelölés készítése…
+	Make Symmetry Path	Szimmetriaútvonal készítése
+	Make Work Path…	Munkaútvonal készítése…
+	Match All	Összes illesztése
+	Match Location	Hely illesztése
+	Match Rotation	Elforgatás illesztése
+	Match Zoom	Nagyítás illesztése
+	Maximum…	Maximum…
+	Measurement Log	Mérési napló
+	Median…	Medián…
+	Medium gray	Középszürke
+	Medium Gray	Középszürke
+	Merge Down	Egyesítés lefelé
+	Merge to HDR Pro	HDR Pro-egyesítés
+	Mesh	Háló
+	Mezzotint…	Mezzotinto…
+	Middle Eastern & South Asian Composer	Közel-keleti és dél-ázsiai szedőmotor
+	Middle Eastern Features	Közel-keleti funkciók
+	Minimize	Minimalizálás
+	Minimum…	Minimum…
+	Modifier Keys	Módosítóbillentyűk
+	Monitor RGB	Monitor-RGB
+	Mosaic…	Mozaik…
+	Motion	Mozgókép
+	Motion Blur…	Mozgási elmosás…
+	Move Panel	Panel áthelyezése
+	Navigator	Navigátor
+	New from Clipboard	Új a vágólapról
+	New Guide Layout…	Új segédvonal-elrendezés…
+	New Guides From Shape	Új segédvonalak alakzatból
+	New Guide…	Új segédvonal…
+	New Layer…	Új réteg…
+	New Shape Layer	Új alakzatréteg
+	New Type Layer	Új szövegréteg
+	New Video Layer	Új videoréteg
+	New Window	Új ablak
+	New Window for Document	Új ablak a dokumentumhoz
+	New Workspace…	Új munkaterület…
+	Next Appearance Mode	Következő megjelenési mód
+	Next Document	Következő dokumentum
+	Next Theme	Következő téma
+	No matching commands	Nincs egyező parancs
+	Notes	Jegyzetek
+	NTSC Colors	NTSC-színek
+	Offset…	Eltolás…
+	Oil Paint…	Olajfestmény…
+	Oldstyle	Régies számok
+	Open As	Megnyitás mint
+	Open Recent	Legutóbbi megnyitása
+	Open Recent is unavailable on the web	A legutóbbi fájlok listája a webes változatban nem érhető el
+	OpenType	OpenType
+	Options	Beállítósáv
+	Ordinals	Sorszámnevek
+	Orientation	Tájolás
+	Ornaments	Díszek
+	Other…	Egyéb…
+	Painting	Festés
+	Panels	Panelek
+	Paragraph Panel	Bekezdés panel
+	Paragraph Styles	Bekezdésstílusok
+	Paragraph Styles Panel	Bekezdésstílusok panel
+	Paste Complete Stroke	Teljes körvonal beillesztése
+	Paste Fill	Kitöltés beillesztése
+	Paste Lorem Ipsum	Lorem ipsum beillesztése
+	Path Blur…	Útvonal-elmosás…
+	Paths	Útvonalak
+	Paths to Illustrator	Útvonalak Illustrator-fájlba
+	Pattern Preview	Mintázat előnézete
+	PhotoCraft	PhotoCraft
+	PhotoCraft on GitHub	PhotoCraft a GitHubon
+	PhotoCraft Website	PhotoCraft-weboldal
+	Photography	Fotózás
+	Picture Frame…	Képkeret…
+	Pinch…	Becsípés…
+	Pixel Art	Pixelgrafika
+	Pixel Art Preview	Pixelgrafikus előnézet
+	Pixel Aspect Ratio	Pixelarány
+	Pixel Aspect Ratio Correction	Pixelarány-korrekció
+	Pixel Grid	Pixelrács
+	Pixelate	Pixelesítés
+	Plug-ins	Bővítmények
+	Pointillize…	Pontozás…
+	Polar Coordinates…	Polárkoordináták…
+	Preferences…	Beállítások…
+	Previous Document	Előző dokumentum
+	Print Size	Nyomtatási méret
+	Pro Light Gray Theme	Pro világosszürke téma
+	Pro Light Theme	Pro világos téma
+	Pro Medium Gray Theme	Pro középszürke téma
+	Pro Theme	Pro téma
+	Proof Colors	Színpróba
+	Proof Setup	Színpróba beállítása
+	Properties	Tulajdonságok
+	Quick Export As PNG	Gyors exportálás PNG-be
+	Quit	Kilépés
+	Quit {app}	Kilépés: {app}
+	Radial Blur…	Sugárirányú elmosás…
+	Rasterize Layer	Réteg raszterizálása
+	Rasterize Layer Style	Rétegstílus raszterizálása
+	Rasterize Layers	Rétegek raszterizálása
+	Rasterize Shape	Alakzat raszterizálása
+	Rasterize Type	Szöveg raszterizálása
+	Rasterize Type Layer	Szövegréteg raszterizálása
+	Raw Defaults	Raw-alapértékek
+	Reduce Noise…	Zajcsökkentés…
+	Release Clipping Mask	Vágómaszk feloldása
+	Relight…	Újravilágítás…
+	Rename Layer…	Réteg átnevezése…
+	Render	Renderelés
+	Replace All Missing Fonts	Összes hiányzó betűtípus cseréje
+	Report an Issue	Hiba bejelentése
+	Report an Issue…	Hiba bejelentése…
+	Reset All	Összes alaphelyzetbe
+	Reset All Tools	Összes eszköz alaphelyzetbe
+	Reset Tool	Eszköz alaphelyzetbe
+	Reset View	Nézet alaphelyzetbe
+	Reset Workspace	Munkaterület alaphelyzetbe
+	Resolve Missing Fonts	Hiányzó betűtípusok kezelése
+	Resolve Missing Fonts…	Hiányzó betűtípusok kezelése…
+	Ripple…	Fodrozódás…
+	Rotate View	Nézetforgatás
+	Rulers	Vonalzók
+	Save As	Mentés másként
+	Save Default Type Styles	Alapértelmezett szövegstílusok mentése
+	Screen Mode	Képernyőmód
+	Scroll menu down	Menü görgetése lefelé
+	Scroll menu up	Menü görgetése felfelé
+	Search menus	Keresés a menükben
+	Select All	Összes kijelölése
+	Select Custom Color…	Egyéni szín kiválasztása…
+	Select Inverse	Kijelölés megfordítása
+	Selection Edges	Kijelölésszélek
+	Settings	Beállítások
+	Shape Blur…	Alakzatos elmosás…
+	Shapes	Alakzatok
+	Sharp	Éles
+	Sharpen	Élesítés
+	Sharpen Edges	Élek élesítése
+	Sharpen More	Erősebb élesítés
+	Shear…	Nyírás…
+	Show	Megjelenítés
+	Show All	Összes megjelenítése
+	Show Extras Options…	Segédelemek beállításai…
+	Show in Explorer	Megjelenítés az Intézőben
+	Show in Folder	Megjelenítés mappában
+	Show menu colors	Menüszínek megjelenítése
+	Show/Hide All Panels	Összes panel megjelenítése/elrejtése
+	Show/Hide Panels	Panelek megjelenítése/elrejtése
+	Simulate Pressure	Nyomás szimulálása
+	Slices	Szeletek
+	Small	Kicsi
+	Smart Blur…	Intelligens elmosás…
+	Smart Guides	Intelligens segédvonalak
+	Smart Sharpen…	Intelligens élesítés…
+	Smooth	Sima
+	Snap	Illesztés
+	Snap To	Illesztési célok
+	Solarize	Szolarizáció
+	Solarized Dark Theme	Solarized sötét téma
+	Spherize…	Gömbösítés…
+	Spin Blur…	Pörgetéses elmosás…
+	Square	Négyzetes
+	Standard Ligatures	Normál ligatúrák
+	Standard Screen Mode	Normál képernyőmód
+	Statistics	Statisztika
+	Stroke Path…	Útvonal körvonalazása…
+	Strong	Erős
+	Studio Light Theme	Studio világos téma
+	Studio Theme	Studio téma
+	Styles	Stílusok
+	Stylistic Alternates	Stilisztikai változatok
+	Stylize	Stilizálás
+	Subtract Shapes at Overlap	Alakzatok kivonása az átfedésben
+	Surface Blur…	Felületi elmosás…
+	Swash	Díszbetűk
+	Swatches	Színminták
+	Sync with system	Rendszer szerint
+	System Info…	Rendszerinformáció…
+	Target Path	Célútvonal
+	Theme	Téma
+	Tile	Mozaikelrendezés
+	Tile All Horizontally	Összes vízszintes mozaikba
+	Tile All Vertically	Összes függőleges mozaikba
+	Tiles…	Csempék…
+	Tilt-Shift…	Tilt-shift…
+	Timeline	Idővonal
+	Titling Alternates	Címbetű-változatok
+	Tool Presets	Eszköz-előbeállítások
+	Tools	Eszközök
+	Trace Contour…	Kontúrkövetés…
+	Transform Symmetry	Szimmetria alakítása
+	Tree…	Fa…
+	Twirl…	Örvény…
+	Unite Shapes at Overlap	Alakzatok egyesítése az átfedésben
+	Unlink Layer Mask	Rétegmaszk szétkapcsolása
+	Unsharp Mask…	Életlenmaszk…
+	Update All Text Layers	Összes szövegréteg frissítése
+	Vanishing Point…	Enyészpont…
+	Variable Data Sets	Változó adatkészletek
+	Vector Mask from Current Path	Vektormaszk az aktuális útvonalból
+	View menu	Nézet menü
+	Warp Text…	Szövegtorzítás…
+	Wave…	Hullám…
+	WIA Support	WIA-támogatás
+	Window	Ablak
+	Windows	Windows
+	Windows LCD	Windows LCD
+	Wind…	Szél…
+	Working Black Plate	Fekete munkalemez
+	Working CMY Plate	CMY munkalemezek
+	Working CMYK	Munka-CMYK
+	Working Cyan Plate	Cián munkalemez
+	Working Magenta Plate	Magenta munkalemez
+	Working Yellow Plate	Sárga munkalemez
+	Workspace	Munkaterület
+	ZigZag…	Cikcakk…
+	Zoom In	Nagyítás
+	Zoom Out	Kicsinyítés
+
+# Tools, brushes and the options bar
+	101 by 101 Average	101 x 101 átlag
+	11 by 11 Average	11 x 11 átlag
+	3 by 3 Average	3 x 3 átlag
+	3 x 3	3 x 3
+	31 by 31 Average	31 x 31 átlag
+	4 x 4	4 x 4
+	5 by 5 Average	5 x 5 átlag
+	5 x 5	5 x 5
+	51 by 51 Average	51 x 51 átlag
+	Add	Hozzáad
+	Add New Artboard	Új rajztábla hozzáadása
+	Add pair	Pár hozzáadása
+	Add space after paragraph	Térköz a bekezdés után
+	Add space before paragraph	Térköz a bekezdés előtt
+	Adds the current gradient to the Gradients panel	Hozzáadja a jelenlegi színátmenetet a Színátmenetek panelhez
+	Adjust for Zoom	Igazítás a nagyításhoz
+	Adjustment layers have nothing to transform	A korrekciós rétegeken nincs mit alakítani
+	Airbrush: keeps depositing paint while the pointer rests.	Festékszóró: a festék akkor is gyűlik, amikor a mutató egy helyben áll.
+	Align with layer	Igazítás a réteghez
+	Aligned	Igazított
+	Alignment	Igazítás
+	All Caps	Csupa nagybetű
+	All Layers	Minden réteg
+	All Layers No Adjustments	Minden réteg, korrekciók nélkül
+	Alt	Alt
+	Alt-click to define a source point to clone from	Alt+kattintással add meg a klónozás forráspontját
+	Alternative	Alternatív
+	Always	Mindig
+	Always Show Overlay	Fedvény megjelenítése mindig
+	Android 1080p	Android 1080p
+	Angle Gradient	Kúpos színátmenet
+	Angle Jitter	Szög ingadozása
+	Angle:	Szög:
+	Anti-alias	Élsimítás
+	Anti-aliasing method	Élsimítási mód
+	Apply Per Tip	Alkalmazás hegyenként
+	Apply the pen's tilt and rotation to the tip shape	A toll dőlését és elforgatását alkalmazza a hegy alakjára
+	Artboard	Rajztábla
+	Artboard Background Color	Rajztábla háttérszíne
+	Artboard from Group	Rajztábla csoportból
+	Artboard from Layers	Rajztábla rétegekből
+	Artboards	Rajztáblák
+	At	Itt
+	Auto Adjust Opacity	Átlátszatlanság automatikus igazítása
+	Auto Center Preview	Előnézet automatikus középre helyezése
+	Auto Show Overlay	Fedvény megjelenítése automatikusan
+	Background Eraser	Háttérradír
+	Baseline	Alapvonal
+	Baseline shift	Alapvonal-eltolás
+	Baseline Shift	Alapvonal-eltolás
+	Basic	Alapbeállítások
+	Before	Előtte
+	Bend:	Hajlás:
+	Bevel	Levágott
+	Bicubic	Bikubikus
+	Bilinear	Bilineáris
+	Black	Fekete
+	Black, White	Fekete, fehér
+	Block	Blokk
+	Blur Tool	Elmosó
+	Bold	Félkövér
+	Both Axes	Mindkét tengely
+	Brightness Jitter	Fényerő ingadozása
+	Bring the selected pin forward	A kijelölt tű előrébb hozása
+	Brush	Ecset
+	Brush Name	Ecsetnév
+	Brush name	Ecsetnév
+	Brush picker	Ecsetválasztó
+	Brush Pose	Ecsettartás
+	Brush Preset Options	Ecset-előbeállítás beállításai
+	Brush preview color	Ecset-előnézet színe
+	Brush Projection	Ecsetvetítés
+	Brush Settings…  (F5): every option of this brush	Ecsetbeállítások…  (F5): az ecset összes beállítása
+	Brush Stroke	Ecsetvonás
+	Brush Tip	Ecsethegy
+	Brush Tip Shape	Ecsethegy alakja
+	Brush Tool	Ecset
+	Build-up	Felhalmozódás
+	Burn	Égetés
+	Burn Tool	Égető
+	Butt / Flat	Tompa / lapos
+	Cache Level:	Gyorsítótárszint:
+	Cancel any current edits (Esc)	Folyamatban lévő módosítások elvetése (Esc)
+	Cancel current crop operation  (Esc)	Körbevágás elvetése  (Esc)
+	Cancel transform	Alakítás elvetése
+	Cancel transform (Esc)	Alakítás elvetése (Esc)
+	Cancel warp (Esc)	Hajlítás elvetése (Esc)
+	Canvas	Vászon
+	Caps	Vonalvégek
+	Catch-up on Stroke End	Utolérés a vonás végén
+	Center	Középen
+	Center text	Szöveg középre igazítása
+	Centre the gradient (offset 0, 0)	Színátmenet középre helyezése (eltolás: 0, 0)
+	Change	Cserél
+	Change All	Mindet cserél
+	Change To:	Csere erre:
+	Character	Karakter
+	Check All Layers	Minden réteg ellenőrzése
+	Check Spelling	Helyesírás-ellenőrzés
+	Clear Override	Felülbírálás törlése
+	Clear Selection	Kijelölés törlése
+	Click a red pupil to neutralize it	Kattints egy vörös pupillára a semlegesítéséhez
+	Click to add a point, right-click to remove	Kattintással pontot adhatsz hozzá, jobb kattintással eltávolíthatod
+	Click to apply, {key}-click to clear overrides, double-click for Style Options	Kattintással alkalmazhatod, {key}+kattintással törölheted a felülbírálásokat, dupla kattintással megnyithatod a stílusbeállításokat
+	Click to edit the gradient	Kattints a színátmenet szerkesztéséhez
+	Click to sample the foreground colour  ·  {key}-click for background	Kattintás: mintavétel az előtérszínhez  ·  {key}+kattintás: a háttérszínhez
+	Clone source set at {x}, {y}	Klónozási forrás beállítva: {x}, {y}
+	Clone Stamp	Klónozó bélyegző
+	Close Style Options	Stílusbeállítások bezárása
+	Color	Szín
+	Color Dynamics	Színdinamika
+	Color Picker (Crop Shield Color)	Színválasztó (takarás színe)
+	Color Picker (Solid Color)	Színválasztó (egyszínű kitöltés)
+	Color Picker (Stroke Color)	Színválasztó (körvonalszín)
+	Color Picker (Text Color)	Színválasztó (szövegszín)
+	Color Replacement	Színcserélő
+	Color:	Szín:
+	Commit any current edits ({key})	Folyamatban lévő módosítások véglegesítése ({key})
+	Commit current crop operation  ({key})	Körbevágás véglegesítése  ({key})
+	Commit Puppet Warp ({key})	Bábtorzítás véglegesítése ({key})
+	Commit transform	Alakítás véglegesítése
+	Commit transform ({key})	Alakítás véglegesítése ({key})
+	Commit warp ({key})	Hajlítás véglegesítése ({key})
+	Condensed	Keskeny
+	Content-Aware	Tartalomérzékeny
+	Content-Aware Move	Tartalomérzékeny mozgatás
+	Contiguous	Összefüggő
+	Control:	Vezérlés:
+	Corners	Sarkok
+	Could not complete the Free Transform command because the layer is locked.	A szabad alakítás nem hajtható végre, mert a réteg zárolva van.
+	Could not transform: the layer is empty	Az alakítás nem hajtható végre: a réteg üres
+	Could not use Puppet Warp: no opaque pixels	A bábtorzítás nem használható: nincsenek átlátszatlan pixelek
+	Could not use Puppet Warp: the layer is empty	A bábtorzítás nem használható: a réteg üres
+	Could not use the move tool because the layer is locked.	A Mozgatás eszköz nem használható, mert a réteg zárolva van.
+	Count Jitter	Darabszám ingadozása
+	Create a new elliptical frame	Új ellipszis alakú keret létrehozása
+	Create a new rectangular frame	Új téglalap alakú keret létrehozása
+	Create Ellipse	Ellipszis létrehozása
+	Create new brush from the current settings	Új ecset a jelenlegi beállításokból
+	Create new brush from these settings	Új ecset ezekből a beállításokból
+	Create new brush preset from the current settings	Új ecset-előbeállítás a jelenlegi beállításokból
+	Create new style (from the selected type)	Új stílus létrehozása (a kijelölt szövegből)
+	Create Polygon	Sokszög létrehozása
+	Create Rectangle	Téglalap létrehozása
+	Create Texture	Textúra létrehozása
+	Create Triangle	Háromszög létrehozása
+	Crop Shield color	Takarás színe
+	current	jelenlegi
+	Current	Jelenlegi
+	Current & Below	Jelenlegi és alatta lévők
+	Current & Below No Adjustments	Jelenlegi és alatta lévők, korrekciók nélkül
+	Current Layer	Jelenlegi réteg
+	Custom	Egyéni
+	Cycle Orientation	Tájolás váltása
+	Cycle Overlay	Fedvény váltása
+	Darken Amount	Sötétítés mértéke
+	Dash	Szakasz
+	Dash / gap lengths × stroke width	Szakasz- és hézaghossz × vonalvastagság
+	Dash offset	Szaggatás eltolása
+	Dashed	Szaggatott
+	Dashed line	Szaggatott vonal
+	Degrees	Fok
+	Delete Brush	Ecset törlése
+	Delete brush	Ecset törlése
+	Delete Crop Preset…	Körbevágási előbeállítás törlése…
+	Delete Group	Csoport törlése
+	Delete style	Stílus törlése
+	Density:	Sűrűség:
+	Depth Jitter	Mélység ingadozása
+	Destination	Cél
+	Diagonal	Átlós
+	Diameter	Átmérő
+	Diameter:	Átmérő:
+	Diamond Gradient	Rombusz alakú színátmenet
+	Discontiguous	Nem összefüggő
+	Divide…	Felosztás…
+	Dodge	Derítés
+	Dodge Tool	Derítő
+	Dodge/Burn	Derítés/égetés
+	Done	Kész
+	Dot	Pont
+	Dots	Pontok
+	Dotted	Pontozott
+	Drag a rectangle around the object	Húzz egy téglalapot az objektum köré
+	Drag the arrow to set the angle, the dots to set the roundness	A nyíl húzásával a szöget, a pontokéval a kerekséget állíthatod
+	Dual Axis	Kettős tengely
+	Dual Brush	Kettős ecset
+	Duplicate	Kettőzés
+	Duplicate style	Stílus kettőzése
+	Dynamics	Dinamika
+	Enable Crop Shield	Körbevágási takarás bekapcsolása
+	Enable {name}	Bekapcsolás: {name}
+	Enhance Edge	Élek javítása
+	Enter a name for the crop preset	Add meg a körbevágási előbeállítás nevét
+	Entire Font	Teljes betűtípus
+	Erase	Radírozás
+	Eraser	Radír
+	Expansion:	Bővítés:
+	Exposure:	Expozíció:
+	Extend	Kiterjesztés
+	Extra Bold	Extrakövér
+	Extra Light	Extravékony
+	ExtraBold	Extrakövér
+	ExtraLight	Extravékony
+	Fade	Halványulás
+	Fade steps	Halványulás lépései
+	Faux Bold	Álfélkövér
+	Faux Italic	Áldőlt
+	Fewer Points	Kevesebb pont
+	Fill Layer	Kitöltőréteg
+	Fill new type layers with placeholder	Új szövegrétegek kitöltése helyőrző szöveggel
+	Find Edges	Élkeresés
+	Finger Painting	Ujjfestés
+	First Line Indent	Első sor behúzása
+	Fixed	Rögzített
+	Flip	Tükrözés
+	Flip X	X-tükrözés
+	Flip X Jitter	X-tükrözés ingadozása
+	Flip Y	Y-tükrözés
+	Flip Y Jitter	Y-tükrözés ingadozása
+	Flow	Áramlás
+	Flow Jitter	Áramlás ingadozása
+	Font	Betűtípus
+	Font size	Betűméret
+	Foreground to Background	Előtérszínből háttérszínbe
+	Foreground/Background Jitter	Előtér/háttér ingadozása
+	From Center	Középpontból
+	Front Image	Elülső kép
+	Gap	Hézag
+	General	Általános
+	Glyph	Glifa
+	Golden Ratio	Aranymetszés
+	Golden Spiral	Aranyspirál
+	Gradient	Színátmenet
+	Gradient Editor	Színátmenet-szerkesztő
+	Gradient Options	Színátmenet beállításai
+	Gradient picker	Színátmenet-választó
+	Gradient stops	Színátmenetpontok
+	Grid view	Rácsnézet
+	Grid:	Rács:
+	Group name	Csoport neve
+	H	M
+	Hard	Kemény
+	Hardness	Keménység
+	Hardness:	Keménység:
+	Healing	Javítás
+	Healing Brush	Javítóecset
+	Height	Magasság
+	Height:	Magasság:
+	Hide Auto Slices	Automatikus szeletek elrejtése
+	History Brush	Előzményecset
+	Horizontal scale	Vízszintes méretarány
+	Horizontal type	Vízszintes szöveg
+	Hue Jitter	Színárnyalat ingadozása
+	Hyphenate	Elválasztás
+	Ignore	Kihagy
+	Ignore All	Mindet kihagy
+	Import Brushes…	Ecsetek importálása…
+	Import Brushes… (.abr)	Ecsetek importálása… (.abr)
+	Impressionist	Impresszionista
+	Indent First	Első sor behúzása
+	Indent first line	Első sor behúzása
+	Indent Left	Bal behúzás
+	Indent left margin	Behúzás balról
+	Indent Right	Jobb behúzás
+	Indent right margin	Behúzás jobbról
+	Initial Direction	Kezdeti irány
+	Inside	Belül
+	Interpolation:	Interpoláció:
+	Italic	Dőlt
+	Justification	Sorkizárás
+	Justify	Sorkizárt
+	Justify all	Teljes sorkizárás
+	Justify last centered	Sorkizárt, utolsó sor középen
+	Justify last left	Sorkizárt, utolsó sor balra
+	Justify last right	Sorkizárt, utolsó sor jobbra
+	Kerning	Alávágás
+	Lasso around an area, then drag the selection	Keríts körbe egy területet lasszóval, majd húzd el a kijelölést
+	Leading	Sorköz
+	Leading (set to the font size × auto-leading when Auto)	Sorköz (automatikus értéknél: betűméret × automatikus sorköz)
+	Left align text	Szöveg balra igazítása
+	Letter	Letter
+	Letter Spacing	Betűköz
+	Library	Könyvtár
+	Ligature	Ligatúra
+	Light	Vékony
+	Limits:	Határok:
+	Linear Gradient	Lineáris színátmenet
+	Linear Height	Lineáris magasság
+	Lines	Vonalak
+	Link radii	Sugarak összekapcsolása
+	List view	Listanézet
+	Load	Töltet
+	Loading fonts…	Betűtípusok betöltése…
+	Location	Hely
+	Location:	Hely:
+	Lock: keep these settings when picking another preset	Zárolva: ezek a beállítások megmaradnak, ha másik előbeállítást választasz
+	Loop	Ismétlődés
+	Lorem Ipsum	Lorem ipsum
+	Maintain aspect ratio	Oldalarány megtartása
+	Make Landscape	Fekvő tájolás
+	Make Portrait	Álló tájolás
+	Make Work Path	Munkaútvonal készítése
+	Match Canvas	Vászonnal egyező
+	Mean:	Átlag:
+	Median:	Medián:
+	Medium	Közepes
+	Metrics	Metrikus
+	Minimum Depth	Minimális mélység
+	Minimum Diameter	Minimális átmérő
+	Minimum Roundness	Minimális kerekség
+	Miter	Hegyes
+	Miter limit	Hegyességi korlát
+	Mix	Keverés
+	Mix Jitter	Keverés ingadozása
+	Mixer Brush	Keverőecset
+	Mode:	Mód:
+	More Points	Több pont
+	Mouse	Egér
+	Move	Mozgatás
+	My Brushes	Saját ecsetek
+	Name	Név
+	Nearest Neighbor	Legközelebbi szomszéd
+	Never	Soha
+	Never Show Overlay	Fedvény megjelenítése soha
+	New Brush	Új ecset
+	New Brush Preset	Új ecset-előbeállítás
+	New Brush Preset…	Új ecset-előbeállítás…
+	Capture Brush Size in Preset	Ecsetméret rögzítése az előbeállításban
+	Include Tool Settings	Eszközbeállítások belefoglalása
+	Include Color	Szín belefoglalása
+	Enter a name for the brush preset	Adjon nevet az ecset-előbeállításnak
+	A brush preset with this name already exists	Már van ilyen nevű ecset-előbeállítás
+	New Crop Preset…	Új körbevágási előbeállítás…
+	New Tool Preset	Új eszköz-előbeállítás
+	No brush presets	Nincs ecset-előbeállítás
+	No character style	Nincs karakterstílus
+	No patterns	Nincs mintázat
+	No subject found — try a rectangle around the object	Nem található fő téma – próbálj egy téglalapot húzni az objektum köré
+	No subject found — try Object Selection or the Lasso	Nem található fő téma – próbáld az Objektumkijelölést vagy a Lasszót
+	Noise	Zaj
+	Not in Dictionary:	Nincs a szótárban:
+	Now drag the selection onto another area	Most húzd a kijelölést egy másik területre
+	Object Selection found nothing there — try a tighter rectangle	Az Objektumkijelölés ott nem talált semmit – próbálj szűkebb téglalapot
+	Off	Ki
+	Off: the speed of the pointer sets the spacing	Kikapcsolva: a térközt a mutató sebessége határozza meg
+	Opacity Jitter	Átlátszatlanság ingadozása
+	Opacity:	Átlátszatlanság:
+	Open paths use centered strokes	Nyitott útvonalon a körvonal középre igazított
+	Optical	Optikai
+	Option-click to define a source point to clone from	Option+kattintással add meg a klónozás forráspontját
+	Outside	Kívül
+	Override Pressure	Nyomás felülbírálása
+	Override Rotation	Elforgatás felülbírálása
+	Override Tilt	Dőlés felülbírálása
+	Paints from the document's opening state	A dokumentum megnyitáskori állapotából fest
+	Paper	Papír
+	Paragraph	Bekezdés
+	Patch	Foltozó
+	Patch:	Foltozás:
+	Pattern	Mintázat
+	Pattern Size	Mintázatméret
+	Pattern Stamp	Mintázatbélyegző
+	Pen	Toll
+	Pen Pressure	Tollnyomás
+	Pen Tilt	Tolldőlés
+	Pencil	Ceruza
+	Perspective Crop	Perspektivikus körbevágás
+	Pin Depth:	Tűmélység:
+	Pixels:	Pixelek:
+	Point Sample	Pontminta
+	Pressure curve	Nyomásgörbe
+	Preview Image	Előnézeti kép
+	Pro	Pro
+	Promote	Előléptetés
+	Protect Detail	Részletek védelme
+	Protect Foreground Color	Előtérszín védelme
+	Protect Texture	Textúra védelme
+	Proximity Match	Közelségi egyezés
+	Pulled String Mode	Húzott zsinór mód
+	Punctuation	Írásjelek
+	Pupil Size	Pupillaméret
+	Puppet Warp is not active	A bábtorzítás nem aktív
+	Purity	Színtisztaság
+	Quick Selection found nothing there	A Gyorskijelölés ott nem talált semmit
+	Radial Gradient	Körkörös színátmenet
+	Radius:	Sugár:
+	Ratio	Arány
+	Raw Data	Nyers adatok
+	Recently Used	Legutóbb használt
+	Redefine style by current selection	Stílus újbóli megadása a jelenlegi kijelölésből
+	Reflected Gradient	Tükrözött színátmenet
+	Regular	Normál
+	Remove	Eltávolítás
+	Remove All Pins	Összes tű eltávolítása
+	Remove pair	Pár eltávolítása
+	Rename Brush	Ecset átnevezése
+	Rename Brush…	Ecset átnevezése…
+	Rename Group	Csoport átnevezése
+	Rename Group…	Csoport átnevezése…
+	Reset	Visszaállít
+	Reset Alignment	Igazítás visszaállítása
+	Reset all tools to their default settings?	Visszaállítod az összes eszközt az alapértelmezett beállításokra?
+	Reset the brush to the defaults	Ecset visszaállítása az alapértékekre
+	Restore original size	Eredeti méret visszaállítása
+	Right align text	Szöveg jobbra igazítása
+	Right click with painting tools	Jobb kattintás festőeszközökkel
+	Rigid	Merev
+	Roman	Álló
+	Rotate:	Forgatás:
+	Rotation	Elforgatás
+	Round	Lekerekített
+	Roundness Jitter	Kerekség ingadozása
+	Roundness:	Kerekség:
+	Rule of Thirds	Harmadolási szabály
+	Sample All Layers	Mintavétel minden rétegből
+	Sample Size:	Mintaméret:
+	Sample:	Minta:
+	Sampling: Background Swatch	Mintavétel: háttérszín
+	Sampling: Continuous	Mintavétel: folyamatos
+	Sampling: Once	Mintavétel: egyszeri
+	Saturate	Telítés
+	Saturation Jitter	Telítettség ingadozása
+	Save As Preset	Mentés előbeállításként
+	Scale:	Méretarány:
+	Scatter	Szóródás
+	Scattering	Szóródás
+	Search Brushes	Ecsetek keresése
+	Search fonts	Betűtípusok keresése
+	Select a type layer or click into text to insert glyphs	Glifák beszúrásához jelölj ki egy szövegréteget, vagy kattints a szövegbe
+	Select a type layer to edit its character and paragraph settings.	Jelölj ki egy szövegréteget a karakter- és bekezdésbeállítások szerkesztéséhez.
+	Select text to apply a character style	Karakterstílus alkalmazásához jelölj ki szöveget
+	Select the crop presets to delete	Jelöld ki a törlendő körbevágási előbeállításokat
+	Select the crop presets to delete:	Jelöld ki a törlendő körbevágási előbeállításokat:
+	Semi Bold	Középkövér
+	SemiBold	Középkövér
+	Send the selected pin backward	A kijelölt tű hátrébb küldése
+	Set additional Crop options	További körbevágási beállítások
+	Set painting symmetry options	Festési szimmetria beállításai
+	Set the overlay options for the Crop tool	A Körbevágás eszköz fedvénybeállításai
+	Set the text color	Szövegszín beállítása
+	Settings:	Beállítások:
+	Shape Dynamics	Alakdinamika
+	Sharpen Tool	Élesítő
+	Show bounding box when dragging layer	Határolókeret megjelenítése réteg húzásakor
+	Show Cropped Area	Levágott terület megjelenítése
+	Show Grid	Rács megjelenítése
+	Show highlight on rollover	Kiemelés rámutatáskor
+	Show Sampling Ring	Mintavételi gyűrű megjelenítése
+	Show slice numbers	Szeletszámok megjelenítése
+	Show:	Megjelenítés:
+	Sides:	Oldalak:
+	Size	Méret
+	Size Jitter	Méret ingadozása
+	Slant	Dőlésszög
+	Slice color	Szeletszín
+	Slice Options	Szeletbeállítások
+	Slice Options…	Szeletbeállítások…
+	Slices are locked (View › Lock Slices)	A szeletek zárolva vannak (Nézet › Szeletek zárolása)
+	Slices From Guides	Szeletek segédvonalakból
+	Small Caps	Kiskapitális
+	Smart quotes	Tipográfiai idézőjelek
+	Smoothing	Simítás
+	Smudge	Maszatoló
+	Smudge Tool	Maszatoló
+	Snap to Origin	Illesztés az origóhoz
+	Soft	Lágy
+	Solid	Folytonos
+	Solid Color	Egyszínű
+	Space After	Térköz utána
+	Space Before	Térköz előtte
+	Spacing	Térköz
+	Sparkle	Csillogás
+	Spell check complete.	A helyesírás-ellenőrzés befejeződött.
+	Split:	Felosztás:
+	Sponge Tool	Szivacs
+	Spot Healing Brush	Foltjavító ecset
+	Stamp Down	Másolat egyesítése lefelé
+	Stamp Visible	Láthatók egyesített másolata
+	Star Ratio:	Csillagarány:
+	Std Dev:	Szórás:
+	Straighten the image by drawing a line on it	Húzz egy vonalat a képen a kiegyenesítéshez
+	Strength:	Erősség:
+	Strikethrough	Áthúzás
+	Stroke Catch-up	Vonás utolérése
+	Stroke color	Körvonalszín
+	Stroke Color	Körvonalszín
+	Stroke Options	Körvonal beállításai
+	Structure:	Struktúra:
+	Style Options	Stílusbeállítások
+	Style Options…	Stílusbeállítások…
+	Style: Normal	Stílus: normál
+	Stylus Wheel	Tollkerék
+	Suggestions:	Javaslatok:
+	Swaps height and width	Felcseréli a magasságot és a szélességet
+	Switch between free transform and warp modes	Váltás a szabad alakítás és a hajlítás mód között
+	Symbols	Szimbólumok
+	Symmetry Off	Szimmetria ki
+	Text color	Szövegszín
+	Text engine	Szövegmotor
+	Text Layer	Szövegréteg
+	Texture Each Tip	Textúra hegyenként
+	The gradient the Gradient tool paints with	A Színátmenet eszközzel festett színátmenet
+	There is no crop size or ratio to save	Nincs menthető körbevágási méret vagy arány
+	Thin	Hajszálvékony
+	Tilt Scale	Dőlés méretaránya
+	Tilt X	Dőlés X
+	Tilt Y	Dőlés Y
+	Time	Idő
+	Toggle text orientation	Szövegirány váltása
+	Toggle the Brush Settings panel	Ecsetbeállítások panel megjelenítése/elrejtése
+	Toggle the Brush Settings panel  (F5)	Ecsetbeállítások panel megjelenítése/elrejtése  (F5)
+	Tolerance:	Tűrés:
+	Tool Options	Eszközbeállítások
+	Tracking	Betűköz
+	Tracking (1/1000 em)	Betűköz (1/1000 em)
+	Transfer	Átvitel
+	Transformation	Alakítás
+	Transparent	Átlátszó
+	Triangle	Háromszög
+	Type Options	Szövegbeállítások
+	Type Styles	Szövegstílusok
+	Type units	Szöveg mértékegysége
+	Type:	Típus:
+	Underline	Aláhúzás
+	Unlock	Feloldás
+	Unlock: picking a preset replaces these settings	Feloldva: előbeállítás választásakor ezek a beállítások lecserélődnek
+	Update the current brush with these settings	A jelenlegi ecset frissítése ezekkel a beállításokkal
+	Updates	Frissítések
+	Use Classic Mode	Klasszikus mód használata
+	Use esc to commit	Véglegesítés az Esc billentyűvel
+	Use finite lengths and a positive pattern total	Véges hosszakat adj meg, és a mintázat teljes hossza legyen pozitív
+	Use legacy free transform	Régi szabad alakítás használata
+	Vary round brush hardness on hud	Kerek ecset keménységének állítása a HUD-on
+	Version	Verzió
+	Vertical	Függőleges
+	Vertical scale	Függőleges méretarány
+	Vertical type	Függőleges szöveg
+	W	Sz
+	W x H x Resolution	Sz x M x felbontás
+	Warp Text	Szövegtorzítás
+	Warp:	Hajlítás:
+	Weight	Vastagság
+	Wet	Nedvesség
+	Wet Edges	Nedves szélek
+	Wetness Jitter	Nedvesség ingadozása
+	Width	Szélesség
+	Width:	Szélesség:
+	X	X
+	{key} to subtract	{key}: kivonás
+	{key}-click to set the source	{key}+kattintással állíthatod be a forrást
+	{label} is not available: {reason}	Nem érhető el: {label} ({reason})
+fontWeight	Black	Ultrakövér
+fontWeight	Bold	Félkövér
+fontWeight	ExtraBold	Extrakövér
+fontWeight	ExtraLight	Extravékony
+fontWeight	Italic	Dőlt
+fontWeight	Light	Vékony
+fontWeight	Medium	Közepes
+fontWeight	Regular	Normál
+fontWeight	SemiBold	Középkövér
+fontWeight	Thin	Hajszálvékony
+
+# Layers, masks, layer styles and blend modes
+	30 fps	30 fps
+	Add Layer Above to Selection	Felette lévő réteg hozzáadása a kijelöléshez
+	Add Layer Below to Selection	Alatta lévő réteg hozzáadása a kijelöléshez
+	Adjustment	Korrekció
+	Advanced Blending	Speciális keverés
+	Align and Distribute	Igazítás és elosztás
+	Align {what}	Igazítás: {what}
+	Alpha	Alfa
+	Altitude	Magasság
+	Angle	Szög
+	Anti-aliased	Élsimítás
+	Appearance (Layer Style)	Megjelenés (rétegstílus)
+	Apply Image	Kép alkalmazása
+	Apply Mask	Maszk alkalmazása
+	Apply next selected layer comp	Következő kijelölt rétegkompozíció alkalmazása
+	Apply previous selected layer comp	Előző kijelölt rétegkompozíció alkalmazása
+	Apply {option}: {state}	Alkalmazás – {option}: {state}
+	Bevel & Emboss	Fazetta és domborítás
+	Black & White	Fekete-fehér
+	Blend Clipped Layers as Group	Vágott rétegek keverése csoportként
+	Blend If:	Keverés, ha:
+	Blend Interior Effects as Group	Belső effektusok keverése csoportként
+	Blend Mode	Keverési mód
+	Blending Options	Keverési beállítások
+	Blue	Kék
+	Bold Italic	Félkövér dőlt
+	Calculations	Számítások
+	Capture the visibility, position and style of every layer with + below, then switch between versions.	Az alábbi + gombbal rögzítheted minden réteg láthatóságát, pozícióját és stílusát, majd válthatsz a változatok között.
+	Channel	Csatorna
+	Channels:	Csatornák:
+	Choke	Zsugorítás
+	Clear Brush Strokes	Ecsetvonások törlése
+	CMYK:	CMYK:
+	Collapse	Összecsukás
+	Collapse All Groups	Összes csoport összecsukása
+	Collapse group  ({key}-click: all groups)	Csoport összecsukása  ({key}+kattintás: minden csoport)
+	Color Burn	Színégetés
+	Color Burn (Paint.NET)	Színégetés (Paint.NET)
+	Color Decontaminate	Színszennyeződés eltávolítása
+	Color Dodge	Színderítés
+	Color Dodge (Paint.NET)	Színderítés (Paint.NET)
+	Color indicates	A szín jelöli
+	Color Indicates Masked Areas	A szín a maszkolt területeket jelöli
+	Color Indicates Selected Areas	A szín a kijelölt területeket jelöli
+	Color Overlay	Színfedés
+	Color Picker (Layer Style Color)	Színválasztó (rétegstílus színe)
+	Color Swatches	Színminták
+	Cone	Kúp
+	Cone (Inverted)	Kúp (fordított)
+	Cone - Inverted	Kúp – fordított
+	Confirm	Megerősít
+	Contour	Kontúr
+	Contour Editor	Kontúrszerkesztő
+	Convert to Alpha Channel	Átalakítás alfacsatornává
+	Corner	Sarokpont
+	Cove - Deep	Öböl – mély
+	Cove - Shallow	Öböl – sekély
+	Create new channel	Új csatorna létrehozása
+	Create new layer	Új réteg létrehozása
+	Create new layer comp	Új rétegkompozíció létrehozása
+	Darken	Sötétítés
+	Darker Color	Sötétebb szín
+	Decontaminate	Szennyeződés eltávolítása
+	Deep	Mély
+	Defringe	Szegélyjavítás
+	Delete Channel	Csatorna törlése
+	Delete current channel	Aktuális csatorna törlése
+	Delete layer comp	Rétegkompozíció törlése
+	Delete layer ‘{name}’?	Törlöd ezt a réteget: „{name}”?
+	Delete layer?	Törlöd a réteget?
+	Delete {count} layers? {names}	{count} réteget törölsz? {names}
+	Depth	Mélység
+	Diagonal (Descending)	Átlós (csökkenő)
+	Diamond	Rombusz alakú
+	Difference	Különbség
+	Direction	Irány
+	Dissolve	Szétszórás
+	Distance	Távolság
+	Divide	Osztás
+	Domed	Domború
+	Domed (Inverted)	Domború (fordított)
+	Don't show again	Ne jelenjen meg újra
+	Double click layer mask launches select and mask	A rétegmaszkra duplán kattintva megnyílik a Kijelölés és maszk
+	Down	Le
+	Drop Shadow	Vetett árnyék
+	Drop shadow	Vetett árnyék
+	Duplicate Channel	Csatorna kettőzése
+	Duplicate Layer	Réteg kettőzése
+	Duplicate Layers	Rétegek kettőzése
+	Edge	Szél
+	Exclusion	Kizárás
+	Exit Quick Mask	Kilépés a gyorsmaszkból
+	Expand	Kibontás
+	Expand Detection Area	Észlelési terület bővítése
+	Expand group  ({key}-click: all groups)	Csoport kibontása  ({key}+kattintás: minden csoport)
+	F cycles the views; hold X to see the image	Az F lépteti a nézeteket; az X nyomva tartásával a kép látszik
+	File Format	Fájlformátum
+	Fill Opacity	Kitöltés átlátszatlansága
+	From	Kezdőszín
+	Fuchsia	Fukszia
+	Gaussian	Gauss
+	General Blend	Általános keverés
+	General Blending	Általános keverés
+	Global Light	Globális fény
+	Gloss Contour	Csillogáskontúr
+	Glow	Izzás
+	GPU backend	GPU-háttérrendszer
+	Gradient Overlay	Színátmenet-fedés
+	Gray	Szürke
+	Green	Zöld
+	Group	Csoport
+	Half Round	Félkör
+	Hard Light	Kemény fény
+	Hard Mix	Kemény keverés
+	Hide the layer's effects  ({key}-click: all layers)	Réteg effektusainak elrejtése  ({key}+kattintás: minden réteg)
+	Horizontally	Vízszintesen
+	Indigo	Indigó
+	Information	Információ
+	Inner Bevel	Belső fazetta
+	Inner Glow	Belső ragyogás
+	Inner Shadow	Belső árnyék
+	Invalid delete command	Érvénytelen törlési parancs
+	Invert	Invertálás
+	Knockout	Kiütés
+	Lab	Lab
+	Last Document State	Dokumentum utolsó állapota
+	Layer deleted, but confirmation preference could not be saved: {error}	A réteg törölve, de a megerősítési beállítás nem menthető: {error}
+	Layer Knocks Out Drop Shadow	A réteg kiüti a vetett árnyékot
+	layer mask	rétegmaszk
+	Layer Mask Hides Effects	A rétegmaszk elrejti az effektusokat
+	Lighten	Világosítás
+	Lighter Color	Világosabb szín
+	Linear	Lineáris
+	Linear Burn	Lineáris égetés
+	Linear Dodge	Lineáris derítés
+	Linear Dodge (Add)	Lineáris derítés (összeadás)
+	Linear Light	Lineáris fény
+	Link	Összekapcsolás
+	Link the mask to the layer	Maszk összekapcsolása a réteggel
+	Link width and height	Szélesség és magasság összekapcsolása
+	Link with Layer	Összekapcsolás a réteggel
+	Load channel as selection	Csatorna betöltése kijelölésként
+	Load Selection	Kijelölés betöltése
+	Load…	Betöltés…
+	Lock Layers	Rétegek zárolása
+	Luminosity	Fényesség
+	Magenta	Magenta
+	Make Default	Legyen alapértelmezett
+	Marching Ants	Menetelő hangyák
+	Masked Areas	Maszkolt területek
+	Masks	Maszkok
+	Merge Channels…	Csatornák egyesítése…
+	Merge Spot Channel	Direktszín-csatorna egyesítése
+	Method	Módszer
+	Minimum	Minimum
+	Missing delete command	Hiányzó törlési parancs
+	Mode	Mód
+	Multiply	Szorzás
+	Negation	Negálás
+	New Channel	Új csatorna
+	New Channel…	Új csatorna…
+	New Spot Channel…	Új direktszín-csatorna…
+	New Style…	Új stílus…
+	Next	Tovább
+	No Color	Nincs szín
+	No document	Nincs dokumentum
+	No Image	Nincs kép
+	No selection	Nincs kijelölés
+	Normal	Normál
+	off	ki
+	On Black	Feketén
+	On Layers	Rétegeken
+	On White	Fehéren
+	Onion Skin	Hagymahéj
+	Opacity	Átlátszatlanság
+	Open Folder	Mappa megnyitása
+	Operation	Művelet
+	Outer Bevel	Külső fazetta
+	Outer Glow	Külső ragyogás
+	Overlay	Átfedés
+	Overlay Color	Átfedés színe
+	Overlay Opacity	Átfedés átlátszatlansága
+	Paint over hair or fur on the image; Alt paints the other mode	Fesd át a hajat vagy a szőrzetet a képen; Alt lenyomásával a másik módban festesz
+	Pass Through	Áteresztés
+	Pattern Overlay	Mintázatfedés
+	Pillow Emboss	Párnás domborítás
+	Pin Light	Pontfény
+	Pixel	Pixel
+	Position	Pozíció
+	Precise	Pontos
+	Preserve Transparency	Átlátszóság megőrzése
+	Quick Mask	Gyorsmaszk
+	Radial	Körkörös
+	Red	Vörös
+	Refine	Finomítás
+	Refine Edge Brush (R)	Élfinomító ecset (R)
+	Refine Strokes	Finomító ecsetvonások
+	Reflect	Visszaverődés
+	Reflected	Tükrözött
+	Rename Channel…	Csatorna átnevezése…
+	Reorder Layer	Réteg átrendezése
+	Reset to Default	Visszaállítás alapértelmezettre
+	Restore Original Edge	Eredeti él visszaállítása
+	Reverse	Megfordítás
+	RGB:	RGB:
+	Ring	Gyűrű
+	Ring - Double	Gyűrű – dupla
+	Rolling Slope - Descending	Hullámos lejtő – csökkenő
+	Rounded Steps	Lekerekített lépcsők
+	Satin	Szatén
+	Save Selection	Kijelölés mentése
+	Save selection as channel	Kijelölés mentése csatornaként
+	Save…	Mentés…
+	Sawtooth 1	Fűrészfog 1
+	Scale Effects	Effektusok méretezése
+	Screen	Képernyő
+	Seafoam	Tengerzöld
+	Select All Layers	Összes réteg kijelölése
+	Select Bottom Layer	Legalsó réteg kijelölése
+	Select Layer Above	Felette lévő réteg kijelölése
+	Select Layer Below	Alatta lévő réteg kijelölése
+	Select Top Layer	Legfelső réteg kijelölése
+	Selected Areas	Kijelölt területek
+	Shadow	Árnyék
+	Shallow	Sekély
+	Show Edge	Él megjelenítése
+	Show Original	Eredeti megjelenítése
+	Show the layer mask as an overlay	Rétegmaszk megjelenítése átfedésként
+	Show the layer's effects  ({key}-click: all layers)	Réteg effektusainak megjelenítése  ({key}+kattintás: minden réteg)
+	Skip	Kihagy
+	Smart Filters	Intelligens szűrők
+	Soft Light	Lágy fény
+	Soften	Lágyítás
+	Source	Forrás
+	Split Channels	Csatornák szétválasztása
+	Spot	Direktszín
+	Spot Channel	Direktszín-csatorna
+	Spot Color	Direktszín
+	Spread	Kiterjedés
+	Stroke	Körvonal
+	Style {name} saved	Stílus mentve: {name}
+	Subtract	Kivonás
+	The document is closed	A dokumentum be van zárva
+	The document or selected layers changed. Please request deletion again.	A dokumentum vagy a kijelölt rétegek megváltoztak. Kérd újra a törlést.
+	This Layer:	Ez a réteg:
+	To	Végszín
+	Toggle visibility	Láthatóság váltása
+	Transparency Shapes Layer	Az átlátszóság alakítja a réteget
+	UI scale	Felület méretezése
+	Underlying Layer:	Alatta lévő réteg:
+	Unlink	Szétkapcsolás
+	Unlink the mask from the layer	Maszk szétkapcsolása a rétegtől
+	Up	Fel
+	Update layer comp (visibility, position and appearance)	Rétegkompozíció frissítése (láthatóság, pozíció és megjelenés)
+	Use Global Light	Globális fény használata
+	vector mask	vektormaszk
+	Vector Mask Hides Effects	A vektormaszk elrejti az effektusokat
+	Vertically	Függőlegesen
+	Visibility	Láthatóság
+	Vivid Light	Élénk fény
+	XOR	XOR
+	Yellow	Sárga
+	{verb} {mask} {layer}	{verb}: {mask} ({layer})
+layerLabel	No Color	Nincs szín
+layerLabel	Red	Piros
+layerLabel	Magenta	Bíbor
+	Use Previous Layer to Create Clipping Mask	Vágómaszk létrehozása az előző réteggel
+	Fill with {mode}-neutral color (white)	Kitöltés {mode} módhoz semleges színnel (fehér)
+	Fill with {mode}-neutral color (black)	Kitöltés {mode} módhoz semleges színnel (fekete)
+	Fill with {mode}-neutral color (50% gray)	Kitöltés {mode} módhoz semleges színnel (50%-os szürke)
+	(No neutral color exists for {mode} mode.)	({mode} módhoz nincs semleges szín.)
+
+# Panels
+	(none)	(nincs)
+	+ Add variable	+ Változó hozzáadása
+	30 frames @ 30 fps	30 képkocka, 30 fps
+	32-bit Preview Options	32 bites előnézet beállításai
+	50% Gray	50%-os szürke
+	80%	80%
+	A save to {name} is still running; try again when it finishes	Még tart egy mentés ide: {name}; próbáld újra, ha befejeződött
+	Add a layer style	Rétegstílus hozzáadása
+	Add a mask  (from the selection; {key} inverts)	Maszk hozzáadása  (a kijelölésből; {key}: invertálás)
+	Add an adjustment	Korrekció hozzáadása
+	Add to selection  ({key})	Hozzáadás a kijelöléshez  ({key})
+	Add vector mask	Vektormaszk hozzáadása
+	Added swatch {name}	Színminta hozzáadva: {name}
+	Adjustment visible	Korrekció látható
+	Align and distribute	Igazítás és elosztás
+	Align horizontal centers	Igazítás a vízszintes középvonalakhoz
+	Align left edges	Igazítás a bal szélekhez
+	Align right edges	Igazítás a jobb szélekhez
+	Always use pressure for opacity	Mindig nyomásfüggő átlátszatlanság
+	Always use pressure for size	Mindig nyomásfüggő méret
+	Appearance Mode	Megjelenési mód
+	Presentation	Megjelenítés
+	Auto Erase	Automatikus radírozás
+	Auto Hide	Automatikus elrejtés
+	Auto-Select:	Automatikus kijelölés:
+	Beep when done	Hangjelzés befejezéskor
+	Brush Preset picker	Ecset-előbeállítás-választó
+	Capture	Rögzítés
+	Change Screen Mode  (F)	Képernyőmód váltása  (F)
+	Click the first point or press {key} to close · Esc cancels	Lezárás: kattintás az első pontra vagy {key} · Esc: megszakítás
+	Click the first point or press {key} to close · {del} removes a point · Esc cancels	Lezárás: kattintás az első pontra vagy {key} · {del}: pont eltávolítása · Esc: megszakítás
+	Click to fill similar colours	Kattintással kitöltheted a hasonló színeket
+	Click to zoom in  ·  {key}-click to zoom out  ·  drag right/left to zoom in/out	Kattintás: nagyítás  ·  {key}+kattintás: kicsinyítés  ·  húzás jobbra/balra: nagyítás/kicsinyítés
+	Click, then move along an edge · click to fasten a point · {alt}-click for a straight segment · double-click to close	Kattints, majd haladj végig egy élen · kattintás: pont rögzítése · {alt}+kattintás: egyenes szakasz · dupla kattintás: lezárás
+	Clip to layer below	Vágás az alatta lévő réteghez
+	Clipped	Vágott
+	Clone source {n} ({key}-click with Clone Stamp to set)	Klónozási forrás: {n} (beállítás: {key}+kattintás a klónozó bélyegzővel)
+	Close Tab Group	Lapcsoport bezárása
+	Collapse Panel Group	Panelcsoport összecsukása
+	Color & Swatches	Szín és színminták
+	Conform	Nyújtás
+	Create a new group	Új csoport létrehozása
+	Create a new layer	Új réteg létrehozása
+	Create new document from current state	Új dokumentum az aktuális állapotból
+	Create new fill or adjustment layer	Új kitöltő- vagy korrekciós réteg létrehozása
+	Create new gradient	Új színátmenet létrehozása
+	Create new group	Új csoport létrehozása
+	Create new pattern from the selection	Új mintázat létrehozása a kijelölésből
+	Create new shape from the current path	Új alakzat létrehozása az aktuális útvonalból
+	Create new snapshot	Új pillanatkép létrehozása
+	Create new style from the selected layer	Új stílus létrehozása a kijelölt rétegből
+	Create new swatch	Új színminta létrehozása
+	Create new tool preset	Új eszköz-előbeállítás létrehozása
+	Create Video Timeline	Videó-idővonal létrehozása
+	Create Warped Text	Torzított szöveg létrehozása
+	Current Tool Only	Csak az aktuális eszköz
+	Curves	Görbék
+	Dark	Sötét
+	Data Set: {name}  ({index}/{total})	Adatkészlet: {name}  ({index}/{total})
+	Data Sets	Adatkészletek
+	Default colours (D)	Alapértelmezett színek (D)
+	Define	Megadás
+	Define at least one variable first.	Előbb adj meg legalább egy változót.
+	Delete Cropped Pixels	Levágott pixelek törlése
+	Delete current state	Aktuális állapot törlése
+	Delete layer	Réteg törlése
+	Delete Timeline	Idővonal törlése
+	Delete Tool Preset	Eszköz-előbeállítás törlése
+	Delete tool preset	Eszköz-előbeállítás törlése
+	Delete Workspace	Munkaterület törlése
+	Discord	Discord
+	Doc: {w} × {h} px	Dok.: {w} × {h} px
+	Drag a box or click four corners · drag the corners onto the edges of a skewed shape · {commit} commits · Esc cancels	Húzz egy keretet, vagy kattints a négy sarokra · húzd a sarkokat a ferde alakzat éleire · {commit}: véglegesítés · Esc: megszakítás
+	Drag a crop box · drag inside to move · edges resize ({ratio} ratio, {centre} centre) · Space moves while drawing · arrows nudge · X swaps orientation · {commit} commits · Esc cancels	Húzz egy körbevágási keretet · belül húzva mozgatod · az élekkel átméretezed ({ratio}: arány, {centre}: középről) · Space: mozgatás rajzolás közben · nyilak: léptetés · X: tájolás cseréje · {commit}: véglegesítés · Esc: megszakítás
+	Drag around the centre to rotate the view  ·  Shift constrains to 15°	A középpont körül húzva forgatod a nézetet  ·  Shift: 15°-os lépések
+	Drag or click polygon points · hold Alt during lasso for straight segments · {add} add · {sub} before drawing subtracts	Húzz, vagy kattints sokszögpontokat · lasszózás közben Alt: egyenes szakaszok · {add}: hozzáadás · {sub} rajzolás előtt: kivonás
+	Drag to draw a gradient	Húzással rajzolhatsz színátmenetet
+	Drag to move the active layer	Húzással mozgathatod az aktív réteget
+	Drag to pan  ·  hold Space with any tool	Húzással mozgathatod a nézetet  ·  bármely eszköznél: Space nyomva tartása
+	Duration	Időtartam
+	Edit in Quick Mask Mode  (Q)	Szerkesztés gyorsmaszk módban  (Q)
+	Edit in Standard Mode  (Q)	Szerkesztés normál módban  (Q)
+	Edit Toolbar	Eszköztár szerkesztése
+	Edit Toolbar…	Eszköztár szerkesztése…
+	Enable airbrush-style build-up effects	Festékszóró-szerű felhalmozódás bekapcsolása
+	Esc to cancel	Esc: megszakítás
+	Expand Panel Group	Panelcsoport kibontása
+	Export Swatches for Exchange…	Színminták exportálása cseréhez…
+	Export Swatches…	Színminták exportálása…
+	Exposure and Gamma	Expozíció és gamma
+	Factor:	Tényező:
+	Fill:	Kitöltés:
+	Filter for adjustment layers	Szűrés korrekciós rétegekre
+	Filter for pixel layers	Szűrés pixelrétegekre
+	Filter for shape layers	Szűrés alakzatrétegekre
+	Filter for smart objects	Szűrés intelligens objektumokra
+	Filter for type layers	Szűrés szövegrétegekre
+	Fit	Igazítás
+	Fit Screen	Képernyőhöz igazítás
+	Fixed Ratio	Rögzített arány
+	Fixed Size	Rögzített méret
+	Folder	Mappa
+	Follows only edges this close to the pointer ([ and ] change it)	Csak a mutatóhoz ennyire közeli éleket követi (a [ és a ] módosítja)
+	Foreground	Előtérszín
+	Frame {current} / {total}	Képkocka: {current} / {total}
+	Frequency	Gyakoriság
+	Gamma:	Gamma:
+	gradients	színátmenetek
+	Group with	Csoportosítás ezzel
+	Group · {n} layer	Csoport · {n} réteg
+	Heart	Szív
+	Hide Properties	Tulajdonságok elrejtése
+	Higher values follow only edges that contrast sharply with their surroundings	Nagyobb értéknél csak a környezetüktől élesen elütő éleket követi
+	Highlight Compression	Csúcsfény-tömörítés
+	Hold Alt while drawing for straight segments	Rajzolás közben az Alt nyomva tartásával egyenes szakaszokat húzhatsz
+	How often fastening points are placed by themselves	Milyen gyakran kerülnek le automatikusan rögzítőpontok
+	Hsb	HSB
+	image file path	képfájl elérési útja
+	Import Brushes	Ecsetek importálása
+	Import Swatches…	Színminták importálása…
+	Imported	Importált
+	Importing {what} from {file}…	{what} importálása. Forrás: {file}…
+	Intersect with	Metszet ezzel
+	Intersect with selection  ({key})	Metszet a kijelöléssel  ({key})
+	Invalid panel layout; restored the default dock	Érvénytelen panelelrendezés; az alapértelmezett dokkolás visszaállítva
+	Join the ArtCraft Discord ({url})	Csatlakozz az ArtCraft Discord-szerveréhez ({url})
+	Keyboard Shortcuts	Billentyűparancsok
+	Kind	Fajta
+	Lasso	Lasszó
+	Link layers	Rétegek összekapcsolása
+	Lock	Zárolás
+	Lock all	Összes zárolása
+	Lock image pixels	Képpixelek zárolása
+	Lock layer	Réteg zárolása
+	Lock position	Pozíció zárolása
+	Lock transparent pixels	Átlátszó pixelek zárolása
+	Lock:	Zárolás:
+	Marquee	Kijelölőkeret
+	Menus	Menük
+	Move Group Down	Csoport mozgatása lefelé
+	Move Group Up	Csoport mozgatása felfelé
+	Move to	Áthelyezés ide
+	Name:	Név:
+	New selection	Új kijelölés
+	New Swatch Group…	Új színmintacsoport…
+	New Swatch…	Új színminta…
+	New Workspace	Új munkaterület
+	Next frame	Következő képkocka
+	No custom shape "{name}": pick one in the options bar or Window › Shapes	Nincs ilyen egyéni alakzat: „{name}”; válassz egyet a beállítósávon vagy az Ablak › Alakzatok panelen
+	No presets for the current tool.	Az aktuális eszközhöz nincs előbeállítás.
+	No properties	Nincsenek tulajdonságok
+	No tool presets.	Nincs eszköz-előbeállítás.
+	Open a document to define variables.	Változók megadásához nyiss meg egy dokumentumot.
+	Open a document to use the timeline.	Az idővonal használatához nyiss meg egy dokumentumot.
+	Opening	Megnyitás
+	Opening {name}	Megnyitás: {name}
+	Opening {name}…	Megnyitás: {name}…
+	Panel	Panel
+	Panel locations are saved in the workspace. Keyboard shortcuts, menus and toolbar are optional.	A panelek helye a munkaterülettel együtt mentődik. A billentyűparancsok, a menük és az eszköztár mentése választható.
+	Panel menu	Panelmenü
+	Patterns	Mintázatok
+	Pause	Szünet
+	Pixel Replacement	Pixelcsere
+	Play	Lejátszás
+	Pressure for Opacity	Nyomásfüggő átlátszatlanság
+	Pressure for Size	Nyomásfüggő méret
+	Prevent auto-nesting in and out of Artboards and Frames	Automatikus be- és kiágyazás tiltása rajztábláknál és kereteknél
+	Previous frame	Előző képkocka
+	Quick Actions	Gyorsműveletek
+	Rasterize Fill Content	Kitöltés tartalmának raszterizálása
+	Rasterize Smart Object	Intelligens objektum raszterizálása
+	Reading…	Olvasás…
+	Remember workspace changes	Munkaterület-módosítások megjegyzése
+	Remove Background	Háttér eltávolítása
+	Remove variable	Változó eltávolítása
+	Rename Tool Preset	Eszköz-előbeállítás átnevezése
+	Rename Tool Preset…	Eszköz-előbeállítás átnevezése…
+	Rename…	Átnevezés…
+	Replace Swatches…	Színminták cseréje…
+	Reset Swatches	Színminták visszaállítása
+	Reset Transform	Alakítás visszaállítása
+	Resize panel window	Panelablak átméretezése
+	Resize panels	Panelek átméretezése
+	Sample Size	Mintaméret
+	Save File	Fájl mentése
+	Save Pixel Aspect Ratio	Pixelarány mentése
+	Saving {name}	Mentés: {name}
+	Scrubby Zoom	Húzásos nagyítás
+	Search commands	Parancsok keresése
+	Search commands, tools and panels	Parancsok, eszközök és panelek keresése
+	Search commands, tools and panels…	Parancsok, eszközök és panelek keresése…
+	Select Subject	Fő téma kijelölése
+	Set additional smoothing options	További simítási beállítások
+	Set background color	Háttérszín beállítása
+	Set foreground color	Előtérszín beállítása
+	Shape:	Alakzat:
+	Shift	Shift
+	Show Extras Options	Segédelemek beállításai
+	Show Overlay	Átfedés megjelenítése
+	Show Transform Controls	Alakítási vezérlők megjelenítése
+	Size:	Méret:
+	Source: not set ({key}-click with Clone Stamp)	Forrás: nincs beállítva ({key}+kattintás a klónozó bélyegzővel)
+	Source: set	Forrás: beállítva
+	Style	Stílus
+	Subtract from selection  ({key})	Kivonás a kijelölésből  ({key})
+	Swap colours (X)	Színek cseréje (X)
+	System title bar	Rendszer címsora
+	Text Replacement	Szövegcsere
+	Thumbnail size (smallest: list)	Bélyegképméret (a legkisebb: lista)
+	Tolerance	Tűrés
+	Toolbar	Eszköztár
+	Type Layer	Szövegréteg
+	Ungroup	Csoport bontása
+	Use tablet pressure to change pen width	A tablet nyomása módosítja a toll szélességét
+	Variables bind a layer's visibility, text or pixels to a named data slot.	A változók egy réteg láthatóságát, szövegét vagy pixeleit egy elnevezett adatmezőhöz kötik.
+	Visible	Látható
+	Warning	Figyelmeztetés
+	Working…	Feldolgozás…
+	Workspaces	Munkaterületek
+	Zoom	Nagyító
+	{label} is writing the file and can no longer be cancelled	{label}: a fájl írása folyamatban, már nem szakítható meg
+	{message} (notes: {n}; {warning})	{message} (megjegyzések: {n}; {warning})
+	{mode} Color · {bits} bit	Színmód: {mode} · {bits} bit
+	{name} Properties	Tulajdonságok: {name}
+	↑↓ navigate   {key} run   esc close	↑↓ navigálás   {key} futtatás   esc bezárás
+navigator	Zoom	Nagyítás mértéke
+
+# Adjustments and filters
+	3D LUT File	3D LUT-fájl
+	90%	90%
+	Absolute	Abszolút
+	Accented Edges	Kiemelt élek
+	Adaptive Wide Angle isn't open	Az Adaptív nagy látószög nincs megnyitva
+	Add Noise	Zaj hozzáadása
+	Add Stop	Átmenetpont hozzáadása
+	Add to Sample	Hozzáadás a mintához
+	Adjust Interval For Loops	Térköz igazítása hurkokhoz
+	Adjustment Preview	Korrekció előnézete
+	Amount	Mérték
+	Amplitude Max	Legnagyobb amplitúdó
+	Amplitude Min	Legkisebb amplitúdó
+	Angled Strokes	Ferde vonások
+	Arbitrary	Tetszőleges
+	Around Center	Középpont körül
+	Artistic	Művészi
+	Author:	Szerző:
+	Auto	Automatikus
+	Automatically level near-horizontal line segments	A közel vízszintes szakaszok automatikus vízszintesre állítása
+	Automatically straighten and level	Automatikus függőlegesre és vízszintesre állítás
+	Automatically straighten near-vertical line segments	A közel függőleges szakaszok automatikus függőlegesre állítása
+	Background Level	Háttérszint
+	Bamboo	Bambusz
+	Bas Relief	Dombormű
+	Base Tree Type	Fa alaptípusa
+	Berries	Bogyók
+	Best	Legjobb
+	Black Clip	Fekete levágása
+	Black Intensity	Fekete intenzitása
+	Black Matte	Fekete háttér
+	Blacks	Feketék
+	Blend If	Keverés, ha
+	Blocks	Tömbök
+	Blue Yellow	Kék–sárga
+	Blues	Kékek
+	Blur Angle	Elmosás szöge
+	Border Thickness	Szegély vastagsága
+	Both	Mindkettő
+	Bottom	Alul
+	Box Blur	Dobozelmosás
+	Branches Color	Ágak színe
+	Branches Height	Ágak magassága
+	Branches Thickness	Ágak vastagsága
+	Brick	Tégla
+	Brightness	Fényerő
+	Brightness/Contrast	Fényerő/kontraszt
+	Bristle Detail	Sörték részletessége
+	Brush Detail	Ecset részletessége
+	Brush Reconstruct Options	Ecsetes helyreállítás beállításai
+	Brush Size	Ecsetméret
+	Brush Strokes	Ecsetvonások
+	Brush Tool Options	Ecset beállításai
+	Brush Type	Ecsettípus
+	Burlap	Zsákvászon
+	Camera Calibration	Fényképezőgép-kalibráció
+	Cancel (Esc)	Mégse (Esc)
+	Manage submitted jobs in the system print queue	Az elküldött feladatok kezelése a rendszer nyomtatási sorában
+	Candle Light	Gyertyaláng
+	Cell Size	Cellaméret
+	Center X	Középpont X
+	Center Y	Középpont Y
+	Chalk & Charcoal	Kréta és szén
+	Chalk Area	Krétás terület
+	Channel Mixer	Csatornakeverő
+	Channel:	Csatorna:
+	Charcoal	Szénrajz
+	Charcoal Area	Szenes terület
+	Charcoal Thickness	Szén vastagsága
+	Chrome	Króm
+	Clear All	Összes törlése
+	Clear Amount	Tiszta terület mértéke
+	Clear Samples	Minták törlése
+	Click to add a point · drag off or {key}-click or Delete to remove	Kattintással pontot adhatsz hozzá · eltávolítás: lehúzás, {key}+kattintás vagy Delete
+	Click to place · Alt-click or drag off-canvas to remove	Kattintással elhelyezheted · eltávolítás: Alt+kattintás vagy a vásznon kívülre húzás
+	Click with the Note tool to add a note.	Jegyzet hozzáadásához kattints a Jegyzet eszközzel.
+	Clumped	Csomós
+	Coarse Dots	Durva pontok
+	Color Balance	Színegyensúly
+	Color Halftone	Színes féltónus
+	Color Lookup	Színleképezés
+	Color Range preview	Színtartomány előnézete
+	Colored Pencil	Színes ceruza
+	Colorize	Színezés
+	Colors	Színek
+	Commit Perspective Warp ({key})	Perspektivikus torzítás véglegesítése ({key})
+	Constant	Állandó
+	Constraints ({n})	Kényszerek ({n})
+	Continue	Folytat
+	Contrast	Kontraszt
+	Contrasty	Kontrasztos
+	Conté Crayon	Conté-kréta
+	Cooling L B B	Hűtőszűrő (LBB)
+	Cooling80	Hűtőszűrő (80)
+	Cooling82	Hűtőszűrő (82)
+	Correction	Korrekció
+	Could not use Perspective Warp: the layer is empty	A perspektivikus torzítás nem használható: a réteg üres
+	Count: {n}	Darabszám: {n}
+	Crack Brightness	Repedések fényereje
+	Crack Depth	Repedések mélysége
+	Crack Spacing	Repedések térköze
+	Craquelure	Krakelé
+	Create a new count group	Új számlálócsoport létrehozása
+	Crop Factor	Szűkítési tényező
+	Crosshatch	Keresztsraffozás
+	Crystallize	Kristályosítás
+	Curve Splits	Görbe osztáspontjai
+	Custom Branch Color	Egyéni ágszín
+	Cutout	Papírkivágás
+	Cyan	Cián
+	Cyan  ·  Red	Cián  ·  Vörös
+	Cyans	Ciánok
+	Daisies	Margaréták
+	Dark Intensity	Sötét intenzitása
+	Dark Rough	Sötét, durva
+	Dark Strokes	Sötét vonások
+	Darken Only	Csak sötétítés
+	Darkness	Sötétség
+	De-Interlace	Váltott soros megjelenítés megszüntetése
+	Deep Blue	Mélykék
+	Deep Emerald	Mély smaragd
+	Deep Red	Mélyvörös
+	Deep Yellow	Mélysárga
+	Default	Alapértelmezett
+	Default Leaves	Alapértelmezett levelek
+	Definition	Határozottság
+	Delete count group	Számlálócsoport törlése
+	Delete effect layer	Effektusréteg törlése
+	Delete note	Jegyzet törlése
+	Delete selected measurements	Kijelölt mérések törlése
+	Density	Sűrűség
+	Depth Map	Mélységtérkép
+	Deselect All	Összes kijelölés megszüntetése
+	Diffuse	Diffúzió
+	Diffuse Glow	Szórt ragyogás
+	Direction Balance	Irányegyensúly
+	Displace	Elmozdítás
+	Display Text	Szöveg megjelenítése
+	Distortion	Torzítás
+	Dither	Árnyalatkeverés
+	Double Line	Kettős vonal
+	Drag on the image to add a constraint; Shift for horizontal/vertical; right-click to delete.	Húzással kényszert adhatsz a képhez; Shift: vízszintes/függőleges; jobb kattintás: törlés.
+	Dry Brush	Száraz ecset
+	Dust & Scratches	Por és karcolások
+	Dynamic color sliders	Dinamikus színcsúszkák
+	Edge Brightness	Élek fényereje
+	Edge Fidelity	Élhűség
+	Edge Intensity	Élek intenzitása
+	Edge Only	Csak élek
+	Edge Simplicity	Élek egyszerűsége
+	Edge Thickness	Élvastagság
+	Edge Width	Élszélesség
+	Emboss	Domborítás
+	Enlarged	Nagyított
+	Export selected measurements (CSV)	Kijelölt mérések exportálása (CSV)
+	Exposure	Expozíció
+	Extrude	Kihúzás
+	Eyedropper	Pipetta
+	Eyedroppers:	Pipetták:
+	Fast	Gyors
+	Fiber Length	Szálhossz
+	Fibers	Szálak
+	Field Blur	Mezőelmosás
+	Film Grain	Filmszemcse
+	Filter Gallery	Szűrőgaléria
+	Filter:	Szűrő:
+	Fine Dots	Finom pontok
+	Fisheye	Halszem
+	Fit in View	Igazítás a nézethez
+	Flame Bottom Alignment	Lángalap igazítása
+	Flame Lines	Lángvonalak
+	Flame Shape	Lángalak
+	Flame Style	Lángstílus
+	Flame Type	Lángtípus
+	Flat Shading	Lapos árnyalás
+	Flower Color	Virágszín
+	Focal Distance	Fókusztávolság
+	Focal Length	Gyújtótávolság
+	Font Size:	Betűméret:
+	Foreground Level	Előtérszint
+	Free	Szabad
+	Freeze Lasso: drag to freeze an area, Alt-drag to thaw it (L)	Fagyasztólasszó: húzással fagyaszthatsz egy területet, Alt+húzással feloldhatod (L)
+	Fresco	Freskó
+	From Right	Jobbról
+	Frosted	Mattüveg
+	Full Spherical	Teljes gömb
+	Fuzziness	Elmosódottság
+	Fuzziness:	Elmosódottság:
+	Gamma	Gamma
+	Gamma Correction	Gammakorrekció
+	Gaussian Blur	Gauss-elmosás
+	Glass	Üveg
+	Glow Amount	Ragyogás mértéke
+	Glow Brightness	Ragyogás fényereje
+	Glow Color	Ragyogás színe
+	Glow Size	Ragyogás mérete
+	Glowing Edges	Izzó élek
+	Gradient Map	Színátmenet-leképezés
+	Grain	Szemcse
+	Grain Type	Szemcsetípus
+	Graininess	Szemcsésség
+	Grainy Dots	Szemcsés pontok
+	Graphic Pen	Grafikus toll
+	Greens	Zöldek
+	Grid size	Rácsméret
+	Grout Width	Fugaszélesség
+	Halftone Pattern	Féltónusmintázat
+	HDR Toning	HDR-tónusozás
+	Hearts	Szívek
+	High Pass	Felüláteresztő
+	Highlight	Csúcsfény
+	Highlight Amount	Csúcsfény mértéke
+	Highlight Area	Csúcsfény-terület
+	Highlight Radius	Csúcsfény sugara
+	Highlight Strength	Csúcsfény erőssége
+	Highlight Tone	Csúcsfény tónusa
+	Highlights	Csúcsfények
+	Highlights from:	Csúcsfények ettől:
+	Horizontal Only	Csak vízszintes
+	Hue	Színárnyalat
+	Hue/Saturation	Színárnyalat/telítettség
+	Image Balance	Képegyensúly
+	In Black	Bemeneti fekete
+	In White	Bemeneti fehér
+	Ink Outlines	Tintakörvonalak
+	Input:	Bemenet:
+	Intensity	Intenzitás
+	Invert All	Összes invertálása
+	Invert has no settings.	Az Invertálásnak nincsenek beállításai.
+	Invert Mask	Maszk invertálása
+	Iris Blur	Íriszelmosás
+	ISO	ISO
+	Ivy	Borostyán
+	Label Size	Címkeméret
+	Layout	Elrendezés
+	Leaf Color	Levélszín
+	Leaves Amount	Levelek mennyisége
+	Leaves Color	Levelek színe
+	Leaves Size	Levélméret
+	Left Diagonal	Balra átlós
+	Legacy	Régi
+	Length:	Hossz:
+	Lens Blur	Objektívelmosás
+	Lens Flare	Lencsecsillanás
+	Less	Kevesebb
+	Level	Szint
+	Level Based	Szintalapú
+	Levels	Szintek
+	Light Dark Balance	Világos–sötét egyensúly
+	Light Direction	Fény iránya
+	Light Intensity	Fényintenzitás
+	Light Rough	Világos, durva
+	Light Source	Fényforrás
+	Lighten Grout	Fuga világosítása
+	Lighten Only	Csak világosítás
+	Lighting Effects	Fényhatások
+	Lightness	Világosság
+	Liquify is not open	A Képlékenyítés nincs megnyitva
+	Load 3D LUT	3D LUT betöltése
+	Load 3D LUT…	3D LUT betöltése…
+	Localized Color Clusters	Helyi színcsoportok
+	Logical Length:	Logikai hossz:
+	Logical Units:	Logikai egységek:
+	Long Lines	Hosszú vonalak
+	Long Strokes	Hosszú vonások
+	Lut	LUT
+	Mac OS	Mac OS
+	Magenta  ·  Green	Magenta  ·  Zöld
+	Magentas	Magenták
+	Map Document	Térkép-dokumentum
+	Marker Size	Jelölőméret
+	Mask All	Összes maszkolása
+	Mask Options	Maszkbeállítások
+	Master	Összes szín
+	Match Color	Színillesztés
+	Max Offset	Legnagyobb eltolás
+	Max Radius	Legnagyobb sugár
+	Measure	Mérés
+	Measurement Scale	Mérési méretarány
+	Measurement Scale Marker	Méretarány-jelölő
+	Medium Dots	Közepes pontok
+	Medium Lines	Közepes vonalak
+	Medium Strokes	Közepes vonások
+	Mesh Size	Hálóméret
+	Mezzotint	Mezzotinto
+	Midtone	Középtónus
+	Midtones	Középtónusok
+	Midtones from:	Középtónusok ettől:
+	Midtones to:	Középtónusok eddig:
+	Monochrome	Monokróm
+	More	Több
+	Mosaic	Mozaik
+	Mosaic Tiles	Mozaiklapok
+	Motion Blur	Mozgási elmosás
+	Move effect layer down	Effektusréteg mozgatása lefelé
+	Move effect layer up	Effektusréteg mozgatása felfelé
+	Movie Prime	Filmes fix objektív
+	Multiple Flames Along Path	Több láng az útvonal mentén
+	Multiple Flames One Direction	Több láng egy irányba
+	Multiple Flames Path Directions	Több láng az útvonal irányaiba
+	Multiple Flames Various Length	Több láng eltérő hosszal
+	Neon Glow	Neonragyogás
+	Neutralize	Semlegesítés
+	Neutrals	Semlegesek
+	New effect layer	Új effektusréteg
+	Next note	Következő jegyzet
+	No author	Nincs szerző
+	No document open	Nincs megnyitott dokumentum
+	None	Nincs
+	Note Paper	Jegyzetpapír
+	Number Of Levels	Szintek száma
+	Ocean Ripple	Óceánfodrozódás
+	Offset	Eltolás
+	Oil Paint	Olajfestmény
+	One Flame Along Path	Egy láng az útvonal mentén
+	Opacity Threshold	Átlátszatlansági küszöb
+	Open	Megnyitás
+	Open a document to select a colour range.	Színtartomány kijelöléséhez nyiss meg egy dokumentumot.
+	Orange	Narancs
+	Out Black	Kimeneti fekete
+	Out From Center	Középponttól kifelé
+	Out Of Gamut	Színtartományon kívüli
+	Out White	Kimeneti fehér
+	Output Channel:	Kimeneti csatorna:
+	Output Levels	Kimeneti szintek
+	Output Levels:	Kimeneti szintek:
+	Output:	Kimenet:
+	Oval	Ovális
+	Overlay Edge	Élátfedés
+	Paint Daubs	Festékpacák
+	Palette Knife	Festőkés
+	Paper Brightness	Papír fényereje
+	Parallel	Párhuzamos
+	Patchwork	Foltvarrás
+	Path Blur	Útvonal-elmosás
+	Pattern Type	Mintázattípus
+	Pencil Width	Ceruzaszélesség
+	Perspective Warp is not active	A perspektivikus torzítás nem aktív
+	Perspective Warp: draw planes along the image's perspective, then switch to Warp	Perspektivikus torzítás: rajzolj síkokat a kép perspektívája mentén, majd válts Hajlítás módra
+	Photo Filter	Fotószűrő
+	Photocopy	Fénymásolat
+	Picture Frame	Képkeret
+	Pinch	Becsípés
+	Pixel Length:	Pixelhossz:
+	Plaster	Gipsz
+	Plastic Wrap	Műanyag fólia
+	Point Curve	Pontgörbe
+	Point Curve Blue	Pontgörbe, kék
+	Point Curve Green	Pontgörbe, zöld
+	Point Curve Red	Pontgörbe, vörös
+	Pointed	Hegyes
+	Pointillize	Pontozás
+	Polar Coordinates	Polárkoordináták
+	Polar To Rectangular	Polárisból derékszögűbe
+	Pond Ripples	Tavi fodrozódás
+	Poster Edges	Poszterélek
+	Posterization	Poszterizáció
+	Posterize	Poszterizálás
+	Preserve Luminosity	Fényesség megőrzése
+	Preset:	Előbeállítás:
+	Presets:	Előbeállítások:
+	Pressure	Nyomás
+	Preview	Előnézet
+	Previous note	Előző jegyzet
+	Pro photo	ProPhoto
+	Processing…	Feldolgozás…
+	ProPhoto	ProPhoto
+	ProPhoto RGB	ProPhoto RGB
+	Protect Tones	Tónusok védelme
+	Radial Blur	Sugárirányú elmosás
+	Radius X	X sugár
+	Radius Y	Y sugár
+	Randomize Length	Véletlenszerű hossz
+	Randomize Shapes	Véletlenszerű alakok
+	Range:	Tartomány:
+	Rate	Ütem
+	Ready	Készen áll
+	Reconstruct	Helyreállítás
+	Rectangular To Polar	Derékszögűből polárisba
+	Red Cyan	Vörös–cián
+	Reds	Vörösek
+	Reduce Color Noise	Színzaj csökkentése
+	Reduce Noise	Zajcsökkentés
+	Relative	Relatív
+	Relief	Domborulat
+	Remove Jpeg Artifact	JPEG-hibák eltávolítása
+	Remove Planes	Síkok eltávolítása
+	Remove stop	Átmenetpont eltávolítása
+	Replace Color	Színcsere
+	Reset to defaults	Alapértékek visszaállítása
+	Restore All	Összes visszaállítása
+	Resume	Folytatás
+	Reticulation	Retikuláció
+	RGB	RGB
+	Right Diagonal	Jobbra átlós
+	Ripple	Fodrozódás
+	Ripple Magnitude	Fodrozódás nagysága
+	Ripple Size	Fodrozódás mérete
+	Rope	Kötél
+	Roses	Rózsák
+	Rough Pastels	Durva pasztell
+	Ruler	Vonalzó
+	Sample: foreground colour	Minta: előtérszín
+	Sampled Colors	Mintavételezett színek
+	Sandstone	Homokkő
+	Saturation	Telítettség
+	Scaling	Méretezés
+	Scallops	Csipkés szél
+	Select and Mask	Kijelölés és maszk
+	Select Data Points	Adatpontok kiválasztása
+	Select:	Kijelölés:
+	Selection	Kijelölés
+	Selection Preview:	Kijelölés előnézete:
+	Selections	Kijelölések
+	Selective Color	Szelektív szín
+	Sepia	Szépia
+	Set Black Point	Feketepont beállítása
+	Set Neutral Gray Point	Semleges szürkepont beállítása
+	Set White Point	Fehérpont beállítása
+	Shadow Amount	Árnyék mértéke
+	Shadow Intensity	Árnyék intenzitása
+	Shadow Radius	Árnyék sugara
+	Shadow Tone	Árnyék tónusa
+	Shadows	Árnyékok
+	Shadows up to:	Árnyékok eddig:
+	Shadows/Highlights	Árnyékok/csúcsfények
+	Shape Blur	Alakzatos elmosás
+	Sharpen Details	Részletek élesítése
+	Sharpen Radius	Élesítési sugár
+	Sharpness	Élesség
+	Shear	Nyírás
+	Short Lines	Rövid vonalak
+	Short Strokes	Rövid vonások
+	Show Backdrop	Háttér megjelenítése
+	Show Mask	Maszk megjelenítése
+	Show Mesh	Háló megjelenítése
+	Show or hide the Notes panel	A Jegyzetek panel megjelenítése vagy elrejtése
+	Sketch	Vázlat
+	Smart Blur	Intelligens elmosás
+	Smart Sharpen	Intelligens élesítés
+	Smoothness	Simaság
+	Smudge Stick	Maszatolórúd
+	Snowflakes	Hópelyhek
+	Source Layer	Forrásréteg
+	Spatter	Fröcskölés
+	Speckle	Pöttyös
+	Speed	Sebesség
+	Spherize	Gömbösítés
+	Spin Blur	Pörgetéses elmosás
+	Sponge	Szivacs
+	Spot:	Spotlámpa:
+	Spray Radius	Szórási sugár
+	Sprayed Strokes	Szórt vonások
+	Sprinkles	Szórt szemcsék
+	Square Size	Négyzetméret
+	sRGB	sRGB
+	Stained Glass	Ólomüveg
+	Stamp	Bélyegző
+	Stars	Csillagok
+	Stippled	Pontozott
+	Stops	Átmenetpontok
+	Straighten	Kiegyenesítés
+	Straighten Layer	Réteg kiegyenesítése
+	Stroke Detail	Vonás részletessége
+	Stroke Direction	Vonás iránya
+	Stroke Length	Vonáshossz
+	Stroke Pressure	Vonásnyomás
+	Stroke Size	Vonásméret
+	Strokes	Vonások
+	Subtract from	Kivonás ebből
+	Subtract from Sample	Kivonás a mintából
+	Sumi-e	Sumi-e
+	Surface Blur	Felületi elmosás
+	Target X	Cél X
+	Target Y	Cél Y
+	Tetrahedral	Tetraéderes
+	Text Position:	Szöveg helye:
+	Texture	Textúra
+	Texture Coverage	Textúrafedettség
+	Texturizer	Textúrázó
+	Thickness	Vastagság
+	This adjustment ({key}) is kept as imported and can't be edited yet.	Ez a korrekció ({key}) importált állapotában marad, és egyelőre nem szerkeszthető.
+	Threshold	Küszöb
+	Threshold Level	Küszöbszint
+	Tile Size	Csempeméret
+	Tiles	Csempék
+	Tilt	Dőlés
+	Tilt-Shift	Tilt-shift
+	Timing	Időzítés
+	Tint Color	Színezés színe
+	Tiny Lens	Apró lencsék
+	Toggle count group visibility	Számlálócsoport láthatóságának váltása
+	Tone Curve	Tónusgörbe
+	Tone:	Tónus:
+	Top	Felül
+	Torn Edges	Tépett szélek
+	Total:	Összesen:
+	Trace Contour	Kontúrkövetés
+	Transparency Threshold	Átlátszósági küszöb
+	Trilinear	Trilineáris
+	Twirl	Örvény
+	Unavailable in this color mode	Ebben a színmódban nem érhető el
+	Undefined Areas	Nem definiált területek
+	Underpainting	Alapozó festés
+	Underwater	Víz alatti
+	Unsharp Mask	Életlenmaszk
+	Use Legacy	Régi módszer használata
+	Use Measurement Scale	Mérési méretarány használata
+	Use Selection In Source	Kijelölés használata a forrásban
+	Use Selection In Target	Kijelölés használata a célban
+	Uses the foreground and background colours.	Az előtér- és a háttérszínt használja.
+	Vertical Only	Csak függőleges
+	Vibrance	Élénkség
+	View Options	Nézetbeállítások
+	Vignette Amount	Vignetta mértéke
+	Vignette Highlights	Vignetta csúcsfényei
+	Vignette Midpoint	Vignetta középpontja
+	Vignette Style	Vignetta stílusa
+	Vine Color	Inda színe
+	Vine With Flowers	Inda virágokkal
+	Vine With Leaves	Inda levelekkel
+	Violent	Heves
+	Violet	Ibolya
+	Warming L B A	Melegítőszűrő (LBA)
+	Warming81	Melegítőszűrő (81)
+	Warming85	Melegítőszűrő (85)
+	Water Paper	Vizes papír
+	Watercolor	Akvarell
+	Wave	Hullám
+	Wavelength Max	Legnagyobb hullámhossz
+	Wavelength Min	Legkisebb hullámhossz
+	Waves	Hullámok
+	White Clip	Fehér levágása
+	White Intensity	Fehér intenzitása
+	White Is High	Fehér a magas
+	White Matte	Fehér háttér
+	Whites	Fehérek
+	Wide Blurry	Széles, elmosódott
+	Wide Sharp	Széles, éles
+	Wind	Szél
+	Yellow  ·  Blue	Sárga  ·  Kék
+	Yellows	Sárgák
+	Zigzag	Cikcakk
+	ZigZag	Cikcakk
+	Zoom in	Nagyítás
+	Zoom out	Kicsinyítés
+	{added}, {removed} subtracted	{added}, {removed} kivonva
+	{index} of {total}	{index} / {total}
+	{n} of {max} sample points	{n} / {max} mintavételi pont
+
+# Camera Raw and camera data
+	After	Utána
+	Aqua	Türkiz
+	Balance	Egyensúly
+	Before (Y)	Előtte (Y)
+	Blending	Keverés
+	Camera Raw	Camera Raw
+	Camera Raw ({name})	Camera Raw ({name})
+	Camera Raw Filter	Camera Raw szűrő
+	Camera Raw Filter ({layer})	Camera Raw szűrő ({layer})
+	Camera Raw isn't open	A Camera Raw nincs megnyitva
+	Cancelled opening {name}	Megnyitás megszakítva: {name}
+	The document “{name}” does not have an embedded {mode} profile.	A(z) „{name}” dokumentumnak nincs beágyazott {mode}-profilja.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	A(z) „{name}” dokumentum beágyazott színprofilja nem egyezik az aktuális {mode}-munkaszíntérrel.
+	Embedded: {embedded}	Beágyazott: {embedded}
+	Working: {working}	Munkaszíntér: {working}
+	Cancelled {label}	Megszakítva: {label}
+	Clarity	Tisztaság
+	Color Detail	Színrészletesség
+	Color Grading	Színtónusozás
+	Color Mixer	Színkeverő
+	Color Priority	Színprioritás
+	Curve	Görbe
+	Curve Darks	Görbe: sötét tónusok
+	Curve Highlights	Görbe: csúcsfények
+	Curve Lights	Görbe: világos tónusok
+	Curve Shadows	Görbe: árnyékok
+	Darks	Sötét tónusok
+	Dehaze	Párátlanítás
+	Detail	Részletesség
+	Developing {name}	Előhívás: {name}
+	Feather	Elmosott szél
+	Full-resolution preview unavailable	A teljes felbontású előnézet nem érhető el
+	Global	Globális
+	Grade Balance	Színtónusozás: egyensúly
+	Grade Blending	Színtónusozás: keverés
+	Grade Global	Színtónusozás: globális
+	Grade Highlights	Színtónusozás: csúcsfények
+	Grade Midtones	Színtónusozás: középtónusok
+	Grade Shadows	Színtónusozás: árnyékok
+	Grain Amount	Szemcse mértéke
+	Grain Roughness	Szemcse érdessége
+	Grain Size	Szemcseméret
+	Hand Tool	Kéz
+	Highlight Clipping Warning (O)	Figyelmeztetés csúcsfény-levágásra (O)
+	Highlight Priority	Csúcsfény-prioritás
+	Hsl Hue	HSL-színárnyalat
+	Hsl Lum	HSL-luminancia
+	Hsl Sat	HSL-telítettség
+	Lights	Világos tónusok
+	Lum	Lum.
+	Luminance	Luminancia
+	Luminance Detail	Luminancia-részletesség
+	Masking	Maszkolás
+	Midpoint	Középpont
+	Noise Color	Zajcsökkentés: szín
+	Noise Color Detail	Zajcsökkentés: színrészletesség
+	Noise Luminance	Zajcsökkentés: luminancia
+	Noise Luminance Detail	Zajcsökkentés: luminancia-részletesség
+	Noise Reduction	Zajcsökkentés
+	Open in camera raw	Megnyitás a Camera Raw-ban
+	Paint Overlay	Ráfestés
+	Previous	Előző
+	Purple	Lila
+	Radius	Sugár
+	Reading	Beolvasás
+	Roughness	Érdesség
+	Roundness	Kerekség
+	Sat	Tel.
+	Scope	Hatókör
+	Shadow Clipping Warning (U)	Figyelmeztetés árnyéklevágásra (U)
+	Sharpen Amount	Élesítés mértéke
+	Sharpen Detail	Élesítés részletessége
+	Sharpen Masking	Élesítés maszkolása
+	Sharpening	Élesítés
+	Show Lab Color Readouts	Lab-színértékek megjelenítése
+	Show Red at 3 o'clock	Vörös a 3 óra irányában
+	Show Selected Region	Kijelölt terület megjelenítése
+	Show Skin Tone Indicator	Bőrtónusjelző megjelenítése
+	Show Vectorscope	Vektorszkóp megjelenítése
+	Temperature	Színhőmérséklet
+	Tint	Színezet
+	Tone Histogram	Tónushisztogram
+	Vignette Feather	Vignetta elmosott széle
+	Vignette Roundness	Vignetta kereksége
+	Vignetting	Vignettálás
+	White Balance: As Shot	Fehéregyensúly: felvétel szerint
+	Zoom Tool	Nagyító
+cameraData	Date Taken	Készítés ideje
+cameraData	Exposure	Expozíciós idő
+cameraData	F-Stop	Rekesz
+cameraData	Focal Length	Gyújtótávolság
+cameraData	Focal Length (35 mm)	Gyújtótávolság (35 mm)
+cameraData	ISO Speed	ISO-érzékenység
+cameraData	Lens	Objektív
+cameraData	Make	Gyártó
+cameraData	Model	Típus
+cameraRaw	Amount	Mérték
+cameraRaw	Aqua	Türkiz
+cameraRaw	Blacks	Feketék
+cameraRaw	Blending	Keverés
+cameraRaw	Blue	Kék
+cameraRaw	Color	Szín
+cameraRaw	Color Detail	Színrészletesség
+cameraRaw	Color Grading	Színtónusozás
+cameraRaw	Darks	Sötét tónusok
+cameraRaw	Global	Globális
+cameraRaw	Green	Zöld
+cameraRaw	Hue	Színárnyalat
+cameraRaw	Light	Fény
+cameraRaw	Lights	Világos tónusok
+cameraRaw	Luminance	Luminancia
+cameraRaw	Luminance Detail	Luminancia-részletesség
+cameraRaw	Magenta	Bíbor
+cameraRaw	Masking	Maszkolás
+cameraRaw	Orange	Narancs
+cameraRaw	Purple	Lila
+cameraRaw	Red	Vörös
+cameraRaw	Roughness	Érdesség
+cameraRaw	Temperature	Színhőmérséklet
+cameraRaw	Tint	Színezet
+cameraRaw	Vibrance	Élénkség
+cameraRaw	Whites	Fehérek
+cameraRaw	Yellow	Sárga
+
+# Dialogs, preferences and file formats
+	% of all commits	Commitok aránya (%)
+	(print to the printer)	(nyomtatás a nyomtatón)
+	0 turns this threshold off; SVG groups nested deeper than 100 levels are always rasterized.	A 0 kikapcsolja ezt a küszöböt; a 100 szintnél mélyebben egymásba ágyazott SVG-csoportok mindig raszterizálódnak.
+	12 Columns	12 oszlop
+	125%	125%
+	150%	150%
+	16 bit	16 bites
+	175%	175%
+	24 bits/pixel	24 bit/pixel
+	300%	300%
+	32 bit (float)	32 bites (lebegőpontos)
+	32 bits/pixel	32 bit/pixel
+	3D	3D
+	5 Columns, 3 Rows	5 oszlop, 3 sor
+	75%	75%
+	8 bit	8 bites
+	8 Columns	8 oszlop
+	@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{binAdded} / −{binDeleted} binary assets, {first} – {last}	@{login}: {prs} PR, {commits} commit, +{added} / −{deleted} sor (Δ {delta}), +{binAdded} / −{binDeleted} bináris elem, {first} – {last}
+	About	Névjegy
+	Absolute Colorimetric	Abszolút kolorimetrikus
+	Action	Művelet
+	Active	Aktív
+	Adaptive	Adaptív
+	Add disk	Lemez hozzáadása
+	Add to favorites	Hozzáadás a kedvencekhez
+	Add to Swatches	Hozzáadás a színmintákhoz
+	Adobe	Adobe
+	Adobe RGB (1998)	Adobe RGB (1998)
+	Adobe RGB (1998) compatible	Adobe RGB (1998)-kompatibilis
+	Advanced	Speciális
+	Adwaita dark	Adwaita sötét
+	All	Mind
+	All shortcuts reset to PhotoCraft defaults.	Minden billentyűparancs visszaállt a PhotoCraft alapértékére.
+	All Slices	Összes szelet
+	All User Slices	Összes felhasználói szelet
+	Always create smart objects when placing	Elhelyezéskor mindig intelligens objektum létrehozása
+	Answer the unsaved-changes prompt first	Előbb válaszolj a nem mentett módosításokra vonatkozó kérdésre
+	Appearance Settings…	Megjelenési beállítások…
+	Apple Watch 45mm	Apple Watch 45 mm
+	Applies at next launch.	A következő indításkor lép életbe.
+	Art & Illustration	Művészet és illusztráció
+	Artist	Alkotó
+	Ask before saving layered tiff	Kérdés rétegzett TIFF mentése előtt
+	Assign working space	Munkaszíntér hozzárendelése
+	Auto Hide Notifications	Értesítések automatikus elrejtése
+	Automatic (recommended)	Automatikus (ajánlott)
+	Automatic uses GPU acceleration when available and falls back to CPU rendering on errors.	Az automatikus mód GPU-gyorsítást használ, ha elérhető, hiba esetén pedig CPU-s renderelésre vált.
+	Autosave	Automatikus mentés
+	Autosave failed: {error}	Az automatikus mentés nem sikerült: {error}
+	Autosave minutes	Automatikus mentés gyakorisága (perc)
+	Background Color	Háttérszín
+	Background Contents	Háttér tartalma
+	Custom background color	Egyéni háttérszín
+	Batch	Kötegelt feldolgozás
+	Binary assets added	Hozzáadott bináris elemek
+	Binary assets removed	Eltávolított bináris elemek
+	Bit depth	Bitmélység
+	Black Point Compensation	Feketepont-kompenzáció
+	BLANK DOCUMENT PRESETS ({n})	ÜRES DOKUMENTUMOK ELŐBEÁLLÍTÁSAI ({n})
+	Bleach Bypass	Kihagyott fehérítés
+	Bottom:	Alsó:
+	Breeze dark	Breeze sötét
+	Breeze light	Breeze világos
+	Cancel	Mégse
+	Canvas color	Vászonszín
+	Canvas custom color	Egyéni vászonszín
+	Caption	Képaláírás
+	Center Columns	Oszlopok középre igazítása
+	Center Crop Marks	Középső vágójelek
+	Centimeters	Centiméter
+	Clear	Kiürít
+	Clear Existing Guides	Meglévő segédvonalak törlése
+	Click to restore the current colour	Kattints a jelenlegi szín visszaállításához
+	Cmd	Cmd
+	CMYK Color	CMYK-szín
+	Coated CMYK	Mázolt papíros CMYK
+	Color Adaptation	Színadaptáció
+	Color Management	Színkezelés
+	Color Mode	Színmód
+	Color Picker (Background Color)	Színválasztó (háttérszín)
+	Color Picker (Fill Color)	Színválasztó (kitöltőszín)
+	Color Picker (Foreground Color)	Színválasztó (előtérszín)
+	Color Picker ({name})	Színválasztó ({name})
+	Color Profile	Színprofil
+	Color space	Színtér
+	Color…	Szín…
+	Column width	Oszlopszélesség
+	Columns	Oszlopok
+	Comic Book	Képregény
+	Command	Parancs
+	command or shortcut	parancs vagy billentyűparancs
+	Commits	Commitok
+	Company	Cég
+	Compare	Összehasonlítás
+	Compatibility	Kompatibilitás
+	Compression	Tömörítés
+	Conditional Mode Change	Feltételes módváltás
+	Contact Sheet II	Kontaktlap II
+	Content-Aware Fill needs a selection on a pixel layer	A tartalomérzékeny kitöltéshez kijelölés kell egy pixelrétegen
+	Contents:	Tartalom:
+	Contributors	Közreműködők
+	Contributors: {contributors} · Commits: {commits}	Közreműködők: {contributors} · Commitok: {commits}
+	Convert document's colors to the working space	A dokumentum színeinek átalakítása a munkaszíntérbe
+	Convert to sRGB	Átalakítás sRGB-re
+	Cool	Hideg
+	Copies	Példányszám
+	Copyright	Szerzői jog
+	Copyright and Contact Info	Szerzői jog és elérhetőség
+	Copyrighted	Szerzői jog által védett
+	Corner Crop Marks	Sarokvágójelek
+	Couldn't open {name}: {error}	A fájl nem nyitható meg: {name} ({error})
+	Couldn't place {name}: {error}	A fájl nem helyezhető el: {name} ({error})
+	Couldn't save preferences: {error}. Retrying…	A beállítások nem menthetők: {error}. Újrapróbálkozás…
+	CPU (no GPU acceleration)	CPU (GPU-gyorsítás nélkül)
+	CPU / Compatibility	CPU / kompatibilitás
+	Create	Létrehoz
+	Create Droplet	Droplet létrehozása
+	Cross Process	Kereszthívás
+	Ctrl	Ctrl
+	Custom Pattern:	Egyéni mintázat:
+	Custom Shapes	Egyéni alakzatok
+	Dark Theme	Sötét téma
+	Data	Adatok
+	Date	Dátum
+	Day For Night	Nappali éjszaka
+	Default PhotoCraft Size	Alapértelmezett PhotoCraft-méret
+	Default printer	Alapértelmezett nyomtató
+	Default restored.	Alapértelmezés visszaállítva.
+	Defaults	Alapértékek
+	Delete	Törlés
+	Delete Shortcut	Billentyűparancs törlése
+	Description	Leírás
+	Diffusion	Diffúzió
+	DirectX 12	DirectX 12
+	Discard Layers and Save a Copy	Rétegek elvetése és másolat mentése
+	Discard the embedded profile (don't color manage)	Beágyazott profil elvetése (nincs színkezelés)
+	Disks	Lemezek
+	Display name	Megjelenített név
+	Display P3	Display P3
+	Display p3	Display P3
+	Do you want to save the changes you made to “{name}” before closing?	Mented a módosításokat bezárás előtt? Dokumentum: „{name}”
+	Do you want to save the changes you made to “{name}” before quitting?	Mented a módosításokat kilépés előtt? Dokumentum: „{name}”
+	Document	Dokumentum
+	Don't Import	Importálás nélkül
+	Don't Save	Mentés nélkül
+	Edit › Keyboard Shortcuts › Reset All to Defaults undoes an import.	Az importálást a Szerkesztés › Billentyűparancsok › Összes visszaállítása alapértékre vonja vissza.
+	Embed Color Profile	Színprofil beágyazása
+	Embedded Profile Mismatch	Eltérő beágyazott profil
+	Emulsion Down	Emulziós oldal lefelé
+	Error	Hiba
+	Exact	Pontos
+	EXIF	EXIF
+	Export As	Exportálás másként
+	Export Options	Exportálás beállításai
+	Export Preferences	Beállítások exportálása
+	Export Presets	Előbeállítások exportálása
+	Export Settings	Exportálási beállítások
+	Export/Import Presets	Előbeállítások exportálása/importálása
+	Exported presets to {path}	Előbeállítások exportálva. Cél: {path}
+	Exported {path}	Exportálva: {path}
+	Exported {path} ({size})	Exportálva: {path} ({size})
+	Extensions	Kiterjesztések
+	Faded Film	Fakult film
+	File Info	Fájladatok
+	File Name	Fájlnév
+	File path	Fájl elérési útja
+	File Settings	Fájlbeállítások
+	Fill color	Kitöltőszín
+	Film & Video	Film és videó
+	Finish	Befejezés
+	First	Első
+	First commit	Első commit
+	Fit Image	Kép méretre igazítása
+	Floating point	Lebegőpontos
+	Focal Length35mm	Gyújtótávolság (35 mm)
+	Foreground Color	Előtérszín
+	Format	Formátum
+	Functions	Funkciók
+	Gamut warning color	Színtartomány-figyelmeztetés színe
+	Gamut warning opacity	Színtartomány-figyelmeztetés átlátszatlansága
+	Gif	GIF
+	GPU	GPU
+	GPU Backend	GPU-háttérrendszer
+	Grab bag	Felhő
+	Graphics	Grafika
+	Gray Gamma 2.2	Szürke, gamma 2.2
+	Grayscale	Szürkeárnyalatos
+	Guide color	Segédvonal színe
+	Guide Layout…	Segédvonal-elrendezés…
+	Gutter	Hasábköz
+	Image previews	Képelőnézetek
+	Image Size	Képméret
+	Import brushes (.abr)	Ecsetek importálása (.abr)
+	Import keyboard shortcuts?	Importálod a billentyűparancsokat?
+	Import Presets	Előbeállítások importálása
+	Import Shortcuts…	Billentyűparancsok importálása…
+	Imported {n} shortcuts from {file}. Click OK to keep them.	{n} billentyűparancs importálva. Forrás: {file}. A megtartásukhoz kattints az OK gombra.
+	Inches	Hüvelyk
+	Including layers will increase file size.	A rétegek mentése növeli a fájlméretet.
+	Integer	Egész
+	Interlaced	Váltott soros
+	Invalid guide layout	Érvénytelen segédvonal-elrendezés
+	ISO Speed	ISO-érzékenység
+	Jpeg quality	JPEG-minőség
+	Jpg	JPG
+	Keyboard Shortcuts and Menus	Billentyűparancsok és menük
+	Keyboard shortcuts imported	Billentyűparancsok importálva
+	Keywords	Kulcsszavak
+	Lab Color	Lab-szín
+	Labels	Címkék
+	Landscape	Fekvő
+	Landscape, 10 x 8	Fekvő, 10 x 8
+	Landscape, 6 x 4	Fekvő, 6 x 4
+	Landscape, 7 x 5	Fekvő, 7 x 5
+	Last	Utolsó
+	Last commit	Utolsó commit
+	Leave as is (don't color manage)	Változatlanul hagyás (nincs színkezelés)
+	Leave empty for automatic size	Automatikus mérethez hagyd üresen
+	Left	Bal
+	Left:	Bal:
+	Legal	Legal
+	Lens	Objektív
+	Light Theme	Világos téma
+	Line delta	Sorváltozás
+	Lines +/−	Sorok +/−
+	Lines added	Hozzáadott sorok
+	Lines deleted	Törölt sorok
+	Load a keyboard shortcut set saved as .kys	.kys formátumban mentett billentyűparancs-készlet betöltése
+	Lossless	Veszteségmentes
+	Lowercase extension	Kisbetűs kiterjesztés
+	Make	Gyártó
+	Margin	Margó
+	Matte	Alapszín
+	Merged PRs	Beolvasztott PR-ek
+	Metadata	Metaadatok
+	Metal	Metal
+	Millimeters	Milliméter
+	Mobile	Mobil
+	Model	Modell
+	Models	Modellek
+	modified	módosítva
+	Mono Contrast	Kontrasztos monokróm
+	Name (A–Z)	Név (A–Z)
+	New Document	Új dokumentum
+	New Guide Layout	Új segédvonal-elrendezés
+	No	Nem
+	No Color Management	Nincs színkezelés
+	No contributor data was built into this copy.	Ez a példány nem tartalmaz közreműködői adatokat.
+	No Dither	Nincs árnyalatkeverés
+	No matching settings	Nincs egyező beállítás
+	No model credits were built into this copy.	Ez a példány nem tartalmaz adatokat a modellek készítőiről.
+	No presets of this type.	Ilyen típusú előbeállítás nincs.
+	No saved presets yet.	Még nincs mentett előbeállítás.
+	Not a web colour: click for the nearest web colour	Nem webes szín: kattints a legközelebbi webes színért
+	Notification Duration (seconds)	Értesítés időtartama (másodperc)
+	Number	Szám
+	OK	OK
+	Only Web Colors	Csak webes színek
+	Open File	Fájl megnyitása
+	OpenGL	OpenGL
+	Optimized	Optimalizált
+	Original	Eredeti
+	Out of gamut for printing: click for the nearest printable colour	Nyomtatási színtartományon kívül: kattints a legközelebbi nyomtatható színért
+	Out of memory	Elfogyott a memória
+	Package	Csomagolás
+	Percent	Százalék
+	Perceptual	Érzékelési
+	Permission denied	Hozzáférés megtagadva
+	Phone	Telefon
+	Photo	Fotó
+	PhotoCraft found your keyboard shortcut set {set} from another image editor on this computer: {n} of its shortcuts differ from PhotoCraft's. Import it?	A PhotoCraft egy másik képszerkesztő billentyűparancs-készletét találta ezen a számítógépen: {set}. Ebben {n} billentyűparancs eltér a PhotoCraftétól. Importálod?
+	PhotoCraft keeps retrying; until a save succeeds, preference changes are lost when it closes.	A PhotoCraft tovább próbálkozik; amíg a mentés nem sikerül, a beállítások módosításai bezáráskor elvesznek.
+	PhotoCraft Manages Colors	A PhotoCraft kezeli a színeket
+	PhotoCraft — an open-source, native image editor written in Rust.	PhotoCraft – nyílt forráskódú, natív képszerkesztő Rust nyelven.
+	Picas	Pica
+	Pixels	Pixel
+	Pixels/Centimeter	Pixel/centiméter
+	Pixels/Inch	Pixel/hüvelyk
+	Place Embedded	Beágyazott elhelyezése
+	Place Linked	Csatolt elhelyezése
+	Png	PNG
+	Points	Pont
+	Portrait	Álló
+	Portrait, 4 x 6	Álló, 4 x 6
+	Portrait, 5 x 7	Álló, 5 x 7
+	Position and Size	Pozíció és méret
+	Postcard	Képeslap
+	Poster	Plakát
+	PostScript (72 points/inch)	PostScript (72 pont/hüvelyk)
+	Preferences can't be saved	A beállítások nem menthetők
+	Preferences saved	Beállítások mentve
+	Preferences were reset: {error}	A beállítások alaphelyzetbe álltak: {error}
+	Preset	Előbeállítás
+	PRESET DETAILS	AZ ELŐBEÁLLÍTÁS RÉSZLETEI
+	Preset Manager	Előbeállítás-kezelő
+	Preset Name	Előbeállítás neve
+	Preset Type	Előbeállítás típusa
+	Press keys	Nyomd le a billentyűket
+	Press keys…	Nyomd le a billentyűket…
+	Print	Nyomtatás
+	Print resolution	Nyomtatási felbontás
+	Print Resolution:	Nyomtatási felbontás:
+	Printed to {path}	Nyomtatva. Cél: {path}
+	Printer	Nyomtató
+	Printer Manages Colors	A nyomtató kezeli a színeket
+	Printer Setup	Nyomtatóbeállítás
+	Printing Marks	Nyomdai jelek
+	Progressive	Progresszív
+	PSD	PSD
+	Public Domain	Közkincs
+	Quality	Minőség
+	Quick export format	Gyors exportálás formátuma
+	Ran script {name}	Parancsfájl lefuttatva: {name}
+	Real name	Valódi név
+	Recent	Legutóbbiak
+	Recover on launch	Helyreállítás indításkor
+	Recovered {name}	Helyreállítva: {name}
+	Recovery	Helyreállítás
+	Registration Marks	Illesztőjelek
+	Relative Colorimetric	Relatív kolorimetrikus
+	Remove from favorites	Eltávolítás a kedvencek közül
+	Rename	Átnevezés
+	Render Video	Videó renderelése
+	Rendering Mode	Renderelési mód
+	Reset All to Defaults	Összes visszaállítása alapértékre
+	Reset Section	Szakasz visszaállítása
+	Resize image during place	Kép átméretezése elhelyezéskor
+	Resolution	Felbontás
+	Resolution: {dpi} pixels/inch	Felbontás: {dpi} pixel/hüvelyk
+	Restore Defaults	Alapértékek visszaállítása
+	Restrictive (Web)	Korlátozott (web)
+	Result	Eredmény
+	Retry	Újrapróbál
+	Reverse the order	Sorrend megfordítása
+	Revert “{name}” to the last saved version? Your changes will be lost.	Visszaállítod az utolsó mentett változatot? A módosításaid elvesznek. Dokumentum: „{name}”
+	RGB Color	RGB-szín
+	Right:	Jobb:
+	Rows	Sorok
+	Rulers & Grids	Vonalzók és rácsok
+	Save a Copy	Másolat mentése
+	Save as PDF	Mentés PDF-ként
+	Save cancelled	Mentés megszakítva
+	Save failed: {error}	A mentés nem sikerült: {error}
+	Save for Web (Legacy)	Mentés webre (régi)
+	Save HTML and Images	HTML és képek mentése
+	Save Preset…	Előbeállítás mentése…
+	Saved	Mentve
+	Scale to Fit Media	Méretezés a papírmérethez
+	Scratch disks	Lapozólemezek
+	Script Events Manager	Parancsfájl-eseménykezelő
+	Search	Keresés
+	Search settings…	Keresés a beállítások között…
+	Selected Artboards	Kijelölt rajztáblák
+	Selective	Szelektív
+	Sensitivity	Érzékenység
+	Sent to the printer ({spooler})	Elküldve a nyomtatóra ({spooler})
+	Services	Szolgáltatások
+	Sessions only	Csak munkamenetek
+	Shape Layer	Alakzatréteg
+	Shortcut removed.	Billentyűparancs eltávolítva.
+	Shortcuts	Billentyűparancsok
+	Show All Menu Items	Összes menüpont megjelenítése
+	Show Guides	Segédvonalak megjelenítése
+	Show rulers	Vonalzók megjelenítése
+	Show Rulers	Vonalzók megjelenítése
+	Show tooltips	Eszköztippek megjelenítése
+	Software	Szoftver
+	Solarized dark	Solarized sötét
+	Sort	Rendezés
+	Square, 12 x 12	Négyzet, 12 x 12
+	Square, 5 x 5	Négyzet, 5 x 5
+	Srgb	sRGB
+	sRGB IEC61966-2.1	sRGB IEC61966-2.1
+	Studio light	Studio világos
+	Studio Light	Studio világos
+	System Info	Rendszerinformáció
+	Table	Táblázat
+	Tabloid	Tabloid
+	Targa Options	Targa-beállítások
+	Target:	Cél:
+	Teal Orange	Kékeszöld-narancs
+	The document does not have an embedded colour profile. Working space: {working}.	A dokumentumnak nincs beágyazott színprofilja. Munkaszíntér: {working}.
+	The document has an embedded colour profile that does not match the working space.\nEmbedded: {embedded}\nWorking: {working}	A dokumentum beágyazott színprofilja eltér a munkaszíntértől.\nBeágyazott: {embedded}\nMunkaszíntér: {working}
+	The keyboard shortcut set was not imported: {error}	A billentyűparancs-készlet importálása nem sikerült: {error}
+	These settings aren't available in PhotoCraft yet.	Ezek a beállítások a PhotoCraftban még nem érhetők el.
+	This fill layer must be rasterized before proceeding. Its fill content will no longer be editable. Rasterize the layer?	A folytatáshoz a kitöltőréteget raszterizálni kell. A kitöltés tartalma ezután nem lesz szerkeszthető. Raszterizálod a réteget?
+	This layer must be rasterized before proceeding.	A folytatáshoz a réteget raszterizálni kell.
+	This shape layer must be rasterized before proceeding. It will no longer be editable as a shape. Rasterize the shape?	A folytatáshoz az alakzatréteget raszterizálni kell. Ezután alakzatként nem lesz szerkeszthető. Raszterizálod az alakzatot?
+	This Smart Object must be rasterized before proceeding. Its contents will no longer be editable. Rasterize the Smart Object?	A folytatáshoz az intelligens objektumot raszterizálni kell. A tartalma ezután nem lesz szerkeszthető. Raszterizálod az intelligens objektumot?
+	This type layer must be rasterized before proceeding. Its text will no longer be editable. Rasterize the type?	A folytatáshoz a szövegréteget raszterizálni kell. A szöveg ezután nem lesz szerkeszthető. Raszterizálod a szöveget?
+	TIFF Options	TIFF-beállítások
+	Top:	Felső:
+	Traditional (72.27 points/inch)	Hagyományos (72,27 pont/hüvelyk)
+	Transparency	Átlátszóság
+	Unix	Unix
+	Unsaved changes	Nem mentett módosítások
+	Untitled	Névtelen
+	Untitled-1	Névtelen-1
+	URLs	URL-ek
+	Use Default	Alapértelmezés használata
+	Use shift key for tool switch	Eszközváltás a Shift billentyűvel
+	Use the embedded profile (instead of the working space)	A beágyazott profil használata (a munkaszíntér helyett)
+	Username	Felhasználónév
+	Version {version}	Verzió: {version}
+	Vulkan	Vulkan
+	Warm	Meleg
+	Web	Web
+	Web Color	Webes szín
+	Web Large	Web, nagy
+	Web Minimum	Web, minimális
+	Web Most Common	Web, leggyakoribb
+	Web Snap	Webes illesztés
+	Webp	WebP
+	Wetness	Nedvesség
+	White	Fehér
+	Width and Height	Szélesség és magasság
+	Working	Munkaszíntér
+	Y	Y
+	Yes	Igen
+	Your keyboard shortcut set {set} is in use here: {n} shortcuts differ from the defaults. Edit › Keyboard Shortcuts shows them; Reset All to Defaults undoes this.	A billentyűparancs-készleted itt is használatban van: {set}. Ebből {n} billentyűparancs eltér az alapértelmezettől. A Szerkesztés › Billentyűparancsok alatt láthatod őket; az Összes visszaállítása alapértékre paranccsal ez visszavonható.
+	{n} commands are not in PhotoCraft.	{n} parancs nem érhető el a PhotoCraftban.
+	{shortcut} assigned.	Billentyűparancs hozzárendelve: {shortcut}
+	{shortcut} is already in use by {commands} and will be removed from it when you click OK.	A billentyűparancs már foglalt: {shortcut}. Jelenlegi parancs: {commands}. Az OK gombra kattintva onnan törlődik.
+
+# Status bar, messages and other labels
+	Action playback failed: {error}	A műveletsor lejátszása sikertelen: {error}
+	Adaptive Wide Angle	Adaptív nagy látószög
+	Add Anchor Point Tool	Horgonypont hozzáadása
+	Add beauty precomp from the AOVs	Beauty előkompozíció hozzáadása az AOV-kből
+	Add to	Hozzáadás
+	Additional plugins folder	További bővítmények mappája
+	Adjustment Layer	Korrekciós réteg
+	Adjustment Properties	Korrekció tulajdonságai
+	Adobe rgb	Adobe RGB
+	Adwaita	Adwaita
+	Adwaita (Dark)	Adwaita (sötét)
+	Adwaita (Light)	Adwaita (világos)
+	Allow agent control	Ágensvezérlés engedélyezése
+	Allow scripts to connect	Parancsfájlok csatlakozásának engedélyezése
+	Alt-click went to the desktop, which moves windows with Alt-drag. Set its window-move key to Super, or latch Alt in Window › Modifier Keys.	Az Alt+kattintást az asztali környezet kapta meg, mert nála az Alt+húzás ablakot mozgat. Állítsd az ablakmozgató billentyűt a Super billentyűre, vagy rögzítsd az Alt billentyűt itt: Ablak › Módosítóbillentyűk.
+	Ambience	Környezeti fény
+	Ambient	Környezeti
+	Anchor:	Rögzítési pont:
+	Animated zoom	Animált nagyítás
+	Anisotropic	Anizotróp
+	Apply At Canvas Bounds	Alkalmazás a vászon szélén is
+	Apply auto tone	Automatikus tónus alkalmazása
+	Apply Layer Comp	Rétegkompozíció alkalmazása
+	Arc	Ív
+	Arch	Boltív
+	Area	Terület
+	Artboard Tool	Rajztábla
+	ArtCraft	ArtCraft
+	Ask	Rákérdezés
+	Aspect Ratio	Oldalarány
+	Assign Profile	Profil hozzárendelése
+	Author	Szerző
+	auto	automatikus
+	Auto collapse icon panels	Ikonpanelek automatikus összecsukása
+	Auto Scale	Automatikus méretezés
+	Auto show hidden panels	Rejtett panelek automatikus megjelenítése
+	Auto show home screen	Kezdőképernyő automatikus megjelenítése
+	Auto-Align Layers	Rétegek automatikus igazítása
+	Auto-Blend Layers	Rétegek automatikus keverése
+	Automatic	Automatikus
+	Back	Vissza
+	Backend: {backend} ({type})	Háttérrendszer: {backend} ({type})
+	Background	Háttér
+	Background Eraser Tool	Háttérradír
+	Begin recording	Rögzítés indítása
+	Bicubic (smooth gradients)	Bikubikus (sima átmenetekhez)
+	Bicubic automatic	Automatikus bikubikus
+	Bicubic sharper	Élesebb bikubikus
+	Bicubic Sharper (reduction)	Élesebb bikubikus (kicsinyítéshez)
+	Bicubic smoother	Simább bikubikus
+	Bicubic Smoother (enlargement)	Simább bikubikus (nagyításhoz)
+	Blade Curvature	Lamellák görbülete
+	Blast	Szélroham
+	Blend	Keverés
+	Border	Szegély
+	Bottom Left	Bal alsó
+	Bottom Right	Jobb alsó
+	Breeze Dark	Breeze sötét
+	Breeze Light	Breeze világos
+	Browse	Tallózás
+	Bulge	Kidudorodás
+	Cache levels	Gyorsítótár-szintek
+	Cache tile size	Gyorsítótár csempemérete
+	Camera Data	Fényképezőgép adatai
+	Camera Raw Defaults	Camera Raw-alapértékek
+	Camera Raw…	Camera Raw…
+	Cancel opening	Megnyitás megszakítása
+	Canvas border	Vászonszegély
+	Canvas extension color:	Vászonbővítés színe:
+	Canvas Size	Vászonméret
+	Category	Kategória
+	Channel1	1. csatorna
+	Channel2	2. csatorna
+	Channel3	3. csatorna
+	Channel4	4. csatorna
+	Circle	Kör
+	Circularity	Köralakúság
+	Classic	Klasszikus
+	Cleanliness	Vonaltisztaság
+	Click a segment to add an anchor point · {alt}-click an anchor to delete it	Kattints egy szakaszra horgonypont hozzáadásához · {alt}+kattintás egy horgonyponton: törlés
+	Click an anchor point to delete it · {alt}-click a segment to add one	Kattints egy horgonypontra a törléséhez · {alt}+kattintás egy szakaszon: új horgonypont
+	Click to pick · Esc to cancel	Kattintás: kiválasztás · Esc: mégse
+	Click: corner · Drag: smooth · {alt}-drag: break handle · Click or drag first point: close · {key} finish · Esc cancel	Kattintás: sarokpont · Húzás: simított pont · {alt}+húzás: fogantyú megtörése · Kattintás vagy húzás az első ponton: lezárás · {key}: befejezés · Esc: mégse
+	Click: select anchor · Drag: move anchor, handle or segment · {shift}-click: add · {alt}-click: whole subpath	Kattintás: horgonypont kijelölése · Húzás: horgonypont, fogantyú vagy szakasz mozgatása · {shift}+kattintás: hozzáadás · {alt}+kattintás: teljes részútvonal
+	Click: smooth point · Double-click: corner · Drag a point: move · Click first point: close · {key} finish	Kattintás: simított pont · Dupla kattintás: sarokpont · Pont húzása: mozgatás · Kattintás az első ponton: lezárás · {key}: befejezés
+	Clipping Path	Vágóútvonal
+	Clone	Klónozás
+	Clone Stamp Tool	Klónozó bélyegző
+	Close	Bezár
+	Color management: {error}	Színkezelés: {error}
+	Color picker	Színválasztó
+	Color Picker	Színválasztó
+	Color Range	Színtartomány
+	Color Replacement Tool	Színcserélő
+	Color Settings	Színbeállítások
+	Color Table	Színtábla
+	ColorSync	ColorSync
+	Compose	Szedés
+	Concise	Tömör
+	Constrain proportions	Arányok megtartása
+	Constraints	Megkötések
+	Content-Aware Fill	Tartalomérzékeny kitöltés
+	Content-Aware Move Tool	Tartalomérzékeny mozgatás
+	Contract	Szűkítés
+	Control port	Vezérlőport
+	Convert Point Tool	Pontátalakító
+	Convert to Linked	Átalakítás csatolttá
+	Convert to Profile	Átalakítás profilra
+	Convert to srgb	Átalakítás sRGB-re
+	Copyright Status	Szerzői jogi állapot
+	Corner radius	Sarokkerekítés sugara
+	Correct C A	Kromatikus aberráció javítása
+	Correct Distortion	Torzítás javítása
+	Correct Vignette	Vignettálás javítása
+	Could not rename the action: {error}	A műveletsor nem nevezhető át: {error}
+	Count Tool	Számláló
+	Create a new document or open an existing file.	Hozz létre egy új dokumentumot, vagy nyiss meg egy meglévő fájlt.
+	Create By	Pótlás módja
+	Create new action	Új műveletsor létrehozása
+	Create new path	Új útvonal létrehozása
+	Crop Tool	Körbevágás
+	Cross	Kereszt
+	Current Size	Jelenlegi méret
+	Current Tool	Aktuális eszköz
+	Cursors	Kurzorok
+	Curvature Pen Tool	Görbületi toll
+	Curve Fit:	Görbeillesztés:
+	Custom dark	Egyéni sötét
+	Custom light	Egyéni világos
+	Custom Shape Tool	Egyéni alakzat
+	Dashed lines	Szaggatott vonalak
+	Date and Time	Dátum és idő
+	Default Foreground and Background Colors	Alapértelmezett előtér- és háttérszín
+	Delete Anchor Point Tool	Horgonypont törlése
+	Delete path	Útvonal törlése
+	Delete Path	Útvonal törlése
+	Delete vector mask	Vektormaszk törlése
+	Depth Mode	Mélységmód
+	Detailed	Részletes
+	Details	Részletek
+	Dimensions:	Méretek:
+	Direct Selection Tool	Közvetlen kijelölés
+	Disable	Kikapcsolás
+	Disabled	Kikapcsolva
+	Dismiss	Elvetés
+	Display	Kijelző
+	Display profile not used	A kijelzőprofil nincs használatban
+	Display profiles: {reason}	Kijelzőprofilok: {reason}
+	Distribution	Eloszlás
+	Doc: {flat}/{layered}	Dokumentum: {flat}/{layered}
+	Document Dimensions	Dokumentum méretei
+	Document Profile	Dokumentumprofil
+	Document Size	Dokumentumméret
+	Document Sizes	Dokumentumméretek
+	Documents	Dokumentumok
+	Draft	Vázlat
+	Drag to move the active shape's path or the Work Path	Húzással mozgathatod az aktív alakzat útvonalát vagy a munkaútvonalat
+	Drag: draw freehand · {alt}-click: straight segment · Release on the start point: close	Húzás: szabadkézi rajzolás · {alt}+kattintás: egyenes szakasz · Elengedés a kezdőponton: lezárás
+	Draw with the Pen tool (P) or make a work path from a selection.	Rajzolj a Toll eszközzel (P), vagy készíts munkaútvonalat egy kijelölésből.
+	Driver: {driver}	Illesztőprogram: {driver}
+	Drop an image or PSD anywhere to open it.	Húzz ide bárhová egy képet vagy PSD-fájlt a megnyitásához.
+	Duplicate Layer Comp	Rétegkompozíció kettőzése
+	Duplicate Path	Útvonal kettőzése
+	Duplication	Kettőzés
+	East asian	Kelet-ázsiai
+	Edge Extension	Szélek kiterjesztése
+	Edit › Paste	Szerkesztés › Beillesztés
+	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	A teljes dokumentumot érintő módosítások (például egy réteg keverési módja, átlátszatlansága vagy láthatósága) az egész dokumentumot újrarajzolják.
+	Effect cache mb	Effektus-gyorsítótár (MB)
+	Efficiency	Hatékonyság
+	Efficiency: 100%	Hatékonyság: 100%
+	Elevation	Magassági szög
+	Eliminate	Eltávolítandó
+	Ellipse Tool	Ellipszis
+	Elliptical Marquee Tool	Ellipszis-kijelölés
+	Enable	Bekapcsolás
+	Enable animations	Animációk engedélyezése
+	Enable flick panning	Lendítéses pásztázás engedélyezése
+	Enable floating document window docking	Lebegő dokumentumablakok dokkolásának engedélyezése
+	Enable narrow options bar	Keskeny beállítósáv engedélyezése
+	Enabled	Bekapcsolva
+	End X	Vég X
+	End Y	Vég Y
+	Enhanced Controls	Bővített vezérlők
+	Eraser Tool	Radír
+	Errors	Hibák
+	Even Fields	Páros félképek
+	Export	Exportálás
+	Export clipboard	Vágólap exportálása
+	Export Contents	Tartalom exportálása
+	Exported contents to {path}	Tartalom exportálva. Cél: {path}
+	Extra large	Nagyon nagy
+	Eyedropper Tool	Pipetta
+	Failed	Sikertelen
+	fallback	tartalék
+	Fallback: {reason}	Tartalék: {reason}
+	File Handling	Fájlkezelés
+	Filename	Fájlnév
+	Fill	Kitöltés
+	Fill Color	Kitöltőszín
+	Fill Path	Útvonal kitöltése
+	Fill path with foreground color	Útvonal kitöltése előtérszínnel
+	Find	Keresés
+	Fine	Finom
+	Fish	Hal
+	Flag	Zászló
+	Flame	Láng
+	Flat	Lapos
+	Focus	Fókusz
+	Focus Area	Fókuszterület
+	Font preview	Betűtípus-előnézet
+	Frame	Keret
+	Frame Tool	Keret
+	Freeform Pen Tool	Szabadkézi toll
+	From Left	Balról
+	Full size tip	Teljes méretű hegy
+	Fullscreen	Teljes képernyő
+	General…	Általános…
+	Generator enabled	Generátor bekapcsolva
+	Generators	Generátorok
+	Generic	Általános
+	GitHub	GitHub
+	Gloss	Csillogás
+	Glossy	Fényes
+	Good	Jó
+	GPU acceleration could not continue. Your documents are unchanged.	A GPU-gyorsítás leállt. A dokumentumok nem változtak.
+	GPU backend preference: {backend}	Előnyben részesített GPU-háttérrendszer: {backend}
+	GPU device was lost; using the CPU renderer.	A GPU-eszköz elérhetetlenné vált; a CPU-s megjelenítő működik.
+	GPU error; using the CPU renderer.	GPU-hiba; a CPU-s megjelenítő működik.
+	GPU retry scheduled	GPU-újrapróbálás ütemezve
+	Gradient Tool	Színátmenet
+	Graphics adapter	Grafikus adapter
+	Graphics adapter: {adapter}	Grafikus adapter: {adapter}
+	Gray Value (Maximum)	Szürkeérték (maximum)
+	Gray Value (Mean)	Szürkeérték (átlag)
+	Gray Value (Median)	Szürkeérték (medián)
+	Gray Value (Minimum)	Szürkeérték (minimum)
+	Grid color	Rács színe
+	Grid colors	Rács színei
+	Grid style	Rács stílusa
+	Grid unit	Rács mértékegysége
+	Gridline every	Rácsvonalak távolsága
+	Group Layer	Csoportréteg
+	Groups	Csoportok
+	Guide style	Segédvonalak stílusa
+	Guides, Grid & Slices	Segédvonalak, rács és szeletek
+	Hand	Kéz
+	Heal	Javítás
+	Healing Brush Tool	Javítóecset
+	Heptagon	Hétszög
+	Hexagon	Hatszög
+	Hidden	Rejtett
+	High	Magas
+	History Brush Tool	Előzményecset
+	History Log	Előzménynapló
+	History states	Előzményállapotok
+	Home	Kezdőképernyő
+	Horizontal Type Mask Tool	Vízszintes szövegmaszk
+	Horizontal Type Tool	Vízszintes szöveg
+	Hotspot	Fényfolt
+	Hsl	HSL
+	Ignore exif profile tag	EXIF-profilcímke figyelmen kívül hagyása
+	Image compositor: {processor}	Képösszeállító: {processor}
+	Image interpolation	Képinterpoláció
+	Image Size:	Képméret:
+	Image Size…	Képméret…
+	Import	Importálás
+	In	Kezdőpont
+	Include in playback	Lejátszásba foglalás
+	Indexed	Indexelt
+	Infinite	Végtelen
+	Inflate	Felfújás
+	Input	Bemenet
+	Input Mode	Bemeneti mód
+	Integrated Density	Integrált sűrűség
+	Integrations	Integrációk
+	Integrations…	Integrációk…
+	Interface	Felület
+	Interpolation	Interpoláció
+	Interpret Footage	Videoanyag értelmezése
+	Interval	Intervallum
+	Invalid {mode} profile	Érvénytelen profil ({mode})
+	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	A dokumentum rétegei nem férnek el a GPU memóriakeretében. Ha a Beállítások › Teljesítmény alatt növeled a memóriahasználatot, a keret is nő, legfeljebb a számítógép memóriájának negyedéig.
+	Join us on Discord	Csatlakozz hozzánk a Discordon
+	Keep Using CPU	Marad a CPU
+	Kernel	Szűrőmag
+	Keyboard	Billentyűzet
+	Label	Címke
+	Lanczos (sharp)	Lanczos (éles)
+	Large document: redrawing on the CPU	Nagy dokumentum: újrarajzolás a CPU-n
+	Large tabs	Nagy lapfülek
+	Lasso Tool	Lasszó
+	Layer Comp	Rétegkompozíció
+	Layer Count	Rétegek száma
+	Layer From Background	Réteg a háttérből
+	Layer Mask	Rétegmaszk
+	Layer Properties	Réteg tulajdonságai
+	Legacy compositing	Régi képösszeállítás
+	Length	Hossz
+	Lens Correction	Objektívkorrekció
+	Libraries	Könyvtárak
+	Light Type	Fényforrás típusa
+	Light X	Fényforrás X
+	Light Y	Fényforrás Y
+	Light Z	Fényforrás Z
+	Lighting	Megvilágítás
+	Line	Vonal
+	Line Tool	Vonal
+	Linux display server	Linuxos megjelenítőszerver
+	Liquify	Képlékenyítés
+	List	Lista
+	Load path as a selection	Útvonal betöltése kijelölésként
+	Lock All	Összes zárolása
+	Locked	Zárolva
+	Low	Alacsony
+	Low resolution previews	Alacsony felbontású előnézetek
+	Lower	Alsó
+	Magic Eraser Tool	Varázsradír
+	Magic Wand Tool	Varázspálca
+	Magnetic Lasso	Mágneses lasszó
+	Magnetic Lasso Tool	Mágneses lasszó
+	Make Selection	Kijelölés készítése
+	Make work path from selection	Munkaútvonal készítése a kijelölésből
+	Manual	Kézi
+	manual	kézi
+	Map Layer	Térképréteg
+	Map Path	Térképfájl
+	Mask	Maszk
+	Mask Incomplete Blocks	Hiányos tömbök maszkolása
+	Maximize	Teljes méret
+	Maximize psd compatibility	PSD-kompatibilitás maximalizálása
+	Memory usage mb	Memóriahasználat (MB)
+	Metallic	Fémesség
+	Middle	Közép
+	Missing glyph protection	Hiányzó glifák elleni védelem
+	Mixer Brush Tool	Keverőecset
+	Modern	Modern
+	Monitor profile in use on {display}: {profile}	Használt monitorprofil ({display}): {profile}
+	Monitor profile in use: {profile}	Használt monitorprofil: {profile}
+	Monitor profile on {display} (main window): {profile}	Monitorprofil ({display}, főablak): {profile}
+	Monitor profile on {display}: {profile}	Monitorprofil ({display}): {profile}
+	Monitor profile: {profile}	Monitorprofil: {profile}
+	Monochromatic	Egyszínű
+	More documents	További dokumentumok
+	More panels	További panelek
+	Move Layer	Réteg mozgatása
+	Move Tool	Mozgatás
+	name	név
+	Native file drag-and-drop is not supported on Wayland yet. Use File › Open, or copy the image in your file manager and paste it with {paste}.	Wayland alatt a natív fájlbehúzás még nem támogatott. Használd a Fájl › Megnyitás… parancsot, vagy másold a képet a fájlkezelőben, és illeszd be ({paste}).
+	Native file drag-and-drop is unavailable	A natív fájlbehúzás nem érhető el
+	Nearest neighbor	Legközelebbi szomszéd
+	Nearest Neighbor (hard edges)	Legközelebbi szomszéd (éles szélek)
+	New	Új
+	new	új
+	New document	Új dokumentum
+	New Document With Mask	Új dokumentum maszkkal
+	New document…	Új dokumentum…
+	New Group	Új csoport
+	New Guide	Új segédvonal
+	New Layer	Új réteg
+	New Layer Comp	Új rétegkompozíció
+	New Layer With Mask	Új réteg maszkkal
+	New Selection	Új kijelölés
+	New Size	Új méret
+	New Video Layer from File	Új videoréteg fájlból
+	No Document	Nincs dokumentum
+	No layers	Nincs réteg
+	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Nincs útvonal, amelyből kijelölés készülhetne: rajzolj egyet a Toll eszközzel, vagy válassz egyet az Útvonalak panelen.
+	Normal tip	Normál hegy
+	Note Tool	Jegyzet
+	Note tool	Jegyzet
+	Nothing to paste: the clipboard holds no image	Nincs mit beilleszteni: a vágólapon nincs kép
+	Object Selection Tool	Objektumkijelölés
+	Octagon	Nyolcszög
+	Odd Fields	Páratlan félképek
+	On	Be
+	on	be
+	Open as smart object	Megnyitás intelligens objektumként
+	Open documents as tabs	Dokumentumok megnyitása lapfülként
+	open source	nyílt forráskódú
+	Opened {name}	Megnyitva: {name}
+	Opened {url}	Megnyitva: {url}
+	Opening…	Megnyitás…
+	Or set Preferences › Performance › Linux display server to X11: PhotoCraft then always starts under XWayland.	Vagy állítsd X11-re a Beállítások › Teljesítmény › Linuxos megjelenítőszerver értékét: a PhotoCraft ekkor mindig XWayland alatt indul.
+	Original Ratio	Eredeti arány
+	Other	Egyéb
+	Out	Végpont
+	Output	Kimenet
+	Overscroll	Túlgörgetés
+	Paint Bucket Tool	Festékesvödör
+	Patch Tool	Foltozó
+	Path	Útvonal
+	Path Selection Tool	Útvonal-kijelölés
+	Path:	Útvonal:
+	Pattern Stamp Tool	Mintázatbélyegző
+	Pen Tool	Toll
+	Pencil Tool	Ceruza
+	Pentagon	Ötszög
+	Percentage	Százalék
+	Performance	Teljesítmény
+	Perimeter	Kerület
+	Perspective Crop Tool	Perspektivikus körbevágás
+	PhotoCraft is using the CPU image compositor. The window may still use your graphics adapter.	A PhotoCraft a CPU-s képösszeállítót használja. Az ablak megjelenítése ettől még használhatja a grafikus adaptert.
+	PhotoCraft website	PhotoCraft-weboldal
+	PhotoCraft — Screen Color Picker	PhotoCraft — Képernyő-színválasztó
+	Photomerge	Fotóegyesítés
+	Pick a screen pixel or press Esc to cancel	Válassz egy pixelt a képernyőn, vagy nyomd meg az Esc billentyűt a megszakításhoz
+	Pick screen color	Szín kiválasztása a képernyőről
+	Pick Color From Image	Szín felvétele a képről
+	Pins	Tűk
+	Pixel Layer	Pixelréteg
+	Place Scale Marker	Méretarány-jelölő elhelyezése
+	Plane	Sík
+	Planes	Síkok
+	Platform: {os} {arch}	Platform: {os} {arch}
+	Play selection	Kijelöltek lejátszása
+	Point	Pont
+	Point size	Pontméret
+	Polygon Tool	Sokszög
+	Polygonal Lasso Tool	Sokszöglasszó
+	Preserve	Megőrzendő
+	Preserve Details	Részletek megőrzése
+	Preserve details	Részletek megőrzése
+	previous reading kept; the last re-read failed: {reason}	az előző érték maradt érvényben; a legutóbbi újraolvasás sikertelen: {reason}
+	Prime105	105 mm-es fix
+	Prime35	35 mm-es fix
+	Pro (Dark)	Pro (sötét)
+	Pro (Light Gray)	Pro (világosszürke)
+	Pro (Light)	Pro (világos)
+	Pro (Medium Gray)	Pro (középszürke)
+	Pro light	Pro világos
+	Pro light gray	Pro világosszürke
+	Pro medium	Pro középszürke
+	Pro Medium	Pro középszürke
+	Profile	Profil
+	Pyramids	Gúlák
+	Quick export location	Gyors exportálás helye
+	Quick Selection	Gyorskijelölés
+	Quick Selection Tool	Gyorskijelölés
+	Random	Véletlenszerű
+	Rasterize svg groups deeper than	SVG-csoportok raszterizálása ennél mélyebb szinten
+	Recent file count	Legutóbbi fájlok száma
+	Recent files	Legutóbbi fájlok
+	Recent Files	Legutóbbi fájlok
+	Recent fonts	Legutóbbi betűtípusok
+	Record ● a sequence of edits, then play ▶ it on any document.	Rögzíts ● egy szerkesztési sorozatot, majd játszd le ▶ bármelyik dokumentumon.
+	Rectangle	Téglalap
+	Rectangle Tool	Téglalap
+	Rectangular Marquee Tool	Téglalap-kijelölés
+	Rectangular Selection	Téglalap-kijelölés
+	Red Eye	Vörösszem-javítás
+	Red Eye Tool	Vörösszem-javító
+	Refine Edge	Élfinomítás
+	Relink to File	Újracsatolás fájlhoz
+	Remove All	Összes eltávolítása
+	Remove from Recent	Eltávolítás a legutóbbiak közül
+	Remove Tool	Eltávolító
+	Remove {name} from Recent	Eltávolítás a legutóbbiak közül: {name}
+	Rename Layer Comp	Rétegkompozíció átnevezése
+	Rendering mode	Renderelési mód
+	Repeat	Ismétlés
+	Replace	Csere
+	Replace Contents	Tartalom cseréje
+	Replace Footage	Videoanyag cseréje
+	Resample	Újramintavételezés
+	Reset Preferences	Beállítások alaphelyzetbe
+	Resolution:	Felbontás:
+	Restore	Előző méret
+	Retry GPU	GPU újrapróbálása
+	Retry GPU requires a restart. Save your work first.	A GPU újrapróbálásához újraindítás kell. Előbb mentsd a munkádat.
+	Rgb	RGB
+	Ridges	Hullámgerincek
+	Right	Jobbra
+	Rise	Emelkedés
+	Rotate View Tool	Nézetforgatás
+	Rotate view with trackpad	Nézetforgatás érintőpárnával
+	Row Order	Csatornasorrend
+	Ruler Tool	Vonalzó
+	Same folder	Ugyanaz a mappa
+	Sample a pixel anywhere on the screen	Mintavétel a képernyő bármely pixeléből
+	Sampler	Színmintavevő
+	Save in background	Mentés a háttérben
+	Save your work and restart PhotoCraft to retry GPU acceleration. CPU rendering remains active for this session.	A GPU-gyorsítás újrapróbálásához mentsd a munkádat, majd indítsd újra a PhotoCraftot. Ebben a munkamenetben a CPU-s megjelenítés marad aktív.
+	Saved a copy as {path}	Másolat mentve: {path}
+	Saved {name}	Mentve: {name}
+	Saved {path}; image assets: {n} in {dir}	Mentve: {path}; képelemek: {n} ({dir})
+	Scale Factor	Méretezési tényező
+	Scale Units	Méretarány mértékegysége
+	Scratch Disks	Lapozólemezek
+	Scratch Sizes	Lapozólemez-méretek
+	Scratch: {size}	Lapozólemez: {size}
+	Screen resolution	Képernyőfelbontás
+	Scroll to zoom	Nagyítás görgetéssel
+	Scrubby slider acceleration	Húzócsúszka gyorsítása
+	Seed	Kezdőérték
+	Select Layer	Réteg kijelölése
+	Selected	Kijelölt
+	Selected at launch: {backend}	Indításkor kiválasztva: {backend}
+	Set Colors	Színek beállítása
+	Set Measurement Scale	Mérési méretarány beállítása
+	Set shape fill type	Alakzat kitöltéstípusának beállítása
+	Set shape stroke type	Alakzat körvonaltípusának beállítása
+	Shape	Alakzat
+	Sharpen for	Élesítés célja
+	Shell Lower	Alsó kagyló
+	Shell Upper	Felső kagyló
+	Shift Edge	Él eltolása
+	Shine	Fénylés
+	shortcut	billentyűparancs
+	Shortcut	Billentyűparancs
+	Show canvas dots	Vászonpontok megjelenítése
+	Show channels in color	Csatornák megjelenítése színesen
+	Show crosshair in brush tip	Szálkereszt az ecsethegyben
+	Show extension panels	Bővítménypanelek megjelenítése
+	Show font names in english	Betűnevek angolul
+	Show only crosshair while painting	Festéskor csak szálkereszt
+	Show transformation values	Alakítási értékek megjelenítése
+	Sides	Oldalak
+	Sine	Szinusz
+	Single Column Marquee Tool	Egyoszlopos kijelölés
+	Single Row Marquee Tool	Egysoros kijelölés
+	Slice Select Tool	Szeletkijelölés
+	Slice Tool	Szelet
+	Smart guide color	Intelligens segédvonalak színe
+	Smart Radius	Intelligens sugár
+	Snap vector tools and transforms to pixel grid	Vektoreszközök és alakítások illesztése a pixelrácshoz
+	Snapshots	Pillanatképek
+	Softness	Lágyság
+	Software adapter	Szoftveres adapter
+	Solarized Dark	Solarized sötét
+	Solid Front Faces	Tömör előlapok
+	Spin	Pörgetés
+	Spot Healing	Foltjavítás
+	Spot Healing Brush Tool	Foltjavító ecset
+	Squareness	Szögletesség
+	Squeeze	Összenyomás
+	Stagger	Lökésszerű
+	Standard	Szabványos
+	Star	Csillag
+	Star ratio	Csillagarány
+	Start X	Kezdő X
+	Start Y	Kezdő Y
+	Step Backward	Lépés vissza
+	Step {step} ({id}) failed: {error}	{step}. lépés ({id}) sikertelen: {error}
+	Stop	Leállítás
+	Stop playing/recording	Lejátszás/rögzítés leállítása
+	Strength	Erősség
+	Stretch	Nyújtás
+	Stroke Path	Útvonal körvonalazása
+	Stroke path with brush	Útvonal körvonalazása ecsettel
+	Stroke Width	Körvonal vastagsága
+	Stroke:	Körvonal:
+	Studio	Studio
+	Studio (Dark)	Studio (sötét)
+	Studio (Light)	Studio (világos)
+	Stylization	Stilizálás
+	Switch Foreground and Background Colors	Előtér- és háttérszín cseréje
+	Switched to CPU rendering	Átváltás CPU-s megjelenítésre
+	System	Rendszer
+	Tablet	Tablet
+	Taper	Elvékonyodás
+	Target	Cél
+	Text file	Szövegfájl
+	The canvas is shown as sRGB. Choose a monitor profile in Edit › Color Settings.	A vászon sRGB-ként jelenik meg. Monitorprofilt itt választhatsz: Szerkesztés › Színbeállítások.
+	The canvas on {display} is shown as sRGB. Choose a monitor profile in Edit › Color Settings.	A vászon sRGB-ként jelenik meg ezen a kijelzőn: {display}. Monitorprofilt itt választhatsz: Szerkesztés › Színbeállítások.
+	The GPU compositor wasn't used: {reason}	A GPU-s képösszeállító nem volt használatban: {reason}
+	This redraw took {seconds} s on the CPU.	Az újrarajzolás ideje a CPU-n: {seconds} s.
+	This session: {reason}	Ebben a munkamenetben: {reason}
+	Tiny	Apró
+	To Center	Középre
+	To drop files, start PhotoCraft under XWayland: `{command}`	Fájlok behúzásához indítsd a PhotoCraftot XWayland alatt: `{command}`
+	Tool	Eszköz
+	Top Left	Bal felső
+	Top Right	Jobb felső
+	Touch gestures	Érintési gesztusok
+	Transform Again on a Copy	Alakítás ismétlése másolaton
+	Transition	Átmenet
+	Transparency & Gamut	Átlátszóság és színtartomány
+	Trap	Ráfutás
+	Tree	Fa
+	Triangle Tool	Háromszög
+	Trim	Levágás
+	Twist	Csavarás
+	Unaltered	Változatlan
+	Uniform	Egyenletes
+	Units	Mértékegységek
+	Units & Rulers	Mértékegységek és vonalzók
+	Unknown	Ismeretlen
+	unknown	ismeretlen
+	unknown type	ismeretlen típus
+	Unnamed {mode} profile	Névtelen profil ({mode})
+	Untagged {mode}	Profil nélkül ({mode})
+	Update	Frissítés
+	Update Layer Comp	Rétegkompozíció frissítése
+	Upper	Felső
+	Use additional plugins folder	További bővítménymappa használata
+	Use Custom Color	Egyéni szín használata
+	Use File › Open, or paste a copied image with {paste}.	Használd a Fájl › Megnyitás… parancsot, vagy illessz be egy másolt képet ({paste}).
+	Use gpu	GPU használata
+	Use tablet pressure	Tablet nyomásérzékelésének használata
+	Vanishing Point	Enyészpont
+	Vertical Type Mask Tool	Függőleges szövegmaszk
+	Vertical Type Tool	Függőleges szöveg
+	Video Frames to Layers	Videókockák rétegekbe
+	View	Nézet
+	Wand	Varázspálca
+	Warmth	Melegség
+	Weight:	Vastagság:
+	Window renderer: {renderer}	Ablakmegjelenítő: {renderer}
+	Work Path	Munkaútvonal
+	World ready	Többnyelvű
+	Wrap	Körbefordítás
+	X11	X11
+	Zoom clicked point to center	Kattintott pont nagyítása középre
+	Zoom resizes windows	Nagyításkor az ablak is átméreteződik
+	Zoom with scroll wheel	Nagyítás görgővel
+	Zoom with trackpad pinch	Nagyítás csippentéssel az érintőpárnán
+	{name} options	{name}: beállítások
+	{size} (was {old})	{size} (korábban: {old})
+	{w} px x {h} px ({ppi} ppi)	{w} px x {h} px ({ppi} ppi)
+	{w} {unit} x {h} {unit} ({ppi} ppi)	{w} {unit} x {h} {unit} ({ppi} ppi)
+	…and {n} more	…és még {n}
+
+# Labels kept for parity with the other catalogs
+	10 fps	10 fps
+	15 fps	15 fps
+	24 fps	24 fps
+	25 fps	25 fps
+	250%	250%
+	3D…	3D…
+	85%	85%
+	95%	95%
+	Accurate	Pontos
+	ACES	ACES
+	Actual Color	Tényleges szín
+	Add a mask  (from the selection; ⌥ inverts)	Maszk hozzáadása  (a kijelölésből; ⌥: invertálás)
+	Add Mask	Maszk hozzáadása
+	Add Pins	Tűk hozzáadása
+	Add to selection  (⇧)	Hozzáadás a kijelöléshez  (⇧)
+	Adds grain to the soft edges of the brush tip.	Szemcsézettséget ad az ecsethegy lágy széleihez.
+	Adjustment Layers	Korrekciós rétegek
+	Adobe Every-line Composer	Adobe többsoros szedőmotor
+	Adobe PDF Presets…	Adobe PDF-előbeállítások…
+	Adobe Single-line Composer	Adobe egysoros szedőmotor
+	Advanced Controls	Speciális vezérlők
+	After (X)	Utána (X)
+	Airbrush: keeps painting while the pointer rests.	Festékszóró: a festés akkor is folytatódik, amikor a mutató áll.
+	Alternates for Current Selection	Változatok a jelenlegi kijelöléshez
+	Aperture	Rekesznyílás
+	Apple RGB	Apple RGB
+	Apply to All	Alkalmaz mindre
+	Are you sure you want to quit?	Biztosan kilépsz?
+	Are you sure?	Biztos vagy benne?
+	Arrangement	Elrendezés
+	Art History Brush	Művészi előzményecset
+	Ask Before Saving Saved Embedded	Rákérdezés a beágyazott tartalom mentése előtt
+	Ask When Pasting	Rákérdezés beillesztéskor
+	Audio	Hang
+	Auto Clean Brush	Ecset automatikus tisztítása
+	Auto-Hide	Automatikus elrejtés
+	Auto-Leading	Automatikus sorköz
+	Auto-leading %	Automatikus sorköz %
+	Automatically Create First Snapshot	Első pillanatkép automatikus létrehozása
+	Automatically Create New Snapshot When Saving	Új pillanatkép automatikus létrehozása mentéskor
+	Avoid Widows/Orphans	Fattyúsorok elkerülése
+	Blend RGB Colors Using Gamma 1.0	RGB-színek keverése 1,0 gammával
+	Blending Mode	Keverési mód
+	Blue, Red, Yellow	Kék, vörös, sárga
+	Browser storage is unavailable; brushes are session-only. Keep this tab open to retain them.	A böngésző tárhelye nem érhető el, ezért az ecsetek csak ebben a munkamenetben maradnak meg. Ne zárd be ezt a lapot, ha meg akarod tartani őket.
+	Brush preset changes are not saved: {error}	Az ecset-előbeállítások módosításai nincsenek mentve: {error}
+	Byline	Szerző
+	Byline Title	Szerző beosztása
+	Camera Make	Fényképezőgép gyártója
+	Camera Model	Fényképezőgép típusa
+	Canvas rotation	Vászonforgatás
+	Caption Credits	Képaláírás és forrás
+	Capture Comp	Rétegkompozíció rögzítése
+	Changes have not been saved.	A módosítások nincsenek mentve.
+	Changes Saved	Módosítások mentve
+	Check for Updates	Frissítések keresése
+	Choose Folder	Mappa kiválasztása
+	Choose…	Kiválasztás…
+	CIE RGB	CIE RGB
+	City	Város
+	Clear History	Előzmények törlése
+	Click sets foreground · right-click sets background	Kattintás: előtérszín · jobb kattintás: háttérszín
+	Click the first point or press ↵ to close · Esc cancels	Lezáráshoz kattints az első pontra, vagy nyomd meg: ↵ · Esc: megszakítás
+	Click to add a point · drag off or ⌘/Ctrl-click or Delete to remove	Kattintással pontot adhatsz hozzá · eltávolítás: lehúzás, ⌘/Ctrl-kattintás vagy Delete
+	Click to add text	Kattints a szöveg hozzáadásához
+	Click to apply, ⌥-click to clear overrides, double-click for Style Options	Kattintás: alkalmazás, ⌥-kattintás: felülbírálások törlése, dupla kattintás: stílusbeállítások
+	Click to zoom in  ·  ⌥-click to zoom out	Kattintás: nagyítás  ·  ⌥-kattintás: kicsinyítés
+	Click: corner · Drag: smooth · Click first point: close · {key} finish · Esc cancel	Kattintás: sarok · Húzás: sima · Kattintás az első pontra: lezárás · {key}: befejezés · Esc: megszakítás
+	Click: corner · Drag: smooth · Click first point: close · ↩ finish · Esc cancel	Kattintás: sarok · Húzás: sima · Kattintás az első pontra: lezárás · ↩: befejezés · Esc: megszakítás
+	Coerce to sRGB	Kényszerítés sRGB-re
+	Collapse group  (⌥-click: all groups)	Csoport összecsukása  (⌥-kattintás: minden csoport)
+	Color Management Policies	Színkezelési szabályok
+	Color Noise Reduction	Színzaj csökkentése
+	ColorMatch RGB	ColorMatch RGB
+	Commit any current edits (⌘↩)	Folyamatban lévő szerkesztések véglegesítése (⌘↩)
+	Commit current crop operation  (↵)	Körbevágás véglegesítése  (↵)
+	Commit Perspective Warp (↩)	Perspektivikus torzítás véglegesítése (↩)
+	Commit Puppet Warp (↩)	Bábtorzítás véglegesítése (↩)
+	Commit transform (↩)	Alakítás véglegesítése (↩)
+	Commit warp (↩)	Hajlítás véglegesítése (↩)
+	Convert Frames > Video Layers	Képkockák átalakítása > Videórétegek
+	Convert to Grayscale	Átalakítás szürkeárnyalatossá
+	Copper	Réz
+	Copyright Info URL	Szerzői jogi információk URL-je
+	Could not open	Nem nyitható meg
+	Country	Ország
+	Create a new layer  (⇧⌘N)	Új réteg létrehozása  (⇧⌘N)
+	Create Date	Létrehozás dátuma
+	Create Multiple Picture Packages	Több képcsomag létrehozása
+	Create new count group	Új számlálócsoport létrehozása
+	Create new set	Új készlet létrehozása
+	Create Plane	Sík létrehozása
+	Create Snapshot	Pillanatkép létrehozása
+	Create…	Létrehozás…
+	Credit	Forrásmegjelölés
+	Current Time	Aktuális idő
+	Custom pattern	Egyéni mintázat
+	Date Created	Létrehozás dátuma
+	DateTime Original	Eredeti dátum és idő
+	Defaults restored.	Alapértékek visszaállítva.
+	Delete Layer…	Réteg törlése…
+	Delete Mask	Maszk törlése
+	Delete Pins	Tűk törlése
+	Delete Preset…	Előbeállítás törlése…
+	Delete Smart Filters	Intelligens szűrők törlése
+	Delete Snapshot	Pillanatkép törlése
+	Delete…	Törlés…
+	Desaturate Monitor Colors By	Monitorszínek telítettségének csökkentése ennyivel
+	Detect Faces	Arcfelismerés
+	Digits	Számjegyek
+	Direction of Stroke	Vonás iránya
+	Disable Mask	Maszk letiltása
+	Discard Changes	Módosítások elvetése
+	Do you want to save you made to “{name}” before quitting?	Mented a módosításokat kilépés előtt? Dokumentum: „{name}”
+	Documentation	Dokumentáció
+	Drag (lasso) or click points (polygonal) · {add} add · {sub} subtract	Húzás (lasszó) vagy pontok kattintással (sokszög) · {add}: hozzáadás · {sub}: kivonás
+	Drag to move the layer	Húzással mozgathatod a réteget
+	Duplicated selection name	Kettőzött kijelölés neve
+	Edit Plane	Sík szerkesztése
+	Edit…	Szerkesztés…
+	Email	E-mail
+	Embed profiles	Profilok beágyazása
+	Enable Mask	Maszk engedélyezése
+	Enable Smart Filters	Intelligens szűrők engedélyezése
+	Enable Timeline Quick Config	Idővonal gyorsbeállításának engedélyezése
+	Enter description…	Írd be a leírást…
+	Error File	Hibafájl
+	EXIF Version	EXIF-verzió
+	Expand All Groups	Összes csoport kibontása
+	Expand group  (⌥-click: all groups)	Csoport kibontása  (⌥-kattintás: minden csoport)
+	Export Image	Kép exportálása
+	Export to	Exportálás célja
+	Exporting…	Exportálás…
+	Exposure Program	Expozíciós program
+	Failed to open file	A fájl nem nyitható meg
+	Failed to save file	A fájl nem menthető
+	Feather Radius	Elmosott szél sugara
+	File Naming	Fájlelnevezés
+	File not found	A fájl nem található
+	File Size	Fájlméret
+	Fill Light	Derítőfény
+	First Color Readout	Első színkijelzés
+	Fit to Window	Ablakhoz igazítás
+	Flash	Vaku
+	Flatten Frames Into Clips	Képkockák egybesimítása klipekbe
+	Flatten Frames Into Layers	Képkockák egybesimítása rétegekbe
+	Frame Duration	Képkocka időtartama
+	Frame Sync	Képkocka-szinkronizálás
+	General Brushes	Általános ecsetek
+	Glyph Scaling	Glifaméretezés
+	Go to Layer	Ugrás a rétegre
+	GPS	GPS
+	Gray:	Szürke:
+	Grayscale Slider	Szürkeárnyalat-csúszka
+	Grid  (⌘')	Rács  (⌘')
+	Hanging Punctuation	Függő írásjelek
+	HDTV (Rec. 709)	HDTV (Rec. 709)
+	Heal Auto	Javítás: automatikus
+	Heal Color	Javítás: szín
+	Heal Off	Javítás: ki
+	Heal On	Javítás: be
+	Hide Grid	Rács elrejtése
+	Hide the layer's effects  (⌥-click: all layers)	Rétegeffektusok elrejtése  (⌥-kattintás: minden réteg)
+	HSB Color	HSB-szín
+	HSL/Grayscale	HSL/szürkeárnyalat
+	Humidity	Páratartalom
+	Import Image	Kép importálása
+	Import Options	Importálási beállítások
+	Import Settings	Beállítások importálása
+	Importing…	Importálás…
+	Import…	Importálás…
+	Include ICC Profile	ICC-profil belefoglalása
+	Industry Standard	Iparági szabvány
+	Info Options…	Információ-beállítások…
+	Initial Direction of Stroke	Vonás kezdőiránya
+	Input Levels	Bemeneti szintek
+	Intersect with selection  (⇧⌥)	Metszet a kijelöléssel  (⇧⌥)
+	Invert Selection	Kijelölés megfordítása
+	Jag	Cakkos
+	Keep proportions	Méretarány megtartása
+	Keep this tab open to retain your brushes.	Ne zárd be ezt a lapot, ha meg akarod tartani az ecseteidet.
+	Keep view in sync	Nézetek szinkronban tartása
+	Keeps the current texture when switching presets.	Előbeállítás váltásakor megtartja a jelenlegi textúrát.
+	Last Modified	Utolsó módosítás
+	Layer Styles	Rétegstílusok
+	Learn More	További információ
+	Lens Corrections	Objektívkorrekciók
+	Lens Info	Objektívadatok
+	Limit Playback	Lejátszás korlátozása
+	Live Preview	Élő előnézet
+	Loading…	Betöltés…
+	Localize Color Clusters	Helyi színcsoportok
+	Lock Image Pixels	Képpixelek zárolása
+	Lock Position	Pozíció zárolása
+	Lock Transparent Pixels	Átlátszó pixelek zárolása
+	Log Errors To File	Hibák naplózása fájlba
+	Luminance Smoothness	Luminancia simasága
+	Mac Crisp	Mac tiszta
+	Mac LCD	Mac LCD
+	Mac Sharp	Mac éles
+	Mac Smooth	Mac sima
+	Mac Strong	Mac erős
+	Metering Mode	Fénymérési mód
+	Minimalistic	Minimalista
+	Missing Profiles: Ask When Opening	Hiányzó profilok: rákérdezés megnyitáskor
+	Modify Date	Módosítás dátuma
+	Mouse Controls	Egérvezérlés
+	Mouse Coordinates	Egérkoordináták
+	Native file drag-and-drop is not supported on Wayland yet. Use File › Open, or run PhotoCraft under XWayland with `WAYLAND_DISPLAY= photocraft`.	A fájlok natív behúzása Waylanden még nem támogatott. Használd a Fájl › Megnyitás parancsot, vagy futtasd a PhotoCraftot XWaylanden: `WAYLAND_DISPLAY= photocraft`.
+	New channel only	Csak új csatorna
+	New document…     ⌘N	Új dokumentum…     ⌘N
+	New Layer from Brush	Új réteg ecsetből
+	New Path	Új útvonal
+	New Snapshot	Új pillanatkép
+	New Video Group	Új videócsoport
+	Newspaper	Újságpapír
+	No Layer Comps	Nincs rétegkompozíció
+	No Layers	Nincs réteg
+	No recent files	Nincs legutóbbi fájl
+	No Results	Nincs találat
+	No Results Found	Nincs találat
+	No Selection	Nincs kijelölés
+	Nonlinear History	Nemlineáris előzmények
+	Nothing to Redo	Nincs mit újra végrehajtani
+	Nothing to Undo	Nincs mit visszavonni
+	NTSC (1953)	NTSC (1953)
+	Object Name / Title	Objektum neve / cím
+	Opacity Mask	Átlátszatlansági maszk
+	Open Image	Kép megnyitása
+	Open…     ⌘O	Megnyitás…     ⌘O
+	Operation canceled	Művelet megszakítva
+	Operation cancelled	Művelet megszakítva
+	Operation completed	Művelet befejezve
+	Operation failed	A művelet sikertelen
+	Overlay: Rule of Thirds	Fedvény: harmadolási szabály
+	Override Action "Save" Commands	A műveletsor „Mentés” parancsainak felülbírálása
+	Page Setup…	Oldalbeállítás…
+	PAL/SECAM	PAL/SECAM
+	Panel Options…	Panelbeállítások…
+	Path to Illustrator…	Útvonal Illustrator-fájlba…
+	PDF Presentation…	PDF-bemutató…
+	Photo (2 × 3 in)	Fotó (2 × 3 in)
+	Photo (4 × 6 in)	Fotó (4 × 6 in)
+	Photo (5 × 7 in)	Fotó (5 × 7 in)
+	Photo (8 × 10 in)	Fotó (8 × 10 in)
+	Picture Package…	Képcsomag…
+	Play Once	Lejátszás egyszer
+	Please wait…	Kis türelmet…
+	Preset Name:	Előbeállítás neve:
+	Profile Mismatches: Ask When Opening	Profileltérés: rákérdezés megnyitáskor
+	Province / State	Megye / állam
+	Quick Sync	Gyors szinkronizálás
+	Quit PhotoCraft	Kilépés a PhotoCraftból
+	Recent Items	Legutóbbi elemek
+	Reference point location	Viszonyítási pont helye
+	Rendering…	Renderelés…
+	Report a Bug	Hiba bejelentése
+	Reset GPU Backend	GPU-háttérrendszer alaphelyzetbe állítása
+	Restart	Újraindítás
+	Restart Required	Újraindítás szükséges
+	Restore last viewed comp	Utoljára megtekintett rétegkompozíció visszaállítása
+	Retry saving presets	Előbeállítások mentésének újrapróbálása
+	Roman Hanging Punctuation	Latin függő írásjelek
+	Rotate Auto	Forgatás: automatikus
+	Rotate Fixed	Forgatás: rögzített
+	Ruler Units	Vonalzó mértékegysége
+	Rulers  (⌘R)	Vonalzók  (⌘R)
+	Save before closing?	Mented bezárás előtt?
+	Save Changes	Módosítások mentése
+	Save Image	Kép mentése
+	Saved Multichannel	Többcsatornásként mentve
+	Saving brush presets… Keep this tab open until saving finishes.	Ecset-előbeállítások mentése… Ne zárd be ezt a lapot, amíg a mentés tart.
+	Saving…	Mentés…
+	Scale Horizontally	Vízszintes méretezés
+	Scale Vertically	Függőleges méretezés
+	Search commands (⌘K)	Parancsok keresése (⌘K)
+	Second Color Readout	Második színkijelzés
+	Select Folder…	Mappa kiválasztása…
+	Select Plane	Sík kijelölése
+	Select Similar Colors	Hasonló színek kijelölése
+	Set New Snapshot as Default	Új pillanatkép beállítása alapértelmezettként
+	Set Start Timecode…	Kezdő időkód beállítása…
+	Show Guides  (⌘;)	Segédvonalak megjelenítése  (⌘;)
+	Show New Snapshot Dialog by Default	Új pillanatkép ablakának megjelenítése alapértelmezés szerint
+	Show the layer's effects  (⌥-click: all layers)	Rétegeffektusok megjelenítése  (⌥-kattintás: minden réteg)
+	Shutter Speed	Záridő
+	Simple	Egyszerű
+	Single Word Justification	Egyszavas sorkizárás
+	Smart Object Layer	Intelligensobjektum-réteg
+	SMPTE C	SMPTE C
+	Snap to Grid	Illesztés a rácshoz
+	Snapshot 1	Pillanatkép 1
+	Some brush presets could not be loaded	Egyes ecset-előbeállítások nem tölthetők be
+	Spacing:	Térköz:
+	Split at Playhead	Felosztás a lejátszófejnél
+	Split Toning	Osztott tónusozás
+	Status Information	Állapotinformáció
+	Step Forward	Lépés előre
+	Stop For Errors	Leállás hiba esetén
+	Subdivisions	Felosztások
+	Subject Distance	Tárgytávolság
+	Subscript	Alsó index
+	Subtract from selection  (⌥)	Kivonás a kijelölésből  (⌥)
+	Superscript	Felső index
+	Supplemental Categories	Kiegészítő kategóriák
+	Switch theme	Témaváltás
+	Technology Previews	Technológiai előzetesek
+	Technology Previews…	Technológiai előzetesek…
+	The current gradient (pick one in Window › Gradients)	A jelenlegi színátmenet (másikat az Ablak › Színátmenetek panelen választhatsz)
+	The file could not be opened.	A fájl nem nyitható meg.
+	The file could not be saved.	A fájl nem menthető.
+	Timecode	Időkód
+	Toggle reference point	Viszonyítási pont be/ki
+	Toolbars	Eszköztárak
+	Total Ink	Teljes festékmennyiség
+	Transmission Reference	Továbbítási azonosító
+	Turbulent	Turbulens
+	UI font size	Felület betűmérete
+	Ultra Bold	Extrakövér
+	Ultra Light	Extravékony
+	Uncoated CMYK	Bevonat nélküli CMYK
+	Unlocked	Zárolás feloldva
+	Unsaved Changes	Nem mentett módosítások
+	Unsupported file format	Nem támogatott fájlformátum
+	Unsupported format	Nem támogatott formátum
+	Urgency	Sürgősség
+	Use File › Open to open an image.	Kép megnyitásához használd a Fájl › Megnyitás parancsot.
+	Uses the foreground and background colors.	Az előtér- és a háttérszínt használja.
+	Violet, Orange	Ibolya, narancs
+	Watercolour look: lighter interior, darker rims.	Akvarellhatás: világosabb belső rész, sötétebb szélek.
+	Web Photo Gallery…	Webes fotógaléria…
+	WebP (lossless)	WebP (veszteségmentes)
+	Wide Gamut RGB	Wide Gamut RGB
+	Word Spacing	Szótávolság
+	Working Gray Plate	Szürke munkalemez
+	Working Space	Munkaszíntér
+	Working Spaces	Munkaszínterek
+	{path}: the path is not valid Unicode; rename the file and open it again.	{path}: az elérési út nem érvényes Unicode-szöveg. Nevezd át a fájlt, és nyisd meg újra.
+	{zoom}%	{zoom}%
+	↑↓ navigate   ↵ run   esc close	↑↓ léptetés   ↵ futtatás   esc bezárás
+	Amount:	Mérték:
+	Apply Vanishing Point ({key})	Enyészpont alkalmazása ({key})
+	Apply the removal ({key})	Eltávolítás alkalmazása ({key})
+	Drag to draw the curve · {key}-click draws a straight line	Húzással rajzold meg a görbét · {key}+kattintás: egyenes vonal
+	Draw to modify the curve	Rajzolj a görbe módosításához
+	Edit points to modify the curve	Szerkeszd a pontokat a görbe módosításához
+	Fix the red plane first: its corners must form a convex quad	Először javítsd a piros síkot: sarkainak konvex négyszöget kell alkotniuk
+	Grid Size:	Rácsméret:
+	Light Blue	Világoskék
+	Light Red	Világospiros
+	Medium Blue	Középkék
+	Merge Group	Csoport egyesítése
+	Protect skin tones	Bőrtónusok védelme
+	Protect:	Védelem:
+	Remove after each stroke	Eltávolítás minden ecsetvonás után
+	Saving {percent}	Mentés: {percent}
+	Scale or rotate the moved area, then press {key}	Méretezd vagy forgasd el az áthelyezett területet, majd nyomd meg: {key}
+	Smooth the curve values	A görbeértékek simítása
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Eltávolítandó ecsetvonások: {n} (Enter: alkalmazás, Esc: mégse)
+	The layer or its mask changed. Drag the mask onto the Trash again.	A réteg vagy a maszkja megváltozott. Húzd újra a maszkot a Kukába.
+	Transform On Drop	Átalakítás elengedéskor
+	Vanishing Point is not active	Az Enyészpont nem aktív
+	Vanishing Point: click four corners to create a plane	Enyészpont: sík létrehozásához kattints a négy sarokra
+	Clear Brush Controls	Ecsetvezérlők törlése
+	Reset All Locked Settings	Összes zárolt beállítás visszaállítása
+	Copy Texture to Other Tools	Textúra másolása más eszközökre
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Műveletek betöltése…
+	Save Actions…	Műveletek mentése…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{n} művelet betöltve. Forrás: {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} lépésnek még nincs megfelelője a PhotoCraftban
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{n} művelet mentve. Cél: {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	{n} Photoshop-megfelelő nélküli lépés kihagyva
+
+	Starting serial	Kezdő sorszám
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Leállítás beszúrása…
+	Save Set…	Készlet mentése…
+	Message:	Üzenet:
+	Allow Continue	Folytatás engedélyezése
+	Show dialog during playback	Párbeszédablak megjelenítése lejátszáskor
+	Select an action first	Először válassz ki egy műveletet
+	Action playback stopped	A művelet lejátszása leállt
+	Step {step} is waiting for its dialog	A(z) {step}. lépés a párbeszédablakára vár
+@plural	{n} action|{n} actions	{n} művelet
+	Object Finder	Objektumkereső
+	No object found there — drag a rectangle around it	Ott nem található objektum – húzz köré egy téglalapot
+	Drag to pan · Scroll to zoom · Double-click to fit	Húzás: mozgatás · Görgetés: nagyítás · Dupla kattintás: igazítás
+	Gradient Preset Options	Színátmenet-előbeállítás beállításai
+	Import .GRD	.GRD importálása
+	Choose a gradient file (.grd).	Válasszon színátmenetfájlt (.grd).
+	Save Settings…	Beállítások mentése…
+	Load Settings…	Beállítások betöltése…
+	Save these settings as a Camera Raw .xmp file	A beállítások mentése Camera Raw .xmp-fájlként
+	Load settings from a Camera Raw .xmp file	Beállítások betöltése Camera Raw .xmp-fájlból
+	Loaded Camera Raw settings from {file}	Camera Raw-beállítások betöltve innen: {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Camera Raw-beállítások betöltve innen: {file} ({n} nem támogatott)
+	Auto Add/Delete	Automatikus hozzáadás/törlés
+	ICO is limited to 256 × 256 pixels	Az ICO legfeljebb 256 × 256 képpont lehet
+
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Csatorna színe
+	Color Indicates:	A szín jelzése:
+	Ink Characteristics	Festék jellemzői
+	Solidity:	Fedőképesség:
+	Redrawing	Újrarajzolás
diff --git a/crates/ui-egui/src/i18n/id.tsv b/crates/ui-egui/src/i18n/id.tsv
index 4ef02d9ecc..dcc02ec185 100644
--- a/crates/ui-egui/src/i18n/id.tsv
+++ b/crates/ui-egui/src/i18n/id.tsv
@@ -12,7 +12,17 @@
 # Product and technology names (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...) stay in Latin
 # letters; the trailing "…" of dialog commands is kept.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Warna Saluran
+	Color Indicates:	Warna Menunjukkan:
+	Solidity:	Soliditas:
+	Ink Characteristics	Karakteristik Tinta
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Lebar kertas
+	Paper Height	Tinggi kertas
 	Rows	Baris
 	Number	Jumlah
 	Margin	Margin
@@ -68,6 +78,8 @@
 	Save	Simpan
 	Save As…	Simpan Sebagai…
 	Save a Copy…	Simpan Salinan…
+	{name} can't keep everything in this document	{name} tidak dapat menyimpan semua isi dokumen ini
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Pilih format yang menyimpan semuanya, seperti Photoshop (PSD), atau simpan salinan.
 	Revert	Kembalikan
 	Export	Ekspor
 	Quick Export as PNG	Ekspor Cepat ke PNG
@@ -105,6 +117,14 @@
 	Script Events Manager…	Pengelola Event Skrip…
 	Import	Impor
 	Browse…	Telusuri…
+	Source Files	File Sumber
+	Use:	Gunakan:
+	Files	File
+	Folder	Folder
+	Add Open Files	Tambahkan File Terbuka
+	Sort By Name	Urutkan Menurut Nama
+	Attempt to Automatically Align Source Images	Coba Sejajarkan Gambar Sumber Secara Otomatis
+	Create Smart Object after Loading Layers	Buat Smart Object setelah Memuat Layer
 	Reveal in Finder	Tampilkan di Finder
 	Show in Explorer	Tampilkan di Explorer
 	Show in Folder	Tampilkan di Folder
@@ -129,6 +149,8 @@
 	Search…	Cari…
 	Check Spelling…	Periksa Ejaan…
 	Find and Replace Text…	Cari dan Ganti Teks…
+	Add to Dictionary	Tambahkan ke Kamus
+	No Spelling Suggestions	Tidak Ada Saran Ejaan
 	Fill…	Isi…
 	Stroke…	Stroke…
 	Content-Aware Fill…	Isi Content-Aware…
@@ -141,6 +163,8 @@
 	Again	Lagi
 	Scale	Skala
 	Rotate	Putar
+	Set horizontal skew	Atur kemiringan horizontal
+	Set vertical skew	Atur kemiringan vertikal
 	Skew	Miringkan
 	Distort	Distorsi
 	Perspective	Perspektif
@@ -346,6 +370,7 @@
 	Update Modified Content	Perbarui Isi yang Diubah
 	Update All Modified Content	Perbarui Semua Isi yang Diubah
 	Stack Mode	Mode Stack
+	Choose Stack Mode:	Pilih Mode Stack:
 	Entropy	Entropi
 	Kurtosis	Kurtosis
 	Maximum	Maksimum
@@ -380,6 +405,7 @@
 	Select Linked Layers	Pilih Layer Tertaut
 	Merge Layers	Gabungkan Layer
 	Merge Down	Gabung ke Bawah
+	Merge Group	Gabungkan Grup
 	Merge Visible	Gabung yang Terlihat
 	Stamp Visible	Stamp yang Terlihat
 	Stamp Down	Stamp ke Bawah
@@ -510,6 +536,9 @@
 	Blur	Blur
 	Blur Gallery	Galeri Blur
 	Field Blur…	Field Blur…
+# Field Blur pins (#3373)
+	No pin selected	Tidak ada pin yang dipilih
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Klik gambar untuk menambah pin; seret pin untuk memindahkannya, atau cincinnya untuk mengubah blur. Delete menghapus pin yang dipilih.
 	Iris Blur…	Iris Blur…
 	Tilt-Shift…	Tilt-Shift…
 	Path Blur…	Path Blur…
@@ -708,6 +737,10 @@
 	Breeze Dark Theme	Tema Breeze Gelap
 	Breeze light	Breeze terang
 	Breeze Light Theme	Tema Breeze Terang
+	Soft dark	Lembut gelap
+	Soft light	Lembut terang
+	Soft Dark Theme	Tema lembut gelap
+	Soft Light Theme	Tema lembut terang
 	Next Theme	Tema Berikutnya
 	Actions	Action
 	Brush Settings	Pengaturan Kuas
@@ -807,6 +840,9 @@
 	Appearance	Tampilan
 	Appearance (Layer Style)	Tampilan (Gaya Layer)
 	Apply Layer Mask	Terapkan Mask Layer
+	Add Mask to Selection	Tambahkan Mask ke Seleksi
+	Subtract Mask from Selection	Kurangi Mask dari Seleksi
+	Intersect Mask with Selection	Iriskan Mask dengan Seleksi
 	Apply Per Tip	Terapkan Per Ujung
 	Apply next selected layer comp	Terapkan layer comp terpilih berikutnya
 	Apply previous selected layer comp	Terapkan layer comp terpilih sebelumnya
@@ -822,11 +858,18 @@
 	Background	Background
 	Background Color	Warna Background
 	Background Contents	Isi Background
+	Custom background color	Warna background kustom
 	Balance	Keseimbangan
 	Baseline	Baseline
 	Baseline shift	Geser baseline
 	Basic	Dasar
 	Before (Y)	Sebelum (Y)
+	Save Settings…	Simpan Pengaturan…
+	Load Settings…	Muat Pengaturan…
+	Save these settings as a Camera Raw .xmp file	Simpan pengaturan ini sebagai berkas .xmp Camera Raw
+	Load settings from a Camera Raw .xmp file	Muat pengaturan dari berkas .xmp Camera Raw
+	Loaded Camera Raw settings from {file}	Pengaturan Camera Raw dimuat dari {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Pengaturan Camera Raw dimuat dari {file} ({n} tidak didukung)
 	Begin recording	Mulai merekam
 	Bend:	Lengkung:
 	Bicubic	Bicubic
@@ -857,6 +900,7 @@
 	Camera Raw isn't open	Camera Raw tidak terbuka
 	Cancel	Batal
 	Cancel (Esc)	Batal (Esc)
+	Manage submitted jobs in the system print queue	Kelola pekerjaan yang dikirim dalam antrean cetak sistem
 	Cancel any current edits (Esc)	Batalkan semua pengeditan saat ini (Esc)
 	Cancel current crop operation  (Esc)	Batalkan operasi crop saat ini  (Esc)
 	Cancel transform (Esc)	Batalkan transformasi (Esc)
@@ -1122,6 +1166,9 @@
 	Ignore All	Abaikan Semua
 	Image Size	Ukuran Gambar
 	Import Brushes…	Impor Kuas…
+	Gradient Preset Options	Opsi Preset Gradien
+	Import .GRD	Impor .GRD
+	Choose a gradient file (.grd).	Pilih file gradien (.grd).
 	Import brushes (.abr)	Impor kuas (.abr)
 	Import Presets	Impor Preset
 	Imported	Diimpor
@@ -2043,6 +2090,11 @@
 	Rename Brush…	Ganti Nama Kuas…
 	Delete Brush	Hapus Kuas
 	New Brush Preset…	Preset Kuas Baru…
+	Capture Brush Size in Preset	Simpan Ukuran Kuas di Preset
+	Include Tool Settings	Sertakan Pengaturan Alat
+	Include Color	Sertakan Warna
+	Enter a name for the brush preset	Masukkan nama untuk preset kuas
+	A brush preset with this name already exists	Preset kuas dengan nama ini sudah ada
 	Brush Preset Options	Opsi Preset Kuas
 	Group name	Nama grup
 	Brush name	Nama kuas
@@ -2099,6 +2151,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Tidak ada path untuk dibuat seleksi: gambar dengan alat Pen atau pilih salah satu di panel Path.
 	Cancel opening	Batalkan pembukaan
 	Cancelled opening {name}	Pembukaan {name} dibatalkan
+	The document “{name}” does not have an embedded {mode} profile.	Dokumen “{name}” tidak memiliki profil {mode} tertanam.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Dokumen “{name}” memiliki profil warna tertanam yang tidak cocok dengan working space {mode} saat ini.
+	Embedded: {embedded}	Tertanam: {embedded}
+	Working: {working}	Working space: {working}
 	Developing {name}	Mengembangkan {name}
 	Cancelled {label}	{label} dibatalkan
 	Esc to cancel	Esc untuk batal
@@ -2412,7 +2468,6 @@
 	Choose…	Pilih…
 	Select Folder…	Pilih Folder…
 	Override Action "Save" Commands	Timpa Perintah Action "Save"
-	File Naming	Penamaan Berkas
 	Compatibility	Kompatibilitas
 	Mac OS	Mac OS
 	Unix	Unix
@@ -2730,6 +2785,7 @@ cameraRaw	Blending	Pembauran
 	Click to pick · Esc to cancel	Klik untuk memilih · Esc untuk membatalkan
 	Pick a screen pixel or press Esc to cancel	Pilih piksel layar atau tekan Esc untuk membatalkan
 	Scroll to zoom	Gulir untuk memperbesar
+	Drag to pan · Scroll to zoom · Double-click to fit	Seret untuk menggeser · Gulir untuk memperbesar · Klik dua kali untuk menyesuaikan
 	Show/Hide All Panels	Tampilkan/Sembunyikan Semua Panel
 	Show/Hide Panels	Tampilkan/Sembunyikan Panel
 	Could not open	Tidak dapat membuka
@@ -2785,6 +2841,7 @@ cameraRaw	Blending	Pembauran
 	Fuchsia	Fuksia
 	Violet	Ungu
 	Large document: redrawing on the CPU	Dokumen besar: menggambar ulang di CPU
+	Redrawing	Menggambar ulang
 	This redraw took {seconds} s on the CPU.	Penggambaran ulang di CPU ini memakan waktu {seconds} dtk.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Suntingan yang mengubah seluruh dokumen, seperti mode campuran, opasitas, atau visibilitas layer, menggambar ulang semuanya.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Layer tidak muat dalam anggaran memori GPU. Menaikkan Pemakaian memori di Preferensi › Performa menaikkan anggaran, hingga seperempat memori komputer ini.
@@ -3013,6 +3070,7 @@ curves	Smooth	Haluskan
 	Paint over hair or fur on the image; Alt paints the other mode	Lukis di atas rambut atau bulu pada gambar; Alt melukis dalam mode lainnya
 	Clear Brush Strokes	Hapus Goresan Kuas
 	Show rulers	Tampilkan Penggaris
+	Presentation	Presentasi
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Klik untuk menempatkan · Alt-klik atau seret ke luar kanvas untuk menghapus
@@ -3035,3 +3093,36 @@ curves	Smooth	Haluskan
 	Light Red	Merah Terang
 	Medium Blue	Biru Sedang
 	Light Gray	Abu-abu Muda
+	Object Finder	Pencari Objek
+	No object found there — drag a rectangle around it	Tidak ada objek ditemukan di sana — seret persegi panjang di sekelilingnya
+	Remove after each stroke	Hapus setelah setiap goresan
+	Apply the removal ({key})	Terapkan penghapusan ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Goresan untuk dihapus: {n} (Enter menerapkan, Esc membatalkan)
+	Clear Brush Controls	Hapus Kontrol Kuas
+	Reset All Locked Settings	Atur Ulang Semua Pengaturan Terkunci
+	Copy Texture to Other Tools	Salin Tekstur ke Alat Lain
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Muat Tindakan…
+	Save Actions…	Simpan Tindakan…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{n} tindakan dimuat dari {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} langkah belum memiliki padanan di PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{n} tindakan disimpan ke {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	{n} langkah tanpa padanan Photoshop dilewati
+
+	File Naming	Penamaan Berkas
+	Starting serial	Nomor urut awal
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Sisipkan Berhenti…
+	Save Set…	Simpan Set…
+	Message:	Pesan:
+	Allow Continue	Izinkan Lanjut
+	Show dialog during playback	Tampilkan dialog saat pemutaran
+	Select an action first	Pilih tindakan terlebih dahulu
+	Action playback stopped	Pemutaran tindakan dihentikan
+	Step {step} is waiting for its dialog	Langkah {step} menunggu dialognya
+@plural	{n} action|{n} actions	{n} tindakan
+	Auto Add/Delete	Tambah/Hapus Otomatis
+	ICO is limited to 256 × 256 pixels	ICO dibatasi hingga 256 × 256 piksel
diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv
index ccd6ce7d24..c077d90aa1 100644
--- a/crates/ui-egui/src/i18n/it.tsv
+++ b/crates/ui-egui/src/i18n/it.tsv
@@ -7,12 +7,22 @@
 #   lines starting with # and blank lines are ignored.
 #
 # Clean-room: every entry was written from the plain meaning of the English label using ordinary
-# Italian computing vocabulary (livello, pennello, selezione, tela ...). No proprietary localisation
+# Italian computing vocabulary (livello, pennello, selezione, quadro ...). No proprietary localisation
 # resource, string table or product UI was consulted or copied; add entries the same way.
 # Product and technology names (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...) stay in Latin
 # letters; the trailing … of dialog commands is kept.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Colore canale
+	Color Indicates:	Il colore indica:
+	Solidity:	Solidità:
+	Ink Characteristics	Caratteristiche inchiostro
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Larghezza della carta
+	Paper Height	Altezza della carta
 	Columns	Colonne
 	Rows	Righe
 	Number	Numero
@@ -26,7 +36,7 @@
 	Center Columns	Centra colonne
 	Clear Existing Guides	Elimina guide esistenti
 	Invalid guide layout	Layout delle guide non valido
-	Leave empty for automatic size	Lasciare vuoto per la dimensione automatica
+	Leave empty for automatic size	Lascia vuoto per la dimensione automatica
 	5 Columns, 3 Rows	5 colonne, 3 righe
 	8 Columns	8 colonne
 	12 Columns	12 colonne
@@ -53,7 +63,7 @@
 	Open…	Apri…
 	Open As…	Apri come…
 	Open EXR Parts…	Apri parti EXR…
-	Add beauty precomp from the AOVs	Aggiungi la precomposizione della bellezza dagli AOV
+	Add beauty precomp from the AOVs	Aggiungi la precomposizione del passaggio beauty dagli AOV
 	Both	Entrambe
 	Left	Sinistra
 	Right	Destra
@@ -70,6 +80,8 @@
 	Save	Salva
 	Save As…	Salva con nome…
 	Save a Copy…	Salva una copia…
+	{name} can't keep everything in this document	{name} non può conservare tutto il contenuto di questo documento
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Scegli un formato che conservi tutto, come Photoshop (PSD), oppure salva una copia.
 	Revert	Ripristina
 	Export	Esporta
 	Quick Export as PNG	Esportazione rapida come PNG
@@ -83,18 +95,18 @@
 	Color Lookup Tables…	Tabelle ricerca colore…
 	Data Sets as Files…	Set di dati come file…
 	Paths to Illustrator…	Tracciati in Illustrator…
-	Render Video…	Rendering video…
+	Render Video…	Esegui rendering video…
 	Generate	Genera
 	Image Assets	Risorse immagine
 	Place Embedded…	Inserisci incorporato…
-	Place Linked…	Inserisci collegato…
-	Package…	Pacchetto…
+	Place Linked…	Inserisci oggetto collegato…
+	Package…	Crea pacchetto…
 	Automate	Automatizza
 	Batch…	Batch…
 	Create Droplet…	Crea droplet…
 	Crop and Straighten Photos	Ritaglia e raddrizza foto
 	Contact Sheet II…	Provino a contatto II…
-	Conditional Mode Change…	Cambio modo condizionale…
+	Conditional Mode Change…	Cambia metodo condizionale…
 	Fit Image…	Adatta immagine…
 	Lens Correction…	Correzione lente…
 	Merge to HDR Pro…	Unisci in HDR Pro…
@@ -107,6 +119,13 @@
 	Script Events Manager…	Gestore eventi script…
 	Import	Importa
 	Browse…	Sfoglia…
+	Source Files	File di origine
+	Use:	Usa:
+	Files	File
+	Add Open Files	Aggiungi file aperti
+	Sort By Name	Ordina per nome
+	Attempt to Automatically Align Source Images	Prova ad allineare automaticamente le immagini di origine
+	Create Smart Object after Loading Layers	Crea oggetto avanzato dopo il caricamento dei livelli
 	Reveal in Finder	Mostra nel Finder
 	Show in Explorer	Mostra in Esplora file
 	Show in Folder	Mostra nella cartella
@@ -129,8 +148,10 @@
 	Paste Lorem Ipsum	Incolla Lorem Ipsum
 	Clear	Cancella
 	Search…	Cerca…
-	Check Spelling…	Controllo ortografico…
+	Check Spelling…	Controlla ortografia…
 	Find and Replace Text…	Trova e sostituisci testo…
+	Add to Dictionary	Aggiungi al dizionario
+	No Spelling Suggestions	Nessun suggerimento ortografico
 	Fill…	Riempi…
 	Stroke…	Traccia…
 	Content-Aware Fill…	Riempimento in base al contenuto…
@@ -145,6 +166,8 @@
 	Transform Again on a Copy	Trasforma di nuovo su una copia
 	Scale	Scala
 	Rotate	Ruota
+	Set horizontal skew	Imposta inclinazione orizzontale
+	Set vertical skew	Imposta inclinazione verticale
 	Skew	Inclina
 	Distort	Distorci
 	Perspective	Prospettiva
@@ -196,7 +219,7 @@
 	Type…	Testo…
 	Enhanced Controls…	Controlli avanzati…
 	Camera Raw…	Camera Raw…
-	Raw Defaults…	Default Raw…
+	Raw Defaults…	Predefiniti Raw…
 	Integrations…	Integrazioni…
 	AI Integrations…	Integrazioni IA…
 	Install Plug-in…	Installa plug-in…
@@ -212,10 +235,10 @@
 	Lab Color	Colore Lab
 	Multichannel	Multicanale
 	8 Bits/Channel	8 bit/canale
-	8 bit	8 bit/canale
+	8 bit	8 bit
 	Integer	Intero
 	16 Bits/Channel	16 bit/canale
-	16 bit	16 bit/canale
+	16 bit	16 bit
 	32 Bits/Channel	32 bit/canale
 	32 bit (float)	32 bit (virgola mobile)
 	Floating point	Virgola mobile
@@ -241,7 +264,7 @@
 	Gradient Map…	Mappa sfumatura…
 	Selective Color…	Colore selettivo…
 	Shadows/Highlights…	Ombre/Luci…
-	HDR Toning…	Viraggio HDR…
+	HDR Toning…	Mappatura tonale HDR…
 	Desaturate	Desatura
 	Match Color…	Corrispondenza colore…
 	Replace Color…	Sostituisci colore…
@@ -265,7 +288,7 @@
 	Data Sets…	Set di dati…
 	Apply Data Set…	Applica set di dati…
 	Variable Data Sets…	Set di dati variabili…
-	Trap…	Sovrastampa…
+	Trap…	Trapping…
 	Analysis	Analisi
 	Set Measurement Scale…	Imposta scala misurazione…
 	Select Data Points…	Seleziona punti dati…
@@ -302,7 +325,7 @@
 	Create Layer	Crea livello
 	Layer Style	Stile livello
 	Blending Options…	Opzioni di fusione…
-	Bevel & Emboss…	Smusso ed effetto rilievo…
+	Bevel & Emboss…	Smusso e rilievo…
 	Use Global Light	Usa luce globale
 	Inner Shadow…	Ombra interna…
 	Inner Glow…	Bagliore interno…
@@ -348,7 +371,7 @@
 	Smart Object	Oggetto avanzato
 	Convert to Smart Object	Converti in oggetto avanzato
 	Convert to Embedded	Converti in incorporato
-	Convert to Linked…	Converti in collegato…
+	Convert to Linked…	Converti in oggetto collegato…
 	Edit Contents	Modifica contenuto
 	Replace Contents…	Sostituisci contenuto…
 	Relink to File…	Ricollega al file…
@@ -356,6 +379,7 @@
 	Update Modified Content	Aggiorna contenuto modificato
 	Update All Modified Content	Aggiorna tutto il contenuto modificato
 	Stack Mode	Modalità pila
+	Choose Stack Mode:	Scegli modalità pila:
 	Entropy	Entropia
 	Kurtosis	Curtosi
 	Maximum	Massimo
@@ -368,8 +392,8 @@
 	Summation	Somma
 	Variance	Varianza
 	Video Layers	Livelli video
-	Interpret Footage…	Interpreta metraggio…
-	Replace Footage…	Sostituisci metraggio…
+	Interpret Footage…	Interpreta filmato…
+	Replace Footage…	Sostituisci filmato…
 	Reload Frame	Ricarica fotogramma
 	Show Altered Video	Mostra video modificato
 	Restore Frame	Ripristina fotogramma
@@ -390,6 +414,7 @@
 	Select Linked Layers	Seleziona livelli collegati
 	Merge Layers	Unisci livelli
 	Merge Down	Unisci sotto
+	Merge Group	Unisci gruppo
 	Merge Visible	Unisci visibili
 	Stamp Visible	Unisci visibili in nuovo
 	Select Layer Above	Seleziona livello sopra
@@ -476,8 +501,8 @@
 	Convert to Point Text	Converti in testo a riga
 	Convert to Paragraph Text	Converti in testo a paragrafo
 	Default Features	Funzionalità predefinite
-	East Asian Features	Funzionalità Asia orientale
-	Middle Eastern Features	Funzionalità Medio Oriente
+	East Asian Features	Funzionalità est-asiatiche
+	Middle Eastern Features	Funzionalità mediorientali
 	Middle Eastern & South Asian Composer	Compositore Medio Oriente e Asia meridionale
 	Update All Text Layers	Aggiorna tutti i livelli di testo
 	Replace All Missing Fonts	Sostituisci tutti i font mancanti
@@ -526,6 +551,9 @@
 	Blur	Sfocatura
 	Blur Gallery	Galleria sfocatura
 	Field Blur…	Sfocatura campo…
+# Field Blur pins (#3373)
+	No pin selected	Nessuna puntina selezionata
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Fai clic sull’immagine per aggiungere una puntina; trascina una puntina per spostarla o il suo anello per cambiare la sfocatura. Canc rimuove la puntina selezionata.
 	Iris Blur…	Sfocatura diaframma…
 	Tilt-Shift…	Miniatura…
 	Path Blur…	Sfocatura tracciato…
@@ -558,7 +586,7 @@
 	Pixelate	Pixellatura
 	Color Halftone…	Mezzetinte a colori…
 	Crystallize…	Cristallizza…
-	Facet	Frattale
+	Facet	Sfaccetta
 	Fragment	Frammento
 	Mezzotint…	Mezzatinta…
 	Mosaic…	Mosaico…
@@ -723,6 +751,10 @@
 	Breeze Dark Theme	Tema Breeze scuro
 	Breeze light	Breeze chiaro
 	Breeze Light Theme	Tema Breeze chiaro
+	Soft dark	Morbido scuro
+	Soft light	Morbido chiaro
+	Soft Dark Theme	Tema morbido scuro
+	Soft Light Theme	Tema morbido chiaro
 	Next Theme	Tema successivo
 	Actions	Azioni
 	Brush Settings	Impostazioni pennello
@@ -772,7 +804,7 @@
 	Split Warp Horizontally	Dividi altera orizzontalmente
 	Split Warp Vertically	Dividi altera verticalmente
 	Statistics…	Statistiche…
-	Refine Strokes	Tratti di perfezionamento
+	Refine Strokes	Tracce di perfezionamento
 @plural	{n} item|{n} items	{n} elemento|{n} elementi
 	Auto	Automatico
 
@@ -809,7 +841,7 @@
 	All Caps	Tutto maiuscolo
 	All Slices	Tutte le sezioni
 	All User Slices	Tutte le sezioni utente
-	All shortcuts reset to PhotoCraft defaults.	Tutte le scorciatoie ripristinate ai default di PhotoCraft.
+	All shortcuts reset to PhotoCraft defaults.	Tutte le scorciatoie ripristinate ai predefiniti di PhotoCraft.
 	Alt	Alt
 	Always use pressure for opacity	Usa sempre pressione per opacità
 	Always use pressure for size	Usa sempre pressione per dimensione
@@ -823,6 +855,9 @@
 	Appearance	Aspetto
 	Appearance (Layer Style)	Aspetto (stile livello)
 	Apply Layer Mask	Applica maschera di livello
+	Add Mask to Selection	Aggiungi maschera alla selezione
+	Subtract Mask from Selection	Sottrai maschera dalla selezione
+	Intersect Mask with Selection	Interseca maschera con la selezione
 	Apply Per Tip	Applica per punta
 	Apply next selected layer comp	Applica composizione livelli successiva selezionata
 	Apply previous selected layer comp	Applica composizione livelli precedente selezionata
@@ -838,11 +873,18 @@
 	Background	Sfondo
 	Background Color	Colore sfondo
 	Background Contents	Contenuto sfondo
+	Custom background color	Colore sfondo personalizzato
 	Balance	Bilanciamento
 	Baseline	Linea base
 	Baseline shift	Scostamento linea base
 	Basic	Base
 	Before (Y)	Prima (Y)
+	Save Settings…	Salva impostazioni…
+	Load Settings…	Carica impostazioni…
+	Save these settings as a Camera Raw .xmp file	Salva queste impostazioni come file .xmp di Camera Raw
+	Load settings from a Camera Raw .xmp file	Carica le impostazioni da un file .xmp di Camera Raw
+	Loaded Camera Raw settings from {file}	Impostazioni Camera Raw caricate da {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Impostazioni Camera Raw caricate da {file} ({n} non supportate)
 	Begin recording	Inizia registrazione
 	Bend:	Curvatura:
 	Bicubic	Bicubica
@@ -874,6 +916,7 @@
 	Cancel	Annulla
 	Reset	Ripristina
 	Cancel (Esc)	Annulla (Esc)
+	Manage submitted jobs in the system print queue	Gestisci i lavori inviati nella coda di stampa del sistema
 	Cancel any current edits (Esc)	Annulla modifiche correnti (Esc)
 	Cancel current crop operation  (Esc)	Annulla operazione ritaglio corrente (Esc)
 	Cancel transform (Esc)	Annulla trasformazione (Esc)
@@ -882,7 +925,7 @@
 	Canvas extension color:	Colore estensione quadro:
 	Capture	Acquisisci
 	Capture the visibility, position and style of every layer with + below, then switch between versions.	Acquisisci visibilità, posizione e stile di ogni livello con + qui sotto, poi passa da una versione all'altra.
-	Catch-up on Stroke End	Recupero a fine tratto
+	Catch-up on Stroke End	Recupero a fine traccia
 	Center	Centro
 	Center Crop Marks	Crocini di ritaglio centrati
 	Center text	Centra testo
@@ -893,21 +936,21 @@
 	Channel Mixer	Miscelatore canali
 	Channel:	Canale:
 	Check All Layers	Controlla tutti i livelli
-	Check Spelling	Controllo ortografico
+	Check Spelling	Controlla ortografia
 	Clarity	Chiarezza
 	Clear All	Cancella tutto
 	Clear Override	Rimuovi eccezione
 	Clear Samples	Cancella campioni
-	Click sets foreground · right-click sets background	Click imposta primo piano · click destro imposta sfondo
-	Click the first point or press {key} to close · Esc cancels	Fai click sul primo punto o premi {key} per chiudere · Esc annulla
-	Click to add a point · drag off or {key}-click or Delete to remove	Click per aggiungere un punto · trascina fuori, {key}-click o Canc per rimuovere
-	Click to apply, {key}-click to clear overrides, double-click for Style Options	Click per applicare, {key}-click per rimuovere eccezioni, doppio click per Opzioni stile
-	Click to edit the gradient	Click per modificare la sfumatura
-	Click to restore the current colour	Click per ripristinare il colore corrente
-	Click to zoom in  ·  {key}-click to zoom out  ·  drag right/left to zoom in/out	Click per ingrandire · {key}-click per ridurre · trascina dx/sx per zoom
-	Click with the Note tool to add a note.	Fai click con lo strumento Nota per aggiungere una nota.
-	Click: corner · Drag: smooth · Click first point: close · {key} finish · Esc cancel	Click: angolo · Trascina: morbido · Click primo punto: chiudi · {key} termina · Esc annulla
-	Click: corner · Drag: smooth · {alt}-drag: break handle · Click or drag first point: close · {key} finish · Esc cancel	Click: angolo · Trascina: morbido · {alt}+trascina: spezza maniglia · Click o trascina sul primo punto: chiudi · {key} termina · Esc annulla
+	Click sets foreground · right-click sets background	Clic imposta primo piano · clic destro imposta sfondo
+	Click the first point or press {key} to close · Esc cancels	Fai clic sul primo punto o premi {key} per chiudere · Esc annulla
+	Click to add a point · drag off or {key}-click or Delete to remove	Clic per aggiungere un punto · trascina fuori, {key}-clic o Canc per rimuovere
+	Click to apply, {key}-click to clear overrides, double-click for Style Options	Clic per applicare, {key}-clic per rimuovere eccezioni, doppio clic per Opzioni stile
+	Click to edit the gradient	Clic per modificare la sfumatura
+	Click to restore the current colour	Clic per ripristinare il colore corrente
+	Click to zoom in  ·  {key}-click to zoom out  ·  drag right/left to zoom in/out	Clic per ingrandire · {key}-clic per ridurre · trascina dx/sx per zoom
+	Click with the Note tool to add a note.	Fai clic con lo strumento Nota per aggiungere una nota.
+	Click: corner · Drag: smooth · Click first point: close · {key} finish · Esc cancel	Clic: angolo · Trascina: morbido · Clic primo punto: chiudi · {key} termina · Esc annulla
+	Click: corner · Drag: smooth · {alt}-drag: break handle · Click or drag first point: close · {key} finish · Esc cancel	Clic: angolo · Trascina: morbido · {alt}+trascina: spezza maniglia · Clic o trascina sul primo punto: chiudi · {key} termina · Esc annulla
 	Clip to layer below	Ritaglia al livello sotto
 	Clipped	Ritagliato
 	Close Style Options	Chiudi opzioni stile
@@ -988,7 +1031,7 @@
 	Default	Predefinito
 	Default colours (D)	Colori predefiniti (D)
 	Default printer	Stampante predefinita
-	Default restored.	Predefiniti ripristinati.
+	Default restored.	Predefinito ripristinato.
 	Define	Definisci
 	Define at least one variable first.	Definisci almeno una variabile prima.
 	Dehaze	Elimina foschia
@@ -1035,7 +1078,7 @@
 	Discord	Discord
 	Dismiss	Chiudi
 	Display P3	Display P3
-	Display Text	Testo display
+	Display Text	Mostra testo
 	Dither	Dithering
 	Divide…	Dividi…
 	Document	Documento
@@ -1043,7 +1086,7 @@
 	Done	Fatto
 	Dots	Punti
 	Drag a rectangle around the object	Trascina un rettangolo attorno all'oggetto
-	Drag on the image to add a constraint; Shift for horizontal/vertical; right-click to delete.	Trascina sull'immagine per aggiungere un vincolo; Maiusc per orizz/vert; click destro per eliminare.
+	Drag on the image to add a constraint; Shift for horizontal/vertical; right-click to delete.	Trascina sull'immagine per aggiungere un vincolo; Maiusc per orizz/vert; clic destro per eliminare.
 	Drag to move the active shape's path or the Work Path	Trascina per spostare il tracciato forma attiva o il Tracciato di lavoro
 	Click: select anchor · Drag: move anchor, handle or segment · {shift}-click: add · {alt}-click: whole subpath	Clic: seleziona punto · Trascina: sposta punto, maniglia o segmento · {shift}-clic: aggiungi · {alt}-clic: intero sottotracciato
 	Draw with the Pen tool (P) or make a work path from a selection.	Disegna con Penna (P) o crea un tracciato di lavoro da una selezione.
@@ -1145,6 +1188,9 @@
 	Ignore All	Ignora tutto
 	Image Size	Dimensione immagine
 	Import Brushes…	Importa pennelli…
+	Gradient Preset Options	Opzioni predefiniti sfumatura
+	Import .GRD	Importa .GRD
+	Choose a gradient file (.grd).	Scegli un file di sfumature (.grd).
 	Import brushes (.abr)	Importa pennelli (.abr)
 	Import Presets	Importa predefiniti
 	Imported	Importato
@@ -1270,7 +1316,7 @@
 	Open a document to use the timeline.	Apri un documento per usare la timeline.
 	Optical	Ottico
 	Optimized	Ottimizzato
-	Option-click to define a source point to clone from	Opzione-click per definire un punto sorgente da clonare
+	Option-click to define a source point to clone from	Opzione-clic per definire un punto sorgente da clonare
 	Original	Originale
 	Output Channel:	Canale output:
 	Output Levels:	Livelli output:
@@ -1371,17 +1417,17 @@
 	Rename…	Rinomina…
 	Resample	Ricampiona
 	Reset All to Defaults	Ripristina tutto ai predefiniti
-	Import Shortcuts…	Importa scelte rapide…
-	Load a keyboard shortcut set saved as .kys	Carica un set di scelte rapide da tastiera salvato come .kys
-	Imported {n} shortcuts from {file}. Click OK to keep them.	Importate {n} scelte rapide da {file}. Fai clic su OK per conservarle.
+	Import Shortcuts…	Importa scorciatoie…
+	Load a keyboard shortcut set saved as .kys	Carica un set di scorciatoie da tastiera salvato come .kys
+	Imported {n} shortcuts from {file}. Click OK to keep them.	Importate {n} scorciatoie da {file}. Fai clic su OK per conservarle.
 	{n} commands are not in PhotoCraft.	{n} comandi non esistono in PhotoCraft.
-	Keyboard shortcuts imported	Scelte rapide da tastiera importate
-	Your keyboard shortcut set {set} is in use here: {n} shortcuts differ from the defaults. Edit › Keyboard Shortcuts shows them; Reset All to Defaults undoes this.	Il tuo set di scelte rapide da tastiera {set} è in uso qui: {n} scelte rapide differiscono dai valori predefiniti. Modifica › Scelte rapide da tastiera le mostra; Ripristina tutto ai valori predefiniti annulla l'importazione.
-	Import keyboard shortcuts?	Importare le scelte rapide da tastiera?
-	PhotoCraft found your keyboard shortcut set {set} from another image editor on this computer: {n} of its shortcuts differ from PhotoCraft's. Import it?	PhotoCraft ha trovato su questo computer il tuo set di scelte rapide da tastiera {set} di un altro editor di immagini: {n} delle sue scelte rapide differiscono da quelle di PhotoCraft. Importarlo?
-	Edit › Keyboard Shortcuts › Reset All to Defaults undoes an import.	Modifica › Scelte rapide da tastiera › Ripristina tutto ai valori predefiniti annulla un'importazione.
+	Keyboard shortcuts imported	Scorciatoie da tastiera importate
+	Your keyboard shortcut set {set} is in use here: {n} shortcuts differ from the defaults. Edit › Keyboard Shortcuts shows them; Reset All to Defaults undoes this.	Il tuo set di scorciatoie da tastiera {set} è in uso qui: {n} scorciatoie differiscono dai predefiniti. Modifica › Scorciatoie da tastiera le mostra; Ripristina tutto ai predefiniti annulla l'importazione.
+	Import keyboard shortcuts?	Importare le scorciatoie da tastiera?
+	PhotoCraft found your keyboard shortcut set {set} from another image editor on this computer: {n} of its shortcuts differ from PhotoCraft's. Import it?	PhotoCraft ha trovato su questo computer il tuo set di scorciatoie da tastiera {set} di un altro editor di immagini: {n} delle sue scorciatoie differiscono da quelle di PhotoCraft. Importarlo?
+	Edit › Keyboard Shortcuts › Reset All to Defaults undoes an import.	Modifica › Scorciatoie da tastiera › Ripristina tutto ai predefiniti annulla un'importazione.
 	Don't Import	Non importare
-	The keyboard shortcut set was not imported: {error}	Il set di scelte rapide da tastiera non è stato importato: {error}
+	The keyboard shortcut set was not imported: {error}	Il set di scorciatoie da tastiera non è stato importato: {error}
 	Reset Section	Reimposta sezione
 	Reset Transform	Reimposta trasformazione
 	Reset to defaults	Ripristina predefiniti
@@ -1419,7 +1465,7 @@
 	Search fonts	Cerca font
 	Select All	Seleziona tutto
 	Select Subject	Seleziona soggetto
-	Select a type layer or click into text to insert glyphs	Seleziona un livello testo o fai click nel testo per inserire glifi
+	Select a type layer or click into text to insert glyphs	Seleziona un livello testo o fai clic nel testo per inserire glifi
 	Select text to apply a character style	Seleziona testo per applicare uno stile carattere
 	Select:	Selezione:
 	Selections	Selezioni
@@ -1571,7 +1617,7 @@
 	Art & Illustration	Arte e illustrazione
 	ArtCraft	ArtCraft
 	Background Eraser Tool	Strumento Gomma per sfondo
-	Bevel & Emboss	Smusso ed effetto rilievo
+	Bevel & Emboss	Smusso e rilievo
 	Blend Mode	Metodo di fusione
 	Blues	Blu
 	Blur Tool	Strumento Sfoca
@@ -1586,8 +1632,8 @@
 	Centimeters	Centimetri
 	Choke	Strozza
 	Classic	Classico
-	Click to add text	Fai click per aggiungere testo
-	Click to fill similar colours	Fai click per riempire colori simili
+	Click to add text	Fai clic per aggiungere testo
+	Click to fill similar colours	Fai clic per riempire colori simili
 	Clone Stamp Tool	Strumento Timbro clone
 	Color Burn	Colore brucia
 	Color Dodge	Colore scherma
@@ -1631,8 +1677,8 @@
 	Emboss	Rilievo
 	Eraser	Gomma
 	Eraser Tool	Strumento Gomma
-	ExtraBold	Extra grassetto
-	ExtraLight	Extra leggero
+	ExtraBold	Extragrassetto
+	ExtraLight	Extraleggero
 	Eyedropper Tool	Strumento Contagocce
 	Fade	Dissolvi
 	Fill Opacity	Opacità riempimento
@@ -1754,7 +1800,7 @@
 	Scratch Sizes	Dimensioni disco virtuale
 	Select Data Points	Seleziona punti dati
 	Selection	Selezione
-	SemiBold	Semi grassetto
+	SemiBold	Semigrassetto
 	Shadows up to:	Ombre fino a:
 	Shape Dynamics	Dinamica forma
 	Sharpen Tool	Strumento Contrasta
@@ -1842,7 +1888,7 @@
 	Brush preview color	Colore anteprima pennello
 	Cache levels	Livelli cache
 	Cache tile size	Dimensione tile cache
-	Camera Raw Defaults	Default Camera Raw
+	Camera Raw Defaults	Predefiniti Camera Raw
 	Canvas border	Bordo quadro
 	Show canvas dots	Mostra punti del quadro
 	Canvas color	Colore quadro
@@ -1863,7 +1909,7 @@
 	Detailed	Dettagliato
 	Disks	Dischi
 	Display p3	Display P3
-	Double click layer mask launches select and mask	Doppio click su maschera livello apre Seleziona e maschera
+	Double click layer mask launches select and mask	Doppio clic su maschera livello apre Seleziona e maschera
 	Drop shadow	Ombra esterna
 	Dynamic color sliders	Slider colore dinamici
 	East asian	Asia orientale
@@ -2024,7 +2070,7 @@
 	Collapse	Comprimi
 	Collapse All Groups	Comprimi tutti i gruppi
 	Collapse Panel Group	Comprimi gruppo pannelli
-	Collapse group  ({key}-click: all groups)	Comprimi gruppo ({key}-click: tutti i gruppi)
+	Collapse group  ({key}-click: all groups)	Comprimi gruppo ({key}-clic: tutti i gruppi)
 	Create new brush from the current settings	Crea nuovo pennello da impostazioni correnti
 	Create new brush from these settings	Crea nuovo pennello da queste impostazioni
 	Update the current brush with these settings	Aggiorna il pennello attuale con queste impostazioni
@@ -2032,9 +2078,9 @@
 	Drag the arrow to set the angle, the dots to set the roundness	Trascina la freccia per impostare l'angolo, i puntini per la rotondità
 	Expand	Espandi
 	Expand Panel Group	Espandi gruppo pannelli
-	Expand group  ({key}-click: all groups)	Espandi gruppo ({key}-click: tutti i gruppi)
+	Expand group  ({key}-click: all groups)	Espandi gruppo ({key}-clic: tutti i gruppi)
 	Fade steps	Passi dissolvenza
-	Hide the layer's effects  ({key}-click: all layers)	Nascondi effetti livello ({key}-click: tutti i livelli)
+	Hide the layer's effects  ({key}-click: all layers)	Nascondi effetti livello ({key}-clic: tutti i livelli)
 	Import Brushes… (.abr)	Importa pennelli… (.abr)
 	Move Group Down	Sposta gruppo giù
 	Move Group Up	Sposta gruppo su
@@ -2042,10 +2088,10 @@
 	Restore original size	Ripristina dimensione originale
 	Roundness:	Rotondità:
 	Search Brushes	Cerca pennelli
-	Show the layer's effects  ({key}-click: all layers)	Mostra effetti livello ({key}-click: tutti i livelli)
+	Show the layer's effects  ({key}-click: all layers)	Mostra effetti livello ({key}-clic: tutti i livelli)
 	Brush picker	Selettore pennelli
 	Erase	Cancella
-	Right click with painting tools	Click destro con strumenti pittura
+	Right click with painting tools	Clic destro con strumenti pittura
 
 # Strings added to the UI after this catalog was first written (rebase onto main, 2026-10).
 	System Info…	Info sistema…
@@ -2056,11 +2102,11 @@
 	Graphics	Grafica
 	Reset GPU Backend	Reimposta backend GPU
 	Applies at next launch.	Si applica al prossimo avvio.
-	Click to sample the foreground colour  ·  {key}-click for background	Click per campionare colore primo piano · {key}-click per sfondo
-	{key}-click to set the source	{key}-click per impostare sorgente
+	Click to sample the foreground colour  ·  {key}-click for background	Clic per campionare colore primo piano · {key}-clic per sfondo
+	{key}-click to set the source	{key}-clic per impostare sorgente
 	{key} to subtract	{key} per sottrarre
-	Clone source {n} ({key}-click with Clone Stamp to set)	Sorgente clone {n} ({key}-click con Timbro clone per impostare)
-	Source: not set ({key}-click with Clone Stamp)	Sorgente: non impostata ({key}-click con Timbro clone)
+	Clone source {n} ({key}-click with Clone Stamp to set)	Sorgente clone {n} ({key}-clic con Timbro clone per impostare)
+	Source: not set ({key}-click with Clone Stamp)	Sorgente: non impostata ({key}-clic con Timbro clone)
 	Pixel Layer	Livello pixel
 	Type Layer	Livello testo
 	Shape Layer	Livello forma
@@ -2082,11 +2128,16 @@
 	Rename Brush…	Rinomina pennello…
 	Delete Brush	Elimina pennello
 	New Brush Preset…	Nuovo predefinito pennello…
+	Capture Brush Size in Preset	Acquisisci dimensione pennello nel predefinito
+	Include Tool Settings	Includi impostazioni strumento
+	Include Color	Includi colore
+	Enter a name for the brush preset	Immetti un nome per il predefinito pennello
+	A brush preset with this name already exists	Esiste già un predefinito pennello con questo nome
 	Brush Preset Options	Opzioni predefiniti pennello
 	Group name	Nome gruppo
 	Brush name	Nome pennello
 	Brush Name	Nome pennello
-	Brush Stroke	Tratto pennello
+	Brush Stroke	Traccia pennello
 	Brush Tip	Punta pennello
 	Off: the speed of the pointer sets the spacing	Off: la velocità del puntatore imposta la spaziatura
 	Tilt Scale	Scala inclinazione
@@ -2111,8 +2162,8 @@
 # Gradient Editor window, opened from the options bar's gradient swatch.
 	Gradient Editor	Editor sfumatura
 	Gradient picker	Selettore sfumatura
-	Gradient stops	Flag sfumatura
-	Save As Preset	Salva come preimpostazione
+	Gradient stops	Punti della sfumatura
+	Save As Preset	Salva come predefinito
 	The gradient the Gradient tool paints with	La sfumatura con cui disegna lo strumento Sfumatura
 	Adds the current gradient to the Gradients panel	Aggiunge la sfumatura corrente al pannello Sfumature
 	The current gradient (pick one in Window › Gradients)	Sfumatura corrente (scegline una in Finestra › Sfumature)
@@ -2139,10 +2190,14 @@
 	OpenGL	OpenGL
 	Use tablet pressure	Usa pressione tavoletta
 	Vulkan	Vulkan
-	Alt-click to define a source point to clone from	Alt-click per definire un punto sorgente da clonare
+	Alt-click to define a source point to clone from	Alt-clic per definire un punto sorgente da clonare
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Nessun tracciato da cui creare selezione: disegnane uno con Penna o selezionane uno nel pannello Tracciati.
 	Cancel opening	Annulla apertura
 	Cancelled opening {name}	Apertura {name} annullata
+	The document “{name}” does not have an embedded {mode} profile.	Il documento “{name}” non ha un profilo {mode} incorporato.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Il documento “{name}” ha un profilo colore incorporato che non corrisponde allo spazio di lavoro {mode} corrente.
+	Embedded: {embedded}	Incorporato: {embedded}
+	Working: {working}	Di lavoro: {working}
 	Developing {name}	Sviluppo di {name}
 	Cancelled {label}	{label} annullato
 	Esc to cancel	Esc per annullare
@@ -2194,7 +2249,7 @@
 	Model	Modello
 	F	F
 	Artist	Artista
-	Spot Color	Colore spot
+	Spot Color	Tinta piatta
 	Roman	Normale
 	Bold Italic	Grassetto corsivo
 	Justification	Giustificazione
@@ -2379,7 +2434,7 @@ cameraRaw	Amount	Quantità
 	Reset Swatches	Ripristina campioni
 	Add to Swatches	Aggiungi ai campioni
 	Convert to Layers	Converti in livelli
-	Apply At Canvas Bounds	Applica effetto ai limiti dell’area di lavoro
+	Apply At Canvas Bounds	Applica ai limiti del quadro
 
 # Shared screen eyedropper and text Color Picker (#1128).
 	Color Picker (Text Color)	Selettore colore (Colore del testo)
@@ -2393,6 +2448,7 @@ cameraRaw	Amount	Quantità
 	Click to pick · Esc to cancel	Clic per scegliere · Esc per annullare
 	Pick a screen pixel or press Esc to cancel	Scegli un pixel dello schermo o premi Esc per annullare
 	Scroll to zoom	Scorri per ingrandire
+	Drag to pan · Scroll to zoom · Double-click to fit	Trascina per spostare · Scorri per ingrandire · Doppio clic per adattare
 	Show/Hide All Panels	Mostra/nascondi tutti i pannelli
 	Show/Hide Panels	Mostra/nascondi pannelli
 	Could not open	Impossibile aprire
@@ -2448,6 +2504,7 @@ cameraRaw	Amount	Quantità
 	Fuchsia	Fucsia
 	Violet	Viola
 	Large document: redrawing on the CPU	Documento grande: ridisegno sulla CPU
+	Redrawing	Ridisegno
 	This redraw took {seconds} s on the CPU.	Questo ridisegno sulla CPU ha richiesto {seconds} s.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Le modifiche che cambiano tutto il documento, come metodo di fusione, opacità o visibilità di un livello, lo ridisegnano per intero.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	I livelli non rientrano nel budget di memoria della GPU. Aumentare Uso memoria in Preferenze › Prestazioni alza il budget, fino a un quarto della memoria di questo computer.
@@ -2459,13 +2516,13 @@ fontWeight	Regular	Normale
 fontWeight	Medium	Medio
 fontWeight	SemiBold	Semigrassetto
 fontWeight	Bold	Grassetto
-fontWeight	ExtraBold	Extra-grassetto
+fontWeight	ExtraBold	Extragrassetto
 fontWeight	Black	Nero
 fontWeight	Italic	Corsivo
 
 # Pattern Stamp tool
-	Pattern Stamp Tool	Strumento Timbro motivo
-	Pattern Stamp	Timbro motivo
+	Pattern Stamp Tool	Strumento Timbro pattern
+	Pattern Stamp	Timbro pattern
 	Impressionist	Impressionista
 	Rotate View	Ruota vista
 	Rotate View Tool	Strumento Ruota vista
@@ -2510,7 +2567,7 @@ fontWeight	Italic	Corsivo
 	Cycle Overlay	Cambia sovrapposizione
 	Cycle Orientation	Cambia orientamento
 	Set the overlay options for the Crop tool	Imposta le opzioni di sovrapposizione dello strumento Taglierina
-	Alt-click went to the desktop, which moves windows with Alt-drag. Set its window-move key to Super, or latch Alt in Window › Modifier Keys.	L’Alt-click è andato al desktop, che sposta le finestre con Alt-trascina. Imposta il suo tasto per spostare le finestre su Super, oppure blocca Alt in Finestra › Tasti modificatori.
+	Alt-click went to the desktop, which moves windows with Alt-drag. Set its window-move key to Super, or latch Alt in Window › Modifier Keys.	L’Alt-clic è andato al desktop, che sposta le finestre con Alt-trascina. Imposta il suo tasto per spostare le finestre su Super, oppure blocca Alt in Finestra › Tasti modificatori.
 
 # Shared Layer Style color picker
 	Color Picker (Layer Style Color)	Selettore colore (colore dello stile livello)
@@ -2529,7 +2586,7 @@ fontWeight	Italic	Corsivo
 	Set additional Crop options	Imposta opzioni di ritaglio aggiuntive
 	Show Cropped Area	Mostra area ritagliata
 	Enable Crop Shield	Attiva schermo di ritaglio
-	Match Canvas	Come la tela
+	Match Canvas	Come il quadro
 	Auto Adjust Opacity	Regola automaticamente opacità
 	Crop Shield color	Colore dello schermo di ritaglio
 	Color Picker (Crop Shield Color)	Selettore colore (Colore dello schermo di ritaglio)
@@ -2631,7 +2688,7 @@ cameraData	Lens	Obiettivo
 	Curvature Pen Tool	Strumento Penna curvatura
 	Curve Fit:	Adattamento curva:
 	Drag: draw freehand · {alt}-click: straight segment · Release on the start point: close	Trascina: disegna a mano libera · {alt}-clic: segmento retto · Rilascia sul punto iniziale: chiudi
-	Click: smooth point · Double-click: corner · Drag a point: move · Click first point: close · {key} finish	Click: punto morbido · Doppio click: angolo · Trascina un punto: sposta · Click primo punto: chiudi · {key} termina
+	Click: smooth point · Double-click: corner · Drag a point: move · Click first point: close · {key} finish	Clic: punto morbido · Doppio clic: angolo · Trascina un punto: sposta · Clic primo punto: chiudi · {key} termina
 	New Crop Preset…	Nuovo predefinito di ritaglio…
 	Delete Crop Preset…	Elimina predefinito di ritaglio…
 	Select the crop presets to delete:	Seleziona i predefiniti di ritaglio da eliminare:
@@ -2680,11 +2737,12 @@ curves	Smooth	Leviga
 	Expand Detection Area	Espandi area di rilevamento
 	Restore Original Edge	Ripristina bordo originale
 	Paint over hair or fur on the image; Alt paints the other mode	Dipingi su capelli o pelo nell'immagine; Alt dipinge nell'altra modalità
-	Clear Brush Strokes	Cancella tratti del pennello
+	Clear Brush Strokes	Cancella tracce del pennello
 	Show rulers	Mostra righelli
+	Presentation	Presentazione
 
 # Color Sampler (added with the i18n coverage repair)
-	Click to place · Alt-click or drag off-canvas to remove	Fai clic per posizionare · Alt-clic o trascina fuori dalla tela per rimuovere
+	Click to place · Alt-click or drag off-canvas to remove	Fai clic per posizionare · Alt-clic o trascina fuori dal quadro per rimuovere
 	No document open	Nessun documento aperto
 	{n} of {max} sample points	{n} di {max} punti di campionamento
 # Print dialog (#2697)
@@ -2719,3 +2777,1326 @@ curves	Smooth	Leviga
 	Light Red	Rosso chiaro
 	Medium Blue	Blu medio
 	Light Gray	Grigio chiaro
+
+# Dynamic labels (filter and adjustment parameters, Camera Raw, panels, dialogs) that the
+# other catalogs already translate
+	No	No
+	Yes	Sì
+@id	select.all	Seleziona tutto
+	Delete Smart Filters	Elimina filtri avanzati
+	Enable Smart Filters	Attiva filtri avanzati
+	New Layer…	Nuovo livello…
+	Delete Layer…	Elimina livello…
+	Select Similar Colors	Seleziona colori simili
+	New Selection	Nuova selezione
+	Canvas rotation	Rotazione quadro
+	Extensions	Estensioni
+	Libraries	Librerie
+	3D	3D
+	Toolbars	Barre strumenti
+	Wand	Bacchetta
+	Healing	Correttivo
+	Pen	Penna
+	Hand	Mano
+	Sampler	Campionatore
+	Note tool	Strumento Nota
+	Magnetic Lasso	Lazo magnetico
+	Art History Brush	Pennello storia artistica
+	Spot Healing	Correttivo al volo
+	Patch	Toppa
+	Content-Aware Move	Spostamento in base al contenuto
+	Perspective Crop	Taglierina prospettica
+	Dodge/Burn	Scherma/Brucia
+	Dynamics	Dinamica
+	Tilt	Inclinazione
+	Defaults restored.	Predefiniti ripristinati.
+	Stop	Interrompi
+	Create new set	Crea nuovo set
+	Technology Previews	Anteprime tecnologiche
+	Create new layer	Crea nuovo livello
+	Group · {n} layer	Gruppo · {n} livello
+	General Blend	Fusione generale
+	Advanced Blending	Fusione avanzata
+	RGB	RGB
+	Spot Channel	Canale tinta piatta
+	Working Gray Plate	Lastra grigia di lavoro
+	HSL/Grayscale	HSL/Scala di grigio
+	Tone Curve	Curva tonale
+	Split Toning	Viraggio separato
+	Lens Corrections	Correzioni lente
+	Camera Calibration	Calibrazione fotocamera
+	Snapshots	Istantanee
+	Recovery	Recupero
+	Fill Light	Luce di riempimento
+	Convert to Grayscale	Converti in scala di grigio
+	Sharpness	Nitidezza
+	Color Noise Reduction	Riduzione disturbo cromatico
+	Luminance Smoothness	Uniformità luminanza
+	Lens	Obiettivo
+	ISO	ISO
+	Focal Length35mm	Lunghezza focale equivalente (35 mm)
+	Aspect Ratio	Proporzioni
+	Time	Ora
+	Enter description…	Inserisci una descrizione…
+	ColorSync	ColorSync
+	ProPhoto	ProPhoto
+	sRGB	sRGB
+	ACES	ACES
+	Industry Standard	Standard di settore
+	Uncoated CMYK	CMYK carta non patinata
+	Newspaper	Carta da giornale
+	Working Spaces	Spazi di lavoro
+	Color Management Policies	Criteri di gestione colore
+	Detect Faces	Rileva volti
+	Localize Color Clusters	Localizza cluster colore
+	Duplicated selection name	Nome selezione duplicata
+	Operation	Operazione
+	New channel only	Solo nuovo canale
+	Masked Areas	Aree mascherate
+	Selected Areas	Aree selezionate
+	Color indicates	Il colore indica
+	Create Snapshot	Crea istantanea
+	Delete Snapshot	Elimina istantanea
+	New Snapshot	Nuova istantanea
+	Snapshot 1	Istantanea 1
+	Step Forward	Avanza di un passo
+	Step Backward	Torna indietro di un passo
+	Nonlinear History	Cronologia non lineare
+	Set New Snapshot as Default	Imposta nuova istantanea come predefinita
+	Automatically Create First Snapshot	Crea automaticamente prima istantanea
+	Automatically Create New Snapshot When Saving	Crea automaticamente nuova istantanea al salvataggio
+	Show New Snapshot Dialog by Default	Mostra per impostazione predefinita la finestra Nuova istantanea
+	Clear History	Cancella cronologia
+	Panel Options…	Opzioni pannello…
+	View menu	Menu Vista
+	Keep view in sync	Mantieni vista sincronizzata
+	{zoom}%	{zoom}%
+	Mouse Controls	Controlli mouse
+	Initial Direction of Stroke	Direzione iniziale della traccia
+	Direction of Stroke	Direzione della traccia
+	Humidity	Umidità
+	Auto Clean Brush	Pulisci automaticamente il pennello
+	Spacing:	Spaziatura:
+	New Layer from Brush	Nuovo livello da pennello
+	New Brush	Nuovo pennello
+	New Tool Preset	Nuovo predefinito strumento
+	Auto-Leading	Interlinea automatica
+	Scale Horizontally	Scala orizzontale
+	Scale Vertically	Scala verticale
+	Baseline Shift	Scostamento linea base
+	Mac LCD	LCD Mac
+	Mac Sharp	Mac nitido
+	Mac Crisp	Mac definito
+	Mac Strong	Mac forte
+	Mac Smooth	Mac morbido
+	Superscript	Apice
+	Subscript	Pedice
+	Ligature	Legatura
+	Alternative	Alternativa
+	Ultra Light	Ultraleggero
+	Extra Light	Extraleggero
+	Semi Bold	Semigrassetto
+	Extra Bold	Extragrassetto
+	Ultra Bold	Ultra grassetto
+	Condensed	Condensato
+	First Line Indent	Rientro prima riga
+	Hanging Punctuation	Punteggiatura sospesa
+	Roman Hanging Punctuation	Punteggiatura latina sospesa
+	Avoid Widows/Orphans	Evita righe vedove/orfane
+	Compose	Composizione
+	Adobe Single-line Composer	Compositore riga singola Adobe
+	Adobe Every-line Composer	Compositore ogni riga Adobe
+	Word Spacing	Spaziatura parole
+	Letter Spacing	Spaziatura lettere
+	Glyph Scaling	Ridimensionamento glifi
+	Auto-leading %	Interlinea automatica %
+	Single Word Justification	Giustificazione parola singola
+	Justify	Giustifica
+	Glyph	Glifo
+	Alternates for Current Selection	Alternative per la selezione corrente
+	Digits	Cifre
+	Path:	Tracciato:
+	Path to Illustrator…	Tracciato in Illustrator…
+	Clipping Path	Tracciato di ritaglio
+	New Path	Nuovo tracciato
+	Duplicate Path	Duplica tracciato
+	Auto-Hide	Nascondi automaticamente
+	X	X
+	Y	Y
+	Frame Sync	Sincronizzazione fotogrammi
+	Quick Sync	Sincronizzazione rapida
+	Audio	Audio
+	Frame Duration	Durata fotogramma
+	Loop	Ciclo
+	Split at Playhead	Dividi all'indicatore di riproduzione
+	Flatten Frames Into Clips	Unisci fotogrammi in clip
+	Flatten Frames Into Layers	Unisci fotogrammi in livelli
+	Convert Frames > Video Layers	Converti fotogrammi > livelli video
+	New Video Layer	Nuovo livello video
+	New Video Group	Nuovo gruppo video
+	Limit Playback	Limita riproduzione
+	Enable Timeline Quick Config	Attiva configurazione rapida timeline
+	Set Start Timecode…	Imposta timecode iniziale…
+	Timecode	Timecode
+	30 fps	30 fps
+	25 fps	25 fps
+	24 fps	24 fps
+	15 fps	15 fps
+	10 fps	10 fps
+	Current Time	Tempo corrente
+	Out	Fine
+	In	Inizio
+	Duration	Durata
+	Repeat	Ripeti
+	Play Once	Riproduci una volta
+	Info Options…	Opzioni informazioni…
+	First Color Readout	Prima lettura colore
+	Second Color Readout	Seconda lettura colore
+	Actual Color	Colore effettivo
+	Grayscale Slider	Cursore scala di grigio
+	Web Color	Colore web
+	HSB Color	Colore HSB
+	Total Ink	Inchiostro totale
+	Opacity Mask	Maschera di opacità
+	Document Size	Dimensione documento
+	Timing	Tempi
+	Status Information	Informazioni di stato
+	Saved Multichannel	Multicanale salvato
+	Mouse Coordinates	Coordinate mouse
+	Ruler Units	Unità righelli
+	Hide	Nascondi
+	Restore last viewed comp	Ripristina ultima composizione visualizzata
+	Select All Layers	Seleziona tutti i livelli
+	Keep proportions	Mantieni proporzioni
+	Interpolation	Interpolazione
+	Caption	Didascalia
+	Caption Credits	Autore didascalia
+	Keywords	Parole chiave
+	Copyright Info URL	URL info copyright
+	Copyright Status	Stato copyright
+	Copyrighted	Protetto da copyright
+	Public Domain	Pubblico dominio
+	Unknown	Sconosciuto
+	Credit	Crediti
+	Transmission Reference	Riferimento trasmissione
+	Urgency	Urgenza
+	High	Alta
+	Low	Bassa
+	Category	Categoria
+	Supplemental Categories	Categorie supplementari
+	Object Name / Title	Nome oggetto / titolo
+	Date Created	Data di creazione
+	City	Città
+	Province / State	Provincia / stato
+	Country	Paese
+	Byline	Autore
+	Byline Title	Qualifica autore
+	Phone	Telefono
+	Email	Email
+	URLs	URL
+	Last Modified	Ultima modifica
+	EXIF	EXIF
+	GPS	GPS
+	Camera Model	Modello fotocamera
+	Camera Make	Marca fotocamera
+	EXIF Version	Versione EXIF
+	Exposure Program	Programma di esposizione
+	Aperture	Apertura diaframma
+	Shutter Speed	Tempo di posa
+	Metering Mode	Modalità di misurazione
+	Light Source	Sorgente luminosa
+	Flash	Flash
+	Lens Info	Info obiettivo
+	ISO Speed	Sensibilità ISO
+	Subject Distance	Distanza soggetto
+	DateTime Original	Data e ora originali
+	Create Date	Data di creazione
+	Modify Date	Data di modifica
+	Raw Data	Dati grezzi
+	Import…	Importa…
+	PDF Presentation…	Presentazione PDF…
+	Create Multiple Picture Packages	Crea più pacchetti di immagini
+	Picture Package…	Pacchetto di immagini…
+	Web Photo Gallery…	Galleria fotografica web…
+	Choose…	Scegli…
+	Select Folder…	Seleziona cartella…
+	Override Action "Save" Commands	Sostituisci i comandi "Salva" dell'azione
+	Compatibility	Compatibilità
+	Mac OS	Mac OS
+	Unix	Unix
+	Include ICC Profile	Includi profilo ICC
+	Error File	File di errori
+	Stop For Errors	Interrompi in caso di errori
+	Log Errors To File	Registra errori su file
+	Errors	Errori
+	Settings	Impostazioni
+	Settings:	Impostazioni:
+	Working Space	Spazio di lavoro
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Gray:	Grigio:
+	Spot:	Tinta piatta:
+	Advanced Controls	Controlli avanzati
+	Desaturate Monitor Colors By	Desatura i colori del monitor di
+	Blend RGB Colors Using Gamma 1.0	Fondi colori RGB con gamma 1,0
+	Profile Mismatches: Ask When Opening	Profili non corrispondenti: chiedi all'apertura
+	Ask When Pasting	Chiedi quando incolli
+	Missing Profiles: Ask When Opening	Profili mancanti: chiedi all'apertura
+	Embed profiles	Incorpora profili
+	Ask Before Saving Saved Embedded	Chiedi prima di salvare il profilo incorporato
+	Coerce to sRGB	Forza in sRGB
+	sRGB IEC61966-2.1	sRGB IEC61966-2.1
+	Adobe RGB (1998)	Adobe RGB (1998)
+	ProPhoto RGB	ProPhoto RGB
+	ColorMatch RGB	ColorMatch RGB
+	Wide Gamut RGB	Wide Gamut RGB
+	Apple RGB	Apple RGB
+	NTSC (1953)	NTSC (1953)
+	PAL/SECAM	PAL/SECAM
+	SMPTE C	SMPTE C
+	HDTV (Rec. 709)	HDTV (Rec. 709)
+	CIE RGB	CIE RGB
+	Graphic and web	Grafica e web
+	Minimalistic	Minimalista
+	Expand All Groups	Espandi tutti i gruppi
+	Photo (2 × 3 in)	Foto (2 × 3 in)
+	Photo (4 × 6 in)	Foto (4 × 6 in)
+	Photo (5 × 7 in)	Foto (5 × 7 in)
+	Photo (8 × 10 in)	Foto (8 × 10 in)
+	Recent Items	Elementi recenti
+	Delete Preset…	Elimina predefinito…
+	Preset Name:	Nome del predefinito:
+	Width and Height	Larghezza e altezza
+	Color Profile	Profilo colore
+	Units	Unità
+	Create new count group	Crea nuovo gruppo conteggio
+	Adjustment Layer	Livello di regolazione
+	Drag to move the layer	Trascina per spostare il livello
+	Go to Layer	Vai al livello
+	After (X)	Dopo (X)
+	Current	Corrente
+	Reference point location	Posizione punto di riferimento
+	Toggle reference point	Mostra/nascondi punto di riferimento
+	Add Pins	Aggiungi pin
+	Delete Pins	Elimina pin
+	Rotate Auto	Rotazione automatica
+	Rotate Fixed	Rotazione fissa
+	Select Plane	Seleziona piano
+	Measure	Misura
+	Heal	Correzione
+	Heal Off	Correzione disattivata
+	Heal On	Correzione attivata
+	Heal Auto	Correzione automatica
+	Blend	Fusione
+	Brush Size	Dimensione pennello
+	Heal Color	Colore correzione
+	Result	Risultato
+	Duplicate	Duplica
+	Fast	Veloce
+	Accurate	Preciso
+	Add to	Aggiungi a
+	Subtract from	Sottrai da
+	Intersect with	Interseca con
+	Capture Comp	Acquisisci composizione
+	No Layer Comps	Nessuna composizione livelli
+	Adobe PDF Presets…	Predefiniti Adobe PDF…
+	3D…	3D…
+	Technology Previews…	Anteprime tecnologiche…
+	Add a mask  (from the selection; ⌥ inverts)	Aggiungi una maschera (dalla selezione; ⌥ inverte)
+	Add to selection  (⇧)	Aggiungi alla selezione (⇧)
+	Airbrush: keeps painting while the pointer rests.	Aerografo: continua a dipingere mentre il puntatore è fermo.
+	Click the first point or press ↵ to close · Esc cancels	Fai clic sul primo punto o premi ↵ per chiudere · Esc annulla
+	Click to add a point · drag off or ⌘/Ctrl-click or Delete to remove	Clic per aggiungere un punto · trascina fuori, ⌘/Ctrl-clic o Canc per rimuovere
+	Click to apply, ⌥-click to clear overrides, double-click for Style Options	Clic per applicare, ⌥-clic per rimuovere eccezioni, doppio clic per Opzioni stile
+	Click to zoom in  ·  ⌥-click to zoom out	Clic per ingrandire · ⌥-clic per ridurre
+	Click: corner · Drag: smooth · Click first point: close · ↩ finish · Esc cancel	Clic: angolo · Trascina: morbido · Clic primo punto: chiudi · ↩ termina · Esc annulla
+	Commit Perspective Warp (↩)	Conferma altera prospettiva (↩)
+	Commit Puppet Warp (↩)	Conferma altera marionetta (↩)
+	Commit any current edits (⌘↩)	Conferma modifiche correnti (⌘↩)
+	Commit current crop operation  (↵)	Conferma operazione ritaglio corrente (↵)
+	Commit transform (↩)	Conferma trasformazione (↩)
+	Commit warp (↩)	Conferma altera (↩)
+	Create a new layer  (⇧⌘N)	Crea nuovo livello (⇧⌘N)
+	Custom pattern	Pattern personalizzato
+	General Brushes	Pennelli generici
+	Grid  (⌘')	Griglia (⌘')
+	Intersect with selection  (⇧⌥)	Interseca con selezione (⇧⌥)
+	New document…     ⌘N	Nuovo documento…     ⌘N
+	Open…     ⌘O	Apri…     ⌘O
+	Rulers  (⌘R)	Righelli (⌘R)
+	Search commands (⌘K)	Cerca comandi (⌘K)
+	Show Guides  (⌘;)	Mostra guide (⌘;)
+	Subtract from selection  (⌥)	Sottrai da selezione (⌥)
+	Uses the foreground and background colors.	Usa i colori di primo piano e di sfondo.
+	↑↓ navigate   ↵ run   esc close	↑↓ naviga   ↵ esegui   esc chiudi
+	Adds grain to the soft edges of the brush tip.	Aggiunge grana ai bordi morbidi della punta del pennello.
+	Keeps the current texture when switching presets.	Mantiene la texture corrente quando cambi predefinito.
+	Watercolour look: lighter interior, darker rims.	Effetto acquerello: interno più chiaro, bordi più scuri.
+	Collapse group  (⌥-click: all groups)	Comprimi gruppo (⌥-clic: tutti i gruppi)
+	Expand group  (⌥-click: all groups)	Espandi gruppo (⌥-clic: tutti i gruppi)
+	Hide the layer's effects  (⌥-click: all layers)	Nascondi effetti livello (⌥-clic: tutti i livelli)
+	Show the layer's effects  (⌥-click: all layers)	Mostra effetti livello (⌥-clic: tutti i livelli)
+cameraRaw	Blacks	Neri
+cameraRaw	Masking	Mascheratura
+@id	edit.stroke	Traccia…
+@id	edit.transform.scale	Scala
+cameraRaw	Luminance	Luminanza
+cameraRaw	Color	Colore
+cameraRaw	Vibrance	Vividezza
+cameraRaw	Color Grading	Gradazione colore
+cameraRaw	Global	Globale
+cameraRaw	Hue	Tonalità
+cameraRaw	Luminance Detail	Dettaglio luminanza
+cameraRaw	Color Detail	Dettaglio colore
+cameraRaw	Roughness	Rugosità
+cameraRaw	Whites	Bianchi
+	Content-Aware Move Tool	Strumento Sposta in base al contenuto
+layerLabel	No Color	Nessun colore
+	Preferences…	Preferenze…
+	Actual Pixels	Pixel effettivi
+	Clipping Mask	Maschera di ritaglio
+	Tool Options	Opzioni strumento
+	Color Picker	Selettore colore
+	Color Swatches	Campioni colore
+	Linear Dodge	Scherma lineare
+	Preview Image	Anteprima immagine
+	Save As	Salva con nome
+	Remove All	Rimuovi tutto
+	Unlock	Sblocca
+	Enable	Attiva
+	Disable	Disattiva
+	On	Attivato
+	Clear Selection	Deseleziona
+	Invert Selection	Inverti selezione
+	Select Inverse	Inverti selezione
+	Contract	Contrai
+	Sample Size	Dimensione campione
+	Strength	Forza
+	Gamma	Gamma
+	Input	Input
+	Input Levels	Livelli input
+	Output Levels	Livelli output
+	Layer Styles	Stili livello
+	Blending Mode	Metodo di fusione
+	Fill Color	Colore di riempimento
+	Stroke Color	Colore della traccia
+	Stroke Width	Spessore traccia
+	Shadow	Ombra
+	Adjustment Layers	Livelli di regolazione
+	Text Layer	Livello di testo
+	Documents	Documenti
+	File Name	Nome file
+	File Format	Formato file
+	Compression	Compressione
+	Artboards	Tavole da disegno
+	Snap to Grid	Aggancia alla griglia
+	Full Screen	Schermo intero
+	Fullscreen	Schermo intero
+	Workspaces	Aree di lavoro
+	Show All	Mostra tutto
+	Hidden	Nascosto
+	Duplicate Layer	Duplica livello
+	Ungroup	Separa
+	Lock Transparent Pixels	Blocca pixel trasparenti
+	Lock Image Pixels	Blocca pixel immagine
+	Lock Position	Blocca posizione
+	Lock All	Blocca tutto
+	Show Rulers	Mostra righelli
+	Guide Layout…	Layout guide…
+	Page Setup…	Imposta pagina…
+	Reset Preferences	Ripristina preferenze
+	Documentation	Documentazione
+	Check for Updates	Verifica aggiornamenti
+	Loading…	Caricamento…
+	Processing…	Elaborazione…
+	Saving…	Salvataggio…
+	Exporting…	Esportazione…
+	Please wait…	Attendi…
+	No selection	Nessuna selezione
+	No layers	Nessun livello
+	No recent files	Nessun file recente
+	Unsupported file format	Formato file non supportato
+	Failed to open file	Impossibile aprire il file
+	Failed to save file	Impossibile salvare il file
+	Operation canceled	Operazione annullata
+	Changes have not been saved.	Le modifiche non sono state salvate.
+	Are you sure?	Sei sicuro?
+	Discard Changes	Ignora modifiche
+	Recent Files	File recenti
+	Open File	Apri file
+	Save File	Salva file
+	Save Changes	Salva modifiche
+	Rendering…	Rendering…
+	Importing…	Importazione…
+	Ready	Pronto
+	Failed	Non riuscito
+	Warning	Avviso
+	Information	Informazioni
+	Retry	Riprova
+	Continue	Continua
+	Skip	Salta
+	Resume	Riprendi
+	Reset All	Ripristina tutto
+	Defaults	Predefiniti
+	Apply to All	Applica a tutti
+	Confirm	Conferma
+	Finish	Termina
+	Back	Indietro
+	Next	Avanti
+	Previous	Precedente
+	More	Altro
+	Less	Meno
+	Manual	Manuale
+	Disabled	Disattivato
+	Locked	Bloccato
+	Unlocked	Sbloccato
+	Delete…	Elimina…
+	Create…	Crea…
+	Edit…	Modifica…
+	Change…	Cambia…
+	Transformation	Trasformazione
+	Scaling	Ridimensionamento
+	Canvas Size	Dimensione quadro
+	Percentage	Percentuale
+	Degrees	Gradi
+	Middle	Centro
+	Diameter	Diametro
+	Intensity	Intensità
+	Sensitivity	Sensibilità
+	Softness	Morbidezza
+	Feather Radius	Raggio sfumatura
+	Library	Libreria
+	Layer Properties	Proprietà livello
+	Groups	Gruppi
+	Masks	Maschere
+	Add Mask	Aggiungi maschera
+	Delete Mask	Elimina maschera
+	Invert Mask	Inverti maschera
+	Enable Mask	Attiva maschera
+	Disable Mask	Disattiva maschera
+	Apply Mask	Applica maschera
+	Import Settings	Importa impostazioni
+	Export Settings	Esporta impostazioni
+	Shortcut	Scorciatoia
+	Shortcuts	Scorciatoie
+	Keyboard	Tastiera
+	Mouse	Mouse
+	Tablet	Tavoletta grafica
+	Display	Monitor
+	Panel	Pannello
+	Hide Grid	Nascondi griglia
+	Fit to Window	Adatta alla finestra
+	Live Preview	Anteprima in tempo reale
+	Before	Prima
+	After	Dopo
+	Compare	Confronta
+	File Size	Dimensione file
+	Filename	Nome file
+	Folder	Cartella
+	Open Folder	Apri cartella
+	Choose Folder	Scegli cartella
+	Browse	Sfoglia
+	Find	Trova
+	Replace	Sostituisci
+	Date	Data
+	Learn More	Ulteriori informazioni
+	Report a Bug	Segnala un bug
+	Updates	Aggiornamenti
+	Update	Aggiorna
+	Restart Required	Riavvio necessario
+	Restart	Riavvia
+	Quit	Esci
+	Quit PhotoCraft	Esci da PhotoCraft
+	Close Window	Chiudi finestra
+	New Window	Nuova finestra
+	Open Image	Apri immagine
+	Save Image	Salva immagine
+	Export Image	Esporta immagine
+	Import Image	Importa immagine
+	Export As	Esporta come
+	Export to	Esporta in
+	Export Options	Opzioni di esportazione
+	Import Options	Opzioni di importazione
+	No Selection	Nessuna selezione
+	No Document	Nessun documento
+	No Image	Nessuna immagine
+	No Layers	Nessun livello
+	No Results	Nessun risultato
+	No Results Found	Nessun risultato trovato
+	Nothing to Undo	Niente da annullare
+	Nothing to Redo	Niente da ripetere
+	Changes Saved	Modifiche salvate
+	Unsaved Changes	Modifiche non salvate
+	Save before closing?	Vuoi salvare prima di chiudere?
+	Are you sure you want to quit?	Vuoi davvero uscire?
+	The file could not be opened.	Impossibile aprire il file.
+	The file could not be saved.	Impossibile salvare il file.
+	Unsupported format	Formato non supportato
+	Out of memory	Memoria insufficiente
+	Permission denied	Permesso negato
+	File not found	File non trovato
+	Operation failed	Operazione non riuscita
+	Operation completed	Operazione completata
+	Operation cancelled	Operazione annullata
+	Sharpen Amount	Quantità contrasto
+	Sharpen Radius	Raggio contrasto
+	Sharpen Detail	Dettaglio contrasto
+	Sharpen Masking	Mascheratura contrasto
+	Noise Luminance	Riduzione disturbo di luminanza
+	Noise Luminance Detail	Dettaglio luminanza (disturbo)
+	Noise Color	Riduzione disturbo cromatico
+	Noise Color Detail	Dettaglio colore (disturbo)
+	Grain Amount	Quantità grana
+	Grain Size	Dimensione grana
+	Grain Roughness	Rugosità grana
+	Vignette Roundness	Rotondità vignettatura
+	Vignette Feather	Sfumatura vignettatura
+	Vignette Highlights	Luci vignettatura
+	Vignette Style	Stile vignettatura
+	Planes	Piani
+	Plane	Piano
+	Shadow Amount	Quantità ombre
+	Shadow Tone	Ampiezza tonale ombre
+	Shadow Radius	Raggio ombre
+	Highlight Amount	Quantità luci
+	Highlight Tone	Ampiezza tonale luci
+	Highlight Radius	Raggio luci
+	Midtone	Contrasto mezzi toni
+	Black Clip	Taglio neri
+	White Clip	Taglio bianchi
+	Fuzziness	Tolleranza
+	Source Layer	Livello sorgente
+	Neutralize	Neutralizza
+	Use Selection In Source	Usa selezione nella sorgente
+	Use Selection In Target	Usa selezione nella destinazione
+	Flame Type	Tipo di fiamma
+	Randomize Length	Lunghezza casuale
+	Interval	Intervallo
+	Adjust Interval For Loops	Regola intervallo per cicli
+	Use Custom Color	Usa colore personalizzato
+	Flame Lines	Linee di fiamma
+	Flame Bottom Alignment	Allineamento base fiamma
+	Flame Style	Stile fiamma
+	Flame Shape	Forma fiamma
+	Randomize Shapes	Forme casuali
+	Frame	Cornice
+	Arrangement	Disposizione
+	Thickness	Spessore
+	Vine Color	Colore del rampicante
+	Flower Color	Colore fiori
+	Leaf Color	Colore foglie
+	Base Tree Type	Tipo di albero base
+	Light Direction	Direzione luce
+	Leaves Amount	Quantità foglie
+	Leaves Size	Dimensione foglie
+	Branches Height	Altezza rami
+	Branches Thickness	Spessore rami
+	Default Leaves	Foglie predefinite
+	Leaves Color	Colore foglie
+	Custom Branch Color	Colore rami personalizzato
+	Branches Color	Colore rami
+	Flat Shading	Ombreggiatura piatta
+	Date and Time	Data e ora
+	Scale Units	Unità di scala
+	Scale Factor	Fattore di scala
+	Area	Area
+	Perimeter	Perimetro
+	Circularity	Circolarità
+	Gray Value (Minimum)	Valore di grigio (minimo)
+	Gray Value (Maximum)	Valore di grigio (massimo)
+	Gray Value (Mean)	Valore di grigio (media)
+	Gray Value (Median)	Valore di grigio (mediana)
+	Integrated Density	Densità integrata
+	Length	Lunghezza
+	In Black	Nero in input
+	In White	Bianco in input
+	Out Black	Nero in output
+	Out White	Bianco in output
+	Tint Color	Colore tinta
+	Stops	Punti della sfumatura
+	Center X	Centro X
+	Center Y	Centro Y
+	Distribution	Distribuzione
+	Monochromatic	Monocromatico
+	Cell Size	Dimensione cella
+	Generators	Generatori
+	Wavelength Min	Lunghezza d'onda min.
+	Wavelength Max	Lunghezza d'onda max.
+	Amplitude Min	Ampiezza min.
+	Amplitude Max	Ampiezza max.
+	Undefined Areas	Aree non definite
+	Preserve	Mantieni
+	Max Radius	Raggio massimo
+	Depth Mode	Modalità profondità
+	Solid Front Faces	Facce anteriori piene
+	Mask Incomplete Blocks	Maschera blocchi incompleti
+	Stylization	Stilizzazione
+	Cleanliness	Pulizia
+	Bristle Detail	Dettaglio setole
+	Lighting	Illuminazione
+	Shine	Brillantezza
+	Max Offset	Scostamento massimo
+	Map Document	Documento mappa
+	Map Path	Percorso file mappa
+	Map Layer	Livello mappa
+	Ridges	Creste
+	Light Type	Tipo di luce
+	Light X	Luce X
+	Light Y	Luce Y
+	Light Z	Luce Z
+	Target X	Destinazione X
+	Target Y	Destinazione Y
+	Hotspot	Area di massima intensità
+	Elevation	Elevazione
+	Ambient	Luce ambiente
+	Warmth	Calore
+	Gloss	Lucentezza
+	Metallic	Metallico
+	Ambience	Luce ambiente
+	White Is High	Bianco in rilievo
+	Reduce Color Noise	Riduci disturbo cromatico
+	Sharpen Details	Contrasta dettagli
+	Remove Jpeg Artifact	Rimuovi artefatti JPEG
+	Blade Curvature	Curvatura lamelle
+	Depth Map	Mappa di profondità
+	Focal Distance	Distanza di messa a fuoco
+	Focus	Messa a fuoco
+	Transition	Transizione
+	Radius X	Raggio X
+	Radius Y	Raggio Y
+	Pins	Pin
+	Blur Angle	Angolo sfocatura
+	Speed	Velocità
+	Taper	Rastremazione
+	Start X	Inizio X
+	Start Y	Inizio Y
+	End X	Fine X
+	End Y	Fine Y
+	Kernel	Kernel
+	Input Mode	Modalità input
+	Row Order	Ordine righe
+	Eliminate	Elimina
+	Create By	Crea tramite
+	List	Elenco
+	Pencil Width	Larghezza matita
+	Stroke Pressure	Pressione traccia
+	Paper Brightness	Luminosità carta
+	Number Of Levels	Numero di livelli
+	Edge Simplicity	Semplicità bordi
+	Edge Fidelity	Fedeltà bordi
+	Brush Detail	Dettaglio pennello
+	Highlight Area	Area luci
+	Glow Size	Dimensione bagliore
+	Glow Brightness	Luminosità bagliore
+	Brush Type	Tipo di pennello
+	Stroke Size	Dimensione traccia
+	Stroke Detail	Dettaglio traccia
+	Highlight Strength	Intensità luci
+	Smoothness	Levigatezza
+	Edge Thickness	Spessore bordi
+	Edge Intensity	Intensità bordi
+	Posterization	Posterizzazione
+	Stroke Length	Lunghezza traccia
+	Relief	Rilievo
+	Definition	Definizione
+	Texture Coverage	Copertura texture
+	Shadow Intensity	Intensità ombre
+	Edge Width	Larghezza bordi
+	Edge Brightness	Luminosità bordi
+	Direction Balance	Bilanciamento direzione
+	Black Intensity	Intensità nero
+	White Intensity	Intensità bianco
+	Dark Intensity	Intensità scuri
+	Custom Pixel Aspect Ratio	Proporzioni pixel personalizzate
+	32-bit Preview Options	Opzioni anteprima 32 bit
+	New Guide	Nuova guida
+	Join the ArtCraft Discord	Unisciti al Discord di ArtCraft
+	Report an Issue	Segnala un problema
+	Load Files into Stack	Carica file in pila
+	Statistics	Statistiche
+	Duplicate Layers	Duplica livelli
+	Edit Toolbar	Modifica barra strumenti
+	Import Brushes	Importa pennelli
+	Load 3D LUT	Carica LUT 3D
+	New document	Nuovo documento
+	Press keys	Premi tasti
+	Rename Group	Rinomina gruppo
+	Rename Tool Preset	Rinomina predefinito strumento
+	Search commands, tools and panels	Cerca comandi, strumenti e pannelli
+	Slice Options	Opzioni sezione
+	Rename Brush	Rinomina pennello
+	Opening	Apertura
+	Reading	Lettura
+	Working	Elaborazione
+	Accented Edges	Bordi accentuati
+	Angled Strokes	Tracce angolate
+	Anisotropic	Anisotropico
+	Around Center	Attorno al centro
+	Artistic	Artistico
+	Bamboo	Bambù
+	Bas Relief	Bassorilievo
+	Berries	Bacche
+	Blast	Esplosione
+	Bleach Bypass	Bleach bypass
+	Blocks	Blocchi
+	Brick	Mattoni
+	Brush Strokes	Pennellate
+	Burlap	Tela di iuta
+	Candle Light	Luce di candela
+	Circle	Cerchio
+	Clumped	Raggruppato
+	Coarse Dots	Punti grossi
+	Colored Pencil	Matita colorata
+	Contrasty	Contrastato
+	Cool	Freddo
+	Craquelure	Craquelure
+	Cross	Croce
+	Cross Process	Processo incrociato
+	Crosshatch	Tratteggio incrociato
+	Cutout	Ritaglio
+	Daisies	Margherite
+	Dark Rough	Ruvido scuro
+	Dark Strokes	Tracce scure
+	Darken Only	Scurisci soltanto
+	Day For Night	Notte americana
+	Deep Blue	Blu intenso
+	Deep Emerald	Smeraldo intenso
+	Deep Red	Rosso intenso
+	Deep Yellow	Giallo intenso
+	Dot	Punto
+	Double Line	Linea doppia
+	Draft	Bozza
+	Dry Brush	Pennello asciutto
+	Duplication	Duplicazione
+	Edge Extension	Estensione bordi
+	Edge Only	Solo bordi
+	Enlarged	Ingrandito
+	Even Fields	Campi pari
+	Faded Film	Pellicola sbiadita
+	Film Grain	Grana pellicola
+	Fine	Fine
+	Fine Dots	Punti fini
+	Flat	Piatto
+	Fresco	Affresco
+	From Left	Da sinistra
+	From Right	Da destra
+	Frosted	Smerigliato
+	Generic	Generico
+	Glass	Vetro
+	Glowing Edges	Bordi luminosi
+	Grainy Dots	Punti granulosi
+	Hearts	Cuori
+	Heptagon	Ettagono
+	Hexagon	Esagono
+	Horizontal Only	Solo orizzontale
+	Infinite	Infinita
+	Ink Outlines	Contorni a inchiostro
+	Ivy	Edera
+	Left Diagonal	Diagonale sinistra
+	Level Based	Basato su livelli
+	Light Rough	Ruvido chiaro
+	Lighten Only	Schiarisci soltanto
+	Long Lines	Linee lunghe
+	Long Strokes	Tracce lunghe
+	Lower	Inferiore
+	Medium Dots	Punti medi
+	Medium Lines	Linee medie
+	Medium Strokes	Tracce medie
+	Mono Contrast	Contrasto monocromatico
+	Mosaic Tiles	Tessere mosaico
+	Multiple Flames Along Path	Più fiamme lungo il tracciato
+	Multiple Flames One Direction	Più fiamme in una direzione
+	Multiple Flames Path Directions	Più fiamme nelle direzioni del tracciato
+	Multiple Flames Various Length	Più fiamme di lunghezza variabile
+	Octagon	Ottagono
+	Odd Fields	Campi dispari
+	One Flame Along Path	Una fiamma lungo il tracciato
+	Out From Center	Dal centro verso l'esterno
+	Oval	Ovale
+	Overlay Edge	Sovrapponi bordi
+	Palette Knife	Spatola
+	Parallel	Parallelo
+	Patchwork	Patchwork
+	Pentagon	Pentagono
+	Point	Puntiforme
+	Pointed	Appuntito
+	Pond Ripples	Increspature stagno
+	Pyramids	Piramidi
+	Random	Casuale
+	Right Diagonal	Diagonale destra
+	Rope	Corda
+	Roses	Rose
+	Sandstone	Arenaria
+	Scallops	Smerli
+	Sepia	Seppia
+	Short Lines	Linee corte
+	Short Strokes	Tracce corte
+	Simple	Semplice
+	Light Intensity	Intensità luce
+	Spray Radius	Raggio spruzzo
+	Stroke Direction	Direzione traccia
+	Graininess	Granulosità
+	Glow Amount	Quantità bagliore
+	Clear Amount	Area senza bagliore
+	Distortion	Distorsione
+	Ripple Size	Dimensione increspatura
+	Ripple Magnitude	Intensità increspatura
+	Charcoal Area	Area carboncino
+	Chalk Area	Area gessetto
+	Charcoal Thickness	Spessore carboncino
+	Light Dark Balance	Bilanciamento chiaro/scuro
+	Foreground Level	Intensità primo piano
+	Background Level	Intensità sfondo
+	Pattern Type	Tipo pattern
+	Image Balance	Bilanciamento immagine
+	Darkness	Oscurità
+	Fiber Length	Lunghezza fibre
+	Crack Spacing	Spaziatura crepe
+	Crack Depth	Profondità crepe
+	Crack Brightness	Luminosità crepe
+	Grain Type	Tipo grana
+	Tile Size	Dimensione tessere
+	Grout Width	Larghezza fughe
+	Lighten Grout	Schiarisci fughe
+	Square Size	Dimensione quadrati
+	Border Thickness	Spessore bordo
+	Correct Distortion	Correggi distorsione
+	Correct Vignette	Correggi vignettatura
+	Correct C A	Correggi aberrazione cromatica
+	Auto Scale	Scala automatica
+	Red Cyan	Rosso/ciano
+	Blue Yellow	Blu/giallo
+	Vignette Amount	Quantità vignettatura
+	Vignette Midpoint	Punto medio vignettatura
+	Constraints	Vincoli
+	Curve Highlights	Luci curva
+	Curve Lights	Toni chiari curva
+	Curve Darks	Toni scuri curva
+	Curve Shadows	Ombre curva
+	Curve Splits	Divisioni curva
+	Point Curve	Curva a punti
+	Point Curve Red	Curva a punti (rosso)
+	Point Curve Green	Curva a punti (verde)
+	Point Curve Blue	Curva a punti (blu)
+	Hsl Hue	Tonalità HSL
+	Hsl Sat	Saturazione HSL
+	Hsl Lum	Luminanza HSL
+	Grade Shadows	Gradazione ombre
+	Grade Midtones	Gradazione mezzi toni
+	Grade Highlights	Gradazione luci
+	Grade Global	Gradazione globale
+	Grade Blending	Fusione gradazione
+	Grade Balance	Bilanciamento gradazione
+	Sine	Sinusoide
+	Sketch	Schizzo
+	Snowflakes	Fiocchi di neve
+	Sparkle	Scintillio
+	Spatter	Spruzzo
+	Speckle	Picchiettato
+	Spin	Rotazione
+	Sprinkles	Granelli sparsi
+	Squareness	Forma quadrata
+	Stagger	Sfalsamento
+	Stained Glass	Vetrata
+	Star	Stella
+	Stars	Stelle
+	Stippled	Punteggiato
+	Stretch	Adatta alle dimensioni
+	Teal Orange	Verde acqua e arancio
+	Tiny Lens	Lente minuscola
+	To Center	Verso il centro
+	Unaltered	Inalterato
+	Underpainting	Pittura di fondo
+	Underwater	Subacqueo
+	Uniform	Uniforme
+	Upper	Superiore
+	Vertical Only	Solo verticale
+	Vine With Flowers	Rampicante con fiori
+	Vine With Leaves	Rampicante con foglie
+	Violent	Violento
+	Warm	Caldo
+	Watercolor	Acquerello
+	Waves	Onde
+	Wide Blurry	Ampio sfocato
+	Wide Sharp	Ampio nitido
+	Wrap	Ripeti ciclicamente
+	Zigzag	Zigzag
+	Wetness	Bagnato
+	AI Integrations	Integrazioni IA
+	Add Noise	Aggiungi disturbo
+	Apply Data Set	Applica set di dati
+	Apply Image	Applica immagine
+	Arbitrary	Arbitrario
+	Artboard from Group	Tavola da gruppo
+	Artboard from Layers	Tavola da livelli
+	Artboards to Files	Tavole da disegno in file
+	Artboards to PDF	Tavole da disegno in PDF
+	Assign Profile	Assegna profilo
+	At	Posizione
+	Auto-Align Layers	Allinea automaticamente livelli
+	Auto-Blend Layers	Fondi automaticamente livelli
+	Batch	Batch
+	Border	Bordo
+	Box Blur	Sfocatura casella
+	Calculations	Calcoli
+	Camera Raw	Camera Raw
+	Camera Raw Filter	Filtro Camera Raw
+	Channel1	Canale 1
+	Channel2	Canale 2
+	Channel3	Canale 3
+	Channel4	Canale 4
+	Clone	Clona
+	Color Decontaminate	Decontamina colore
+	Color Halftone	Mezzetinte a colori
+	Color Lookup Tables	Tabelle ricerca colore
+	Color Settings	Impostazioni colore
+	Color Table	Tabella colori
+	Conditional Mode Change	Cambia metodo condizionale
+	Content-Aware Fill	Riempimento in base al contenuto
+	Convert to Linked	Converti in oggetto collegato
+	Convert to Profile	Converti in profilo
+	Crystallize	Cristallizza
+	Data	Dati
+	Data Sets as Files	Set di dati come file
+	De-Interlace	Deinterlaccia
+	Define Brush Preset	Definisci predefinito pennello
+	Define Custom Shape	Definisci forma personale
+	Define Pattern	Definisci pattern
+	Defringe	Elimina frange
+	Diffuse	Diffondi
+	Diffuse Glow	Bagliore diffuso
+	Displace	Sposta
+	Do you want to save you made to “{name}” before quitting?	Vuoi salvare le modifiche apportate a “{name}” prima di uscire?
+	Dust & Scratches	Polvere e graffi
+	Export Contents	Esporta contenuto
+	Export Preferences	Preferenze di esportazione
+	Export/Import Presets	Esporta/Importa predefiniti
+	Extrude	Estrudi
+	Fibers	Fibre
+	Field Blur	Sfocatura campo
+	File Info	Info file
+	Filter Gallery	Galleria filtri
+	Find and Replace Text	Trova e sostituisci testo
+	Fit Image	Adatta immagine
+	Flame	Fiamma
+	Focus Area	Area di messa a fuoco
+	Gaussian Blur	Sfocatura gaussiana
+	Global Light	Luce globale
+	Group from Layers	Gruppo da livelli
+	HDR Toning	Mappatura tonale HDR
+	High Pass	Passa alto
+	Highlight	Luci
+	Image Processor	Elaborazione immagini
+	Install Plug-in	Installa plug-in
+	Interpret Footage	Interpreta filmato
+	Iris Blur	Sfocatura diaframma
+	Jag	Frastagliato
+	Label	Etichetta
+	Layer Comps to Files	Composizioni livelli in file
+	Layer Content Options	Opzioni contenuto livello
+	Layer From Background	Livello dallo sfondo
+	Layer from Background	Livello dallo sfondo
+	Layers to Files	Livelli in file
+	Legacy	Legacy
+	Lens Blur	Sfocatura lente
+	Lens Correction	Correzione lente
+	Lens Flare	Riflesso obiettivo
+	Lighting Effects	Effetti di luce
+	Liquify	Fluidifica
+	Lock Layers	Blocca livelli
+	Lum	Lum
+	Match Color	Corrispondenza colore
+	Merge to HDR Pro	Unisci in HDR Pro
+	Mezzotint	Mezzatinta
+	Mosaic	Mosaico
+	Motion Blur	Movimento sfocato
+	Native file drag-and-drop is not supported on Wayland yet. Use File › Open, or run PhotoCraft under XWayland with `WAYLAND_DISPLAY= photocraft`.	Il drag-and-drop nativo dei file non è ancora supportato su Wayland. Usa File › Apri, oppure avvia PhotoCraft sotto XWayland con `WAYLAND_DISPLAY= photocraft`.
+	Neon Glow	Bagliore neon
+	New Guide Layout	Nuovo layout guide
+	New Video Layer from File	Nuovo livello video da file
+	Ocean Ripple	Increspatura oceano
+	Oil Paint	Pittura a olio
+	Open As	Apri come
+	Package	Crea pacchetto
+	Paint Daubs	Macchie di colore
+	Path Blur	Sfocatura tracciato
+	Paths to Illustrator	Tracciati in Illustrator
+	Photomerge	Photomerge
+	Picture Frame	Cornice immagine
+	Pinch	Pizzica
+	Place Embedded	Inserisci incorporato
+	Place Linked	Inserisci oggetto collegato
+	Place Scale Marker	Inserisci indicatore scala
+	Plastic Wrap	Pellicola plastica
+	Pointillize	Puntinatura
+	Polar Coordinates	Coordinate polari
+	Polar To Rectangular	Da polari a rettangolari
+	Poster Edges	Bordi poster
+	Preset Manager	Gestore predefiniti
+	Profile	Profilo
+	Radial Blur	Sfocatura radiale
+	Raw Defaults	Predefiniti Raw
+	Rectangular To Polar	Da rettangolari a polari
+	Reduce Noise	Riduci disturbo
+	Relink to File	Ricollega al file
+	Render Video	Esegui rendering video
+	Replace Color	Sostituisci colore
+	Replace Contents	Sostituisci contenuto
+	Replace Footage	Sostituisci filmato
+	Resolve Missing Fonts	Risolvi font mancanti
+	Ripple	Increspatura
+	Rough Pastels	Pastelli ruvidi
+	Sat	Sat
+	Save a Copy	Salva una copia
+	Save for Web (Legacy)	Salva per Web (legacy)
+	Scale Effects	Scala effetti
+	Script Events Manager	Gestore eventi script
+	Search menus	Cerca nei menu
+	Seed	Seme
+	Select and Mask	Seleziona e maschera
+	Set Measurement Scale	Imposta scala misurazione
+	Shadows/Highlights	Ombre/Luci
+	Shape Blur	Sfocatura forma
+	Shear	Inclina
+	Smart Blur	Sfocatura avanzata
+	Smart Sharpen	Contrasto intelligente
+	Smudge Stick	Bastoncino sfumino
+	Solid Color	Colore pieno
+	Spherize	Sferizza
+	Spin Blur	Sfocatura rotazione
+	Spot	Faretto
+	Sprayed Strokes	Tracce spruzzate
+	Strokes	Tracce
+	Sumi-e	Sumi-e
+	Surface Blur	Sfocatura superficie
+	Texturizer	Texturizzatore
+	Tiles	Mattonelle
+	Tilt-Shift	Miniatura
+	Trace Contour	Traccia contorno
+	Trap	Trapping
+	Tree	Albero
+	Trim	Elimina bordi
+	Turbulent	Turbolento
+	Twirl	Vortice
+	Unsharp Mask	Maschera di contrasto
+	Use File › Open to open an image.	Usa File › Apri per aprire un'immagine.
+	Vanishing Point	Punto di fuga
+	Variable Data Sets	Set di dati variabili
+	Video Frames to Layers	Fotogrammi video in livelli
+	WIA Support	Supporto WIA
+	Warp Text	Altera testo
+	Wind	Vento
+	ZigZag	ZigZag
+	Vertical Type Tool	Strumento Testo verticale
+	About {app}	Informazioni su {app}
+	Hide {app}	Nascondi {app}
+	Quit {app}	Esci da {app}
+	Services	Servizi
+	Hide Others	Nascondi altre app
+	Lut	LUT
+	Cooling L B B	Filtro freddo (LBB)
+	Cooling80	Filtro freddo (80)
+	Cooling82	Filtro freddo (82)
+	Hsb	HSB
+	Hsl	HSL
+	Movie Prime	Focale fissa cinematografica
+	Prime105	Focale fissa 105 mm
+	Prime35	Focale fissa 35 mm
+	Rgb	RGB
+	Warming L B A	Filtro caldo (LBA)
+	Warming81	Filtro caldo (81)
+	Warming85	Filtro caldo (85)
+@id	filter.sharpen.sharpen	Contrasta
+	Good	Buona
+	Best	Migliore
+	Adjustment Properties	Proprietà regolazione
+	Default Foreground and Background Colors	Colori di primo piano e sfondo predefiniti
+	Move Layer	Sposta livello
+	Rectangular Selection	Selezione rettangolare
+	Reorder Layer	Riordina livello
+	Select Layer	Seleziona livello
+	Set Colors	Imposta colori
+	Switch Foreground and Background Colors	Scambia colori di primo piano e sfondo
+	Target	Destinazione
+
+# Path, channel, layer style, status and System Info labels the Czech catalog added
+	Make Work Path…	Crea tracciato di lavoro…
+	Create Vector Mask	Crea maschera vettoriale
+	Make Selection…	Crea selezione…
+	Fill Path…	Riempi tracciato…
+	Clipping Path…	Tracciato di ritaglio…
+	Free Transform Path	Trasformazione libera tracciato
+	Unite Shapes at Overlap	Unisci forme nella sovrapposizione
+	Subtract Shapes at Overlap	Sottrai forme nella sovrapposizione
+	Copy Fill	Copia riempimento
+	Copy Complete Stroke	Copia traccia completa
+	Paste Fill	Incolla riempimento
+	Paste Complete Stroke	Incolla traccia completa
+	Make Symmetry Path	Crea tracciato di simmetria
+	Disable Symmetry Path	Disattiva tracciato di simmetria
+	Dark Gray	Grigio scuro
+	Medium Gray	Grigio medio
+	Select Custom Color…	Seleziona colore personale…
+	Color Picker (Custom Canvas Color)	Selettore colore (colore quadro personale)
+	Duplicate Channel	Duplica canale
+	Delete Channel	Elimina canale
+	Rename Channel…	Rinomina canale…
+	Merge Spot Channel	Unisci canale tinta piatta
+	Convert to Alpha Channel	Converti in canale alfa
+	Exit Quick Mask	Esci da maschera veloce
+	New Channel…	Nuovo canale…
+	New Spot Channel…	Nuovo canale tinta piatta…
+	Split Channels	Dividi canali
+	Merge Channels…	Unisci canali…
+	Color Indicates Masked Areas	Il colore indica le aree mascherate
+	Color Indicates Selected Areas	Il colore indica le aree selezionate
+	✓ Color Indicates Masked Areas	✓ Il colore indica le aree mascherate
+	✓ Color Indicates Selected Areas	✓ Il colore indica le aree selezionate
+	Up	Su
+	To	A
+	Shallow	Superficiale
+	Deep	Profonda
+	Blend Interior Effects as Group	Fondi effetti interni come gruppo
+	Blend Clipped Layers as Group	Fondi livelli ritagliati come gruppo
+	Transparency Shapes Layer	Forme di trasparenza del livello
+	Layer Mask Hides Effects	La maschera di livello nasconde gli effetti
+	Vector Mask Hides Effects	La maschera vettoriale nasconde gli effetti
+	General Blending	Fusione generale
+	This Layer:	Questo livello:
+	Underlying Layer:	Livello sottostante:
+	Nothing to paste: the clipboard holds no image	Niente da incollare: gli appunti non contengono un'immagine
+	Preferences saved	Preferenze salvate
+	Invalid panel layout; restored the default dock	Disposizione dei pannelli non valida; ripristinata quella predefinita
+	Preferences were reset: {error}	Le preferenze sono state reimpostate: {error}
+	Recovered {name}	Recuperato: {name}
+	Couldn't save preferences: {error}. Retrying…	Impossibile salvare le preferenze: {error}. Nuovo tentativo…
+	Autosave failed: {error}	Salvataggio automatico non riuscito: {error}
+	Exported presets to {path}	Predefiniti esportati in {path}
+	Ran script {name}	Script eseguito: {name}
+	Sent to the printer ({spooler})	Inviato alla stampante ({spooler})
+	Printed to {path}	Stampato in {path}
+	Exported {path} ({size})	Esportato: {path} ({size})
+	Exported {path}	Esportato: {path}
+	Added swatch {name}	Campione aggiunto: {name}
+	Step {step} ({id}) failed: {error}	Passaggio {step} ({id}) non riuscito: {error}
+	Could not rename the action: {error}	Impossibile rinominare l'azione: {error}
+	Action playback failed: {error}	Riproduzione dell'azione non riuscita: {error}
+	Clone source set at {x}, {y}	Sorgente clone impostata in {x}, {y}
+	Color management: {error}	Gestione del colore: {error}
+	Opened {url}	Aperto: {url}
+	No custom shape "{name}": pick one in the options bar or Window › Shapes	Nessuna forma personale "{name}": scegline una nella barra delle opzioni o in Finestra › Forme
+	Saved a copy as {path}	Copia salvata come {path}
+	Exported contents to {path}	Contenuto esportato in {path}
+	{label} is not available: {reason}	{label} non è disponibile: {reason}
+	Saved {path}; image assets: {n} in {dir}	Salvato: {path}; risorse immagine: {n} in {dir}
+	{message} (notes: {n}; {warning})	{message} (note: {n}; {warning})
+	Preferences can't be saved	Impossibile salvare le preferenze
+	PhotoCraft keeps retrying; until a save succeeds, preference changes are lost when it closes.	PhotoCraft continua a riprovare; finché un salvataggio non riesce, le modifiche alle preferenze andranno perse alla chiusura.
+	GPU retry scheduled	Nuovo tentativo GPU programmato
+	Save your work and restart PhotoCraft to retry GPU acceleration. CPU rendering remains active for this session.	Salva il lavoro e riavvia PhotoCraft per riprovare l'accelerazione GPU. Per questa sessione resta attivo il rendering su CPU.
+	GPU device was lost; using the CPU renderer.	Dispositivo GPU perso; uso il rendering su CPU.
+	GPU error; using the CPU renderer.	Errore GPU; uso il rendering su CPU.
+	Couldn't open {name}: {error}	Impossibile aprire {name}: {error}
+	Toggle the Brush Settings panel	Mostra/nascondi il pannello Impostazioni pennello
+	New Brush Preset	Nuovo predefinito pennello
+	Grid view	Vista a griglia
+	List view	Vista a elenco
+	{verb} {mask} {layer}	{verb}: {mask}, {layer}
+	Unlink	Scollega
+	Link	Collega
+	layer mask	maschera di livello
+	vector mask	maschera vettoriale
+	Commit transform	Conferma trasformazione
+	Cancel transform	Annulla trasformazione
+	Scroll menu up	Scorri il menu in alto
+	Scroll menu down	Scorri il menu in basso
+	This type layer must be rasterized before proceeding. Its text will no longer be editable. Rasterize the type?	Per procedere il livello di testo deve essere rasterizzato. Il testo non sarà più modificabile. Rasterizzare il testo?
+	This shape layer must be rasterized before proceeding. It will no longer be editable as a shape. Rasterize the shape?	Per procedere il livello forma deve essere rasterizzato. Non sarà più modificabile come forma. Rasterizzare la forma?
+	This Smart Object must be rasterized before proceeding. Its contents will no longer be editable. Rasterize the Smart Object?	Per procedere l'oggetto avanzato deve essere rasterizzato. Il contenuto non sarà più modificabile. Rasterizzare l'oggetto avanzato?
+	This fill layer must be rasterized before proceeding. Its fill content will no longer be editable. Rasterize the layer?	Per procedere il livello di riempimento deve essere rasterizzato. Il riempimento non sarà più modificabile. Rasterizzare il livello?
+	This layer must be rasterized before proceeding.	Per procedere il livello deve essere rasterizzato.
+	Color Picker (Background Color)	Selettore colore (colore sfondo)
+	Color Picker (Foreground Color)	Selettore colore (colore primo piano)
+	Adwaita (Light)	Adwaita (chiaro)
+	Adwaita (Dark)	Adwaita (scuro)
+	Breeze Light	Breeze chiaro
+	Breeze Dark	Breeze scuro
+	Solarized Dark	Solarized scuro
+	Open Recent is unavailable on the web	Apri recenti non è disponibile sul web
+	Graphics adapter: {adapter}	Scheda grafica: {adapter}
+	Backend: {backend} ({type})	Backend: {backend} ({type})
+	Driver: {driver}	Driver: {driver}
+	GPU backend preference: {backend}	Backend GPU preferito: {backend}
+	Selected at launch: {backend}	Scelto all'avvio: {backend}
+	Image compositor: {processor}	Compositore immagine: {processor}
+	Fallback: {reason}	Ripiego: {reason}
+	This session: {reason}	Questa sessione: {reason}
+	Window renderer: {renderer}	Renderer finestra: {renderer}
+	Software adapter	Scheda software
+	Graphics adapter	Scheda grafica
+	unknown	sconosciuto
+	unknown type	tipo sconosciuto
+	auto	automatico
+	Platform: {os} {arch}	Piattaforma: {os} {arch}
+	previous reading kept; the last re-read failed: {reason}	lettura precedente mantenuta; l'ultima rilettura non è riuscita: {reason}
+	Monitor profile: {profile}	Profilo monitor: {profile}
+	Display profiles: {reason}	Profili dello schermo: {reason}
+	Monitor profile in use on {display}: {profile}	Profilo monitor in uso su {display}: {profile}
+	Monitor profile in use: {profile}	Profilo monitor in uso: {profile}
+	The canvas is shown as sRGB. Choose a monitor profile in Edit › Color Settings.	Il quadro è mostrato come sRGB. Scegli un profilo monitor in Modifica › Impostazioni colore.
+	The canvas on {display} is shown as sRGB. Choose a monitor profile in Edit › Color Settings.	Il quadro su {display} è mostrato come sRGB. Scegli un profilo monitor in Modifica › Impostazioni colore.
+	Display profile not used	Profilo dello schermo non usato
+	Monitor profile on {display} (main window): {profile}	Profilo monitor su {display} (finestra principale): {profile}
+	Monitor profile on {display}: {profile}	Profilo monitor su {display}: {profile}
+	manual	manuale
+	fallback	ripiego
+	Importing {what} from {file}…	Importazione di {what} da {file}…
+	brushes	pennelli
+	gradients	sfumature
+@plural	Imported {n} brush from {file}|Imported {n} brushes from {file}	{n} pennello importato da {file}|{n} pennelli importati da {file}
+@plural	Imported {n} gradient from {file}|Imported {n} gradients from {file}	{n} sfumatura importata da {file}|{n} sfumature importate da {file}
+@plural	Imported {n} pattern from {file}|Imported {n} patterns from {file}	{n} pattern importato da {file}|{n} pattern importati da {file}
+	Data Set: {name}  ({index}/{total})	Set di dati: {name}  ({index}/{total})
+	(none)	(nessuno)
+navigator	Zoom	Zoom
+	Apply {option}: {state}	Applica {option}: {state}
+	on	attivo
+	off	disattivo
+	This adjustment ({key}) is kept as imported and can't be edited yet.	Questa regolazione ({key}) resta come è stata importata e non si può ancora modificare.
+	Join the ArtCraft Discord ({url})	Unisciti al Discord di ArtCraft ({url})
+	{index} of {total}	{index} di {total}
+	{shortcut} assigned.	{shortcut} assegnata.
+	{shortcut} is already in use by {commands} and will be removed from it when you click OK.	{shortcut} è già usata da {commands} e verrà rimossa quando fai clic su OK.
+	Object Finder	Ricerca oggetti
+	No object found there — drag a rectangle around it	Nessun oggetto trovato lì: trascina un rettangolo intorno
+	Remove after each stroke	Rimuovi dopo ogni tratto
+	Apply the removal ({key})	Applica la rimozione ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Tratti da rimuovere: {n} (Invio applica, Esc annulla)
+	Clear Brush Controls	Cancella controlli pennello
+	Reset All Locked Settings	Ripristina tutte le impostazioni bloccate
+	Copy Texture to Other Tools	Copia texture su altri strumenti
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Carica azioni…
+	Save Actions…	Salva azioni…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Caricata {n} azione da {file}|Caricate {n} azioni da {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} passaggio non ha ancora un equivalente in PhotoCraft|{n} passaggi non hanno ancora un equivalente in PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Salvata {n} azione in {file}|Salvate {n} azioni in {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Omesso {n} passaggio senza equivalente in Photoshop|Omessi {n} passaggi senza equivalente in Photoshop
+
+	File Naming	Denominazione file
+	Starting serial	Numero di serie iniziale
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Inserisci interruzione…
+	Save Set…	Salva set…
+	Message:	Messaggio:
+	Allow Continue	Consenti di continuare
+	Show dialog during playback	Mostra la finestra di dialogo durante l’esecuzione
+	Select an action first	Seleziona prima un’azione
+	Action playback stopped	Esecuzione dell’azione interrotta
+	Step {step} is waiting for its dialog	Il passaggio {step} attende la sua finestra di dialogo
+@plural	{n} action|{n} actions	{n} azione|{n} azioni
+	Auto Add/Delete	Aggiungi/elimina automaticamente
+	ICO is limited to 256 × 256 pixels	ICO è limitato a 256 × 256 pixel
diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv
index ffca724d17..9f074e3e30 100644
--- a/crates/ui-egui/src/i18n/ja.tsv
+++ b/crates/ui-egui/src/i18n/ja.tsv
@@ -15,7 +15,17 @@
 # Product and technology names (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...) stay in Latin
 # letters; the trailing "…" of dialog commands is kept.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	チャンネルカラー
+	Color Indicates:	着色表示:
+	Solidity:	濃度:
+	Ink Characteristics	インキの特性
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	用紙の幅
+	Paper Height	用紙の高さ
 	Rows	行
 	Number	数
 	Top:	上:
@@ -65,18 +75,20 @@
 	Close	閉じる
 	Minimize	最小化
 	Maximize	最大化
-	Restore	元に戻す（縮小）
+	Restore	元に戻す (縮小)
 	Close All	すべて閉じる
 	Close Others	ほかを閉じる
 	Save	保存
 	Save As…	名前を付けて保存…
 	Save a Copy…	コピーを保存…
+	{name} can't keep everything in this document	{name} にはこのドキュメントの内容をすべて保存できません
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Photoshop (PSD) などすべてを保持できる形式を選ぶか、コピーを保存してください。
 	Revert	復帰
 	Export	書き出し
 	Quick Export as PNG	PNG としてクイック書き出し
 	Export As…	書き出し形式を指定…
 	Export Preferences…	書き出しの環境設定…
-	Save for Web (Legacy)…	Web 用に保存(従来方式)…
+	Save for Web (Legacy)…	Web 用に保存 (従来方式)…
 	Artboards to Files…	アートボードをファイルへ…
 	Artboards to PDF…	アートボードを PDF へ…
 	Layers to Files…	レイヤーをファイルへ…
@@ -108,6 +120,14 @@
 	Script Events Manager…	スクリプトイベント管理…
 	Import	読み込み
 	Browse…	参照…
+	Source Files	ソースファイル
+	Use:	使用:
+	Files	ファイル
+	Folder	フォルダー
+	Add Open Files	開いているファイルを追加
+	Sort By Name	名前順に並べ替え
+	Attempt to Automatically Align Source Images	ソース画像の自動整列を試す
+	Create Smart Object after Loading Layers	レイヤーの読み込み後にスマートオブジェクトを作成
 	Reveal in Finder	Finder で表示
 	Show in Explorer	エクスプローラーで表示
 	Show in Folder	フォルダーで表示
@@ -132,6 +152,8 @@
 	Search…	検索…
 	Check Spelling…	スペルチェック…
 	Find and Replace Text…	テキストを検索して置換…
+	Add to Dictionary	辞書に追加
+	No Spelling Suggestions	スペルの候補はありません
 	Fill…	塗りつぶし…
 	Stroke…	境界線を描く…
 	Content-Aware Fill…	コンテンツに応じた塗りつぶし…
@@ -146,6 +168,8 @@
 	Transform Again on a Copy	複製してもう一度変形
 	Scale	拡大・縮小
 	Rotate	回転
+	Set horizontal skew	水平方向の斜体を設定
+	Set vertical skew	垂直方向の斜体を設定
 	Skew	斜体
 	Distort	ゆがみ
 	Perspective	遠近法
@@ -218,7 +242,7 @@
 	16 Bits/Channel	16 ビット/チャンネル
 	16 bit	16 ビット
 	32 Bits/Channel	32 ビット/チャンネル
-	32 bit (float)	32 ビット（float）
+	32 bit (float)	32 ビット (float)
 	Floating point	浮動小数点
 	Color Table…	カラーテーブル…
 	Bitmap…	ビットマップ…
@@ -301,16 +325,16 @@
 	Rename Layer	レイヤー名を変更
 	Create Layer	レイヤーを作成
 	Layer Style	レイヤースタイル
-	Blending Options…	レイヤー効果の描画オプション…
+	Blending Options…	レイヤー効果…
 	Bevel & Emboss…	ベベルとエンボス…
 	Use Global Light	グローバルライトを使用
-	Inner Shadow…	シャドウ(内側)…
-	Inner Glow…	光彩(内側)…
+	Inner Shadow…	シャドウ (内側)…
+	Inner Glow…	光彩 (内側)…
 	Satin…	サテン…
 	Color Overlay…	カラーオーバーレイ…
 	Gradient Overlay…	グラデーションオーバーレイ…
 	Pattern Overlay…	パターンオーバーレイ…
-	Outer Glow…	光彩(外側)…
+	Outer Glow…	光彩 (外側)…
 	Drop Shadow…	ドロップシャドウ…
 	Copy Layer Style	レイヤースタイルをコピー
 	Paste Layer Style	レイヤースタイルを貼り付け
@@ -357,6 +381,7 @@
 	Update Modified Content	変更されたコンテンツを更新
 	Update All Modified Content	変更されたコンテンツをすべて更新
 	Stack Mode	スタックモード
+	Choose Stack Mode:	スタックモードを選択:
 	Entropy	エントロピー
 	Kurtosis	尖度
 	Maximum	最大値
@@ -391,6 +416,7 @@
 	Select Linked Layers	リンクしたレイヤーを選択
 	Merge Layers	レイヤーを結合
 	Merge Down	下のレイヤーと結合
+	Merge Group	グループを結合
 	Merge Visible	表示レイヤーを結合
 	Stamp Visible	表示レイヤーをスタンプ
 	Select Layer Above	上のレイヤーを選択
@@ -527,22 +553,25 @@
 	Blur	ぼかし
 	Blur Gallery	ぼかしギャラリー
 	Field Blur…	フィールドぼかし…
+# Field Blur pins (#3373)
+	No pin selected	ピンが選択されていません
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	画像をクリックしてピンを追加します。ピンをドラッグして移動し、リングをドラッグしてぼかしを変更します。Delete キーで選択したピンを削除します。
 	Iris Blur…	虹彩絞りぼかし…
 	Tilt-Shift…	チルトシフト…
 	Path Blur…	パスぼかし…
 	Spin Blur…	回転ぼかし…
-	Blur More	ぼかし(強)
-	Box Blur…	ぼかし(ボックス)…
-	Gaussian Blur…	ぼかし(ガウス)…
-	Lens Blur…	ぼかし(レンズ)…
-	Motion Blur…	ぼかし(移動)…
-	Radial Blur…	ぼかし(円形)…
-	Shape Blur…	ぼかし(シェイプ)…
-	Smart Blur…	ぼかし(詳細)…
-	Surface Blur…	ぼかし(表面)…
+	Blur More	ぼかし (強)
+	Box Blur…	ぼかし (ボックス)…
+	Gaussian Blur…	ぼかし (ガウス)…
+	Lens Blur…	ぼかし (レンズ)…
+	Motion Blur…	ぼかし (移動)…
+	Radial Blur…	ぼかし (円形)…
+	Shape Blur…	ぼかし (シェイプ)…
+	Smart Blur…	ぼかし (詳細)…
+	Surface Blur…	ぼかし (表面)…
 	Average	平均
 	Displace…	置き換え…
-	Pinch…	つまみ…
+	Pinch…	つまむ…
 	Polar Coordinates…	極座標…
 	Ripple…	波紋…
 	Shear…	シアー…
@@ -554,7 +583,7 @@
 	Add Noise…	ノイズを加える…
 	Despeckle	ダスト除去
 	Dust & Scratches…	ダスト&スクラッチ…
-	Median…	メディアン…
+	Median…	明るさの中間値…
 	Reduce Noise…	ノイズを軽減…
 	Pixelate	ピクセレート
 	Color Halftone…	カラーハーフトーン…
@@ -563,10 +592,10 @@
 	Fragment	フラグメント
 	Mezzotint…	メゾティント…
 	Mosaic…	モザイク…
-	Pointillize…	ポインティリスト…
+	Pointillize…	点描…
 	Render	描画
 	Clouds	雲模様
-	Difference Clouds	雲模様(差の絶対値)
+	Difference Clouds	雲模様 (差の絶対値)
 	Fibers…	繊維…
 	Flame…	炎…
 	Lens Flare…	レンズフレア…
@@ -576,7 +605,7 @@
 	Tree…	木…
 	Sharpen	シャープ
 	Sharpen Edges	輪郭のみシャープ
-	Sharpen More	シャープ(強)
+	Sharpen More	シャープ (強)
 	Smart Sharpen…	スマートシャープ…
 	Unsharp Mask…	アンシャープマスク…
 	High Pass…	ハイパス…
@@ -686,11 +715,11 @@
 	Tile	並べて表示
 	Tile All Horizontally	すべてを横に並べる
 	Tile All Vertically	すべてを縦に並べる
-	2-up Horizontal	2 アップ(横)
-	2-up Vertical	2 アップ(縦)
-	3-up Horizontal	3 アップ(横)
-	3-up Stacked	3 アップ(積み重ね)
-	3-up Vertical	3 アップ(縦)
+	2-up Horizontal	2 アップ (横)
+	2-up Vertical	2 アップ (縦)
+	3-up Horizontal	3 アップ (横)
+	3-up Stacked	3 アップ (積み重ね)
+	3-up Vertical	3 アップ (縦)
 	4-up	4 アップ
 	6-up	6 アップ
 	Consolidate All to Tabs	すべてをタブに統合
@@ -711,13 +740,13 @@
 	Lock Workspace	ワークスペースをロック
 	Theme	テーマ
 	Pro Theme	プロテーマ
-	Pro Medium Gray Theme	プロ(中間グレー)テーマ
-	Pro Light Gray Theme	プロ(ライトグレー)テーマ
-	Pro Light Theme	プロ(ライト)テーマ
+	Pro Medium Gray Theme	プロ (中間グレー) テーマ
+	Pro Light Gray Theme	プロ (ライトグレー) テーマ
+	Pro Light Theme	プロ (ライト) テーマ
 	Studio Theme	スタジオテーマ
-	Studio Light Theme	スタジオ(ライト)テーマ
-	Adwaita Light Theme	Adwaita(ライト)テーマ
-	Adwaita Dark Theme	Adwaita(ダーク)テーマ
+	Studio Light Theme	スタジオ (ライト) テーマ
+	Adwaita Light Theme	Adwaita (ライト) テーマ
+	Adwaita Dark Theme	Adwaita (ダーク) テーマ
 	Classic Theme	クラシックテーマ
 	Solarized dark	Solarized ダーク
 	Solarized Dark Theme	Solarized ダークテーマ
@@ -725,6 +754,10 @@
 	Breeze Dark Theme	Breeze ダークテーマ
 	Breeze light	Breeze ライト
 	Breeze Light Theme	Breeze ライトテーマ
+	Soft dark	ソフトダーク
+	Soft light	ソフトライト
+	Soft Dark Theme	ソフトダークテーマ
+	Soft Light Theme	ソフトライトテーマ
 	Next Theme	次のテーマ
 	Actions	アクション
 	Brush Settings	ブラシ設定
@@ -824,8 +857,11 @@
 	Answer the unsaved-changes prompt first	先に未保存の変更の確認に答えてください
 	Anti-alias	アンチエイリアス
 	Appearance	外観
-	Appearance (Layer Style)	外観(レイヤースタイル)
+	Appearance (Layer Style)	外観 (レイヤースタイル)
 	Apply Layer Mask	レイヤーマスクを適用
+	Add Mask to Selection	マスクを選択範囲に追加
+	Subtract Mask from Selection	選択範囲からマスクを削除
+	Intersect Mask with Selection	選択範囲とマスクの共通範囲
 	Apply Per Tip	先端ごとに適用
 	Apply next selected layer comp	次のレイヤーカンプを適用
 	Apply previous selected layer comp	前のレイヤーカンプを適用
@@ -841,18 +877,25 @@
 	Background	背景
 	Background Color	背景色
 	Background Contents	背景の内容
+	Custom background color	カスタム背景色
 	Balance	バランス
 	Baseline	ベースライン
 	Baseline shift	ベースラインシフト
 	Basic	基本
 	Before (Y)	補正前(Y)
+	Save Settings…	設定を保存…
+	Load Settings…	設定を読み込み…
+	Save these settings as a Camera Raw .xmp file	この設定を Camera Raw の .xmp ファイルとして保存
+	Load settings from a Camera Raw .xmp file	Camera Raw の .xmp ファイルから設定を読み込む
+	Loaded Camera Raw settings from {file}	{file} から Camera Raw の設定を読み込みました
+	Loaded Camera Raw settings from {file} ({n} not supported)	{file} から Camera Raw の設定を読み込みました（未対応: {n}）
 	Begin recording	記録を開始
 	Bend:	曲げ:
 	Bicubic	バイキュービック
-	Bicubic (smooth gradients)	バイキュービック(滑らかな階調)
+	Bicubic (smooth gradients)	バイキュービック (滑らかな階調)
 	Automatic	自動
-	Bicubic Smoother (enlargement)	バイキュービック法 - 滑らか(拡大)
-	Bicubic Sharper (reduction)	バイキュービック法 - シャープ(縮小)
+	Bicubic Smoother (enlargement)	バイキュービック法 - 滑らか (拡大)
+	Bicubic Sharper (reduction)	バイキュービック法 - シャープ (縮小)
 	Bilinear	バイリニア
 	Black	黒
 	Black & White	白黒
@@ -860,7 +903,7 @@
 	Black, White	黒、白
 	Blacks	ブラック
 	Blending	合成
-	Blending Options	描画オプション
+	Blending Options	レイヤー効果
 	Blue	青
 	Blue, Red, Yellow	青、赤、黄
 	Both Axes	両方の軸
@@ -876,6 +919,7 @@
 	Camera Raw isn't open	Camera Raw は開いていません
 	Cancel	キャンセル
 	Cancel (Esc)	キャンセル(Esc)
+	Manage submitted jobs in the system print queue	送信済みのジョブはシステムの印刷キューで管理してください
 	Cancel any current edits (Esc)	現在の編集をキャンセル(Esc)
 	Cancel current crop operation  (Esc)	現在の切り抜きをキャンセル(Esc)
 	Cancel transform (Esc)	変形をキャンセル(Esc)
@@ -982,7 +1026,7 @@
 	Custom Shapes	カスタムシェイプ
 	Cyan	シアン
 	Cyan  ·  Red	シアン · 赤
-	Darken	比較(暗)
+	Darken	比較 (暗)
 	Darks	暗部
 	Data Sets	データセット
 	Default	既定
@@ -1030,7 +1074,7 @@
 	Diamond Gradient	ダイヤモンド形グラデーション
 	Difference	差の絶対値
 	Diffusion	拡散
-	Discard the embedded profile (don't color manage)	埋め込みプロファイルを破棄(カラーマネジメントしない)
+	Discard the embedded profile (don't color manage)	埋め込みプロファイルを破棄 (カラーマネジメントしない)
 	Discontiguous	不連続
 	Discord	Discord
 	Dismiss	閉じる
@@ -1070,7 +1114,7 @@
 	Exact	正確
 	Expansion:	拡張:
 	Export Presets	プリセットを書き出し
-	Export selected measurements (CSV)	選択した測定値を書き出し(CSV)
+	Export selected measurements (CSV)	選択した測定値を書き出し (CSV)
 	Exposure	露光量
 	Exposure and Gamma	露光量とガンマ
 	Exposure:	露光量:
@@ -1147,7 +1191,10 @@
 	Ignore All	すべて無視
 	Image Size	画像サイズ
 	Import Brushes…	ブラシを読み込み…
-	Import brushes (.abr)	ブラシ(.abr)を読み込み
+	Gradient Preset Options	グラデーションプリセットのオプション
+	Import .GRD	.GRD を読み込み
+	Choose a gradient file (.grd).	グラデーションファイル (.grd) を選択してください。
+	Import brushes (.abr)	ブラシ (.abr) を読み込み
 	Import Presets	プリセットを読み込み
 	Imported	読み込み済み
 	Indent First	先頭行の字下げ
@@ -1160,12 +1207,12 @@
 	Inside	内側
 	Interlaced	インターレース
 	Interpolation:	補間方法:
-	Intersect with selection  ({key})	選択範囲との共通部分({key})
+	Intersect with selection  ({key})	選択範囲との共通部分  ({key})
 	Invert All	すべて反転
 	Invert has no settings.	階調の反転には設定がありません。
 	Italic	イタリック
 	Join us on Discord	Discord に参加
-	Justify all	均等配置(最終行も)
+	Justify all	均等配置 (最終行も)
 	Justify last centered	最終行中央揃えの両端揃え
 	Justify last left	最終行左揃えの両端揃え
 	Justify last right	最終行右揃えの両端揃え
@@ -1175,18 +1222,18 @@
 	Kind	種類
 	Label Size	ラベルのサイズ
 	Labels	ラベル
-	Lanczos (sharp)	ランチョス(シャープ)
+	Lanczos (sharp)	ランチョス (シャープ)
 	Landscape	横向き
 	Last Document State	ドキュメントの最後の状態
 	Layout	レイアウト
 	Leading	行送り
-	Leading (set to the font size × auto-leading when Auto)	行送り(自動のときはフォントサイズ × 自動行送り)
-	Leave as is (don't color manage)	そのまま(カラーマネジメントしない)
+	Leading (set to the font size × auto-leading when Auto)	行送り (自動のときはフォントサイズ × 自動行送り)
+	Leave as is (don't color manage)	そのまま (カラーマネジメントしない)
 	Left align text	左揃え
 	Length:	長さ:
 	Level	レベル
 	Levels	レベル補正
-	Lighten	比較(明)
+	Lighten	比較 (明)
 	Lightness	明度
 	Lights	ライト
 	Limits:	制限:
@@ -1240,7 +1287,7 @@
 	Name	名前
 	Name:	名前:
 	Nearest Neighbor	ニアレストネイバー
-	Nearest Neighbor (hard edges)	ニアレストネイバー(ハードエッジ)
+	Nearest Neighbor (hard edges)	ニアレストネイバー (ハードエッジ)
 	New Size	新しいサイズ
 	New document…	新規ドキュメント…
 	New effect layer	新規効果レイヤー
@@ -1390,7 +1437,7 @@
 	Resolution:	解像度:
 	Restore All	すべて復元
 	Restore Defaults	既定に戻す
-	Restrictive (Web)	制限(Web)
+	Restrictive (Web)	制限 (Web)
 	Right align text	右揃え
 	Rigid	剛体
 	Rotate:	回転:
@@ -1456,7 +1503,7 @@
 	Size:	サイズ:
 	Slice Options…	スライスオプション…
 	Slices From Guides	ガイドからスライス
-	Slices are locked (View › Lock Slices)	スライスはロックされています(表示 › スライスをロック)
+	Slices are locked (View › Lock Slices)	スライスはロックされています (表示 › スライスをロック)
 	Small Caps	スモールキャップ
 	Smoothing	スムージング
 	Space After	後ろのスペース
@@ -1470,7 +1517,7 @@
 	Straighten Layer	レイヤーの角度補正
 	Strength:	強さ:
 	Strikethrough	取り消し線
-	Stroke	線
+	Stroke	境界線
 	Stroke Catch-up	ストロークの追従
 	Stroke:	線:
 	Location:	位置:
@@ -1479,7 +1526,7 @@
 	Style Options…	スタイルオプション…
 	Style: Normal	スタイル: 通常
 	Subtract from Sample	サンプルから削除
-	Subtract from selection  ({key})	選択範囲から削除({key})
+	Subtract from selection  ({key})	選択範囲から削除 ({key})
 	Suggestions:	候補:
 	Swap colours (X)	描画色と背景色を入れ替え(X)
 	Swaps height and width	高さと幅を入れ替えます
@@ -1492,7 +1539,7 @@
 	Texture Each Tip	先端ごとにテクスチャ
 	Threshold	しきい値
 	Threshold Level	しきい値レベル
-	Thumbnail size (smallest: list)	サムネールのサイズ(最小: リスト)
+	Thumbnail size (smallest: list)	サムネールのサイズ (最小: リスト)
 	Tilt X	傾き X
 	Tilt Y	傾き Y
 	Tint	色かぶり補正
@@ -1505,7 +1552,7 @@
 	Top	上
 	Total:	合計:
 	Tracking	トラッキング
-	Tracking (1/1000 em)	トラッキング(1/1000 em)
+	Tracking (1/1000 em)	トラッキング (1/1000 em)
 	Transparency	透明
 	Transparent	透明
 	Trilinear	トライリニア
@@ -1514,11 +1561,11 @@
 	Underline	下線
 	Untitled	名称未設定
 	Untitled-1	名称未設定-1
-	Update layer comp (visibility, position and appearance)	レイヤーカンプを更新(表示状態・位置・外観)
+	Update layer comp (visibility, position and appearance)	レイヤーカンプを更新 (表示状態・位置・外観)
 	Use Default	既定を使用
 	Use Legacy	従来方式を使用
 	Use Measurement Scale	測定スケールを使用
-	Use the embedded profile (instead of the working space)	埋め込みプロファイルを使用(作業用スペースの代わり)
+	Use the embedded profile (instead of the working space)	埋め込みプロファイルを使用 (作業用スペースの代わり)
 	Variables bind a layer's visibility, text or pixels to a named data slot.	変数は、レイヤーの表示状態・テキスト・ピクセルを、名前付きのデータ枠に結び付けます。
 	Vertical scale	垂直比率
 	Vibrance	自然な彩度
@@ -1553,8 +1600,8 @@
 	↑↓ navigate   {key} run   esc close	↑↓ 移動   {key} 実行   esc 閉じる
 	Version {version}	バージョン {version}
 	New Document	新規ドキュメント
-	New Document With Mask	新規ドキュメント（マスク付き）
-	New Layer With Mask	新規レイヤー（マスク付き）
+	New Document With Mask	新規ドキュメント (マスク付き)
+	New Layer With Mask	新規レイヤー (マスク付き)
 	Saved	保存済み
 	Save Preset…	プリセットを保存…
 	Preset Name	プリセット名
@@ -1658,8 +1705,8 @@
 	Indexed	インデックス
 	Initial Direction	初期の方向
 	Inner Bevel	内側ベベル
-	Inner Glow	光彩(内側)
-	Inner Shadow	シャドウ(内側)
+	Inner Glow	光彩 (内側)
+	Inner Shadow	シャドウ (内側)
 	Lab	Lab
 	Landscape, 10 x 8	横向き、10 x 8
 	Landscape, 6 x 4	横向き、6 x 4
@@ -1673,12 +1720,12 @@
 	Light	ライト
 	Line Tool	直線ツール
 	Linear	線形
-	Linear Burn	焼き込み(リニア)
+	Linear Burn	焼き込み (リニア)
 	Linear Height	線形の高さ
 	Link with Layer	レイヤーとリンク
 	Lorem Ipsum	ダミーテキスト
 	Magentas	マゼンタ系
-	Magic Eraser Tool	背景消しゴム(自動)ツール
+	Magic Eraser Tool	背景消しゴム (自動) ツール
 	Magic Wand Tool	自動選択ツール
 	Marquee	選択
 	Mean:	平均:
@@ -1701,7 +1748,7 @@
 	Original Ratio	元の縦横比
 	Out Of Gamut	色域外
 	Outer Bevel	外側ベベル
-	Outer Glow	光彩(外側)
+	Outer Glow	光彩 (外側)
 	Overlay	オーバーレイ
 	Paint Bucket Tool	塗りつぶしツール
 	Paints from the document's opening state	ドキュメントを開いた時点の状態から描画します
@@ -1730,10 +1777,10 @@
 	PostScript (72 points/inch)	PostScript (72 ポイント/インチ)
 	Postcard	はがき
 	Poster	ポスター
-	Pro (Dark)	プロ(ダーク)
-	Pro (Light)	プロ(ライト)
-	Pro (Light Gray)	プロ(ライトグレー)
-	Pro (Medium Gray)	プロ(中間グレー)
+	Pro (Dark)	プロ (ダーク)
+	Pro (Light)	プロ (ライト)
+	Pro (Light Gray)	プロ (ライトグレー)
+	Pro (Medium Gray)	プロ (中間グレー)
 	Protect Texture	テクスチャを保護
 	Purple	紫
 	Quick Mask	クイックマスク
@@ -1774,8 +1821,8 @@
 	Square, 12 x 12	正方形、12 x 12
 	Square, 5 x 5	正方形、5 x 5
 	Std Dev:	標準偏差:
-	Studio (Dark)	スタジオ(ダーク)
-	Studio (Light)	スタジオ(ライト)
+	Studio (Dark)	スタジオ (ダーク)
+	Studio (Light)	スタジオ (ライト)
 	Stylus Wheel	スタイラスホイール
 	Subtract	減算
 	Tabloid	タブロイド
@@ -1836,9 +1883,9 @@
 	Autosave	自動保存
 	Autosave minutes	自動保存の間隔(分)
 	Beep when done	完了時にビープ音を鳴らす
-	Bicubic automatic	バイキュービック(自動)
-	Bicubic sharper	バイキュービック(シャープ)
-	Bicubic smoother	バイキュービック(滑らか)
+	Bicubic automatic	バイキュービック (自動)
+	Bicubic sharper	バイキュービック (シャープ)
+	Bicubic smoother	バイキュービック (滑らか)
 	Bit depth	ビット深度
 	Brush preview color	ブラシプレビューの色
 	Cache levels	キャッシュレベル
@@ -1855,8 +1902,8 @@
 	Control port	制御ポート
 	Convert to srgb	sRGB に変換
 	Cursors	カーソル
-	Custom dark	カスタム(ダーク)
-	Custom light	カスタム(ライト)
+	Custom dark	カスタム (ダーク)
+	Custom light	カスタム (ライト)
 	Dark	ダーク
 	Dark gray	ダークグレー
 	Dashed lines	破線
@@ -1933,9 +1980,9 @@
 	Preserve details	ディテールを保持
 	Print resolution	印刷解像度
 	Pro	プロ
-	Pro light	プロ(ライト)
-	Pro light gray	プロ(ライトグレー)
-	Pro medium	プロ(中間)
+	Pro light	プロ (ライト)
+	Pro light gray	プロ (ライトグレー)
+	Pro medium	プロ (中間)
 	Pro photo	ProPhoto
 	Quick export format	クイック書き出しの形式
 	Quick export location	クイック書き出しの保存先
@@ -1974,9 +2021,9 @@
 	Srgb	sRGB
 	Standard	標準
 	Studio	スタジオ
-	Studio light	スタジオ(ライト)
+	Studio light	スタジオ (ライト)
 	Adwaita	Adwaita
-	Adwaita dark	Adwaita(ダーク)
+	Adwaita dark	Adwaita (ダーク)
 	Subdivisions	分割数
 	System	システム
 	Text engine	テキストエンジン
@@ -2003,8 +2050,8 @@
 	Pass Through	通過
 	Dissolve	ディザ合成
 	Darker Color	カラー比較(暗)
-	Linear Dodge (Add)	覆い焼き(リニア)- 加算
-	Lighter Color	カラー比較(明)
+	Linear Dodge (Add)	覆い焼き (リニア)- 加算
+	Lighter Color	カラー比較 (明)
 	Soft Light	ソフトライト
 	Hard Light	ハードライト
 	Vivid Light	ビビッドライト
@@ -2025,7 +2072,7 @@
 	Collapse	折りたたむ
 	Collapse All Groups	すべてのグループを折りたたむ
 	Collapse Panel Group	パネルグループを折りたたむ
-	Collapse group  ({key}-click: all groups)	グループを折りたたむ({key}+クリック: すべてのグループ)
+	Collapse group  ({key}-click: all groups)	グループを折りたたむ ({key}+クリック: すべてのグループ)
 	Create new brush from the current settings	現在の設定から新規ブラシを作成
 	Create new brush from these settings	この設定から新規ブラシを作成
 	Delete brush	ブラシを削除
@@ -2033,9 +2080,9 @@
 	Drag the arrow to set the angle, the dots to set the roundness	矢印をドラッグして角度、点をドラッグして真円率を設定
 	Expand	展開
 	Expand Panel Group	パネルグループを展開
-	Expand group  ({key}-click: all groups)	グループを展開({key}+クリック: すべてのグループ)
+	Expand group  ({key}-click: all groups)	グループを展開 ({key}+クリック: すべてのグループ)
 	Fade steps	フェードのステップ数
-	Hide the layer's effects  ({key}-click: all layers)	レイヤーの効果を隠す({key}+クリック: すべてのレイヤー)
+	Hide the layer's effects  ({key}-click: all layers)	レイヤーの効果を隠す ({key}+クリック: すべてのレイヤー)
 	Import Brushes… (.abr)	ブラシを読み込み…(.abr)
 	Move Group Down	グループを下へ移動
 	Move Group Up	グループを上へ移動
@@ -2043,7 +2090,7 @@
 	Restore original size	元のサイズに戻す
 	Roundness:	真円率:
 	Search Brushes	ブラシを検索
-	Show the layer's effects  ({key}-click: all layers)	レイヤーの効果を表示({key}+クリック: すべてのレイヤー)
+	Show the layer's effects  ({key}-click: all layers)	レイヤーの効果を表示 ({key}+クリック: すべてのレイヤー)
 	Brush picker	ブラシピッカー
 	Erase	消去
 	Right click with painting tools	描画ツールで右クリック
@@ -2060,8 +2107,8 @@
 	Click to sample the foreground colour  ·  {key}-click for background	クリックで描画色を取得 · {key}+クリックで背景色を取得
 	{key}-click to set the source	{key}+クリックでソースを設定
 	{key} to subtract	{key} で削除
-	Clone source {n} ({key}-click with Clone Stamp to set)	コピーソース {n}({key}+クリックでコピースタンプのソースを設定)
-	Source: not set ({key}-click with Clone Stamp)	ソース: 未設定({key}+クリックでコピースタンプ)
+	Clone source {n} ({key}-click with Clone Stamp to set)	コピーソース {n} ({key}+クリックでコピースタンプのソースを設定)
+	Source: not set ({key}-click with Clone Stamp)	ソース: 未設定 ({key}+クリックでコピースタンプ)
 	Pixel Layer	ピクセルレイヤー
 	Type Layer	文字レイヤー
 	Shape Layer	シェイプレイヤー
@@ -2083,6 +2130,11 @@
 	Rename Brush…	ブラシの名前を変更…
 	Delete Brush	ブラシを削除
 	New Brush Preset…	新規ブラシプリセット…
+	Capture Brush Size in Preset	ブラシサイズをプリセットに保存
+	Include Tool Settings	ツール設定を含める
+	Include Color	カラーを含める
+	Enter a name for the brush preset	ブラシプリセットの名前を入力してください
+	A brush preset with this name already exists	この名前のブラシプリセットは既に存在します
 	Brush Preset Options	ブラシプリセットのオプション
 	Group name	グループ名
 	Brush name	ブラシ名
@@ -2128,7 +2180,7 @@
 	Create new path	新規パスを作成
 	Delete path	パスを削除
 	Delete vector mask	ベクトルマスクを削除
-	CPU (no GPU acceleration)	CPU(GPU アクセラレーションなし)
+	CPU (no GPU acceleration)	CPU (GPU アクセラレーションなし)
 	DirectX 12	DirectX 12
 	GPU backend	GPU バックエンド
 	Linux display server	Linux ディスプレイサーバー
@@ -2140,6 +2192,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	選択範囲を作成するパスがありません。ペンツールで描くか、パスパネルでパスを選択してください。
 	Cancel opening	開くのをキャンセル
 	Cancelled opening {name}	{name} を開くのをキャンセルしました
+	The document “{name}” does not have an embedded {mode} profile.	ドキュメント「{name}」には埋め込み {mode} プロファイルがありません。
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	ドキュメント「{name}」の埋め込みカラープロファイルは、現在の {mode} 作業用スペースと一致しません。
+	Embedded: {embedded}	埋め込み: {embedded}
+	Working: {working}	作業用スペース: {working}
 	Developing {name}	{name} を現像中
 	Cancelled {label}	{label} をキャンセルしました
 	Esc to cancel	Esc キーでキャンセル
@@ -2163,17 +2219,17 @@
 	Automatic (recommended)	自動（推奨）
 	CPU / Compatibility	CPU / 互換性
 	Automatic uses GPU acceleration when available and falls back to CPU rendering on errors.	自動モードは利用可能な場合にGPUを使用し、エラー時はCPU描画に切り替えます。
-	Switched to CPU rendering	CPU描画に切り替えました
-	GPU acceleration could not continue. Your documents are unchanged.	GPUアクセラレーションを継続できませんでした。ドキュメントは変更されていません。
-	PhotoCraft is using the CPU image compositor. The window may still use your graphics adapter.	PhotoCraftはCPUで画像を合成しています。ウィンドウは引き続きグラフィックスアダプターを使用する場合があります。
-	Retry GPU requires a restart. Save your work first.	GPUの再試行には再起動が必要です。先に作業を保存してください。
-	Keep Using CPU	CPUを使い続ける
-	Retry GPU	GPUを再試行
+	Switched to CPU rendering	CPU 描画に切り替えました
+	GPU acceleration could not continue. Your documents are unchanged.	GPU アクセラレーションを継続できませんでした。ドキュメントは変更されていません。
+	PhotoCraft is using the CPU image compositor. The window may still use your graphics adapter.	PhotoCraft は CPU で画像を合成しています。ウィンドウは引き続きグラフィックスアダプターを使用する場合があります。
+	Retry GPU requires a restart. Save your work first.	GPU の再試行には再起動が必要です。先に作業を保存してください。
+	Keep Using CPU	CPU を使い続ける
+	Retry GPU	GPU を再試行
 	Advanced	詳細設定
-	GPU Backend	GPUバックエンド
+	GPU Backend	GPU バックエンド
 	Details	詳細
 	Rendering mode	レンダリングモード
-	Freeze Lasso: drag to freeze an area, Alt-drag to thaw it (L)	フリーズなげなわ：ドラッグで範囲をフリーズ、Alt+ドラッグで解凍 (L)
+	Freeze Lasso: drag to freeze an area, Alt-drag to thaw it (L)	投げ縄でマスク操作: ドラッグで範囲をマスク、Alt+ドラッグで消去 (L)
 	Shadow Clipping Warning (U)	シャドウのクリッピング警告 (U)
 	Highlight Clipping Warning (O)	ハイライトのクリッピング警告 (O)
 	Show Lab Color Readouts	Lab カラー値を表示
@@ -2282,11 +2338,11 @@ cameraRaw	Color	カラー
 	Apply At Canvas Bounds	カンバスの境界に効果を適用
 
 # Shared screen eyedropper and text Color Picker (#1128).
-	Color Picker (Text Color)	カラーピッカー（文字色）
+	Color Picker (Text Color)	カラーピッカー (文字色)
 	Color Picker ({name})	カラーピッカー（{name}）
-	Color Picker (Fill Color)	カラーピッカー（塗りつぶしカラー）
+	Color Picker (Fill Color)	カラーピッカー (塗りつぶしカラー)
 	Fill color	塗りつぶしカラー
-	Color Picker (Stroke Color)	カラーピッカー（線のカラー）
+	Color Picker (Stroke Color)	カラーピッカー (線のカラー)
 	Stroke color	線のカラー
 	Pick screen color	画面の色を選択
 	Sample a pixel anywhere on the screen	画面上の任意のピクセルから色を取得
@@ -2305,7 +2361,7 @@ cameraRaw	Color	カラー
 	Color…	カラー…
 	50% Gray	50% グレー
 	Color Adaptation	カラー適応
-	{size} (was {old})	{size}(変更前 {old})
+	{size} (was {old})	{size} (変更前 {old})
 	Cone	円錐
 	Cone (Inverted)	円錐 (反転)
 	Domed	ドーム
@@ -2348,11 +2404,12 @@ cameraRaw	Color	カラー
 	Fuchsia	フクシア
 	Violet	紫
 	Reset	初期化
-	Large document: redrawing on the CPU	大きなドキュメント：CPUで再描画しています
-	This redraw took {seconds} s on the CPU.	この再描画はCPUで{seconds}秒かかりました。
+	Large document: redrawing on the CPU	大きなドキュメント: CPU で再描画しています
+	Redrawing	再描画中
+	This redraw took {seconds} s on the CPU.	この再描画は CPU で {seconds} 秒かかりました。
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	レイヤーの描画モード、不透明度、表示/非表示など、ドキュメント全体に関わる編集では全体が再描画されます。
-	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	レイヤーがGPUメモリの予算に収まりません。環境設定 › パフォーマンスのメモリ使用量を増やすと、このコンピューターのメモリの4分の1まで予算が増えます。
-	The GPU compositor wasn't used: {reason}	GPUコンポジターは使用されませんでした：{reason}
+	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	レイヤーが GPU メモリの予算に収まりません。環境設定 › パフォーマンスのメモリ使用量を増やすと、このコンピューターのメモリの4分の1まで予算が増えます。
+	The GPU compositor wasn't used: {reason}	GPU コンポジターは使用されませんでした: {reason}
 fontWeight	Thin	極細
 fontWeight	ExtraLight	特細
 fontWeight	Light	細字
@@ -2387,13 +2444,13 @@ fontWeight	Italic	斜体
 	51 by 51 Average	51 × 51 平均
 	101 by 101 Average	101 × 101 平均
 	Sample Size:	サンプルサイズ:
-	All Layers No Adjustments	すべてのレイヤー（色調補正なし）
-	Current & Below No Adjustments	現在のレイヤーとその下（色調補正なし）
+	All Layers No Adjustments	すべてのレイヤー (色調補正なし)
+	Current & Below No Adjustments	現在のレイヤーとその下 (色調補正なし)
 	Show Sampling Ring	サンプリングリングを表示
 
 # Color Picker warnings
-	Out of gamut for printing: click for the nearest printable colour	印刷の色域外：クリックすると最も近い印刷可能な色になります
-	Not a web colour: click for the nearest web colour	Web カラーではありません：クリックすると最も近い Web カラーになります
+	Out of gamut for printing: click for the nearest printable colour	印刷の色域外: クリックすると最も近い印刷可能な色になります
+	Not a web colour: click for the nearest web colour	Web カラーではありません: クリックすると最も近い Web カラーになります
 
 # Generated labels: filter/gallery parameter names, option choices and gallery names (camelCase keys shown as words) (added 2026-10, checked against the code)
 	Accented Edges	輪郭の強調
@@ -2777,7 +2834,7 @@ fontWeight	Italic	斜体
 	Auto-Align Layers	レイヤーを自動整列
 	Auto-Blend Layers	レイヤーを自動合成
 	Bold Italic	太字斜体
-	Box Blur	ぼかし(ボックス)
+	Box Blur	ぼかし (ボックス)
 	Bulge	膨らみ
 	Burn	焼き込み
 	Camera Raw Filter	Camera Raw フィルター
@@ -2824,7 +2881,7 @@ fontWeight	Italic	斜体
 	Fish	魚形
 	Flag	旗
 	Focus Area	焦点領域
-	Gaussian Blur	ぼかし(ガウス)
+	Gaussian Blur	ぼかし (ガウス)
 	Global Light	グローバル光源
 	Gray Value (Maximum)	グレー値 (最大)
 	Gray Value (Mean)	グレー値 (平均)
@@ -2844,7 +2901,7 @@ fontWeight	Italic	斜体
 	Label	ラベル
 	Layer Comp	レイヤーカンプ
 	Layer From Background	背景からレイヤーへ
-	Lens Blur	ぼかし(レンズ)
+	Lens Blur	ぼかし (レンズ)
 	Lens Correction	レンズ補正
 	Lens Flare	レンズフレア
 	Lighting Effects	照明効果
@@ -2872,11 +2929,11 @@ fontWeight	Italic	斜体
 	Pencil Tool	鉛筆ツール
 	Perimeter	周囲長
 	Photomerge	写真を貼り合わせ
-	Pinch	つまみ
+	Pinch	つまむ
 	Place Embedded	埋め込みで配置
 	Place Linked	リンクで配置
 	Place Scale Marker	スケールマーカーを配置
-	Pointillize	ポインティリスト
+	Pointillize	点描
 	Polar Coordinates	極座標
 	Preserve Transparency	透明部分を保持
 	Preset Manager	プリセットマネージャー
@@ -2884,7 +2941,7 @@ fontWeight	Italic	斜体
 	Punctuation	句読点
 	Quick Selection	クイック選択
 	RGB	RGB
-	Radial Blur	ぼかし(円形)
+	Radial Blur	ぼかし (円形)
 	Reading	読み取り
 	Recovery	リカバリー
 	Rectangle	長方形
@@ -2897,7 +2954,7 @@ fontWeight	Italic	斜体
 	Ripple	波紋
 	Rise	上昇
 	Ruler	定規
-	Save for Web (Legacy)	Web 用に保存(従来方式)
+	Save for Web (Legacy)	Web 用に保存 (従来方式)
 	Scale Effects	効果を拡大・縮小
 	Scale Factor	拡大・縮小の倍率
 	Scale Units	スケール単位
@@ -2906,19 +2963,19 @@ fontWeight	Italic	斜体
 	Sepia	セピア
 	Set Measurement Scale	測定スケールを設定
 	Shadows/Highlights	シャドウ・ハイライト
-	Shape Blur	ぼかし(シェイプ)
+	Shape Blur	ぼかし (シェイプ)
 	Shear	シアー
 	Shell Lower	シェル (下)
 	Shell Upper	シェル (上)
 	Slice Options	スライスオプション
-	Smart Blur	ぼかし(詳細)
+	Smart Blur	ぼかし (詳細)
 	Smart Sharpen	スマートシャープ
 	Software	ソフトウェア
 	Spherize	球面
 	Spin Blur	回転ぼかし
 	Squeeze	絞り込み
 	Stroke Path	パスのストローク
-	Surface Blur	ぼかし(表面)
+	Surface Blur	ぼかし (表面)
 	Symbols	記号
 	Tiles	タイル
 	Tilt-Shift	チルトシフト
@@ -3256,7 +3313,6 @@ fontWeight	Italic	斜体
 	Exposure Program	露出プログラム
 	Extra Bold	エクストラボールド
 	Extra Light	エクストラライト
-	File Naming	ファイル名の付け方
 	Fill Light	フィルライト
 	First Color Readout	最初のカラー読み取り
 	Flash	フラッシュ
@@ -3458,9 +3514,9 @@ fontWeight	Italic	斜体
 	Alt-click went to the desktop, which moves windows with Alt-drag. Set its window-move key to Super, or latch Alt in Window › Modifier Keys.	Alt+クリックはデスクトップに取られました（Alt+ドラッグでウィンドウを移動する設定です）。デスクトップのウィンドウ移動キーを Super に変更するか、ウィンドウ › 修飾キーで Alt を固定してください。
 
 # Shared Layer Style color picker
-	Color Picker (Layer Style Color)	カラーピッカー（レイヤースタイルの色）
+	Color Picker (Layer Style Color)	カラーピッカー (レイヤースタイルの色)
 	Auto Hide Notifications	通知を自動的に隠す
-	Notification Duration (seconds)	通知の表示時間（秒）
+	Notification Duration (seconds)	通知の表示時間 (秒)
 	Appearance Mode	外観モード
 	Dark Theme	ダークテーマ
 	Light Theme	ライトテーマ
@@ -3469,7 +3525,7 @@ fontWeight	Italic	斜体
 	Next Appearance Mode	次の外観モード
 	Sync with system	システムと同期
 	Active	適用中
-	Color Picker (Solid Color)	カラーピッカー（べた塗り）
+	Color Picker (Solid Color)	カラーピッカー (べた塗り)
 	Straighten the image by drawing a line on it	画像上に線を描いて角度を補正
 	Set additional Crop options	切り抜きの追加オプションを設定
 	Show Cropped Area	切り抜かれた領域を表示
@@ -3477,7 +3533,7 @@ fontWeight	Italic	斜体
 	Match Canvas	カンバスに合わせる
 	Auto Adjust Opacity	不透明度を自動調整
 	Crop Shield color	切り抜きシールドのカラー
-	Color Picker (Crop Shield Color)	カラーピッカー（切り抜きシールドのカラー）
+	Color Picker (Crop Shield Color)	カラーピッカー (切り抜きシールドのカラー)
 	From Center	中心から
 	Link radii	半径をリンク
 	Star Ratio:	星の比率:
@@ -3489,7 +3545,7 @@ fontWeight	Italic	斜体
 	Click to add a point, right-click to remove	クリックでポイントを追加、右クリックで削除
 	Some brush presets could not be loaded	一部のブラシプリセットを読み込めませんでした
 	Retry saving presets	プリセットの保存を再試行
-	Brush preset changes are not saved: {error}	ブラシプリセットの変更は保存されていません：{error}
+	Brush preset changes are not saved: {error}	ブラシプリセットの変更は保存されていません: {error}
 	Keep this tab open to retain your brushes.	ブラシを保持するには、このタブを開いたままにしてください。
 	Browser storage is unavailable; brushes are session-only. Keep this tab open to retain them.	ブラウザーのストレージを利用できないため、ブラシはこのセッション中のみ有効です。保持するには、このタブを開いたままにしてください。
 	Saving brush presets… Keep this tab open until saving finishes.	ブラシプリセットを保存中… 保存が完了するまでこのタブを開いたままにしてください。
@@ -3524,7 +3580,7 @@ fontWeight	Italic	斜体
 	No subject found — try a rectangle around the object	被写体が見つかりません — オブジェクトを囲む長方形を試してください
 	Click the first point or press {key} to close · {del} removes a point · Esc cancels	最初の点をクリックするか {key} を押して閉じる · {del} で点を削除 · Esc でキャンセル
 	Click, then move along an edge · click to fasten a point · {alt}-click for a straight segment · double-click to close	クリックしてエッジに沿って動かす · クリックで固定ポイント · {alt}-クリックで直線セグメント · ダブルクリックで閉じる
-	Follows only edges this close to the pointer ([ and ] change it)	ポインターからこの距離内のエッジだけをたどる（[ と ] で変更）
+	Follows only edges this close to the pointer ([ and ] change it)	ポインターからこの距離内のエッジだけをたどる ([ と ] で変更)
 	Higher values follow only edges that contrast sharply with their surroundings	値を大きくすると、周囲とのコントラストが強いエッジだけをたどる
 	How often fastening points are placed by themselves	固定ポイントが自動で置かれる頻度
 	Appearance Settings…	外観設定…
@@ -3600,10 +3656,10 @@ curves	Smooth	スムーズ
 	Smooth the curve values	カーブの値を滑らかにする
 	Drag to draw the curve · {key}-click draws a straight line	ドラッグしてカーブを描画 · {key}+クリックで直線を描画
 	Grid Size:	グリッドサイズ:
-	Vanishing Point: click four corners to create a plane	消点：4 つの角をクリックして面を作成します
+	Vanishing Point: click four corners to create a plane	消点: 4 つの角をクリックして面を作成します
 	Vanishing Point is not active	消点はアクティブではありません
 	Apply Vanishing Point ({key})	消点を適用({key})
-	Fix the red plane first: its corners must form a convex quad	先に赤い面を修正してください：角が凸四角形になる必要があります
+	Fix the red plane first: its corners must form a convex quad	先に赤い面を修正してください: 角が凸四角形になる必要があります
 # Select and Mask view modes (#1754)
 	Onion Skin	オニオンスキン
 	Marching Ants	点線の境界
@@ -3620,6 +3676,7 @@ curves	Smooth	スムーズ
 	Paint over hair or fur on the image; Alt paints the other mode	画像の髪や毛の上をペイントします。Alt で反対のモードでペイント
 	Clear Brush Strokes	ブラシストロークを消去
 	Show rulers	定規を表示
+	Presentation	プレゼンテーション
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	クリックで配置 · Alt キーを押しながらクリック、またはカンバス外へドラッグで削除
@@ -3650,10 +3707,111 @@ curves	Smooth	スムーズ
 @plural	{n} sample point removed|{n} sample points removed	サンプルポイント {n} 個を削除しました
 @plural	{n} slice|{n} slices	{n} 個のスライス
 @plural	{n} step|{n} steps	{n} ステップ
-@plural	{warning} (+{n} more brush preset warning)|{warning} (+{n} more brush preset warnings)	{warning}(ほかにブラシプリセットの警告 {n} 件)
-@plural	{what} with {n} warning|{what} with {n} warnings	{what}(警告 {n} 件)
+@plural	{warning} (+{n} more brush preset warning)|{warning} (+{n} more brush preset warnings)	{warning} (ほかにブラシプリセットの警告 {n} 件)
+@plural	{what} with {n} warning|{what} with {n} warnings	{what} (警告 {n} 件)
 # View › Guides › New Guide… › Color
 	Light Blue	ライトブルー
 	Light Red	ライトレッド
 	Medium Blue	ミディアムブルー
 	Light Gray	ライトグレー
+	Object Finder	オブジェクトファインダー
+	No object found there — drag a rectangle around it	そこにオブジェクトが見つかりません — 周囲に矩形をドラッグしてください
+	Remove after each stroke	ストロークごとに削除
+	Apply the removal ({key})	削除を適用 ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	削除するストローク: {n} (Enter で適用、Esc で取り消し)
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	アクションを読み込み…
+	Save Actions…	アクションを保存…
+	{name} (Photoshop)	{name}（Photoshop）
+	{message} ({note})	{message}（{note}）
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{file} からアクション {n} 個を読み込みました
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} 個のステップにはまだ PhotoCraft の対応機能がありません
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{file} にアクション {n} 個を保存しました
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Photoshop に対応するもののない {n} 個のステップを省きました
+
+	File Naming	ファイル名の付け方
+	Starting serial	開始番号
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	ストップを挿入…
+	Save Set…	セットを保存…
+	Message:	メッセージ:
+	Allow Continue	続行を許可
+	Show dialog during playback	再生中にダイアログを表示
+	Select an action first	先にアクションを選択してください
+	Action playback stopped	アクションの再生を停止しました
+	Step {step} is waiting for its dialog	ステップ {step} はダイアログを待っています
+@plural	{n} action|{n} actions	アクション {n} 個
+
+# Liquify tool names (shown via tl!(tool.label()) in the UI, so they are not found by the static scan)
+	Forward Warp	前方ワープ
+	Twirl Clockwise	時計回りに渦巻き
+	Twirl Counterclockwise	反時計回りに渦巻き
+	Pucker	収縮
+	Bloat	膨張
+	Push Left	ピクセル移動
+	Freeze Mask	ブラシでマスクを描画
+	Thaw Mask	ブラシでマスクを消去
+
+# Panel menu items and section labels passed to tl!() as variables (channels panel, paths panel, layer style)
+	Convert to Alpha Channel	アルファチャンネルに変換
+	Delete Channel	チャンネルを削除
+	Duplicate Channel	チャンネルを複製
+	Exit Quick Mask	クイックマスクを終了
+	Merge Channels…	チャンネルを結合…
+	Merge Spot Channel	スポットチャンネルを結合
+	New Channel…	新規チャンネル…
+	New Spot Channel…	新規スポットチャンネル…
+	Rename Channel…	チャンネル名を変更…
+	Split Channels	チャンネルを分割
+	Save Path	パスを保存
+	General Blending	通常の描画
+
+# Character panel tooltip (shown once the tooltip helpers in type_tool.rs pass their text through tl!)
+	Kerning: Metrics, Optical or a value in 1/1000 em (Alt+←/→ at the caret)	カーニング: メトリクス、オプティカル、または 1/1000 em 単位の値 (キャレット位置で Alt+←/→)
+
+# Glyphs panel "Show" categories (text/src/glyphs.rs; the dropdown passes them through tl!)
+	Basic Latin	基本ラテン文字
+	Latin 1	ラテン 1
+	Latin Extended-A	ラテン拡張 A
+	Latin Extended-B	ラテン拡張 B
+	Greek	ギリシャ文字
+	Cyrillic	キリル文字
+	Numbers	数字
+	Currency	通貨記号
+	Math Symbols	数学記号
+	Arrows	矢印
+
+# Dialog field labels generated from parameter names (Warp Text, Trim, Calculations, Apply Image; not seen by the tl! scanner)
+	Bend	曲げ
+	Horizontal Distortion	水平方向のゆがみ
+	Vertical Distortion	垂直方向のゆがみ
+	Based On	基準
+	Source Channel	ソースのチャンネル
+	Source Invert	ソースを反転
+	Mask Channel	マスクのチャンネル
+	Source1 Channel	ソース 1 のチャンネル
+	Source1 Invert	ソース 1 を反転
+	Source2 Channel	ソース 2 のチャンネル
+	Source2 Invert	ソース 2 を反転
+	R g b	RGB
+
+# Canvas background menu, Blend If labels and Advanced Blending options
+	Dark Gray	ダークグレー
+	Medium Gray	ミディアムグレー
+	Select Custom Color…	カスタムカラーを選択…
+	This Layer:	現在のレイヤー:
+	Underlying Layer:	下のレイヤー:
+	Blend Interior Effects as Group	内部効果をまとめて描画
+	Blend Clipped Layers as Group	クリップされたレイヤーをまとめて描画
+	Transparency Shapes Layer	透明シェイプレイヤー
+	Layer Mask Hides Effects	レイヤーマスクで効果を隠す
+	Vector Mask Hides Effects	ベクトルマスクで効果を隠す
+	Auto Add/Delete	自動追加・削除
+
+# Restored rows (custom print paper #3820, brush presets, Vanishing Point help, brush panel menu)
+	Drag to pan · Scroll to zoom · Double-click to fit	ドラッグで移動 · スクロールでズーム · ダブルクリックで全体表示
+	Clear Brush Controls	ブラシのコントロールを消去
+	Reset All Locked Settings	ロックされた設定をすべて初期化
+	Copy Texture to Other Tools	テクスチャを他のツールにコピー
+	ICO is limited to 256 × 256 pixels	ICO は 256 × 256 ピクセルまでです
diff --git a/crates/ui-egui/src/i18n/ko.tsv b/crates/ui-egui/src/i18n/ko.tsv
index 62495a8d44..eefa162a65 100644
--- a/crates/ui-egui/src/i18n/ko.tsv
+++ b/crates/ui-egui/src/i18n/ko.tsv
@@ -7,7 +7,20 @@
 # Licensed MIT OR Apache-2.0. See LICENSE-translations.txt and ATTRIBUTION.md.
 # Product names and technology names retain their spelling.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	채널 색상
+	Color Indicates:	색상 표시 내용:
+	Solidity:	견고도:
+	Masked Areas	마스크 영역
+	Selected Areas	선택 영역
+	Spot Color	별색
+	Ink Characteristics	잉크 특성
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	용지 너비
+	Paper Height	용지 높이
 	Columns	열
 	Rows	행
 	Number	개수
@@ -60,6 +73,8 @@
 	Save	저장
 	Save As…	다른 이름으로 저장…
 	Save a Copy…	사본 저장…
+	{name} can't keep everything in this document	{name}에는 이 문서의 모든 내용을 저장할 수 없습니다
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Photoshop(PSD)처럼 모든 내용을 유지하는 형식을 선택하거나 사본을 저장하세요.
 	Revert	되돌리기
 	Export	내보내기
 	Quick Export as PNG	PNG로 빠르게 내보내기
@@ -97,6 +112,14 @@
 	Script Events Manager…	스크립트 이벤트 관리자…
 	Import	가져오기
 	Browse…	찾아보기…
+	Source Files	소스 파일
+	Use:	사용:
+	Files	파일
+	Folder	폴더
+	Add Open Files	열린 파일 추가
+	Sort By Name	이름순 정렬
+	Attempt to Automatically Align Source Images	소스 이미지 자동 정렬 시도
+	Create Smart Object after Loading Layers	레이어를 불러온 후 스마트 오브젝트 만들기
 	Reveal in Finder	Finder에서 보기
 	Show in Explorer	파일 탐색기에서 보기
 	Show in Folder	폴더에서 보기
@@ -121,6 +144,8 @@
 	Search…	검색…
 	Check Spelling…	맞춤법 검사…
 	Find and Replace Text…	텍스트 찾기 및 바꾸기…
+	Add to Dictionary	사전에 추가
+	No Spelling Suggestions	맞춤법 제안 없음
 	Fill…	채우기…
 	Stroke…	획…
 	Content-Aware Fill…	내용 인식 채우기…
@@ -135,6 +160,8 @@
 	Transform Again on a Copy	사본에 변형 다시 적용
 	Scale	크기 조절
 	Rotate	회전
+	Set horizontal skew	가로 기울이기 설정
+	Set vertical skew	세로 기울이기 설정
 	Skew	기울이기
 	Distort	왜곡
 	Perspective	원근
@@ -341,6 +368,7 @@
 	Update Modified Content	수정된 내용 업데이트
 	Update All Modified Content	수정된 모든 내용 업데이트
 	Stack Mode	스택 모드
+	Choose Stack Mode:	스택 모드 선택:
 	Entropy	엔트로피
 	Kurtosis	첨도
 	Maximum	최대값
@@ -375,6 +403,7 @@
 	Select Linked Layers	연결된 레이어 선택
 	Merge Layers	레이어 병합
 	Merge Down	아래 레이어와 병합
+	Merge Group	그룹 병합
 	Merge Visible	보이는 레이어 병합
 	Stamp Visible	보이는 레이어의 병합 사본 만들기
 	Select Layer Above	위 레이어 선택
@@ -511,6 +540,9 @@
 	Blur	흐림 효과
 	Blur Gallery	흐림 효과 갤러리
 	Field Blur…	필드 흐림 효과…
+# Field Blur pins (#3373)
+	No pin selected	선택한 핀 없음
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	이미지를 클릭하여 핀을 추가합니다. 핀을 드래그하여 이동하고, 링을 드래그하여 흐림 정도를 바꿉니다. Delete 키로 선택한 핀을 삭제합니다.
 	Iris Blur…	조리개 흐림 효과…
 	Tilt-Shift…	기울기-이동…
 	Path Blur…	패스 흐림 효과…
@@ -699,6 +731,10 @@
 	Breeze Dark Theme	Breeze 어두운 테마
 	Breeze light	Breeze 밝게
 	Breeze Light Theme	Breeze 밝은 테마
+	Soft dark	소프트 다크
+	Soft light	소프트 라이트
+	Soft Dark Theme	소프트 다크 테마
+	Soft Light Theme	소프트 라이트 테마
 	Next Theme	다음 테마
 	Actions	액션
 	Brush Settings	브러시 설정
@@ -798,6 +834,9 @@
 	Appearance	모양새
 	Appearance (Layer Style)	모양새(레이어 스타일)
 	Apply Layer Mask	레이어 마스크 적용
+	Add Mask to Selection	선택 영역에 마스크 추가
+	Subtract Mask from Selection	선택 영역에서 마스크 빼기
+	Intersect Mask with Selection	마스크와 선택 영역 교차
 	Apply Per Tip	끝당 적용
 	Apply next selected layer comp	선택한 다음 레이어 구성 요소 적용
 	Apply previous selected layer comp	선택한 이전 레이어 구성 요소 적용
@@ -813,11 +852,18 @@
 	Background	배경
 	Background Color	배경색
 	Background Contents	배경 내용
+	Custom background color	사용자 정의 배경색
 	Balance	균형
 	Baseline	기준선
 	Baseline shift	기준선 이동
 	Basic	기본
 	Before (Y)	이전 (Y)
+	Save Settings…	설정 저장…
+	Load Settings…	설정 불러오기…
+	Save these settings as a Camera Raw .xmp file	이 설정을 Camera Raw .xmp 파일로 저장
+	Load settings from a Camera Raw .xmp file	Camera Raw .xmp 파일에서 설정 불러오기
+	Loaded Camera Raw settings from {file}	{file}에서 Camera Raw 설정을 불러왔습니다
+	Loaded Camera Raw settings from {file} ({n} not supported)	{file}에서 Camera Raw 설정을 불러왔습니다 (미지원 {n}개)
 	Begin recording	기록 시작
 	Bend:	구부림:
 	Bicubic	쌍입방
@@ -849,6 +895,7 @@
 	Cancel	취소
 	Reset	재설정
 	Cancel (Esc)	취소 (Esc)
+	Manage submitted jobs in the system print queue	제출된 작업은 시스템 인쇄 대기열에서 관리하세요
 	Cancel any current edits (Esc)	현재 편집 취소 (Esc)
 	Cancel current crop operation  (Esc)	현재 자르기 작업 취소  (Esc)
 	Cancel transform (Esc)	변형 취소 (Esc)
@@ -1116,6 +1163,9 @@
 	Ignore All	모두 무시
 	Image Size	이미지 크기
 	Import Brushes…	브러시 가져오기…
+	Gradient Preset Options	그레이디언트 사전 설정 옵션
+	Import .GRD	.GRD 가져오기
+	Choose a gradient file (.grd).	그레이디언트 파일 (.grd)을 선택하세요.
 	Import brushes (.abr)	브러시 가져오기(.abr)
 	Import Presets	사전 설정 가져오기
 	Imported	가져옴
@@ -2040,6 +2090,11 @@
 	Rename Brush…	브러시 이름 바꾸기…
 	Delete Brush	브러시 삭제
 	New Brush Preset…	새 브러시 사전 설정…
+	Capture Brush Size in Preset	사전 설정에 브러시 크기 캡처
+	Include Tool Settings	도구 설정 포함
+	Include Color	색상 포함
+	Enter a name for the brush preset	브러시 사전 설정의 이름을 입력하십시오
+	A brush preset with this name already exists	이 이름의 브러시 사전 설정이 이미 있습니다
 	Brush Preset Options	브러시 사전 설정 옵션
 	Group name	그룹 이름
 	Brush name	브러시 이름
@@ -2098,6 +2153,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	선택 영역으로 만들 패스가 없습니다: 펜 도구로 그리거나 패스 패널에서 선택하세요.
 	Cancel opening	열기 취소
 	Cancelled opening {name}	{name} 열기를 취소했습니다
+	The document “{name}” does not have an embedded {mode} profile.	문서 “{name}”에 포함된 {mode} 프로파일이 없습니다.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	문서 “{name}”에 포함된 색상 프로파일이 현재 {mode} 작업 색상 공간과 일치하지 않습니다.
+	Embedded: {embedded}	포함됨: {embedded}
+	Working: {working}	작업 색상 공간: {working}
 	Developing {name}	{name} 현상 중
 	Cancelled {label}	{label} 작업을 취소했습니다
 	Esc to cancel	Esc 키로 취소
@@ -2906,6 +2965,7 @@ cameraRaw	Color	색상
 	Click to pick · Esc to cancel	클릭하여 선택 · Esc로 취소
 	Pick a screen pixel or press Esc to cancel	화면 픽셀을 선택하거나 Esc를 눌러 취소
 	Scroll to zoom	스크롤하여 확대/축소
+	Drag to pan · Scroll to zoom · Double-click to fit	드래그하여 이동 · 스크롤하여 확대/축소 · 두 번 클릭하여 맞추기
 	Show/Hide All Panels	모든 패널 표시/숨기기
 	Show/Hide Panels	패널 표시/숨기기
 	Could not open	열 수 없음
@@ -2955,6 +3015,7 @@ cameraRaw	Color	색상
 	Indigo	남색
 	Fuchsia	자홍색
 	Large document: redrawing on the CPU	큰 문서: CPU에서 다시 그리는 중
+	Redrawing	다시 그리는 중
 	This redraw took {seconds} s on the CPU.	이번 다시 그리기는 CPU에서 {seconds}초 걸렸습니다.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	레이어의 혼합 모드, 불투명도, 표시 여부처럼 문서 전체를 바꾸는 편집은 문서 전체를 다시 그립니다.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	레이어가 GPU 메모리 예산에 맞지 않습니다. 환경 설정 › 성능에서 메모리 사용량을 늘리면 이 컴퓨터 메모리의 4분의 1까지 예산이 늘어납니다.
@@ -3195,6 +3256,7 @@ curves	Smooth	매끄럽게
 	Paint over hair or fur on the image; Alt paints the other mode	이미지의 머리카락이나 털 위를 칠합니다. Alt는 다른 모드로 칠합니다
 	Clear Brush Strokes	브러시 획 지우기
 	Show rulers	눈금자 표시
+	Presentation	프레젠테이션
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	클릭하여 배치 · Alt-클릭 또는 캔버스 밖으로 드래그하여 제거
@@ -3217,3 +3279,36 @@ curves	Smooth	매끄럽게
 	Light Red	연한 빨강
 	Medium Blue	중간 파랑
 	Light Gray	연한 회색
+	Object Finder	개체 찾기
+	No object found there — drag a rectangle around it	그곳에서 개체를 찾지 못했습니다 — 주위에 사각형을 드래그하세요
+	Remove after each stroke	획마다 제거
+	Apply the removal ({key})	제거 적용 ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	제거할 획: {n} (Enter 적용, Esc 취소)
+	Clear Brush Controls	브러시 제어 지우기
+	Reset All Locked Settings	모든 잠긴 설정 재설정
+	Copy Texture to Other Tools	다른 도구로 텍스처 복사
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	액션 불러오기…
+	Save Actions…	액션 저장…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{file}에서 액션 {n}개를 불러왔습니다
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n}개 단계에는 아직 PhotoCraft에 해당하는 기능이 없습니다
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{file}에 액션 {n}개를 저장했습니다
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Photoshop에 해당하는 기능이 없는 {n}개 단계를 제외했습니다
+
+	File Naming	파일 이름 지정
+	Starting serial	시작 일련번호
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	정지 삽입…
+	Save Set…	세트 저장…
+	Message:	메시지:
+	Allow Continue	계속 허용
+	Show dialog during playback	재생 중 대화 상자 표시
+	Select an action first	먼저 액션을 선택하세요
+	Action playback stopped	액션 재생이 중지되었습니다
+	Step {step} is waiting for its dialog	{step}단계가 대화 상자를 기다리고 있습니다
+@plural	{n} action|{n} actions	액션 {n}개
+	Auto Add/Delete	자동 추가/삭제
+	ICO is limited to 256 × 256 pixels	ICO는 256 × 256픽셀로 제한됩니다
diff --git a/crates/ui-egui/src/i18n/live_tests.rs b/crates/ui-egui/src/i18n/live_tests.rs
index 6dcec32e92..89c47ef1ac 100644
--- a/crates/ui-egui/src/i18n/live_tests.rs
+++ b/crates/ui-egui/src/i18n/live_tests.rs
@@ -20,6 +20,7 @@ fn requested_languages_resolve_regional_preferences() {
         ("fr-CA", "fr"),
         ("id-ID", "id"),
         ("vi-VN", "vi"),
+        ("sr-RS", "sr"),
     ] {
         assert_eq!(Lang::from_pref(tag), lang(code), "{tag}");
     }
@@ -92,7 +93,8 @@ fn dynamic_brush_sections_have_translations_and_draw_in_the_selected_language()
         h.state_mut().ui.panels.brush_settings = true;
         h.run_steps(4);
         let text = drawn_text(&h);
-        assert!(text.iter().filter(|text| text.as_str() == "画笔笔尖形状").count() >= 2, "both the section row and heading must be translated");
+        // The section row is the only place the name is drawn: the options pane has no heading (#3477).
+        assert_eq!(text.iter().filter(|text| text.as_str() == "画笔笔尖形状").count(), 1, "the section row must be translated");
         assert!(!text.iter().any(|text| text == "Brush Tip Shape"));
     });
 }
@@ -387,7 +389,8 @@ fn czech_status_notices_and_navigator_draw_translated_text() {
         });
         h.run_steps(4);
         let text = drawn_text(&h);
-        for want in ["Zvětšení", "Soubor English file.psd se nepodařilo otevřít: disk full", "Předvolby nelze uložit"] {
+        // The Navigator's own text is its tab title now: its zoom row has no label (#4840).
+        for want in ["Navigátor", "Soubor English file.psd se nepodařilo otevřít: disk full", "Předvolby nelze uložit"] {
             assert!(text.iter().any(|text| text == want), "missing {want}: {text:?}");
         }
         // Czech text must be drawable by the bundled fonts, including the new notices.
diff --git a/crates/ui-egui/src/i18n/mod.rs b/crates/ui-egui/src/i18n/mod.rs
index ecf21f46d0..b976e395fc 100644
--- a/crates/ui-egui/src/i18n/mod.rs
+++ b/crates/ui-egui/src/i18n/mod.rs
@@ -39,7 +39,7 @@ pub struct LangInfo {
     /// Catalog file contents, raw-deflated by build.rs (empty for the built-in English); see
     /// [`LangInfo::text`].
     pub source: &'static [u8],
-    /// Plural form index for a count (English: 0 = one, 1 = other; Japanese and Chinese: always 0;
+    /// Plural form index for a count (English: 0 = one, 1 = other; Japanese, Chinese and Hungarian: always 0;
     /// Czech: 0 = one, 1 = few (2–4), 2 = other; French: 0 = one (0 and 1), 1 = other). A catalog's `@plural` entries list one form per
     /// index.
     pub plural: fn(u64) -> usize,
@@ -115,8 +115,8 @@ fn plural_polish(n: u64) -> usize {
     }
 }
 
-/// A catalog file as deflated by build.rs (the binary would otherwise carry ~1.9 MB of
-/// translations, which the web build's size gate can't afford).
+/// A catalog file as packed by build.rs (`pack_catalogs`; the binary would otherwise carry ~2.2 MB
+/// of translations, which the web build's size gate can't afford). See [`unpack`].
 macro_rules! catalog {
     ($code:literal) => {
         include_bytes!(concat!(env!("OUT_DIR"), "/i18n/", $code, ".tsv.deflate"))
@@ -140,8 +140,54 @@ fn inflate(source: &[u8]) -> Result<String, String> {
     Ok(text)
 }
 
+/// Every catalog entry's `context<TAB>source`, stored once for all catalogs (build.rs).
+static KEYS: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/i18n/keys.deflate"));
+
+/// Restore a catalog file from its packed form (build.rs `pack_catalogs`): entry lines refer to
+/// [`KEYS`] instead of repeating the English source. Bad data gives an error (and the language
+/// falls back to English), never a panic.
+fn unpack(source: &[u8]) -> Result<String, String> {
+    static KEY_TEXT: OnceLock<Result<String, String>> = OnceLock::new();
+    if source.is_empty() {
+        return Ok(String::new());
+    }
+    let keys: Vec<&str> = KEY_TEXT.get_or_init(|| inflate(KEYS)).as_ref().map_err(|e| format!("catalog keys: {e}"))?.split('\n').collect();
+    expand(&inflate(source)?, &keys)
+}
+
+/// [`unpack`]'s second step: replace each packed entry line with its key and translation.
+fn expand(packed: &str, keys: &[&str]) -> Result<String, String> {
+    let mut text = String::with_capacity(packed.len().saturating_mul(2));
+    let mut next = 0usize;
+    for (n, line) in packed.split('\n').enumerate() {
+        if n > 0 {
+            text.push('\n');
+        }
+        let bad = || format!("packed line {}: bad key reference", n + 1);
+        let (index, tr) = if let Some(tr) = line.strip_prefix('\x01') {
+            (next, tr)
+        } else if let Some(rest) = line.strip_prefix('\x02') {
+            let (offset, tr) = rest.split_once('\t').ok_or_else(bad)?;
+            let offset: i64 = offset.parse().map_err(|_| bad())?;
+            let index = i64::try_from(next).ok().and_then(|n| n.checked_add(offset)).and_then(|i| usize::try_from(i).ok()).ok_or_else(bad)?;
+            (index, tr)
+        } else {
+            text.push_str(line.strip_prefix('\x03').unwrap_or(line));
+            continue;
+        };
+        text.push_str(keys.get(index).ok_or_else(bad)?);
+        text.push('\t');
+        text.push_str(tr);
+        next = index.saturating_add(1);
+        if text.len() as u64 > MAX_CATALOG_BYTES {
+            return Err(format!("over {MAX_CATALOG_BYTES} bytes"));
+        }
+    }
+    Ok(text)
+}
+
 /// The registry. English first: it is the fallback and the source language.
-pub static LANGUAGES: [LangInfo; 18] = [
+pub static LANGUAGES: [LangInfo; 21] = [
     LangInfo { code: "en", name: "English", source: b"", plural: plural_one_other, complete_menus: false, catalog: OnceLock::new() },
     LangInfo { code: "ja", name: "日本語", source: catalog!("ja"), plural: plural_none, complete_menus: true, catalog: OnceLock::new() },
     LangInfo { code: "zh-hans", name: "简体中文", source: catalog!("zh-hans"), plural: plural_none, complete_menus: true, catalog: OnceLock::new() },
@@ -152,6 +198,10 @@ pub static LANGUAGES: [LangInfo; 18] = [
     LangInfo { code: "ru", name: "Русский", source: catalog!("ru"), plural: plural_russian, complete_menus: true, catalog: OnceLock::new() },
     // Ukrainian has the same one/few/many rule for integer counts.
     LangInfo { code: "uk", name: "Українська", source: catalog!("uk"), plural: plural_russian, complete_menus: true, catalog: OnceLock::new() },
+    // Serbian (Latin script, Ekavian) has the same one/few/many rule for integer counts. `sr-RS`,
+    // `sr-Latn-*` and `sr_RS@latin` resolve here; so do Cyrillic `sr` locales, which read Latin
+    // rather than English.
+    LangInfo { code: "sr", name: "Srpski", source: catalog!("sr"), plural: plural_russian, complete_menus: true, catalog: OnceLock::new() },
     LangInfo { code: "cs", name: "Čeština", source: catalog!("cs"), plural: plural_cs, complete_menus: true, catalog: OnceLock::new() },
     LangInfo { code: "fr", name: "Français", source: catalog!("fr"), plural: plural_fr, complete_menus: true, catalog: OnceLock::new() },
     LangInfo { code: "id", name: "Bahasa Indonesia", source: catalog!("id"), plural: plural_none, complete_menus: true, catalog: OnceLock::new() },
@@ -164,6 +214,10 @@ pub static LANGUAGES: [LangInfo; 18] = [
     // Dutch; `nl-NL` and `nl-BE` locales both resolve here.
     LangInfo { code: "nl", name: "Nederlands", source: catalog!("nl"), plural: plural_one_other, complete_menus: true, catalog: OnceLock::new() },
     LangInfo { code: "it", name: "Italiano", source: catalog!("it"), plural: plural_one_other, complete_menus: true, catalog: OnceLock::new() },
+    // Hungarian: a count takes the singular noun ("3 réteg"), so one plural form.
+    LangInfo { code: "hu", name: "Magyar", source: catalog!("hu"), plural: plural_none, complete_menus: true, catalog: OnceLock::new() },
+    // Turkish; `tr`, `tr-TR` and `tr_TR` locales resolve here.
+    LangInfo { code: "tr", name: "Türkçe", source: catalog!("tr"), plural: plural_none, complete_menus: true, catalog: OnceLock::new() },
     // Vietnamese; `vi-VN` resolves here.
     LangInfo { code: "vi", name: "Tiếng Việt", source: catalog!("vi"), plural: plural_none, complete_menus: true, catalog: OnceLock::new() },
 ];
@@ -171,7 +225,7 @@ pub static LANGUAGES: [LangInfo; 18] = [
 impl LangInfo {
     /// The catalog file's text (empty for English, or if the bundled data can't be inflated).
     pub fn text(&self) -> String {
-        inflate(self.source).unwrap_or_else(|e| {
+        unpack(self.source).unwrap_or_else(|e| {
             log::error!("translation catalog {}: {e}; showing English", self.code);
             String::new()
         })
@@ -418,6 +472,11 @@ mod tests {
         assert_eq!(lang_from_tag("it-CH"), Lang::from_code("it"));
         assert_eq!(lang_from_tag("nl_NL.UTF-8"), Lang::from_code("nl"));
         assert_eq!(lang_from_tag("nl-BE"), Lang::from_code("nl"));
+        assert_eq!(lang_from_tag("hu_HU.UTF-8"), Lang::from_code("hu"));
+        assert_eq!(lang_from_tag("hu-HU"), Lang::from_code("hu"));
+        assert_eq!(lang_from_tag("tr_TR.UTF-8"), Lang::from_code("tr"));
+        assert_eq!(lang_from_tag("tr-TR"), Lang::from_code("tr"));
+        assert_eq!(lang_from_tag("tr"), Lang::from_code("tr"));
         // Traditional Chinese: by region, by script, and with a region after the script.
         assert_eq!(lang_from_tag("zh_TW.UTF-8"), Some(ZH()));
         assert_eq!(lang_from_tag("zh-TW"), Some(ZH()));
@@ -513,6 +572,22 @@ mod tests {
         assert_eq!(trn(es, 3, "{n} item", "{n} items"), "3 elementos");
     }
 
+    #[test]
+    fn hungarian_resolves_and_keeps_the_singular_after_counts() {
+        let hu = Lang::from_code("hu").expect("hu registered");
+        for tag in ["hu", "hu_HU.UTF-8", "hu-HU"] {
+            assert_eq!(lang_from_tag(tag), Some(hu), "{tag}");
+        }
+        assert!(hu.complete_menus());
+        assert_eq!(hu.name(), "Magyar");
+        assert_eq!(tr(hu, "Layer"), "Réteg");
+        for (n, expected) in [(0, "0 réteg"), (1, "1 réteg"), (3, "3 réteg"), (21, "21 réteg")] {
+            assert_eq!(trn(hu, n, "{n} layer", "{n} layers"), expected);
+        }
+        assert_eq!(tr_ctx(hu, "layerLabel", "Red"), "Piros");
+        assert_eq!(tr(hu, "Red"), "Vörös");
+    }
+
     #[test]
     fn brazilian_portuguese_resolves_and_pluralises() {
         let pt = Lang::from_code("pt-br").expect("pt-br registered");
@@ -551,6 +626,94 @@ mod tests {
         assert_eq!(trn(ru(), 111, "{n} item", "{n} items"), "111 элементов");
     }
 
+    #[test]
+    fn russian_status_messages_agree_with_counts() {
+        let ru = Lang::from_code("ru").expect("ru registered");
+        let cases = [
+            (
+                "Exported {n} swatch to {file}",
+                "Exported {n} swatches to {file}",
+                ["Экспортирован {n} образец в {file}", "Экспортированы {n} образца в {file}", "Экспортировано {n} образцов в {file}"],
+            ),
+            (
+                "Imported {n} brush from {group}",
+                "Imported {n} brushes from {group}",
+                ["Импортирована {n} кисть из {group}", "Импортированы {n} кисти из {group}", "Импортировано {n} кистей из {group}"],
+            ),
+            (
+                "Imported {n} swatch from {file}",
+                "Imported {n} swatches from {file}",
+                ["Импортирован {n} образец из {file}", "Импортированы {n} образца из {file}", "Импортировано {n} образцов из {file}"],
+            ),
+            ("Played {n} step", "Played {n} steps", ["Воспроизведён {n} шаг", "Воспроизведены {n} шага", "Воспроизведено {n} шагов"]),
+            (
+                "Updated {n} linked smart object changed on disk",
+                "Updated {n} linked smart objects changed on disk",
+                [
+                    "Обновлён {n} связанный смарт-объект, изменённый на диске",
+                    "Обновлены {n} связанных смарт-объекта, изменённых на диске",
+                    "Обновлено {n} связанных смарт-объектов, изменённых на диске",
+                ],
+            ),
+            (
+                "{n} layer recorded by this comp was deleted. Update the comp, or clear the warning.",
+                "{n} layers recorded by this comp were deleted. Update the comp, or clear the warning.",
+                [
+                    "Удалён {n} слой, записанный в этом варианте. Обновите вариант или сбросьте предупреждение.",
+                    "Удалены {n} слоя, записанных в этом варианте. Обновите вариант или сбросьте предупреждение.",
+                    "Удалено {n} слоёв, записанных в этом варианте. Обновите вариант или сбросьте предупреждение.",
+                ],
+            ),
+            ("{n} sample point removed", "{n} sample points removed", ["Удалена {n} точка замера", "Удалены {n} точки замера", "Удалено {n} точек замера"]),
+            (
+                "Loaded {n} action from {file}",
+                "Loaded {n} actions from {file}",
+                ["Загружена {n} операция из {file}", "Загружены {n} операции из {file}", "Загружено {n} операций из {file}"],
+            ),
+            (
+                "Saved {n} action to {file}",
+                "Saved {n} actions to {file}",
+                ["Сохранена {n} операция в {file}", "Сохранены {n} операции в {file}", "Сохранено {n} операций в {file}"],
+            ),
+            (
+                "{n} step with no Photoshop equivalent left out",
+                "{n} steps with no Photoshop equivalent left out",
+                [
+                    "Пропущен {n} шаг без эквивалента в Photoshop",
+                    "Пропущены {n} шага без эквивалента в Photoshop",
+                    "Пропущено {n} шагов без эквивалента в Photoshop",
+                ],
+            ),
+        ];
+        // Include zero, teens, and compound counts as well as each basic form.
+        for (n, form) in [(0, 2), (1, 0), (2, 1), (3, 1), (4, 1), (5, 2), (11, 2), (12, 2), (14, 2), (21, 0), (22, 1), (25, 2), (101, 0), (112, 2)] {
+            for (one, other, forms) in cases {
+                let expected = forms[form].replace("{n}", &n.to_string());
+                assert_eq!(trn(ru, n, one, other), expected, "{one}, n={n}");
+            }
+        }
+        assert_eq!(
+            fmt(&trn(ru, 2, "Imported {n} brush from {group}", "Imported {n} brushes from {group}"), &[("group", "Кисти")]),
+            "Импортированы 2 кисти из Кисти"
+        );
+        assert_eq!(
+            fmt(&trn(ru, 22, "Loaded {n} action from {file}", "Loaded {n} actions from {file}"), &[("file", "actions.atn")]),
+            "Загружены 22 операции из actions.atn"
+        );
+    }
+
+    #[test]
+    fn russian_font_weights_and_reviewed_labels() {
+        let ru = Lang::from_code("ru").expect("ru registered");
+        assert_eq!(tr_ctx(ru, "fontWeight", "ExtraLight"), "Сверхтонкий");
+        assert_eq!(tr_ctx(ru, "fontWeight", "Light"), "Лёгкий");
+        assert_eq!(tr_ctx(ru, "fontWeight", "ExtraBold"), "Сверхжирный");
+        assert_eq!(tr_ctx(ru, "fontWeight", "Black"), "Сверхжирный (Black)");
+        assert_eq!(tr(ru, "Delete and Fill Selection"), "Удалить и залить выделение");
+        assert_eq!(tr(ru, "Discard the embedded profile (don't color manage)"), "Не использовать встроенный профиль (без управления цветом)");
+        assert_eq!(tr(ru, "No object found there — drag a rectangle around it"), "Объект не найден — обведите его прямоугольником");
+    }
+
     #[test]
     fn ukrainian_resolves_locales_and_preferences() {
         let uk = Lang::from_code("uk").expect("uk registered");
@@ -609,6 +772,66 @@ mod tests {
         }
     }
 
+    #[test]
+    fn serbian_resolves_locales_and_preferences() {
+        let sr = Lang::from_code("sr").expect("sr registered");
+        assert_eq!(sr.name(), "Srpski");
+        assert!(sr.complete_menus());
+        for tag in ["sr", "SR", "sr-RS", "sr_RS", "sr_RS.UTF-8", "sr_RS@latin", "sr-Latn", "sr-Latn-RS", "sr-Cyrl-RS", "sr-ME"] {
+            assert_eq!(lang_from_tag(tag), Some(sr), "{tag}");
+            assert_eq!(Lang::from_pref(tag), sr, "{tag}");
+        }
+        assert_eq!(tr(sr, "File"), "Datoteka");
+        assert_eq!(tr(sr, "Layer"), "Sloj");
+        assert_eq!(tr(sr, "New document…"), "Novi dokument…");
+        assert_eq!(tr_id(sr, "select.all", "All"), "Izaberi sve", "an id override wins over the plain label");
+        assert_eq!(tr(sr, "All"), "Sve");
+        assert_eq!(tr_ctx(sr, "cameraRaw", "Light"), "Svetlo");
+        assert_eq!(tr_ctx(sr, "fontWeight", "Light"), "Lagano");
+        assert_eq!(fmt(tr(sr, "Camera Raw Filter ({layer})"), &[("layer", "Background")]), "Camera Raw filter (Background)");
+        for key in ["Alt", "⌥"] {
+            assert_eq!(
+                fmt(tr(sr, "Add a mask  (from the selection; {key} inverts)"), &[("key", key)]),
+                format!("Dodaj masku  (iz selekcije; {key} invertuje)")
+            );
+        }
+    }
+
+    #[test]
+    fn serbian_plural_messages_handle_teens_and_compound_counts() {
+        let sr = Lang::from_code("sr").expect("sr registered");
+        for (n, item, layer) in [
+            (0, "stavki", "slojeva"),
+            (1, "stavka", "sloj"),
+            (2, "stavke", "sloja"),
+            (4, "stavke", "sloja"),
+            (5, "stavki", "slojeva"),
+            (11, "stavki", "slojeva"),
+            (12, "stavki", "slojeva"),
+            (14, "stavki", "slojeva"),
+            (21, "stavka", "sloj"),
+            (22, "stavke", "sloja"),
+            (25, "stavki", "slojeva"),
+            (101, "stavka", "sloj"),
+            (111, "stavki", "slojeva"),
+            (112, "stavki", "slojeva"),
+            (122, "stavke", "sloja"),
+        ] {
+            assert_eq!(trn(sr, n, "{n} item", "{n} items"), format!("{n} {item}"));
+            assert_eq!(trn(sr, n, "{n} layer", "{n} layers"), format!("{n} {layer}"));
+            assert_eq!(trn(sr, n, "Group · {n} layer", "Group · {n} layers"), format!("Grupa · {n} {layer}"));
+        }
+        for (n, expected) in [
+            (1, "Uklonjena je 1 tačka uzorkovanja"),
+            (3, "Uklonjene su 3 tačke uzorkovanja"),
+            (5, "Uklonjeno je 5 tačaka uzorkovanja"),
+            (13, "Uklonjeno je 13 tačaka uzorkovanja"),
+            (21, "Uklonjena je 21 tačka uzorkovanja"),
+        ] {
+            assert_eq!(trn(sr, n, "{n} sample point removed", "{n} sample points removed"), expected);
+        }
+    }
+
     #[test]
     fn catalog_kinds_are_parsed_and_looked_up() {
         let c = Catalog::parse("# c\n\tHello\tこんにちは\n@id\tfile.save\t保存する\nmenu\tWindows\tウィンドウ群\n@plural\t{n} file|{n} files\t{n} 個\n\n");
@@ -677,13 +900,13 @@ mod tests {
         assert_eq!(tr(CS(), "All"), "Vše");
     }
 
-    /// The deflated catalogs in the binary inflate to exactly the `.tsv` files.
+    /// The packed catalogs in the binary unpack to exactly the `.tsv` files.
     #[test]
-    fn deflated_catalogs_match_their_files() {
+    fn packed_catalogs_match_their_files() {
         let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/i18n");
         for l in LANGUAGES.iter().skip(1) {
             let file = std::fs::read_to_string(dir.join(format!("{}.tsv", l.code))).unwrap();
-            assert_eq!(inflate(l.source).unwrap(), file, "{}", l.code);
+            assert_eq!(unpack(l.source).unwrap(), file, "{}", l.code);
             assert!(l.source.len() < file.len() / 2, "{}: stored deflated", l.code);
         }
         assert_eq!(LANGUAGES[0].text(), "", "English has no catalog");
@@ -707,6 +930,18 @@ mod tests {
         assert_eq!(tr(Lang(info), "Layer"), "Layer", "falls back to English");
     }
 
+    /// Packed lines unpack to their keys; references to keys that don't exist are an error, not a
+    /// panic.
+    #[test]
+    fn packed_lines_unpack_and_bad_references_are_errors() {
+        let keys = ["\tOpen", "@id\tfile.open", "\tClose"];
+        let packed = "# c\n\x01Ouvrir\n\x02-1\tOuvrir\n\x02+1\tFermer\n\x03\x01x\n";
+        assert_eq!(expand(packed, &keys).unwrap(), "# c\n\tOpen\tOuvrir\n\tOpen\tOuvrir\n\tClose\tFermer\n\x01x\n");
+        for bad in ["\x02-1\tx", "\x02 3\tx", "\x023", "\x029223372036854775807\tx", "\x02-9223372036854775808\tx", "\x01a\n\x01b\n\x01c\n\x01d"] {
+            assert!(expand(bad, &keys).is_err(), "{bad:?}");
+        }
+    }
+
     /// Every bundled catalog is well-formed and consistent with its sources.
     #[test]
     fn bundled_catalogs_are_consistent() {
@@ -966,6 +1201,25 @@ mod tests {
         assert_eq!(tr(Lang::EN, "Seafoam"), "Seafoam");
     }
 
+    /// These labels are passed to `tl!` dynamically, so the literal coverage scan misses them.
+    #[test]
+    fn russian_dynamic_selection_theme_and_measurement_labels_are_translated() {
+        let ru = Lang::from_code("ru").expect("ru registered");
+        let (inverse_label, _) =
+            crate::canvas_tool_menu::SELECTION_MENU.iter().flatten().find(|(_, id)| *id == "select.inverse").expect("selection menu has Select Inverse");
+        assert_eq!(tr(ru, inverse_label), "Инвертировать выделение");
+        for kind in [crate::theme::ThemeKind::ProLight, crate::theme::ThemeKind::ProLightGray] {
+            assert!(has(ru, kind.label()), "Russian theme label missing {}", kind.label());
+        }
+        for (_, label) in photocraft_engine::analysis_cmds::COLUMNS {
+            assert!(has(ru, label), "Russian measurement header missing {label}");
+        }
+        assert_eq!(tr(ru, "Pro (Light)"), "Pro (светлая)");
+        assert_eq!(tr(ru, "Pro (Light Gray)"), "Pro (светло-серая)");
+        assert_eq!(tr(ru, "Date and Time"), "Дата и время");
+        assert_eq!(tr(ru, "Integrated Density"), "Интегральная плотность");
+    }
+
     /// Font style labels are built from dynamic words (weights, "Italic"), so the literal
     /// scanner cannot cover them; "Light" there is a weight, distinct from the Camera Raw
     /// "Light" section (`type_tool::style_label`).
diff --git a/crates/ui-egui/src/i18n/nl.tsv b/crates/ui-egui/src/i18n/nl.tsv
index c0abbe55ed..68e98a6fef 100644
--- a/crates/ui-egui/src/i18n/nl.tsv
+++ b/crates/ui-egui/src/i18n/nl.tsv
@@ -8,7 +8,17 @@
 # stay as they are; the trailing "…" of dialog commands is kept. UI text addresses the user
 # informally ("je") and uses sentence case.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Kanaalkleur
+	Color Indicates:	Kleur geeft aan:
+	Solidity:	Soliditeit:
+	Ink Characteristics	Inktkenmerken
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Papierbreedte
+	Paper Height	Papierhoogte
 	Rows	Rijen
 	Number	Aantal
 	Top:	Boven:
@@ -63,6 +73,8 @@
 	Save	Opslaan
 	Save As…	Opslaan als…
 	Save a Copy…	Kopie opslaan…
+	{name} can't keep everything in this document	{name} kan niet alles in dit document bewaren
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Kies een indeling die alles bewaart, zoals Photoshop (PSD), of sla een kopie op.
 	Revert	Terugzetten
 	Export	Exporteren
 	Quick Export as PNG	Snel exporteren als PNG
@@ -100,6 +112,13 @@
 	Script Events Manager…	Beheer scriptgebeurtenissen…
 	Import	Importeren
 	Browse…	Bladeren…
+	Source Files	Bronbestanden
+	Use:	Gebruiken:
+	Files	Bestanden
+	Add Open Files	Geopende bestanden toevoegen
+	Sort By Name	Sorteren op naam
+	Attempt to Automatically Align Source Images	Proberen bronafbeeldingen automatisch uit te lijnen
+	Create Smart Object after Loading Layers	Slim object maken na laden van lagen
 	Reveal in Finder	Weergeven in Finder
 	Show in Explorer	Weergeven in Verkenner
 	Show in Folder	Weergeven in map
@@ -124,6 +143,8 @@
 	Search…	Zoeken…
 	Check Spelling…	Spelling controleren…
 	Find and Replace Text…	Tekst zoeken en vervangen…
+	Add to Dictionary	Aan woordenboek toevoegen
+	No Spelling Suggestions	Geen spellingsuggesties
 	Fill…	Vullen…
 	Stroke…	Omlijnen…
 	Content-Aware Fill…	Inhoudsbewust vullen…
@@ -138,6 +159,8 @@
 	Transform Again on a Copy	Opnieuw transformeren op een kopie
 	Scale	Schalen
 	Rotate	Roteren
+	Set horizontal skew	Horizontale schuinte instellen
+	Set vertical skew	Verticale schuinte instellen
 	Skew	Schuintrekken
 	Distort	Vervormen
 	Perspective	Perspectief
@@ -349,6 +372,7 @@
 	Update Modified Content	Gewijzigde inhoud bijwerken
 	Update All Modified Content	Alle gewijzigde inhoud bijwerken
 	Stack Mode	Stapelmodus
+	Choose Stack Mode:	Stapelmodus kiezen:
 	Entropy	Entropie
 	Kurtosis	Kurtosis
 	Maximum	Maximum
@@ -383,6 +407,7 @@
 	Select Linked Layers	Gekoppelde lagen selecteren
 	Merge Layers	Lagen samenvoegen
 	Merge Down	Omlaag samenvoegen
+	Merge Group	Groep samenvoegen
 	Merge Visible	Zichtbare samenvoegen
 	Stamp Visible	Zichtbare stempelen
 	Select Layer Above	Laag erboven selecteren
@@ -518,6 +543,9 @@
 	Blur	Vervagen
 	Blur Gallery	Vervagingsgalerie
 	Field Blur…	Veldvervaging…
+# Field Blur pins (#3373)
+	No pin selected	Geen speld geselecteerd
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Klik in de afbeelding om een speld toe te voegen; sleep een speld om hem te verplaatsen, of zijn ring om de vervaging te wijzigen. Delete verwijdert de geselecteerde speld.
 	Iris Blur…	Irisvervaging…
 	Tilt-Shift…	Tilt-shift…
 	Path Blur…	Padvervaging…
@@ -704,6 +732,10 @@
 	Breeze Dark Theme	Breeze-thema donker
 	Breeze light	Breeze licht
 	Breeze Light Theme	Breeze-thema licht
+	Soft dark	Zacht donker
+	Soft light	Zacht licht
+	Soft Dark Theme	Zacht donker thema
+	Soft Light Theme	Zacht licht thema
 	Adwaita Light Theme	Adwaita-thema licht
 	Adwaita Dark Theme	Adwaita-thema donker
 	Adwaita	Adwaita
@@ -806,6 +838,9 @@
 	Appearance	Weergave
 	Appearance (Layer Style)	Weergave (laagstijl)
 	Apply Layer Mask	Laagmasker toepassen
+	Add Mask to Selection	Masker aan selectie toevoegen
+	Subtract Mask from Selection	Masker van selectie aftrekken
+	Intersect Mask with Selection	Masker met selectie laten snijden
 	Apply Per Tip	Per punt toepassen
 	Apply next selected layer comp	Volgende geselecteerde laagcompositie toepassen
 	Apply previous selected layer comp	Vorige geselecteerde laagcompositie toepassen
@@ -821,11 +856,18 @@
 	Background	Achtergrond
 	Background Color	Achtergrondkleur
 	Background Contents	Achtergrondinhoud
+	Custom background color	Aangepaste achtergrondkleur
 	Balance	Balans
 	Baseline	Basislijn
 	Baseline shift	Basislijnverschuiving
 	Basic	Basis
 	Before (Y)	Voor (Y)
+	Save Settings…	Instellingen opslaan…
+	Load Settings…	Instellingen laden…
+	Save these settings as a Camera Raw .xmp file	Deze instellingen opslaan als Camera Raw-.xmp-bestand
+	Load settings from a Camera Raw .xmp file	Instellingen laden uit een Camera Raw-.xmp-bestand
+	Loaded Camera Raw settings from {file}	Camera Raw-instellingen geladen uit {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Camera Raw-instellingen geladen uit {file} ({n} niet ondersteund)
 	Begin recording	Opname starten
 	Bend:	Buiging:
 	Bicubic	Bicubisch
@@ -856,6 +898,7 @@
 	Cancel	Annuleren
 	Reset	Herstellen
 	Cancel (Esc)	Annuleren (Esc)
+	Manage submitted jobs in the system print queue	Beheer verzonden taken in de afdrukwachtrij van het systeem
 	Cancel any current edits (Esc)	Huidige bewerkingen annuleren (Esc)
 	Cancel current crop operation  (Esc)	Huidige bijsnijbewerking annuleren  (Esc)
 	Cancel transform (Esc)	Transformatie annuleren (Esc)
@@ -1129,6 +1172,9 @@
 	Ignore All	Alles negeren
 	Image Size	Afbeeldingsgrootte
 	Import Brushes…	Penselen importeren…
+	Gradient Preset Options	Opties voor verloopvoorinstellingen
+	Import .GRD	.GRD importeren
+	Choose a gradient file (.grd).	Kies een verloopbestand (.grd).
 	Import brushes (.abr)	Penselen (.abr) importeren
 	Import Presets	Voorinstellingen importeren
 	Imported	Geïmporteerd
@@ -2050,6 +2096,11 @@
 	Rename Brush…	Penseel hernoemen…
 	Delete Brush	Penseel verwijderen
 	New Brush Preset…	Nieuwe penseelvoorinstelling…
+	Capture Brush Size in Preset	Penseelgrootte vastleggen in voorinstelling
+	Include Tool Settings	Gereedschapsinstellingen opnemen
+	Include Color	Kleur opnemen
+	Enter a name for the brush preset	Voer een naam in voor de penseelvoorinstelling
+	A brush preset with this name already exists	Er bestaat al een penseelvoorinstelling met deze naam
 	Brush Preset Options	Opties penseelvoorinstelling
 	Group name	Groepsnaam
 	Brush name	Penseelnaam
@@ -2109,6 +2160,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Geen pad om een selectie van te maken: teken er een met het pengereedschap of selecteer er een in het paneel Paden.
 	Cancel opening	Openen annuleren
 	Cancelled opening {name}	Openen van {name} geannuleerd
+	The document “{name}” does not have an embedded {mode} profile.	Het document “{name}” heeft geen ingesloten {mode}-profiel.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Het document “{name}” heeft een ingesloten kleurprofiel dat niet overeenkomt met de huidige {mode}-werkruimte.
+	Embedded: {embedded}	Ingesloten: {embedded}
+	Working: {working}	Werkruimte: {working}
 	Developing {name}	{name} wordt ontwikkeld
 	Cancelled {label}	{label} geannuleerd
 	Esc to cancel	Esc om te annuleren
@@ -2329,6 +2384,7 @@
 	Click to pick · Esc to cancel	Klik om te kiezen · Esc om te annuleren
 	Pick a screen pixel or press Esc to cancel	Kies een schermpixel of druk op Esc om te annuleren
 	Scroll to zoom	Scrollen om te zoomen
+	Drag to pan · Scroll to zoom · Double-click to fit	Sleep om te pannen · Scroll om te zoomen · Dubbelklik om passend te maken
 	Show/Hide All Panels	Alle panelen tonen/verbergen
 	Show/Hide Panels	Panelen tonen/verbergen
 	Could not open	Kan niet openen
@@ -2378,6 +2434,7 @@ layerLabel	No Color	Geen kleur
 	Fuchsia	Fuchsia
 	Violet	Violet
 	Large document: redrawing on the CPU	Groot document: opnieuw tekenen op de CPU
+	Redrawing	Opnieuw tekenen
 	This redraw took {seconds} s on the CPU.	Opnieuw tekenen duurde {seconds} s op de CPU.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Bewerkingen die het hele document veranderen, zoals de overvloeimodus, dekking of zichtbaarheid van een laag, tekenen alles opnieuw.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	De lagen passen niet binnen het GPU-geheugenbudget. Door Geheugengebruik te verhogen in Voorkeuren › Prestaties wordt het budget groter, tot een kwart van het geheugen van deze computer.
@@ -2803,7 +2860,6 @@ cameraRaw	Color	Kleur
 	Choose…	Kiezen…
 	Select Folder…	Map selecteren…
 	Override Action "Save" Commands	Opdrachten "Opslaan" in actie negeren
-	File Naming	Bestandsnamen
 	Compatibility	Compatibiliteit
 	Include ICC Profile	ICC-profiel opnemen
 	Error File	Foutbestand
@@ -3771,6 +3827,7 @@ curves	Smooth	Vloeiend maken
 	Include in playback	Opnemen in afspelen
 	Scale:	Schaal:
 	Snap to Origin	Uitlijnen op oorsprong
+	Presentation	Presentatie
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Klik om te plaatsen · Alt-klik of sleep buiten het canvas om te verwijderen
@@ -3807,3 +3864,36 @@ curves	Smooth	Vloeiend maken
 	Light Red	Lichtrood
 	Medium Blue	Middelblauw
 	Light Gray	Lichtgrijs
+	Object Finder	Objectzoeker
+	No object found there — drag a rectangle around it	Daar is geen object gevonden — sleep er een rechthoek omheen
+	Remove after each stroke	Verwijderen na elke streek
+	Apply the removal ({key})	Verwijdering toepassen ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Streken om te verwijderen: {n} (Enter past toe, Esc annuleert)
+	Clear Brush Controls	Penseelbesturing wissen
+	Reset All Locked Settings	Alle vergrendelde instellingen opnieuw instellen
+	Copy Texture to Other Tools	Structuur kopiëren naar andere gereedschappen
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Handelingen laden…
+	Save Actions…	Handelingen opslaan…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{n} handeling geladen uit {file}|{n} handelingen geladen uit {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} stap heeft nog geen equivalent in PhotoCraft|{n} stappen hebben nog geen equivalent in PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{n} handeling opgeslagen in {file}|{n} handelingen opgeslagen in {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	{n} stap zonder Photoshop-equivalent weggelaten|{n} stappen zonder Photoshop-equivalent weggelaten
+
+	File Naming	Bestandsnamen
+	Starting serial	Beginnummer
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Stop invoegen…
+	Save Set…	Set opslaan…
+	Message:	Bericht:
+	Allow Continue	Doorgaan toestaan
+	Show dialog during playback	Dialoogvenster tonen tijdens afspelen
+	Select an action first	Selecteer eerst een handeling
+	Action playback stopped	Afspelen van de handeling gestopt
+	Step {step} is waiting for its dialog	Stap {step} wacht op zijn dialoogvenster
+@plural	{n} action|{n} actions	{n} handeling|{n} handelingen
+	Auto Add/Delete	Automatisch toevoegen/verwijderen
+	ICO is limited to 256 × 256 pixels	ICO is beperkt tot 256 × 256 pixels
diff --git a/crates/ui-egui/src/i18n/pl.tsv b/crates/ui-egui/src/i18n/pl.tsv
index 557b193e11..2d76183794 100644
--- a/crates/ui-egui/src/i18n/pl.tsv
+++ b/crates/ui-egui/src/i18n/pl.tsv
@@ -18,7 +18,17 @@
 # Conventions: menus are nouns (Plik, Edycja, Obraz ...), commands are infinitives (Otwórz…,
 # Zapisz jako…), sentence case as in the English source. Quotes: „…”.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Kolor kanału
+	Color Indicates:	Kolor oznacza:
+	Solidity:	Gęstość:
+	Ink Characteristics	Właściwości farby
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Szerokość papieru
+	Paper Height	Wysokość papieru
 	Rows	Wiersze
 	Number	Liczba
 	Top:	Góra:
@@ -70,6 +80,8 @@
 	Save	Zapisz
 	Save As…	Zapisz jako…
 	Save a Copy…	Zapisz kopię…
+	{name} can't keep everything in this document	{name} nie może zachować wszystkiego z tego dokumentu
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Wybierz format, który zachowa wszystko, na przykład Photoshop (PSD), lub zapisz kopię.
 	Revert	Przywróć ostatnio zapisany
 	Export	Eksportuj
 	Quick Export as PNG	Szybki eksport jako PNG
@@ -107,6 +119,14 @@
 	Script Events Manager…	Menedżer zdarzeń skryptów…
 	Import	Importuj
 	Browse…	Przeglądaj…
+	Source Files	Pliki źródłowe
+	Use:	Użyj:
+	Files	Pliki
+	Folder	Folder
+	Add Open Files	Dodaj otwarte pliki
+	Sort By Name	Sortuj według nazwy
+	Attempt to Automatically Align Source Images	Spróbuj automatycznie wyrównać obrazy źródłowe
+	Create Smart Object after Loading Layers	Utwórz obiekt inteligentny po wczytaniu warstw
 	Reveal in Finder	Pokaż w Finderze
 	Show in Explorer	Pokaż w Eksploratorze
 	Show in Folder	Pokaż w folderze
@@ -131,6 +151,8 @@
 	Search…	Szukaj…
 	Check Spelling…	Sprawdź pisownię…
 	Find and Replace Text…	Znajdź i zamień tekst…
+	Add to Dictionary	Dodaj do słownika
+	No Spelling Suggestions	Brak sugestii pisowni
 	Fill…	Wypełnij…
 	Stroke…	Obrys…
 	Content-Aware Fill…	Wypełnienie z uwzględnieniem zawartości…
@@ -144,6 +166,8 @@
 	Transform Again on a Copy	Przekształć ponownie na kopii
 	Scale	Skaluj
 	Rotate	Obróć
+	Set horizontal skew	Ustaw pochylenie poziome
+	Set vertical skew	Ustaw pochylenie pionowe
 	Skew	Pochyl
 	Distort	Zniekształć
 	Perspective	Perspektywa
@@ -355,6 +379,7 @@
 	Update Modified Content	Aktualizuj zmodyfikowaną zawartość
 	Update All Modified Content	Aktualizuj całą zmodyfikowaną zawartość
 	Stack Mode	Tryb stosu
+	Choose Stack Mode:	Wybierz tryb stosu:
 	Entropy	Entropia
 	Kurtosis	Kurtoza
 	Maximum	Maksimum
@@ -389,6 +414,7 @@
 	Select Linked Layers	Zaznacz połączone warstwy
 	Merge Layers	Scal warstwy
 	Merge Down	Scal w dół
+	Merge Group	Scal grupę
 	Merge Visible	Scal widoczne
 	Stamp Visible	Odbij widoczne
 	Select Layer Above	Zaznacz warstwę powyżej
@@ -526,6 +552,9 @@
 	Blur	Rozmycie
 	Blur Gallery	Galeria rozmyć
 	Field Blur…	Rozmycie pola…
+# Field Blur pins (#3373)
+	No pin selected	Nie zaznaczono pinezki
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Kliknij obraz, aby dodać pinezkę; przeciągnij pinezkę, aby ją przesunąć, lub jej pierścień, aby zmienić rozmycie. Delete usuwa zaznaczoną pinezkę.
 	Iris Blur…	Rozmycie irysowe…
 	Tilt-Shift…	Tilt-shift…
 	Path Blur…	Rozmycie ścieżki…
@@ -724,6 +753,10 @@
 	Breeze Dark Theme	Ciemny motyw Breeze
 	Breeze light	Breeze jasny
 	Breeze Light Theme	Jasny motyw Breeze
+	Soft dark	Łagodny ciemny
+	Soft light	Łagodny jasny
+	Soft Dark Theme	Łagodny ciemny motyw
+	Soft Light Theme	Łagodny jasny motyw
 	Next Theme	Następny motyw
 	Actions	Akcje
 	Brush Settings	Ustawienia pędzla
@@ -824,6 +857,9 @@
 	Appearance	Wygląd
 	Appearance (Layer Style)	Wygląd (styl warstwy)
 	Apply Layer Mask	Zastosuj maskę warstwy
+	Add Mask to Selection	Dodaj maskę do zaznaczenia
+	Subtract Mask from Selection	Odejmij maskę od zaznaczenia
+	Intersect Mask with Selection	Część wspólna maski i zaznaczenia
 	Apply Per Tip	Zastosuj dla każdego odcisku
 	Apply next selected layer comp	Zastosuj następną zaznaczoną kompozycję warstw
 	Apply previous selected layer comp	Zastosuj poprzednią zaznaczoną kompozycję warstw
@@ -839,11 +875,18 @@
 	Background	Tło
 	Background Color	Kolor tła
 	Background Contents	Zawartość tła
+	Custom background color	Niestandardowy kolor tła
 	Balance	Balans
 	Baseline	Linia bazowa
 	Baseline shift	Przesunięcie linii bazowej
 	Basic	Podstawowe
 	Before (Y)	Przed (Y)
+	Save Settings…	Zapisz ustawienia…
+	Load Settings…	Wczytaj ustawienia…
+	Save these settings as a Camera Raw .xmp file	Zapisz te ustawienia jako plik .xmp Camera Raw
+	Load settings from a Camera Raw .xmp file	Wczytaj ustawienia z pliku .xmp Camera Raw
+	Loaded Camera Raw settings from {file}	Wczytano ustawienia Camera Raw z pliku {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Wczytano ustawienia Camera Raw z pliku {file} (nieobsługiwane: {n})
 	Begin recording	Rozpocznij nagrywanie
 	Bend:	Zgięcie:
 	Bicubic	Dwusześcienna
@@ -874,6 +917,7 @@
 	Camera Raw isn't open	Camera Raw nie jest otwarty
 	Cancel	Anuluj
 	Cancel (Esc)	Anuluj (Esc)
+	Manage submitted jobs in the system print queue	Zarządzaj przesłanymi zadaniami w systemowej kolejce drukowania
 	Cancel any current edits (Esc)	Anuluj wszystkie bieżące zmiany (Esc)
 	Cancel current crop operation  (Esc)	Anuluj bieżące przycinanie  (Esc)
 	Cancel transform (Esc)	Anuluj przekształcanie (Esc)
@@ -1143,6 +1187,9 @@
 	Ignore All	Ignoruj wszystko
 	Image Size	Rozmiar obrazu
 	Import Brushes…	Importuj pędzle…
+	Gradient Preset Options	Opcje ustawień predefiniowanych gradientu
+	Import .GRD	Importuj .GRD
+	Choose a gradient file (.grd).	Wybierz plik gradientów (.grd).
 	Import brushes (.abr)	Importuj pędzle (.abr)
 	Import Presets	Importuj ustawienia wstępne
 	Imported	Zaimportowano
@@ -2132,6 +2179,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Brak ścieżki, z której można utworzyć zaznaczenie: narysuj ją narzędziem Pióro lub wybierz w panelu Ścieżki.
 	Cancel opening	Anuluj otwieranie
 	Cancelled opening {name}	Anulowano otwieranie {name}
+	The document “{name}” does not have an embedded {mode} profile.	Dokument „{name}” nie ma osadzonego profilu {mode}.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Dokument „{name}” ma osadzony profil kolorów, który nie pasuje do bieżącej przestrzeni roboczej {mode}.
+	Embedded: {embedded}	Osadzony: {embedded}
+	Working: {working}	Przestrzeń robocza: {working}
 	Cancelled {label}	Anulowano: {label}
 	Esc to cancel	Esc, aby anulować
 	Opened {name}	Otworzono: {name}
@@ -2450,7 +2501,6 @@
 	Choose…	Wybierz…
 	Select Folder…	Wybierz folder…
 	Override Action "Save" Commands	Zastąp polecenia „Zapisz” w akcji
-	File Naming	Nazewnictwo plików
 	Compatibility	Zgodność
 	Mac OS	Mac OS
 	Unix	Unix
@@ -3333,6 +3383,7 @@ cameraRaw	Roughness	Chropowatość
 	Click to pick · Esc to cancel	Kliknij, aby wybrać · Esc, aby anulować
 	Pick a screen pixel or press Esc to cancel	Wybierz piksel ekranu lub naciśnij Esc, aby anulować
 	Scroll to zoom	Przewijaj, aby zmieniać powiększenie
+	Drag to pan · Scroll to zoom · Double-click to fit	Przeciągnij, aby przesunąć · Przewijaj, aby powiększyć · Kliknij dwukrotnie, aby dopasować
 	Open in camera raw	Otwórz w Camera Raw
 	System title bar	Systemowy pasek tytułu
 	More documents	Więcej dokumentów
@@ -3362,6 +3413,11 @@ cameraRaw	Roughness	Chropowatość
 	Channels:	Kanały:
 	Knockout	Wycięcie
 	New Brush Preset…	Nowe ustawienie wstępne pędzla…
+	Capture Brush Size in Preset	Zapisz rozmiar pędzla w ustawieniu wstępnym
+	Include Tool Settings	Uwzględnij ustawienia narzędzia
+	Include Color	Uwzględnij kolor
+	Enter a name for the brush preset	Wpisz nazwę ustawienia wstępnego pędzla
+	A brush preset with this name already exists	Ustawienie wstępne pędzla o tej nazwie już istnieje
 	Brush Preset Options	Opcje ustawień wstępnych pędzla
 
 # Fill dialog, layer style contours and Image Size
@@ -3408,6 +3464,7 @@ cameraRaw	Roughness	Chropowatość
 	Indigo	Indygo
 	Fuchsia	Fuksja
 	Large document: redrawing on the CPU	Duży dokument: odświeżanie na CPU
+	Redrawing	Odświeżanie
 	This redraw took {seconds} s on the CPU.	To odświeżenie na CPU trwało {seconds} s.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Zmiany obejmujące cały dokument, takie jak tryb mieszania, krycie lub widoczność warstwy, odświeżają go w całości.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Warstwy nie mieszczą się w budżecie pamięci GPU. Zwiększenie wartości Użycie pamięci w Preferencje › Wydajność zwiększa budżet, maksymalnie do jednej czwartej pamięci tego komputera.
@@ -3622,6 +3679,7 @@ curves	Smooth	Wygładź
 	Paint over hair or fur on the image; Alt paints the other mode	Maluj po włosach lub sierści na obrazie; Alt maluje w drugim trybie
 	Clear Brush Strokes	Wyczyść pociągnięcia pędzla
 	Show rulers	Pokaż linijki
+	Presentation	Prezentacja
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Kliknij, aby umieścić · Alt-kliknij lub przeciągnij poza obszar roboczy, aby usunąć
@@ -3644,3 +3702,36 @@ curves	Smooth	Wygładź
 	Light Red	Jasnoczerwony
 	Medium Blue	Średnioniebieski
 	Light Gray	Jasnoszary
+	Object Finder	Wyszukiwanie obiektów
+	No object found there — drag a rectangle around it	Nie znaleziono tam obiektu — przeciągnij wokół niego prostokąt
+	Remove after each stroke	Usuwaj po każdym pociągnięciu
+	Apply the removal ({key})	Zastosuj usuwanie ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Pociągnięcia do usunięcia: {n} (Enter stosuje, Esc anuluje)
+	Clear Brush Controls	Wyczyść elementy sterujące pędzlem
+	Reset All Locked Settings	Resetuj wszystkie zablokowane ustawienia
+	Copy Texture to Other Tools	Kopiuj teksturę do innych narzędzi
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Wczytaj operacje…
+	Save Actions…	Zapisz operacje…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Wczytano {n} operację z {file}|Wczytano {n} operacje z {file}|Wczytano {n} operacji z {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} krok nie ma jeszcze odpowiednika w PhotoCraft|{n} kroki nie mają jeszcze odpowiednika w PhotoCraft|{n} kroków nie ma jeszcze odpowiednika w PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Zapisano {n} operację do {file}|Zapisano {n} operacje do {file}|Zapisano {n} operacji do {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Pominięto {n} krok bez odpowiednika w Photoshopie|Pominięto {n} kroki bez odpowiednika w Photoshopie|Pominięto {n} kroków bez odpowiednika w Photoshopie
+
+	File Naming	Nazewnictwo plików
+	Starting serial	Początkowy numer seryjny
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Wstaw zatrzymanie…
+	Save Set…	Zapisz zestaw…
+	Message:	Komunikat:
+	Allow Continue	Zezwól na kontynuację
+	Show dialog during playback	Pokazuj okno dialogowe podczas odtwarzania
+	Select an action first	Najpierw wybierz operację
+	Action playback stopped	Odtwarzanie operacji zatrzymane
+	Step {step} is waiting for its dialog	Krok {step} czeka na swoje okno dialogowe
+@plural	{n} action|{n} actions	{n} operacja|{n} operacje|{n} operacji
+	Auto Add/Delete	Automatyczne dodawanie/usuwanie
+	ICO is limited to 256 × 256 pixels	ICO jest ograniczony do 256 × 256 pikseli
diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv
index b7aea50bf0..0d48ba9b47 100644
--- a/crates/ui-egui/src/i18n/pt-br.tsv
+++ b/crates/ui-egui/src/i18n/pt-br.tsv
@@ -15,7 +15,17 @@
 # entries the same way. Product and technology names (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...)
 # stay as they are; the trailing "…" of dialog commands is kept.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Cor do canal
+	Color Indicates:	A cor indica:
+	Solidity:	Solidez:
+	Ink Characteristics	Características da tinta
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Largura do papel
+	Paper Height	Altura do papel
 	Rows	Linhas
 	Number	Número
 	Margin	Margem
@@ -71,13 +81,15 @@
 	Save	Salvar
 	Save As…	Salvar como…
 	Save a Copy…	Salvar uma cópia…
+	{name} can't keep everything in this document	{name} não consegue manter tudo o que há neste documento
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Escolha um formato que mantenha tudo, como Photoshop (PSD), ou salve uma cópia.
 	Revert	Reverter
 	Export	Exportar
 	Quick Export as PNG	Exportação rápida como PNG
 	Export As…	Exportar como…
 	Export Preferences…	Preferências de exportação…
 	Save for Web (Legacy)…	Salvar para Web (legado)…
-	Artboards to Files…	Prancheta em arquivos…
+	Artboards to Files…	Pranchetas em arquivos…
 	Artboards to PDF…	Pranchetas em PDF…
 	Layers to Files…	Camadas em arquivos…
 	Layer Comps to Files…	Composições de camadas em arquivos…
@@ -108,6 +120,13 @@
 	Script Events Manager…	Gerenciador de eventos de scripts…
 	Import	Importar
 	Browse…	Procurar…
+	Source Files	Arquivos de origem
+	Use:	Usar:
+	Files	Arquivos
+	Add Open Files	Adicionar arquivos abertos
+	Sort By Name	Classificar por nome
+	Attempt to Automatically Align Source Images	Tentar alinhar automaticamente as imagens de origem
+	Create Smart Object after Loading Layers	Criar objeto inteligente após carregar as camadas
 	Reveal in Finder	Mostrar no Finder
 	Show in Explorer	Mostrar no Explorador
 	Show in Folder	Mostrar na pasta
@@ -132,6 +151,8 @@
 	Search…	Pesquisar…
 	Check Spelling…	Verificar ortografia…
 	Find and Replace Text…	Localizar e substituir texto…
+	Add to Dictionary	Adicionar ao dicionário
+	No Spelling Suggestions	Sem sugestões de ortografia
 	Fill…	Preencher…
 	Stroke…	Traçado…
 	Content-Aware Fill…	Preenchimento sensível ao conteúdo…
@@ -144,6 +165,8 @@
 	Again	Novamente
 	Scale	Escala
 	Rotate	Girar
+	Set horizontal skew	Definir inclinação horizontal
+	Set vertical skew	Definir inclinação vertical
 	Skew	Inclinar
 	Distort	Distorcer
 	Perspective	Perspectiva
@@ -349,6 +372,7 @@
 	Update Modified Content	Atualizar conteúdo modificado
 	Update All Modified Content	Atualizar todo o conteúdo modificado
 	Stack Mode	Modo de pilha
+	Choose Stack Mode:	Escolher modo de pilha:
 	Entropy	Entropia
 	Kurtosis	Curtose
 	Maximum	Máximo
@@ -383,6 +407,7 @@
 	Select Linked Layers	Selecionar camadas vinculadas
 	Merge Layers	Mesclar camadas
 	Merge Down	Mesclar para baixo
+	Merge Group	Mesclar grupo
 	Merge Visible	Mesclar visíveis
 	Stamp Visible	Carimbar visíveis
 	Stamp Down	Carimbar para baixo
@@ -512,6 +537,9 @@
 	Blur	Desfoque
 	Blur Gallery	Galeria de desfoque
 	Field Blur…	Desfoque de campo…
+# Field Blur pins (#3373)
+	No pin selected	Nenhum alfinete selecionado
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Clique na imagem para adicionar um alfinete; arraste um alfinete para movê-lo ou o anel dele para alterar o desfoque. Delete remove o alfinete selecionado.
 	Iris Blur…	Desfoque de íris…
 	Tilt-Shift…	Tilt-shift…
 	Path Blur…	Desfoque de demarcador…
@@ -653,7 +681,7 @@
 	Mesh	Malha
 	Edit Pins	Editar alfinetes
 	Document Bounds	Limites do documento
-	Show Extras Options…	Opções de mostrar extras…
+	Show Extras Options…	Opções de exibição de extras…
 	Rulers	Réguas
 	Snap	Encaixar
 	Snap To	Encaixar em
@@ -710,6 +738,10 @@
 	Breeze Dark Theme	Tema Breeze Escuro
 	Breeze light	Breeze claro
 	Breeze Light Theme	Tema Breeze Claro
+	Soft dark	Suave escuro
+	Soft light	Suave claro
+	Soft Dark Theme	Tema suave escuro
+	Soft Light Theme	Tema suave claro
 	Next Theme	Próximo tema
 	Actions	Ações
 	Brush Settings	Configurações do pincel
@@ -759,7 +791,7 @@
 	Split Warp Horizontally	Dividir deformação horizontalmente
 	Split Warp Vertically	Dividir deformação verticalmente
 	Statistics…	Estatísticas…
-	Refine Strokes	Traços de refinamento
+	Refine Strokes	Refinar traços
 @plural	{n} item|{n} items	{n} item|{n} itens
 	Auto	Automático
 	(print to the printer)	(imprimir na impressora)
@@ -808,6 +840,9 @@
 	Appearance	Aparência
 	Appearance (Layer Style)	Aparência (estilo de camada)
 	Apply Layer Mask	Aplicar máscara de camada
+	Add Mask to Selection	Adicionar máscara à seleção
+	Subtract Mask from Selection	Subtrair máscara da seleção
+	Intersect Mask with Selection	Fazer interseção da máscara com a seleção
 	Apply Per Tip	Aplicar por ponta
 	Apply next selected layer comp	Aplicar a próxima composição de camadas selecionada
 	Apply previous selected layer comp	Aplicar a composição de camadas selecionada anterior
@@ -823,11 +858,18 @@
 	Background	Plano de fundo
 	Background Color	Cor de fundo
 	Background Contents	Conteúdo do plano de fundo
+	Custom background color	Cor de fundo personalizada
 	Balance	Equilíbrio
 	Baseline	Linha de base
 	Baseline shift	Deslocamento da linha de base
 	Basic	Básico
 	Before (Y)	Antes (Y)
+	Save Settings…	Salvar configurações…
+	Load Settings…	Carregar configurações…
+	Save these settings as a Camera Raw .xmp file	Salvar estas configurações como arquivo .xmp do Camera Raw
+	Load settings from a Camera Raw .xmp file	Carregar configurações de um arquivo .xmp do Camera Raw
+	Loaded Camera Raw settings from {file}	Configurações do Camera Raw carregadas de {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Configurações do Camera Raw carregadas de {file} ({n} sem suporte)
 	Begin recording	Iniciar gravação
 	Bend:	Curvatura:
 	Bicubic	Bicúbica
@@ -858,6 +900,7 @@
 	Camera Raw isn't open	Camera Raw não está aberto
 	Cancel	Cancelar
 	Cancel (Esc)	Cancelar (Esc)
+	Manage submitted jobs in the system print queue	Gerencie os trabalhos enviados na fila de impressão do sistema
 	Cancel any current edits (Esc)	Cancelar as edições atuais (Esc)
 	Cancel current crop operation  (Esc)	Cancelar a operação de corte atual  (Esc)
 	Cancel transform (Esc)	Cancelar transformação (Esc)
@@ -1125,6 +1168,9 @@
 	Ignore All	Ignorar tudo
 	Image Size	Tamanho da imagem
 	Import Brushes…	Importar pincéis…
+	Gradient Preset Options	Opções de predefinições de degradê
+	Import .GRD	Importar .GRD
+	Choose a gradient file (.grd).	Escolha um arquivo de degradês (.grd).
 	Import brushes (.abr)	Importar pincéis (.abr)
 	Import Presets	Importar predefinições
 	Imported	Importado
@@ -1356,10 +1402,10 @@
 	Imported {n} shortcuts from {file}. Click OK to keep them.	{n} atalhos importados de {file}. Clique em OK para mantê-los.
 	{n} commands are not in PhotoCraft.	{n} comandos não existem no PhotoCraft.
 	Keyboard shortcuts imported	Atalhos de teclado importados
-	Your keyboard shortcut set {set} is in use here: {n} shortcuts differ from the defaults. Edit › Keyboard Shortcuts shows them; Reset All to Defaults undoes this.	Seu conjunto de atalhos de teclado {set} está em uso aqui: {n} atalhos diferem dos padrões. Editar › Atalhos de teclado os mostra; Redefinir tudo para o padrão desfaz isso.
+	Your keyboard shortcut set {set} is in use here: {n} shortcuts differ from the defaults. Edit › Keyboard Shortcuts shows them; Reset All to Defaults undoes this.	Seu conjunto de atalhos de teclado {set} está em uso aqui: {n} atalhos diferem dos padrões. Editar › Atalhos de teclado os mostra; Redefinir tudo para os padrões desfaz isso.
 	Import keyboard shortcuts?	Importar atalhos de teclado?
 	PhotoCraft found your keyboard shortcut set {set} from another image editor on this computer: {n} of its shortcuts differ from PhotoCraft's. Import it?	O PhotoCraft encontrou neste computador seu conjunto de atalhos de teclado {set} de outro editor de imagens: {n} de seus atalhos diferem dos do PhotoCraft. Importá-lo?
-	Edit › Keyboard Shortcuts › Reset All to Defaults undoes an import.	Editar › Atalhos de teclado › Redefinir tudo para o padrão desfaz uma importação.
+	Edit › Keyboard Shortcuts › Reset All to Defaults undoes an import.	Editar › Atalhos de teclado › Redefinir tudo para os padrões desfaz uma importação.
 	Don't Import	Não importar
 	The keyboard shortcut set was not imported: {error}	O conjunto de atalhos de teclado não foi importado: {error}
 	Reset Section	Redefinir seção
@@ -2010,7 +2056,7 @@
 	Show the layer's effects  ({key}-click: all layers)	Mostrar os efeitos da camada  ({key}-clique: todas as camadas)
 	Brush picker	Seletor de pincéis
 	Erase	Apagar
-	Right click with painting tools	Clique direito com ferramentas de pintura
+	Right click with painting tools	Clique com o botão direito com ferramentas de pintura
 	System Info…	Informações do sistema…
 	System Info	Informações do sistema
 	More panels	Mais painéis
@@ -2045,6 +2091,11 @@
 	Rename Brush…	Renomear pincel…
 	Delete Brush	Excluir pincel
 	New Brush Preset…	Nova predefinição de pincel…
+	Capture Brush Size in Preset	Capturar tamanho do pincel na predefinição
+	Include Tool Settings	Incluir configurações da ferramenta
+	Include Color	Incluir cor
+	Enter a name for the brush preset	Digite um nome para a predefinição de pincel
+	A brush preset with this name already exists	Já existe uma predefinição de pincel com este nome
 	Brush Preset Options	Opções de predefinições de pincel
 	Group name	Nome do grupo
 	Brush name	Nome do pincel
@@ -2103,6 +2154,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Nenhum demarcador para criar a seleção: desenhe um com a ferramenta Caneta ou selecione um no painel Demarcadores.
 	Cancel opening	Cancelar abertura
 	Cancelled opening {name}	Abertura de {name} cancelada
+	The document “{name}” does not have an embedded {mode} profile.	O documento “{name}” não tem um perfil {mode} incorporado.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	O documento “{name}” tem um perfil de cores incorporado que não corresponde ao espaço de trabalho {mode} atual.
+	Embedded: {embedded}	Incorporado: {embedded}
+	Working: {working}	Espaço de trabalho: {working}
 	Developing {name}	Revelando {name}
 	Cancelled {label}	{label} cancelado
 	Esc to cancel	Esc para cancelar
@@ -2418,7 +2473,6 @@
 	Choose…	Escolher…
 	Select Folder…	Selecionar pasta…
 	Override Action "Save" Commands	Substituir comandos "Salvar" da ação
-	File Naming	Nomenclatura de arquivos
 	Compatibility	Compatibilidade
 	Mac OS	Mac OS
 	Unix	Unix
@@ -2614,7 +2668,7 @@
 	Shadow Clipping Warning (U)	Aviso de corte de sombras (U)
 	Highlight Clipping Warning (O)	Aviso de corte de realces (O)
 	Show Lab Color Readouts	Mostrar leituras de cor Lab
-	Show Vectorscope	Mostrar vectorscópio
+	Show Vectorscope	Mostrar vetorscópio
 	Show Red at 3 o'clock	Mostrar vermelho na posição de 3 horas
 	Show Skin Tone Indicator	Mostrar indicador de tom de pele
 	Tone Histogram	Histograma de tons
@@ -2667,7 +2721,7 @@ cameraRaw	Whites	Brancos
 	Drag or click polygon points · hold Alt during lasso for straight segments · {add} add · {sub} before drawing subtracts	Arraste ou clique nos pontos do polígono · segure Alt durante o laço para segmentos retos · {add} adicionar · {sub} antes de desenhar subtrai
 	Extend	Estender
 	Structure:	Estrutura:
-	Content-Aware Move Tool	Ferramenta Mover com reconhecimento de conteúdo
+	Content-Aware Move Tool	Ferramenta Mover sensível ao conteúdo
 	TIFF Options	Opções de TIFF
 	Targa Options	Opções de Targa
 	24 bits/pixel	24 bits/pixel
@@ -2748,6 +2802,7 @@ cameraRaw	Whites	Brancos
 	Click to pick · Esc to cancel	Clique para escolher · Esc para cancelar
 	Pick a screen pixel or press Esc to cancel	Escolha um pixel da tela ou pressione Esc para cancelar
 	Scroll to zoom	Role para ampliar
+	Drag to pan · Scroll to zoom · Double-click to fit	Arraste para mover · Role para ampliar · Clique duas vezes para ajustar
 	Show/Hide All Panels	Mostrar/ocultar todos os painéis
 	Show/Hide Panels	Mostrar/ocultar painéis
 	Could not open	Não foi possível abrir
@@ -2803,6 +2858,7 @@ cameraRaw	Whites	Brancos
 	Fuchsia	Fúcsia
 	Violet	Violeta
 	Large document: redrawing on the CPU	Documento grande: redesenhando na CPU
+	Redrawing	Redesenhando
 	This redraw took {seconds} s on the CPU.	Este redesenho na CPU levou {seconds} s.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Edições que mudam o documento inteiro, como modo de mesclagem, opacidade ou visibilidade de uma camada, redesenham tudo.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	As camadas não cabem no orçamento de memória da GPU. Aumentar Uso de memória em Preferências › Desempenho eleva o orçamento, até um quarto da memória deste computador.
@@ -2815,7 +2871,7 @@ fontWeight	Medium	Médio
 fontWeight	SemiBold	Seminegrito
 fontWeight	Bold	Negrito
 fontWeight	ExtraBold	Extranegrito
-fontWeight	Black	Ultraniegra
+fontWeight	Black	Ultranegrito
 fontWeight	Italic	Itálico
 
 # Pattern Stamp tool
@@ -3032,6 +3088,7 @@ curves	Smooth	Suavizar
 	Paint over hair or fur on the image; Alt paints the other mode	Pinte sobre cabelo ou pelo na imagem; Alt pinta no outro modo
 	Clear Brush Strokes	Limpar traços do pincel
 	Show rulers	Mostrar réguas
+	Presentation	Apresentação
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Clique para posicionar · Alt-clique ou arraste para fora da tela para remover
@@ -3299,7 +3356,7 @@ layerLabel	No Color	Sem cor
 	In White	Branco de entrada
 	Out Black	Preto de saída
 	Out White	Branco de saída
-	Tint Color	Cor da matiz
+	Tint Color	Cor da tonalidade
 	Stops	Pontos de parada
 	Center X	Centro X
 	Center Y	Centro Y
@@ -3652,7 +3709,7 @@ layerLabel	No Color	Sem cor
 	Defringe	Remover halos
 	Diffuse	Difusão
 	Diffuse Glow	Brilho difuso
-	Displace	Mesclar
+	Displace	Deslocar
 	Do you want to save you made to “{name}” before quitting?	Deseja salvar as alterações feitas em “{name}” antes de sair?
 	Dust & Scratches	Poeira e rabiscos
 	Export Contents	Exportar conteúdo
@@ -3687,7 +3744,7 @@ layerLabel	No Color	Sem cor
 	Legacy	Legado
 	Lens Blur	Desfoque de lente
 	Lens Correction	Correção de lente
-	Lens Flare	Reflexo de flash
+	Lens Flare	Reflexo de lente
 	Lighting Effects	Efeitos de iluminação
 	Liquify	Dissolver
 	Lock Layers	Bloquear camadas
@@ -3837,3 +3894,36 @@ layerLabel	No Color	Sem cor
 	Light Red	Vermelho-claro
 	Medium Blue	Azul médio
 	Light Gray	Cinza-claro
+	Object Finder	Localizador de objetos
+	No object found there — drag a rectangle around it	Nenhum objeto encontrado ali — arraste um retângulo ao redor dele
+	Remove after each stroke	Remover após cada traço
+	Apply the removal ({key})	Aplicar a remoção ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Traços a remover: {n} (Enter aplica, Esc cancela)
+	Clear Brush Controls	Limpar controles de pincel
+	Reset All Locked Settings	Redefinir todas as configurações bloqueadas
+	Copy Texture to Other Tools	Copiar textura para outras ferramentas
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Carregar ações…
+	Save Actions…	Salvar ações…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{n} ação carregada de {file}|{n} ações carregadas de {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} etapa ainda não tem equivalente no PhotoCraft|{n} etapas ainda não têm equivalente no PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{n} ação salva em {file}|{n} ações salvas em {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	{n} etapa sem equivalente no Photoshop foi omitida|{n} etapas sem equivalente no Photoshop foram omitidas
+
+	File Naming	Nomenclatura de arquivos
+	Starting serial	Número de série inicial
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Inserir parada…
+	Save Set…	Salvar conjunto…
+	Message:	Mensagem:
+	Allow Continue	Permitir continuar
+	Show dialog during playback	Mostrar a caixa de diálogo durante a reprodução
+	Select an action first	Selecione uma ação primeiro
+	Action playback stopped	Reprodução da ação interrompida
+	Step {step} is waiting for its dialog	A etapa {step} está aguardando sua caixa de diálogo
+@plural	{n} action|{n} actions	{n} ação|{n} ações
+	Auto Add/Delete	Adicionar/excluir automaticamente
+	ICO is limited to 256 × 256 pixels	ICO é limitado a 256 × 256 pixels
diff --git a/crates/ui-egui/src/i18n/ru.tsv b/crates/ui-egui/src/i18n/ru.tsv
index 75d3dd8a84..11a3cb6b2e 100644
--- a/crates/ui-egui/src/i18n/ru.tsv
+++ b/crates/ui-egui/src/i18n/ru.tsv
@@ -17,9 +17,19 @@
 # letters; the trailing "…" of dialog commands is kept; the colon of a label ("Width:") becomes
 # the Russian typographic equivalent, with the space the source carries.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Цвет канала
+	Color Indicates:	Цветом обозначены:
+	Solidity:	Плотность:
+	Ink Characteristics	Характеристики краски
+
 # Menus
 
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Ширина бумаги
+	Paper Height	Высота бумаги
 	Rows	Строки
 	Number	Количество
 	Margin	Поля
@@ -79,6 +89,8 @@
 	Save	Сохранить
 	Save As…	Сохранить как…
 	Save a Copy…	Сохранить копию…
+	{name} can't keep everything in this document	{name} не может сохранить все содержимое этого документа
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Выберите формат, который сохранит все, например Photoshop (PSD), или сохраните копию.
 	Save…	Сохранить…
 	Revert	Восстановить
 	Import	Импорт
@@ -114,7 +126,7 @@
 	Fill…	Выполнить заливку…
 	Stroke…	Обвести…
 	Content-Aware Fill…	Заливка с учётом содержимого…
-	Delete and Fill Selection	Удалить и заполнить выделение
+	Delete and Fill Selection	Удалить и залить выделение
 	Define Brush Preset…	Определить кисть…
 	Define Pattern…	Определить паттерн…
 	Define Custom Shape…	Определить свою фигуру…
@@ -202,6 +214,9 @@
 	Enable Layer Mask	Включить маску слоя
 	Disable Layer Mask	Отключить маску слоя
 	Apply Layer Mask	Применить маску слоя
+	Add Mask to Selection	Добавить маску к выделению
+	Subtract Mask from Selection	Вычесть маску из выделения
+	Intersect Mask with Selection	Пересечь маску с выделением
 	Link Layer Mask	Связать маску слоя
 	Unlink Layer Mask	Отвязать маску слоя
 	Vector Mask	Векторная маска
@@ -270,6 +285,8 @@
 	Check Spelling	Проверка орфографии
 	Language Options	Языковые параметры
 	Find and Replace Text…	Найти и заменить текст…
+	Add to Dictionary	Добавить в словарь
+	No Spelling Suggestions	Нет вариантов написания
 	Paste Lorem Ipsum	Вставить условный текст
 	Glyphs Panel	Панель «Глифы»
 	Type Styles	Стили текста
@@ -326,6 +343,9 @@
 	Oil Paint…	Масляная живопись…
 	Blur Gallery	Галерея размытия
 	Field Blur…	Размытие по полю…
+# Field Blur pins (#3373)
+	No pin selected	Булавка не выбрана
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Щелкните изображение, чтобы добавить булавку; перетащите булавку, чтобы переместить ее, или ее кольцо, чтобы изменить размытие. Delete удаляет выбранную булавку.
 	Iris Blur…	Диафрагменное размытие…
 	Tilt-Shift…	Наклон-сдвиг…
 	Path Blur…	Размытие по контуру…
@@ -579,6 +599,7 @@
 	OK	OK
 	Cancel	Отмена
 	Cancel (Esc)	Отмена (Esc)
+	Manage submitted jobs in the system print queue	Управляйте отправленными заданиями в системной очереди печати
 	Done	Готово
 	Apply	Применить
 	Reset	Сброс
@@ -892,7 +913,7 @@
 	Assign working space	Назначить рабочее пространство
 	Use the embedded profile (instead of the working space)	Использовать встроенный профиль (вместо рабочего пространства)
 	Leave as is (don't color manage)	Оставить как есть (без управления цветом)
-	Discard the embedded profile (don't color manage)	Отклонить встроенный профиль (без управления цветом)
+	Discard the embedded profile (don't color manage)	Не использовать встроенный профиль (без управления цветом)
 	Embed Color Profile	Встроить цветовой профиль
 	Assign Profile…	Назначить профиль…
 	Convert to Profile…	Преобразовать в профиль…
@@ -1017,9 +1038,17 @@
 	Rename Brush…	Переименовать кисть…
 	Delete Brush	Удалить кисть
 	Import Brushes…	Импортировать кисти…
+	Gradient Preset Options	Параметры наборов градиентов
+	Import .GRD	Импортировать .GRD
+	Choose a gradient file (.grd).	Выберите файл градиентов (.grd).
 	Brush Name	Имя кисти
 	Brush Stroke	Мазок кисти
 	New Brush Preset…	Новый набор параметров кисти…
+	Capture Brush Size in Preset	Сохранить размер кисти в наборе
+	Include Tool Settings	Включить настройки инструмента
+	Include Color	Включить цвет
+	Enter a name for the brush preset	Введите имя набора параметров кисти
+	A brush preset with this name already exists	Набор параметров кисти с таким именем уже существует
 	Brush Preset Options	Параметры наборов кистей
 	New Brush	Новая кисть
 	Create new brush from these settings	Создать новую кисть из этих параметров
@@ -1181,6 +1210,8 @@
 	Offset	Смещение
 	Reset Transform	Сбросить трансформацию
 	Rotate	Повернуть
+	Set horizontal skew	Задать наклон по горизонтали
+	Set vertical skew	Задать наклон по вертикали
 	Flip Horizontal	Отразить по горизонтали
 	Flip Vertical	Отразить по вертикали
 	Frame Sync	Синхронизация кадров
@@ -1375,7 +1406,6 @@
 	Choose…	Выбрать…
 	Select Folder…	Выбрать папку…
 	Override Action "Save" Commands	Переопределить команды «Сохранить» в операции
-	File Naming	Именование файлов
 	Compatibility	Совместимость
 	Windows	Windows
 	Mac OS	Mac OS
@@ -1427,6 +1457,10 @@
 	Breeze Dark Theme	Тёмная тема Breeze
 	Breeze light	Breeze светлая
 	Breeze Light Theme	Светлая тема Breeze
+	Soft dark	Мягкая тёмная
+	Soft light	Мягкая светлая
+	Soft Dark Theme	Мягкая тёмная тема
+	Soft Light Theme	Мягкая светлая тема
 	Studio Theme	Тема Studio
 	Studio Light Theme	Светлая тема Studio
 	Adwaita Light Theme	Светлая тема Adwaita
@@ -1495,6 +1529,7 @@
 	Preset Name:	Имя набора:
 	Width and Height	Ширина и высота
 	Background Contents	Содержимое фона
+	Custom background color	Свой цвет фона
 	White	Белый
 	Background Color	Цвет фона
 	Transparent	Прозрачный
@@ -1677,6 +1712,12 @@
 	Show in Explorer	Показать в Проводнике
 	Show in Folder	Показать в папке
 	Before (Y)	До (Y)
+	Save Settings…	Сохранить настройки…
+	Load Settings…	Загрузить настройки…
+	Save these settings as a Camera Raw .xmp file	Сохранить эти настройки в файл Camera Raw .xmp
+	Load settings from a Camera Raw .xmp file	Загрузить настройки из файла Camera Raw .xmp
+	Loaded Camera Raw settings from {file}	Настройки Camera Raw загружены из {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Настройки Camera Raw загружены из {file} (не поддерживается: {n})
 	After (X)	После (X)
 	Original	Оригинал
 	Current	Текущий
@@ -1830,6 +1871,14 @@
 	Border…	Граница…
 	Bottom Edges	Нижние края
 	Browse…	Обзор…
+	Source Files	Исходные файлы
+	Use:	Использовать:
+	Files	Файлы
+	Folder	Папка
+	Add Open Files	Добавить открытые файлы
+	Sort By Name	Сортировать по имени
+	Attempt to Automatically Align Source Images	Попытаться автоматически выровнять исходные изображения
+	Create Smart Object after Loading Layers	Создать смарт-объект после загрузки слоёв
 	Canvas Guides	Направляющие холста
 	Character Styles Panel	Панель «Стили символов»
 	Clear Canvas Guides	Удалить направляющие холста
@@ -1897,6 +1946,7 @@
 	Lock Layers…	Заблокировать слои…
 	Mean	Среднее
 	Merge Down	Выполнить сведение
+	Merge Group	Объединить группу
 	Merge Layers	Объединить слои
 	Merge Shape Components	Объединить компоненты фигуры
 	Merge Visible	Свести видимые
@@ -1948,6 +1998,7 @@
 	Solid Color…	Однотонный цвет…
 	Square	Квадрат
 	Stack Mode	Режим стопки
+	Choose Stack Mode:	Выберите режим стопки:
 	Standard Deviation	Стандартное отклонение
 	Statistics…	Статистика…
 	Stylistic Alternates	Стилистические варианты
@@ -2423,6 +2474,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Нет контура для создания выделения: нарисуйте его инструментом «Перо» или выберите на панели «Контуры».
 	Cancel opening	Отменить открытие
 	Cancelled opening {name}	Открытие {name} отменено
+	The document “{name}” does not have an embedded {mode} profile.	В документе «{name}» нет встроенного профиля {mode}.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Встроенный цветовой профиль документа «{name}» не совпадает с текущим рабочим пространством {mode}.
+	Embedded: {embedded}	Встроенный: {embedded}
+	Working: {working}	Рабочее пространство: {working}
 	Developing {name}	Обработка {name}
 	Cancelled {label}	{label}: отменено
 	Esc to cancel	Esc — отмена
@@ -2590,6 +2645,7 @@ cameraRaw	Roughness	Неровность
 	Click to pick · Esc to cancel	Щелчок — выбрать · Esc — отменить
 	Pick a screen pixel or press Esc to cancel	Выберите пиксель на экране или нажмите Esc для отмены
 	Scroll to zoom	Колесо — изменить масштаб
+	Drag to pan · Scroll to zoom · Double-click to fit	Перетаскивание — перемещение · Колесо — масштаб · Двойной щелчок — вписать
 	Show/Hide All Panels	Показать/скрыть все панели
 	Show/Hide Panels	Показать/скрыть панели
 	Could not open	Не удалось открыть
@@ -2647,19 +2703,20 @@ cameraRaw	Roughness	Неровность
 	Fuchsia	Фуксия
 	Violet	Фиолетовый
 	Large document: redrawing on the CPU	Большой документ: перерисовка на CPU
+	Redrawing	Перерисовка
 	This redraw took {seconds} s on the CPU.	Эта перерисовка на CPU заняла {seconds} с.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Правки, затрагивающие весь документ, например режим наложения, непрозрачность или видимость слоя, перерисовывают его целиком.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Слои не помещаются в бюджет памяти GPU. Увеличение параметра «Память» в разделе Настройки › Производительность повышает бюджет, но не больше четверти памяти этого компьютера.
 	The GPU compositor wasn't used: {reason}	Компоновщик GPU не использовался: {reason}
 fontWeight	Thin	Тонкий
-fontWeight	ExtraLight	Особо светлый
-fontWeight	Light	Светлый
+fontWeight	ExtraLight	Сверхтонкий
+fontWeight	Light	Лёгкий
 fontWeight	Regular	Обычный
 fontWeight	Medium	Средний
 fontWeight	SemiBold	Полужирный
 fontWeight	Bold	Жирный
-fontWeight	ExtraBold	Особо жирный
-fontWeight	Black	Чёрный
+fontWeight	ExtraBold	Сверхжирный
+fontWeight	Black	Сверхжирный (Black)
 fontWeight	Italic	Курсив
 
 # Pattern Stamp tool
@@ -2955,6 +3012,7 @@ curves	Smooth	Сгладить
 	Select the crop presets to delete	Выберите наборы параметров кадрирования для удаления
 	Enter a name for the crop preset	Введите имя набора параметров кадрирования
 	There is no crop size or ratio to save	Нет размера или соотношения сторон кадрирования для сохранения
+	Presentation	Представление
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Щёлкните, чтобы разместить · Alt-щелчок или перетаскивание за пределы холста для удаления
@@ -2973,16 +3031,16 @@ curves	Smooth	Сгладить
 	The layer or its mask changed. Drag the mask onto the Trash again.	Слой или его маска изменились. Перетащите маску в корзину ещё раз.
 	Delete the vector mask?	Удалить векторную маску?
 # Counted status messages and labels (#3454; adapted from PR #3821)
-@plural	Exported {n} swatch to {file}|Exported {n} swatches to {file}	Экспортирован {n} образец в {file}|Экспортировано {n} образца в {file}|Экспортировано {n} образцов в {file}
-@plural	Imported {n} brush from {group}|Imported {n} brushes from {group}	Импортирована {n} кисть из {group}|Импортировано {n} кисти из {group}|Импортировано {n} кистей из {group}
-@plural	Imported {n} swatch from {file}|Imported {n} swatches from {file}	Импортирован {n} образец из {file}|Импортировано {n} образца из {file}|Импортировано {n} образцов из {file}
-@plural	Played {n} step|Played {n} steps	Воспроизведён {n} шаг|Воспроизведено {n} шага|Воспроизведено {n} шагов
-@plural	Updated {n} linked smart object changed on disk|Updated {n} linked smart objects changed on disk	Обновлён {n} связанный смарт-объект, изменённый на диске|Обновлено {n} связанных смарт-объекта, изменённых на диске|Обновлено {n} связанных смарт-объектов, изменённых на диске
+@plural	Exported {n} swatch to {file}|Exported {n} swatches to {file}	Экспортирован {n} образец в {file}|Экспортированы {n} образца в {file}|Экспортировано {n} образцов в {file}
+@plural	Imported {n} brush from {group}|Imported {n} brushes from {group}	Импортирована {n} кисть из {group}|Импортированы {n} кисти из {group}|Импортировано {n} кистей из {group}
+@plural	Imported {n} swatch from {file}|Imported {n} swatches from {file}	Импортирован {n} образец из {file}|Импортированы {n} образца из {file}|Импортировано {n} образцов из {file}
+@plural	Played {n} step|Played {n} steps	Воспроизведён {n} шаг|Воспроизведены {n} шага|Воспроизведено {n} шагов
+@plural	Updated {n} linked smart object changed on disk|Updated {n} linked smart objects changed on disk	Обновлён {n} связанный смарт-объект, изменённый на диске|Обновлены {n} связанных смарт-объекта, изменённых на диске|Обновлено {n} связанных смарт-объектов, изменённых на диске
 @plural	Saved for Web: {n} file|Saved for Web: {n} files	Сохранено для Web: {n} файл|Сохранено для Web: {n} файла|Сохранено для Web: {n} файлов
-@plural	{n} layer recorded by this comp was deleted. Update the comp, or clear the warning.|{n} layers recorded by this comp were deleted. Update the comp, or clear the warning.	Удалён {n} слой, записанный в этом варианте. Обновите вариант или сбросьте предупреждение.|Удалено {n} слоя, записанных в этом варианте. Обновите вариант или сбросьте предупреждение.|Удалено {n} слоёв, записанных в этом варианте. Обновите вариант или сбросьте предупреждение.
+@plural	{n} layer recorded by this comp was deleted. Update the comp, or clear the warning.|{n} layers recorded by this comp were deleted. Update the comp, or clear the warning.	Удалён {n} слой, записанный в этом варианте. Обновите вариант или сбросьте предупреждение.|Удалены {n} слоя, записанных в этом варианте. Обновите вариант или сбросьте предупреждение.|Удалено {n} слоёв, записанных в этом варианте. Обновите вариант или сбросьте предупреждение.
 @plural	{n} plane|{n} planes	{n} плоскость|{n} плоскости|{n} плоскостей
 @plural	{n} preset|{n} presets	{n} набор|{n} набора|{n} наборов
-@plural	{n} sample point removed|{n} sample points removed	Удалена {n} точка замера|Удалено {n} точки замера|Удалено {n} точек замера
+@plural	{n} sample point removed|{n} sample points removed	Удалена {n} точка замера|Удалены {n} точки замера|Удалено {n} точек замера
 @plural	{n} slice|{n} slices	{n} фрагмент|{n} фрагмента|{n} фрагментов
 @plural	{n} step|{n} steps	{n} шаг|{n} шага|{n} шагов
 @plural	{warning} (+{n} more brush preset warning)|{warning} (+{n} more brush preset warnings)	{warning} (и ещё {n} предупреждение о наборах кистей)|{warning} (и ещё {n} предупреждения о наборах кистей)|{warning} (и ещё {n} предупреждений о наборах кистей)
@@ -2992,3 +3050,56 @@ curves	Smooth	Сгладить
 	Light Red	Светло-красный
 	Medium Blue	Средне-синий
 	Light Gray	Светло-серый
+	Object Finder	Поиск объектов
+	No object found there — drag a rectangle around it	Объект не найден — обведите его прямоугольником
+	Remove after each stroke	Удалять после каждого штриха
+	Apply the removal ({key})	Применить удаление ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Штрихов к удалению: {n} (Enter применяет, Esc отменяет)
+	Clear Brush Controls	Очистить параметры кисти
+	Reset All Locked Settings	Сбросить все заблокированные параметры
+	Copy Texture to Other Tools	Скопировать текстуру в другие инструменты
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Загрузить операции…
+	Save Actions…	Сохранить операции…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Загружена {n} операция из {file}|Загружены {n} операции из {file}|Загружено {n} операций из {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} шаг пока не имеет эквивалента в PhotoCraft|{n} шага пока не имеют эквивалента в PhotoCraft|{n} шагов пока не имеют эквивалента в PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Сохранена {n} операция в {file}|Сохранены {n} операции в {file}|Сохранено {n} операций в {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Пропущен {n} шаг без эквивалента в Photoshop|Пропущены {n} шага без эквивалента в Photoshop|Пропущено {n} шагов без эквивалента в Photoshop
+
+	File Naming	Именование файлов
+	Starting serial	Начальный порядковый номер
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Вставить остановку…
+	Save Set…	Сохранить набор…
+	Message:	Сообщение:
+	Allow Continue	Разрешить продолжение
+	Show dialog during playback	Показывать диалог при воспроизведении
+	Select an action first	Сначала выберите операцию
+	Action playback stopped	Воспроизведение операции остановлено
+	Step {step} is waiting for its dialog	Шаг {step} ожидает своего диалога
+@plural	{n} action|{n} actions	{n} операция|{n} операции|{n} операций
+	Auto Add/Delete	Автодобавление/удаление
+	ICO is limited to 256 × 256 pixels	ICO ограничен размером 256 × 256 пикселей
+
+# Dynamic selection context menu and appearance favorites
+	Select Inverse	Инвертировать выделение
+	Pro (Light)	Pro (светлая)
+	Pro (Light Gray)	Pro (светло-серая)
+
+# Measurement Log column headers (analysis_cmds::COLUMNS)
+	Label	Метка
+	Date and Time	Дата и время
+	Scale Units	Единицы масштаба
+	Scale Factor	Коэффициент масштаба
+	Area	Площадь
+	Perimeter	Периметр
+	Circularity	Круглость
+	Gray Value (Minimum)	Уровень серого (минимум)
+	Gray Value (Maximum)	Уровень серого (максимум)
+	Gray Value (Mean)	Уровень серого (среднее)
+	Gray Value (Median)	Уровень серого (медиана)
+	Integrated Density	Интегральная плотность
+	Length	Длина
diff --git a/crates/ui-egui/src/i18n/sr.tsv b/crates/ui-egui/src/i18n/sr.tsv
new file mode 100644
index 0000000000..f47fe20162
--- /dev/null
+++ b/crates/ui-egui/src/i18n/sr.tsv
@@ -0,0 +1,4213 @@
+# Serbian (sr) catalog, Latin script, Ekavian. Columns, separated by a TAB:  context <TAB> source <TAB> translation
+#
+#   context  empty                a plain UI string; `source` is the English text in the code
+#            @id                  a command id (e.g. file.saveAs): wins over the English text for
+#                                 that menu item, so one id can read differently from its twin
+#            @plural              `source` is "one|other" (English forms); the translation lists
+#                                 the Serbian forms "one|few|many" (1, 21, 101 … | 2–4, 22–24 … but
+#                                 not 12–14 | everything else), see `plural` in i18n/mod.rs
+#   escapes  \n  \t  \\  inside a column. `{name}` placeholders must appear in both columns.
+#   lines starting with # and blank lines are ignored.
+#
+# Clean-room: every entry was written from the plain meaning of the English label using ordinary
+# Serbian computing vocabulary (sloj, maska, selekcija, četkica, gradijent, zamućenje,
+# neprozirnost, providnost ...). No proprietary localisation resource, string table or product UI
+# was consulted or copied; in particular not the Serbian localisation of Adobe Photoshop. Add
+# entries the same way.
+# Conventions: Serbian Latin script (latinica), Ekavian (ekavica), sentence case. Menus are nouns
+# (Datoteka, Uređivanje, Slika ...), commands are imperatives (Otvori…, Sačuvaj kao…), tools read
+# "Alatka …" (Alatka četkica, Alatka za pomeranje), presets are "šabloni", patterns "šare" and
+# swatches "uzorci boja". Serbian quotation marks „…“ around names. Product and technology names
+# (PhotoCraft, ArtCraft, Camera Raw, OpenType, Lab ...) stay as they are; RGB/CMYK stay as they
+# are; the trailing "…" of dialog commands is kept. A count that is not an @plural entry is kept
+# out of noun agreement ("Broj: {n}", "slojeva: {n}") so every number reads correctly.
+
+# Guide layout dialog
+	Rows	Redovi
+	Number	Broj
+	Margin	Margina
+	Top:	Gore:
+	Left:	Levo:
+	Bottom:	Dole:
+	Right:	Desno:
+	Target:	Cilj:
+	Selected Artboards	Izabrane radne table
+	Center Columns	Centriraj kolone
+	Clear Existing Guides	Ukloni postojeće vodilje
+	Invalid guide layout	Neispravan raspored vodilja
+	Leave empty for automatic size	Ostavite prazno za automatsku veličinu
+	5 Columns, 3 Rows	5 kolona, 3 reda
+	8 Columns	8 kolona
+	12 Columns	12 kolona
+
+	File	Datoteka
+	Edit	Uređivanje
+	Image	Slika
+	Layer	Sloj
+	Type	Tekst
+	Select	Selekcija
+	Selected	Izabrano
+	Scope	Opseg
+	Top Left	Gore levo
+	Top Right	Gore desno
+	Bottom Left	Dole levo
+	Bottom Right	Dole desno
+	Filter	Filter
+	View	Prikaz
+	Window	Prozor
+	Help	Pomoć
+	(coming soon)	(uskoro)
+	New…	Novo…
+	Open…	Otvori…
+	Open As…	Otvori kao…
+	Open EXR Parts…	Otvori EXR delove…
+	Add beauty precomp from the AOVs	Dodaj „beauty“ predkompoziciju iz AOV prolaza
+	Both	Oba
+	Left	Levo
+	Right	Desno
+	Open Recent	Otvori nedavno
+	Clear Recent Files	Obriši spisak nedavnih datoteka
+	Remove from Recent	Ukloni iz nedavnih
+	Remove {name} from Recent	Ukloni {name} iz nedavnih
+	Close	Zatvori
+	Minimize	Umanji
+	Maximize	Uvećaj
+	Restore	Vrati
+	Close All	Zatvori sve
+	Close Others	Zatvori ostale
+	Save	Sačuvaj
+	Save As…	Sačuvaj kao…
+	Save a Copy…	Sačuvaj kopiju…
+	{name} can't keep everything in this document	{name} ne može da sačuva sve iz ovog dokumenta
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Izaberite format koji sve čuva, na primer Photoshop (PSD), ili sačuvajte kopiju.
+	Revert	Vrati sačuvano
+	Export	Izvoz
+	Quick Export as PNG	Brzi izvoz u PNG
+	Export As…	Izvezi kao…
+	Export Preferences…	Podešavanja izvoza…
+	Save for Web (Legacy)…	Sačuvaj za veb (staro)…
+	Artboards to Files…	Radne table u datoteke…
+	Artboards to PDF…	Radne table u PDF…
+	Layers to Files…	Slojevi u datoteke…
+	Layer Comps to Files…	Kompozicije slojeva u datoteke…
+	Color Lookup Tables…	Tabele preslikavanja boja…
+	Data Sets as Files…	Skupovi podataka kao datoteke…
+	Paths to Illustrator…	Putanje u Illustrator…
+	Render Video…	Renderuj video…
+	Generate	Generisanje
+	Image Assets	Slikovni resursi
+	Place Embedded…	Postavi ugrađeno…
+	Place Linked…	Postavi povezano…
+	Package…	Spakuj…
+	Automate	Automatizacija
+	Batch…	Grupna obrada…
+	Create Droplet…	Napravi droplet…
+	Crop and Straighten Photos	Opseci i ispravi fotografije
+	Contact Sheet II…	Kontakt-list II…
+	Conditional Mode Change…	Uslovna promena režima…
+	Fit Image…	Uklopi sliku…
+	Lens Correction…	Korekcija objektiva…
+	Merge to HDR Pro…	Spoji u HDR Pro…
+	Photomerge…	Spajanje fotografija…
+	Scripts	Skripte
+	Image Processor…	Obrada slika…
+	Delete All Empty Layers	Obriši sve prazne slojeve
+	Flatten All Layer Effects	Spljošti sve efekte slojeva
+	Flatten All Masks	Spljošti sve maske
+	Script Events Manager…	Upravljač događajima skripti…
+	Import	Uvoz
+	Browse…	Pregledaj…
+	Source Files	Izvorne datoteke
+	Use:	Koristi:
+	Files	Datoteke
+	Add Open Files	Dodaj otvorene datoteke
+	Sort By Name	Poređaj po imenu
+	Attempt to Automatically Align Source Images	Pokušaj automatski poravnati izvorne slike
+	Create Smart Object after Loading Layers	Napravi pametni objekat posle učitavanja slojeva
+	Reveal in Finder	Prikaži u Finderu
+	Show in Explorer	Prikaži u Exploreru
+	Show in Folder	Prikaži u fascikli
+	File Info…	Informacije o datoteci…
+	Print…	Štampaj…
+	Print One Copy	Štampaj jedan primerak
+	Exit	Izađi
+	Undo	Opozovi
+	Redo	Ponovi
+	Toggle Last State	Prebaci na poslednje stanje
+	Fade…	Ublaži…
+	Cut	Iseci
+	Copy	Kopiraj
+	Copy Merged	Kopiraj spojeno
+	Paste	Nalepi
+	Paste Special	Specijalno lepljenje
+	Paste in Place	Nalepi na isto mesto
+	Paste Into	Nalepi unutra
+	Paste Outside	Nalepi spolja
+	Paste Lorem Ipsum	Nalepi Lorem Ipsum
+	Clear	Obriši
+	Search…	Pretraga…
+	Check Spelling…	Proveri pravopis…
+	Find and Replace Text…	Pronađi i zameni tekst…
+	Fill…	Popuni…
+	Stroke…	Ocrtaj…
+	Content-Aware Fill…	Popuna prema sadržaju…
+	Delete and Fill Selection	Obriši i popuni selekciju
+	Content-Aware Scale	Skaliranje prema sadržaju
+	Puppet Warp	Lutkarsko krivljenje
+	Perspective Warp	Perspektivno krivljenje
+	Free Transform	Slobodna transformacija
+	Transform	Transformacija
+	Again	Ponovo
+	Scale	Skaliranje
+	Rotate	Rotacija
+	Skew	Iskošenje
+	Set horizontal skew	Podesi horizontalno iskošenje
+	Set vertical skew	Podesi vertikalno iskošenje
+	Distort	Izobličenje
+	Perspective	Perspektiva
+	Warp	Krivljenje
+	Flip Horizontal	Okreni horizontalno
+	Flip Vertical	Okreni vertikalno
+	Rotate 180°	Rotiraj za 180°
+	Rotate 90° Clockwise	Rotiraj za 90° udesno
+	Rotate 90° Counter Clockwise	Rotiraj za 90° ulevo
+	180°	180°
+	90° Clockwise	90° udesno
+	90° Counter Clockwise	90° ulevo
+	Arbitrary…	Proizvoljno…
+	Auto-Align Layers…	Automatski poravnaj slojeve…
+	Auto-Blend Layers…	Automatski stopi slojeve…
+	Define Brush Preset…	Definiši šablon četkice…
+	Define Pattern…	Definiši šaru…
+	Define Custom Shape…	Definiši prilagođeni oblik…
+	Purge	Isprazni
+	Clipboard	Ostava
+	Histories	Istorije
+	Video Cache	Video keš
+	All	Sve
+	Presets	Šabloni
+	Preset Manager…	Upravljač šablonima…
+	Migrate Presets	Prenesi šablone
+	Export/Import Presets…	Izvoz/uvoz šablona…
+	Color Settings…	Podešavanja boja…
+	Assign Profile…	Dodeli profil…
+	Convert to Profile…	Pretvori u profil…
+	Keyboard Shortcuts…	Prečice na tastaturi…
+	Menus…	Meniji…
+	Toolbar…	Traka alatki…
+	Preferences	Podešavanja
+	General…	Opšte…
+	Interface…	Interfejs…
+	Workspace…	Radni prostor…
+	Tools…	Alatke…
+	History Log…	Dnevnik istorije…
+	File Handling…	Rukovanje datotekama…
+	Export…	Izvoz…
+	Performance…	Performanse…
+	Scratch Disks…	Radni diskovi…
+	Cursors…	Kursori…
+	Transparency & Gamut…	Providnost i gamut…
+	Units & Rulers…	Jedinice i lenjiri…
+	Guides, Grid & Slices…	Vodilje, mreža i isečci…
+	Plug-ins…	Dodaci…
+	Type…	Tekst…
+	Enhanced Controls…	Napredne kontrole…
+	Camera Raw…	Camera Raw…
+	Raw Defaults…	Podrazumevana Raw podešavanja…
+	Integrations…	Integracije…
+	AI Integrations…	AI integracije…
+	Install Plug-in…	Instaliraj dodatak…
+	Language Options	Jezičke opcije
+	Settings…	Podešavanja…
+	Mode	Režim
+	Bitmap	Bitmapa
+	Grayscale	Nijanse sive
+	Duotone	Duoton
+	Indexed Color	Indeksirane boje
+	RGB Color	RGB boje
+	CMYK Color	CMYK boje
+	Lab Color	Lab boje
+	Multichannel	Višekanalno
+	8 Bits/Channel	8 bita/kanal
+	16 Bits/Channel	16 bita/kanal
+	32 Bits/Channel	32 bita/kanal
+	Color Table…	Tabela boja…
+	Bitmap…	Bitmapa…
+	Duotone…	Duoton…
+	Indexed Color…	Indeksirane boje…
+	Adjustments	Korekcije
+	Brightness/Contrast…	Osvetljenost/kontrast…
+	Levels…	Nivoi…
+	Curves…	Krive…
+	Exposure…	Ekspozicija…
+	Vibrance…	Živost…
+	Hue/Saturation…	Nijansa/zasićenost…
+	Color Balance…	Balans boja…
+	Black & White…	Crno-belo…
+	Photo Filter…	Foto-filter…
+	Channel Mixer…	Mešač kanala…
+	Color Lookup…	Preslikavanje boja…
+	Invert	Invertuj
+	Posterize…	Posterizuj…
+	Threshold…	Prag…
+	Gradient Map…	Mapa gradijenta…
+	Selective Color…	Selektivna boja…
+	Shadows/Highlights…	Senke/svetla…
+	HDR Toning…	HDR toniranje…
+	Desaturate	Ukloni zasićenost
+	Match Color…	Uskladi boje…
+	Replace Color…	Zameni boju…
+	Equalize	Izjednači
+	Auto Tone	Automatski ton
+	Auto Contrast	Automatski kontrast
+	Auto Color	Automatske boje
+	Image Size…	Veličina slike…
+	Canvas Size…	Veličina platna…
+	Image Rotation	Rotacija slike
+	Flip Canvas Horizontal	Okreni platno horizontalno
+	Flip Canvas Vertical	Okreni platno vertikalno
+	Crop	Opseci
+	Trim…	Odseci ivice…
+	Reveal All	Otkrij sve
+	Duplicate…	Dupliraj…
+	Apply Image…	Primeni sliku…
+	Calculations…	Proračuni…
+	Variables	Promenljive
+	Define…	Definiši…
+	Data Sets…	Skupovi podataka…
+	Apply Data Set…	Primeni skup podataka…
+	Variable Data Sets…	Promenljivi skupovi podataka…
+	Trap…	Trepovanje…
+	Analysis	Analiza
+	Set Measurement Scale…	Postavi razmeru merenja…
+	Select Data Points…	Izaberi tačke podataka…
+	Record Measurements	Zabeleži merenja
+	Ruler Tool	Alatka lenjir
+	Count Tool	Alatka za brojanje
+	Place Scale Marker…	Postavi oznaku razmere…
+	Custom…	Prilagođeno…
+	New	Novo
+	Layer…	Sloj…
+	Group…	Grupa…
+	Group from Layers…	Grupa od slojeva…
+	Artboard…	Radna tabla…
+	Artboard from Group…	Radna tabla od grupe…
+	Artboard from Layers…	Radna tabla od slojeva…
+	Layer via Copy	Sloj kopiranjem
+	Layer via Cut	Sloj isecanjem
+	Layer From Background…	Sloj od pozadine…
+	Layer from Background…	Sloj od pozadine…
+	Background From Layer	Pozadina od sloja
+	New Shape Layer	Novi sloj oblika
+	New Type Layer	Novi tekstualni sloj
+	New Fill Layer	Novi sloj popune
+	New Adjustment Layer	Novi korekcioni sloj
+	New Layer Based Slice	Novi isečak zasnovan na sloju
+	New Smart Object via Copy	Novi pametni objekat kopiranjem
+	New Blank Video Layer	Novi prazan video sloj
+	New Video Layer from File…	Novi video sloj iz datoteke…
+	Duplicate Layer…	Dupliraj sloj…
+	Delete Layer	Obriši sloj
+	Delete	Obriši
+	Rename Layer	Preimenuj sloj
+	Create Layer	Napravi sloj
+	Layer Style	Stil sloja
+	Blending Options…	Opcije stapanja…
+	Bevel & Emboss…	Kosina i reljef…
+	Inner Shadow…	Unutrašnja senka…
+	Inner Glow…	Unutrašnji sjaj…
+	Satin…	Saten…
+	Color Overlay…	Prekrivanje bojom…
+	Gradient Overlay…	Prekrivanje gradijentom…
+	Pattern Overlay…	Prekrivanje šarom…
+	Outer Glow…	Spoljašnji sjaj…
+	Drop Shadow…	Bačena senka…
+	Copy Layer Style	Kopiraj stil sloja
+	Paste Layer Style	Nalepi stil sloja
+	Clear Layer Style	Ukloni stil sloja
+	Global Light…	Globalno svetlo…
+	Hide All Effects	Sakrij sve efekte
+	Scale Effects…	Skaliraj efekte…
+	Smart Filter	Pametni filter
+	Convert for Smart Filters	Pretvori za pametne filtere
+	Clear Smart Filters	Ukloni pametne filtere
+	Disable Smart Filters	Onemogući pametne filtere
+	Delete Filter Mask	Obriši masku filtera
+	Disable Filter Mask	Onemogući masku filtera
+	Solid Color…	Puna boja…
+	Gradient…	Gradijent…
+	Pattern…	Šara…
+	Layer Mask	Maska sloja
+	Vector Mask	Vektorska maska
+	Reveal Selection	Otkrij selekciju
+	Hide Selection	Sakrij selekciju
+	Hide All	Sakrij sve
+	From Transparency	Iz providnosti
+	Delete Vector Mask	Obriši vektorsku masku
+	Enable Layer Mask	Omogući masku sloja
+	Disable Layer Mask	Onemogući masku sloja
+	Enable Vector Mask	Omogući vektorsku masku
+	Link Layer Mask	Poveži masku sloja
+	Unlink Layer Mask	Razveži masku sloja
+	Link Vector Mask	Poveži vektorsku masku
+	Add Vector Mask	Dodaj vektorsku masku
+	Vector Mask from Current Path	Vektorska maska od tekuće putanje
+	Create Clipping Mask	Napravi masku isecanja
+	Release Clipping Mask	Otpusti masku isecanja
+	Smart Objects	Pametni objekti
+	Smart Object	Pametni objekat
+	Convert to Smart Object	Pretvori u pametni objekat
+	Convert to Embedded	Pretvori u ugrađeni
+	Convert to Layers	Pretvori u slojeve
+	Convert to Linked…	Pretvori u povezani…
+	Edit Contents	Uredi sadržaj
+	Replace Contents…	Zameni sadržaj…
+	Relink to File…	Ponovo poveži sa datotekom…
+	Export Contents…	Izvezi sadržaj…
+	Update Modified Content	Ažuriraj izmenjeni sadržaj
+	Update All Modified Content	Ažuriraj sav izmenjeni sadržaj
+	Stack Mode	Režim steka
+	Choose Stack Mode:	Izaberite režim steka:
+	Entropy	Entropija
+	Kurtosis	Kurtozis
+	Maximum	Maksimum
+	Mean	Srednja vrednost
+	Median	Medijana
+	Minimum	Minimum
+	Range	Opseg
+	Skewness	Asimetrija
+	Standard Deviation	Standardna devijacija
+	Summation	Zbir
+	Variance	Varijansa
+	Video Layers	Video slojevi
+	Interpret Footage…	Tumači snimak…
+	Replace Footage…	Zameni snimak…
+	Reload Frame	Ponovo učitaj kadar
+	Show Altered Video	Prikaži izmenjeni video
+	Restore Frame	Vrati kadar
+	Restore All Frames	Vrati sve kadrove
+	Insert Blank Frame	Umetni prazan kadar
+	Delete Frame	Obriši kadar
+	Duplicate Frame	Dupliraj kadar
+	Frame from Layers	Okvir od slojeva
+	Video Frames to Layers…	Video kadrovi u slojeve…
+	Rasterize	Rasterizuj
+	Rasterize Type	Rasterizuj tekst
+	Rasterize Type Layer	Rasterizuj tekstualni sloj
+	Rasterize Shape	Rasterizuj oblik
+	New Guide Layout…	Novi raspored vodilja…
+	New Guides From Shape	Nove vodilje od oblika
+	Lock Layers…	Zaključaj slojeve…
+	Link Layers	Poveži slojeve
+	Select Linked Layers	Izaberi povezane slojeve
+	Merge Layers	Spoji slojeve
+	Merge Down	Spoji nadole
+	Merge Group	Spoji grupu
+	Merge Visible	Spoji vidljive
+	Stamp Visible	Utisni vidljive
+	Stamp Down	Utisni nadole
+	Flatten Image	Spljošti sliku
+	Matting	Čišćenje ivica
+	Color Decontaminate…	Dekontaminacija boja…
+	Remove Black Matte	Ukloni crni oreol
+	Remove White Matte	Ukloni beli oreol
+	Defringe…	Ukloni rub…
+	Group Layers	Grupiši slojeve
+	Ungroup Layers	Razgrupiši slojeve
+	Hide Layers	Sakrij slojeve
+	Arrange	Raspored
+	Bring to Front	Premesti na vrh
+	Bring Forward	Pomeri napred
+	Send Backward	Pomeri nazad
+	Send to Back	Premesti na dno
+	Reverse	Obrni
+	Combine Shapes	Kombinuj oblike
+	Unite Shapes	Ujedini oblike
+	Subtract Front Shape	Oduzmi prednji oblik
+	Intersect Shape Areas	Presek oblasti oblika
+	Exclude Overlapping Shapes	Isključi preklapajuće oblike
+	Merge Shape Components	Spoji komponente oblika
+	Align	Poravnaj
+	Top Edges	Gornje ivice
+	Vertical Centers	Vertikalni centri
+	Bottom Edges	Donje ivice
+	Left Edges	Leve ivice
+	Horizontal Centers	Horizontalni centri
+	Right Edges	Desne ivice
+	Distribute	Raspodeli
+	Vertically	Vertikalno
+	Horizontally	Horizontalno
+	Layer Edges	Ivice sloja
+	Isolate Layers	Izoluj slojeve
+	Layer Content Options…	Opcije sadržaja sloja…
+	Fill Content	Sadržaj popune
+	Deselect Layers	Poništi izbor slojeva
+	Find Layers	Pronađi slojeve
+	Layer Comps	Kompozicije slojeva
+	Layers	Slojevi
+	All Layers	Svi slojevi
+	Hidden Layers	Skriveni slojevi
+	Mask All Objects	Maskiraj sve objekte
+	Subject	Subjekat
+	Sky	Nebo
+	Panels	Paneli
+	Character Panel	Panel znakova
+	Paragraph Panel	Panel pasusa
+	Character Styles Panel	Panel stilova znakova
+	Paragraph Styles Panel	Panel stilova pasusa
+	Glyphs Panel	Panel glifova
+	Anti-Alias	Uglađivanje ivica
+	Sharp	Oštro
+	Crisp	Jasno
+	Strong	Snažno
+	Smooth	Glatko
+	Windows LCD	Windows LCD
+	Windows	Windows
+	Orientation	Orijentacija
+	Horizontal	Horizontalno
+	Vertical	Vertikalno
+	OpenType	OpenType
+	Standard Ligatures	Standardne ligature
+	Contextual Alternates	Kontekstualne alternative
+	Discretionary Ligatures	Opcione ligature
+	Swash	Kićeni oblici
+	Oldstyle	Starinske cifre
+	Stylistic Alternates	Stilske alternative
+	Titling Alternates	Naslovne alternative
+	Ornaments	Ornamenti
+	Ordinals	Redni brojevi
+	Fractions	Razlomci
+	Create Work Path	Napravi radnu putanju
+	Convert to Shape	Pretvori u oblik
+	Warp Text…	Krivljenje teksta…
+	Convert to Point Text	Pretvori u tačkasti tekst
+	Convert to Paragraph Text	Pretvori u tekst pasusa
+	Default Features	Podrazumevane funkcije
+	East Asian Features	Funkcije za istočnoazijska pisma
+	Middle Eastern Features	Funkcije za bliskoistočna pisma
+	Middle Eastern & South Asian Composer	Slagač za bliskoistočna i južnoazijska pisma
+	Update All Text Layers	Ažuriraj sve tekstualne slojeve
+	Replace All Missing Fonts	Zameni sve fontove koji nedostaju
+	Resolve Missing Fonts…	Razreši fontove koji nedostaju…
+	Font Preview Size	Veličina pregleda fonta
+	None	Ništa
+	Small	Mala
+	Medium	Srednja
+	Large	Velika
+	Extra Large	Veoma velika
+	Huge	Ogromna
+	Load Default Type Styles	Učitaj podrazumevane stilove teksta
+	Save Default Type Styles	Sačuvaj podrazumevane stilove teksta
+	Deselect	Poništi selekciju
+	Reselect	Ponovo izaberi
+	Inverse	Inverzno
+	Inverse Selection	Obrni selekciju
+	Similar	Slično
+	Color Range…	Opseg boja…
+	Focus Area…	Oblast fokusa…
+	Select and Mask…	Izaberi i maskiraj…
+# Select and Mask dialog labels
+	Smart Radius	Pametni poluprečnik
+	Shift Edge	Pomeri ivicu
+	Decontaminate	Očisti boje
+	Output	Izlaz
+	Refine Edge	Doteraj ivicu
+	Modify	Izmeni
+	Border…	Obod…
+	Smooth…	Izgladi…
+	Expand…	Proširi…
+	Contract…	Suzi…
+	Feather…	Omekšaj ivice…
+	Grow	Uvećaj
+	Transform Selection	Transformiši selekciju
+	Edit in Quick Mask Mode	Uredi u režimu brze maske
+	Load Selection…	Učitaj selekciju…
+	Save Selection…	Sačuvaj selekciju…
+	Match All	Uskladi sve
+	Last Filter	Poslednji filter
+	Filter Gallery…	Galerija filtera…
+	Adaptive Wide Angle…	Prilagodljivi široki ugao…
+	Camera Raw Filter…	Camera Raw filter…
+	Liquify…	Tečno izobličavanje…
+	Vanishing Point…	Tačka nestajanja…
+	Blur	Zamućenje
+	Blur Gallery	Galerija zamućenja
+	Field Blur…	Zamućenje polja…
+	No pin selected	Nijedna čioda nije izabrana
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Kliknite na sliku da dodate čiodu; prevucite čiodu da je pomerite ili njen prsten da promenite zamućenje. Delete uklanja izabranu čiodu.
+	Iris Blur…	Iris zamućenje…
+	Tilt-Shift…	Tilt-shift…
+	Path Blur…	Zamućenje duž putanje…
+	Spin Blur…	Rotaciono zamućenje…
+	Blur More	Jače zamućenje
+	Box Blur…	Pravougaono zamućenje…
+	Gaussian Blur…	Gausovo zamućenje…
+	Lens Blur…	Zamućenje objektiva…
+	Motion Blur…	Zamućenje pokreta…
+	Radial Blur…	Radijalno zamućenje…
+	Shape Blur…	Zamućenje oblikom…
+	Smart Blur…	Pametno zamućenje…
+	Surface Blur…	Površinsko zamućenje…
+	Average	Prosek
+	Displace…	Premeštanje…
+	Pinch…	Skupljanje…
+	Polar Coordinates…	Polarne koordinate…
+	Ripple…	Talasanje…
+	Shear…	Smicanje…
+	Spherize…	Sferizacija…
+	Twirl…	Uvrtanje…
+	Wave…	Talas…
+	ZigZag…	Cik-cak…
+	Noise	Šum
+	Add Noise…	Dodaj šum…
+	Despeckle	Ukloni mrlje
+	Dust & Scratches…	Prašina i ogrebotine…
+	Median…	Medijana…
+	Reduce Noise…	Smanji šum…
+	Pixelate	Pikselizacija
+	Color Halftone…	Polutonski raster u boji…
+	Crystallize…	Kristalizacija…
+	Facet	Fasete
+	Fragment	Fragmentacija
+	Mezzotint…	Mecotinta…
+	Mosaic…	Mozaik…
+	Pointillize…	Poentilizam…
+	Render	Renderovanje
+	Clouds	Oblaci
+	Difference Clouds	Oblaci razlike
+	Fibers…	Vlakna…
+	Flame…	Plamen…
+	Lens Flare…	Odsjaj objektiva…
+	Lighting Effects…	Efekti osvetljenja…
+	Relight…	Ponovno osvetljavanje…
+	Picture Frame…	Ram za sliku…
+	Tree…	Drvo…
+	Sharpen	Izoštravanje
+	Sharpen Edges	Izoštri ivice
+	Sharpen More	Jače izoštravanje
+	Smart Sharpen…	Pametno izoštravanje…
+	Unsharp Mask…	Maska neoštrine…
+	High Pass…	Visokopropusni filter…
+	Stylize	Stilizacija
+	Diffuse…	Rasipanje…
+	Emboss…	Reljef…
+	Extrude…	Istiskivanje…
+	Find Edges	Pronađi ivice
+	Oil Paint…	Uljana boja…
+	Solarize	Solarizacija
+	Tiles…	Pločice…
+	Trace Contour…	Praćenje konture…
+	Wind…	Vetar…
+	Video	Video
+	De-Interlace…	Uklanjanje preplitanja…
+	NTSC Colors	NTSC boje
+	Other	Ostalo
+	Maximum…	Maksimum…
+	Minimum…	Minimum…
+	Offset…	Pomak…
+	Plug-ins	Dodaci
+	Proof Setup	Podešavanje probnog prikaza
+	Proof Colors	Probne boje
+	Gamut Warning	Upozorenje o gamutu
+	Working CMYK	Radni CMYK
+	Working Cyan Plate	Radna cijan ploča
+	Working Magenta Plate	Radna magenta ploča
+	Working Yellow Plate	Radna žuta ploča
+	Working Black Plate	Radna crna ploča
+	Working CMY Plate	Radna CMY ploča
+	Legacy Macintosh RGB	Stari Macintosh RGB
+	Internet Standard RGB	Internet standard RGB
+	Monitor RGB	RGB monitora
+	Color Blindness — Protanopia-type	Daltonizam — tip protanopije
+	Color Blindness — Deuteranopia-type	Daltonizam — tip deuteranopije
+	Zoom In	Uvećaj prikaz
+	Zoom Out	Umanji prikaz
+	Fit on Screen	Uklopi u ekran
+	Fit Layer(s) on Screen	Uklopi sloj(eve) u ekran
+	Fit Artboard on Screen	Uklopi radnu tablu u ekran
+	100%	100%
+	200%	200%
+	75%	75%
+	80%	80%
+	85%	85%
+	90%	90%
+	95%	95%
+	125%	125%
+	150%	150%
+	175%	175%
+	250%	250%
+	300%	300%
+	Print Size	Veličina za štampu
+	Pixel Aspect Ratio	Odnos stranica piksela
+	Pixel Aspect Ratio Correction	Korekcija odnosa stranica piksela
+	Custom Pixel Aspect Ratio…	Prilagođeni odnos stranica piksela…
+	Square	Kvadrat
+	D1/DV NTSC (0.91)	D1/DV NTSC (0.91)
+	D1/DV NTSC Widescreen (1.21)	D1/DV NTSC, široki ekran (1.21)
+	D1/DV PAL (1.09)	D1/DV PAL (1.09)
+	D1/DV PAL Widescreen (1.46)	D1/DV PAL, široki ekran (1.46)
+	Anamorphic 2:1 (2)	Anamorfno 2:1 (2)
+	HDV 1080/DVCPRO HD 720 (1.33)	HDV 1080/DVCPRO HD 720 (1.33)
+	DVCPRO HD 1080/HDV 1080 (1.5)	DVCPRO HD 1080/HDV 1080 (1.5)
+	32-bit Preview Options…	Opcije 32-bitnog pregleda…
+	Screen Mode	Režim ekrana
+	Standard Screen Mode	Standardni režim ekrana
+	Full Screen Mode With Menu Bar	Režim celog ekrana sa trakom menija
+	Full Screen Mode	Režim celog ekrana
+	Cycle Screen Mode	Smenjuj režime ekrana
+	Show	Prikaži
+	Extras	Dodatni elementi
+	Selection Edges	Ivice selekcije
+	Target Path	Ciljna putanja
+	Current Path	Tekuća putanja
+	Grid	Mreža
+	Guides	Vodilje
+	Canvas Guides	Vodilje platna
+	Artboard Guides	Vodilje radne table
+	Count	Broj
+	Smart Guides	Pametne vodilje
+	Slices	Isečci
+	Notes	Beleške
+	Pixel Grid	Mreža piksela
+	Pixel Art	Piksel-art
+	Pixel Art Preview	Pregled piksel-arta
+	Pattern Preview	Pregled šare
+	Brush Preview	Pregled četkice
+	Mesh	Mrežica
+	Edit Pins	Uredi čiode
+	Document Bounds	Granice dokumenta
+	Show Extras Options…	Opcije prikaza dodatnih elemenata…
+	Rulers	Lenjiri
+	Snap	Prianjanje
+	Snap To	Prianjaj uz
+	Lock Guides	Zaključaj vodilje
+	Clear Guides	Ukloni vodilje
+	Clear Selected Artboard Guides	Ukloni vodilje izabranih radnih tabli
+	Clear Canvas Guides	Ukloni vodilje platna
+	New Guide…	Nova vodilja…
+	Lock Slices	Zaključaj isečke
+	Clear Slices	Ukloni isečke
+	Match Zoom	Uskladi zum
+	Match Location	Uskladi položaj
+	Match Rotation	Uskladi rotaciju
+	Cascade	Kaskadno
+	Tile	Popločaj
+	Tile All Horizontally	Popločaj sve horizontalno
+	Tile All Vertically	Popločaj sve vertikalno
+	2-up Horizontal	Po 2, horizontalno
+	2-up Vertical	Po 2, vertikalno
+	3-up Horizontal	Po 3, horizontalno
+	3-up Stacked	Po 3, naslagano
+	3-up Vertical	Po 3, vertikalno
+	4-up	Po 4
+	6-up	Po 6
+	Consolidate All to Tabs	Objedini sve u kartice
+	Float in Window	Odvoji u prozor
+	Float All in Windows	Odvoji sve u prozore
+	New Window for Document	Novi prozor za dokument
+	Workspace	Radni prostor
+	Essentials	Osnovno
+	Graphic and Web	Grafika i veb
+	Painting	Slikanje
+	Photography	Fotografija
+	New Workspace…	Novi radni prostor…
+	Delete Workspace…	Obriši radni prostor…
+	Reset Workspace	Resetuj radni prostor
+	Reset Tool	Resetuj alatku
+	Reset All Tools	Resetuj sve alatke
+	Reset all tools to their default settings?	Vratiti sve alatke na podrazumevana podešavanja?
+	Lock Workspace	Zaključaj radni prostor
+	Theme	Tema
+	Pro Theme	Pro tema
+	Pro Medium Gray Theme	Pro srednje siva tema
+	Pro Light Gray Theme	Pro svetlosiva tema
+	Pro Light Theme	Pro svetla tema
+	Studio Theme	Studio tema
+	Studio Light Theme	Studio svetla tema
+	Adwaita Light Theme	Adwaita svetla tema
+	Adwaita Dark Theme	Adwaita tamna tema
+	Classic Theme	Klasična tema
+	Solarized dark	Solarized tamna
+	Solarized Dark Theme	Solarized tamna tema
+	Breeze dark	Breeze tamna
+	Breeze Dark Theme	Breeze tamna tema
+	Breeze light	Breeze svetla
+	Breeze Light Theme	Breeze svetla tema
+	Soft dark	Meka tamna
+	Soft Dark Theme	Meka tamna tema
+	Soft light	Meka svetla
+	Soft Light Theme	Meka svetla tema
+	Next Theme	Sledeća tema
+	Actions	Radnje
+	Brush Settings	Podešavanja četkice
+	Brushes	Četkice
+	Channels	Kanali
+	Character	Znak
+	Character Styles	Stilovi znakova
+	Clone Source	Izvor kloniranja
+	Color	Boja
+	Glyphs	Glifovi
+	Gradients	Gradijenti
+	Histogram	Histogram
+	History	Istorija
+	Info	Informacije
+	Measurement Log	Dnevnik merenja
+	Modifier Keys	Modifikatorski tasteri
+	Navigator	Navigator
+	Options	Opcije
+	Paragraph	Pasus
+	Paragraph Styles	Stilovi pasusa
+	Paths	Putanje
+	Patterns	Šare
+	Properties	Svojstva
+	Shapes	Oblici
+	Styles	Stilovi
+	Swatches	Uzorci boja
+	Timeline	Vremenska linija
+	Tool Presets	Šabloni alatki
+	Tools	Alatke
+	About PhotoCraft	O programu PhotoCraft
+	PhotoCraft Website	Veb-sajt PhotoCraft-a
+	PhotoCraft on GitHub	PhotoCraft na GitHub-u
+	ArtCraft Website	Veb-sajt ArtCraft-a
+	Join the ArtCraft Discord…	Pridružite se ArtCraft Discord zajednici…
+	Report an Issue…	Prijavi problem…
+	WIA Support…	WIA podrška…
+	Apply	Primeni
+	HSB/HSL	HSB/HSL
+	Invert…	Invertuj…
+	Load Files into Stack…	Učitaj datoteke u stek…
+	Motion	Pokret
+	Notes…	Beleške…
+	Other…	Ostalo…
+	Remove Warp Split	Ukloni podelu krivljenja
+	Shape	Oblik
+	Split Warp Crosswise	Podeli krivljenje unakrsno
+	Split Warp Horizontally	Podeli krivljenje horizontalno
+	Split Warp Vertically	Podeli krivljenje vertikalno
+	Statistics…	Statistika…
+	Refine Strokes	Doteraj poteze
+@plural	{n} item|{n} items	{n} stavka|{n} stavke|{n} stavki
+	Auto	Automatski
+	(print to the printer)	(štampaj na štampaču)
+	+ Add variable	+ Dodaj promenljivu
+	30 frames @ 30 fps	30 kadrova pri 30 fps
+	3D LUT File	3D LUT datoteka
+	Absolute	Apsolutno
+	Absolute Colorimetric	Apsolutno kolorimetrijski
+	Action	Radnja
+	Adaptive	Prilagodljivo
+	Adaptive Wide Angle isn't open	Prilagodljivi široki ugao nije otvoren
+	Add	Dodaj
+	Add Layer Mask	Dodaj masku sloja
+	Add Mask to Selection	Dodaj masku selekciji
+	Subtract Mask from Selection	Oduzmi masku od selekcije
+	Intersect Mask with Selection	Presek maske i selekcije
+	Add Stop	Dodaj tačku
+	Add a layer style	Dodaj stil sloja
+	Add a mask  (from the selection; {key} inverts)	Dodaj masku  (iz selekcije; {key} invertuje)
+	Add an adjustment	Dodaj korekciju
+	Add disk	Dodaj disk
+	Add space after paragraph	Dodaj razmak posle pasusa
+	Add space before paragraph	Dodaj razmak pre pasusa
+	Add to Sample	Dodaj u uzorak
+	Add to selection  ({key})	Dodaj u selekciju  ({key})
+	Adjust for Zoom	Prilagodi zumu
+	Adjustment visible	Korekcija je vidljiva
+	Adobe RGB (1998) compatible	Kompatibilno sa Adobe RGB (1998)
+	Align and Distribute	Poravnanje i raspodela
+	Align and distribute	Poravnanje i raspodela
+	Align horizontal centers	Poravnaj horizontalne centre
+	Align left edges	Poravnaj leve ivice
+	Align right edges	Poravnaj desne ivice
+	Aligned	Poravnato
+	All Caps	Sve velika slova
+	All Slices	Svi isečci
+	All User Slices	Svi korisnički isečci
+	All shortcuts reset to PhotoCraft defaults.	Sve prečice su vraćene na podrazumevane vrednosti PhotoCraft-a.
+	Alt	Alt
+	Always use pressure for opacity	Uvek koristi pritisak za neprozirnost
+	Always use pressure for size	Uvek koristi pritisak za veličinu
+	Amount	Količina
+	Anchor:	Sidro:
+	Angle	Ugao
+	Angle Gradient	Ugaoni gradijent
+	Angle Jitter	Kolebanje ugla
+	Answer the unsaved-changes prompt first	Prvo odgovorite na upit o nesačuvanim izmenama
+	Anti-alias	Uglađivanje ivica
+	Appearance	Izgled
+	Appearance (Layer Style)	Izgled (stil sloja)
+	Apply Layer Mask	Primeni masku sloja
+	Apply Per Tip	Primeni po vrhu
+	Apply next selected layer comp	Primeni sledeću izabranu kompoziciju slojeva
+	Apply previous selected layer comp	Primeni prethodnu izabranu kompoziciju slojeva
+	Artboard	Radna tabla
+	Artboard Background Color	Boja pozadine radne table
+	Assign working space	Dodeli radni prostor boja
+	Author:	Autor:
+	Auto Hide	Automatski sakrij
+	Auto-Select:	Automatski izbor:
+	Automatically level near-horizontal line segments	Automatski izravnaj skoro horizontalne segmente linija
+	Automatically straighten and level	Automatski ispravi i izravnaj
+	Automatically straighten near-vertical line segments	Automatski ispravi skoro vertikalne segmente linija
+	Background	Pozadina
+	Background Color	Boja pozadine
+	Background Contents	Sadržaj pozadine
+	Custom background color	Prilagođena boja pozadine
+	Balance	Balans
+	Baseline	Osnovna linija
+	Baseline shift	Pomak osnovne linije
+	Basic	Osnovno
+	Before (Y)	Pre (Y)
+	Begin recording	Započni snimanje
+	Bend:	Savijanje:
+	Bicubic	Bikubično
+	Bicubic (smooth gradients)	Bikubično (glatki prelazi)
+	Automatic	Automatski
+	Bicubic Smoother (enlargement)	Bikubično glađe (uvećanje)
+	Bicubic Sharper (reduction)	Bikubično oštrije (smanjenje)
+	Bilinear	Bilinearno
+	Black	Crna
+	Black & White	Crno-belo
+	Black Point Compensation	Kompenzacija crne tačke
+	Black, White	Crna, bela
+	Blacks	Crne
+	Blending	Stapanje
+	Blending Options	Opcije stapanja
+	Blue	Plava
+	Blue, Red, Yellow	Plava, crvena, žuta
+	Both Axes	Obe ose
+	Bottom	Dole
+	Brightness	Osvetljenost
+	Brightness Jitter	Kolebanje osvetljenosti
+	Brightness/Contrast	Osvetljenost/kontrast
+	Bring the selected pin forward	Pomeri izabranu čiodu napred
+	Brush Preset picker	Birač šablona četkice
+	Brush Reconstruct Options	Opcije četkice za rekonstrukciju
+	Brush Tool Options	Opcije alatke četkica
+	Cache Level:	Nivo keša:
+	Camera Raw isn't open	Camera Raw nije otvoren
+	Cancel	Otkaži
+	Cancel (Esc)	Otkaži (Esc)
+	Cancel any current edits (Esc)	Otkaži sve tekuće izmene (Esc)
+	Cancel current crop operation  (Esc)	Otkaži tekuće opsecanje  (Esc)
+	Cancel transform (Esc)	Otkaži transformaciju (Esc)
+	Cancel warp (Esc)	Otkaži krivljenje (Esc)
+	Canvas	Platno
+	Canvas extension color:	Boja proširenja platna:
+	Capture	Zabeleži
+	Capture the visibility, position and style of every layer with + below, then switch between versions.	Zabeležite vidljivost, položaj i stil svakog sloja dugmetom + ispod, a zatim se prebacujte između verzija.
+	Catch-up on Stroke End	Sustizanje na kraju poteza
+	Center	Centar
+	Center Crop Marks	Središnje oznake za sečenje
+	Center text	Centriraj tekst
+	Change	Promeni
+	Change All	Promeni sve
+	Change Screen Mode  (F)	Promeni režim ekrana  (F)
+	Change To:	Promeni u:
+	Channel Mixer	Mešač kanala
+	Channel:	Kanal:
+	Check All Layers	Proveri sve slojeve
+	Check Spelling	Provera pravopisa
+	Clarity	Jasnoća
+	Clear All	Obriši sve
+	Clear Override	Ukloni nadjačavanje
+	Clear Samples	Obriši uzorke
+	Click sets foreground · right-click sets background	Klik postavlja boju prednjeg plana · desni klik postavlja boju pozadine
+	Click the first point or press {key} to close · Esc cancels	Kliknite prvu tačku ili pritisnite {key} da zatvorite · Esc otkazuje
+	Click to add a point · drag off or {key}-click or Delete to remove	Kliknite da dodate tačku · prevucite van, {key}-klik ili Delete da uklonite
+	Click to apply, {key}-click to clear overrides, double-click for Style Options	Kliknite da primenite, {key}-klik da uklonite nadjačavanja, dvoklik za opcije stila
+	Click to edit the gradient	Kliknite da uredite gradijent
+	Click to restore the current colour	Kliknite da vratite tekuću boju
+	Click to zoom in  ·  {key}-click to zoom out  ·  drag right/left to zoom in/out	Kliknite da uvećate  ·  {key}-klik da umanjite  ·  prevucite udesno/ulevo da uvećate/umanjite
+	Click with the Note tool to add a note.	Kliknite alatkom za beleške da dodate belešku.
+	Click: corner · Drag: smooth · Click first point: close · {key} finish · Esc cancel	Klik: ugao · Prevlačenje: glatko · Klik na prvu tačku: zatvori · {key} završi · Esc otkaži
+	Click: corner · Drag: smooth · {alt}-drag: break handle · Click or drag first point: close · {key} finish · Esc cancel	Klik: ugao · Prevlačenje: glatko · {alt}-prevlačenje: razdvoji ručicu · Klik ili prevlačenje prve tačke: zatvori · {key} završi · Esc otkaži
+	Clip to layer below	Iseci prema sloju ispod
+	Clipped	Isečeno
+	Close Style Options	Zatvori opcije stila
+	Cmd	Cmd
+	Coated CMYK	Premazani CMYK
+	Color & Swatches	Boja i uzorci
+	Color Balance	Balans boja
+	Color Detail	Detalji boje
+	Color Grading	Gradacija boja
+	Color Lookup	Preslikavanje boja
+	Color Management	Upravljanje bojama
+	Color Mixer	Mešač boja
+	Color Mode	Režim boja
+	Color Priority	Prioritet boje
+	Color Range preview	Pregled opsega boja
+	Color:	Boja:
+	Colorize	Oboji
+	Colors	Boje
+	Commit Perspective Warp ({key})	Potvrdi perspektivno krivljenje ({key})
+	Commit Puppet Warp ({key})	Potvrdi lutkarsko krivljenje ({key})
+	Commit any current edits ({key})	Potvrdi sve tekuće izmene ({key})
+	Commit current crop operation  ({key})	Potvrdi tekuće opsecanje  ({key})
+	Commit transform ({key})	Potvrdi transformaciju ({key})
+	Commit warp ({key})	Potvrdi krivljenje ({key})
+	Constant	Konstantno
+	Constrain proportions	Zadrži proporcije
+	Contact Sheet II	Kontakt-list II
+	Content-Aware	Prema sadržaju
+	Contiguous	Susedno
+	Contrast	Kontrast
+	Control:	Kontrola:
+	Convert document's colors to the working space	Pretvori boje dokumenta u radni prostor
+	Convert to sRGB	Pretvori u sRGB
+	Copies	Primerci
+	Copper	Bakar
+	Copyright	Autorska prava
+	Copyright and Contact Info	Autorska prava i kontakt podaci
+	Corner Crop Marks	Ugaone oznake za sečenje
+	Corner radius	Poluprečnik ugla
+	Correction	Korekcija
+	Count Jitter	Kolebanje broja
+	Create	Napravi
+	Create Droplet	Napravi droplet
+	Create Texture	Napravi teksturu
+	Create Video Timeline	Napravi video vremensku liniju
+	Create a new count group	Napravi novu grupu brojanja
+	Create a new document or open an existing file.	Napravite novi dokument ili otvorite postojeću datoteku.
+	Create a new group	Napravi novu grupu
+	Create a new layer	Napravi novi sloj
+	Create new action	Napravi novu radnju
+	Create new channel	Napravi novi kanal
+	Create new document from current state	Napravi novi dokument od tekućeg stanja
+	Create new fill or adjustment layer	Napravi novi sloj popune ili korekcioni sloj
+	Create new gradient	Napravi novi gradijent
+	Create new group	Napravi novu grupu
+	Create new layer comp	Napravi novu kompoziciju slojeva
+	Create new pattern from the selection	Napravi novu šaru od selekcije
+	Create new shape from the current path	Napravi novi oblik od tekuće putanje
+	Create new snapshot	Napravi novi snimak stanja
+	Create new tool preset	Napravi novi šablon alatke
+	Crop Factor	Faktor izreza
+	Ctrl	Ctrl
+	Current & Below	Tekući i ispod
+	Current Layer	Tekući sloj
+	Current Size	Trenutna veličina
+	Current Tool Only	Samo tekuća alatka
+	Curve	Kriva
+	Curves	Krive
+	Custom	Prilagođeno
+	Custom Shapes	Prilagođeni oblici
+	Cyan	Cijan
+	Cyan  ·  Red	Cijan  ·  crvena
+	Darken	Zatamnjenje
+	Darks	Tamni tonovi
+	Data Sets	Skupovi podataka
+	Default	Podrazumevano
+	Default colours (D)	Podrazumevane boje (D)
+	Default printer	Podrazumevani štampač
+	Default restored.	Podrazumevano stanje je vraćeno.
+	Define	Definiši
+	Define at least one variable first.	Prvo definišite bar jednu promenljivu.
+	Dehaze	Uklanjanje izmaglice
+	Delete Cropped Pixels	Obriši isečene piksele
+	Delete Group	Obriši grupu
+	Delete Layer Mask	Obriši masku sloja
+	Delete Layers	Obriši slojeve
+	Delete Shortcut	Obriši prečicu
+	Delete Timeline	Obriši vremensku liniju
+	Delete Tool Preset	Obriši šablon alatke
+	Delete count group	Obriši grupu brojanja
+	Delete current channel	Obriši tekući kanal
+	Delete current state	Obriši tekuće stanje
+	Delete effect layer	Obriši sloj efekta
+
+# Layers-panel trash confirmation
+	Delete layer ‘{name}’?	Obrisati sloj „{name}“?
+	Delete {count} layers? {names}	Obrisati izabrane slojeve ({count})? {names}
+	Delete layer?	Obrisati sloj?
+	The document is closed	Dokument je zatvoren
+	The document or selected layers changed. Please request deletion again.	Dokument ili izabrani slojevi su se promenili. Ponovo zatražite brisanje.
+	Missing delete command	Nedostaje komanda za brisanje
+	Invalid delete command	Neispravna komanda za brisanje
+	Layer deleted, but confirmation preference could not be saved: {error}	Sloj je obrisan, ali podešavanje potvrde nije moglo da se sačuva: {error}
+
+	Delete layer	Obriši sloj
+	Delete layer comp	Obriši kompoziciju slojeva
+	Delete note	Obriši belešku
+	Delete selected measurements	Obriši izabrana merenja
+	Delete style	Obriši stil
+	Delete tool preset	Obriši šablon alatke
+	Density	Gustina
+	Density:	Gustina:
+	Depth	Dubina
+	Depth Jitter	Kolebanje dubine
+	Description	Opis
+	Deselect All	Poništi sav izbor
+	Detail	Detalji
+	Diamond Gradient	Romboidni gradijent
+	Difference	Razlika
+	Diffusion	Difuzija
+	Discard the embedded profile (don't color manage)	Odbaci ugrađeni profil (bez upravljanja bojama)
+	Discontiguous	Nesusedno
+	Discord	Discord
+	Dismiss	Odbaci
+	Display P3	Display P3
+	Display Text	Tekst za prikaz
+	Dither	Diterovanje
+	Divide…	Podeli…
+	Document	Dokument
+	Don't Save	Nemoj sačuvati
+	No	Ne
+	Yes	Da
+	Done	Gotovo
+	Dots	Tačke
+	Drag a rectangle around the object	Prevucite pravougaonik oko objekta
+	Drag on the image to add a constraint; Shift for horizontal/vertical; right-click to delete.	Prevucite po slici da dodate ograničenje; Shift za horizontalno/vertikalno; desni klik za brisanje.
+	Drag to move the active shape's path or the Work Path	Prevucite da pomerite putanju aktivnog oblika ili radnu putanju
+	Click: select anchor · Drag: move anchor, handle or segment · {shift}-click: add · {alt}-click: whole subpath	Klik: izaberi sidrišnu tačku · Prevlačenje: pomeri tačku, ručicu ili segment · {shift}-klik: dodaj · {alt}-klik: cela podputanja
+	Draw with the Pen tool (P) or make a work path from a selection.	Crtajte alatkom pero (P) ili napravite radnu putanju od selekcije.
+	Drop an image or PSD anywhere to open it.	Prevucite sliku ili PSD bilo gde da biste je otvorili.
+	Duplicate Layers…	Dupliraj slojeve…
+	Duplicate style	Dupliraj stil
+	Edit Toolbar…	Uredi traku alatki…
+	Edit in Quick Mask Mode  (Q)	Uredi u režimu brze maske  (Q)
+	Edit in Standard Mode  (Q)	Uredi u standardnom režimu  (Q)
+	Effects	Efekti
+	Embed Color Profile	Ugradi profil boja
+	Embedded Profile Mismatch	Neslaganje ugrađenog profila
+	Enable airbrush-style build-up effects	Omogući postepeno nagomilavanje kao kod vazdušne četkice
+	Enhance Edge	Poboljšaj ivicu
+	Entire Font	Ceo font
+	Exact	Tačno
+	Expansion:	Proširenje:
+	Export Presets	Izvezi šablone
+	Export selected measurements (CSV)	Izvezi izabrana merenja (CSV)
+	Exposure	Ekspozicija
+	Exposure and Gamma	Ekspozicija i gama
+	Exposure:	Ekspozicija:
+	Eyedropper	Pipeta
+	Factor:	Faktor:
+	Faux Bold	Lažno podebljano
+	Faux Italic	Lažni kurziv
+	Feather	Omekšavanje ivica
+	Fewer Points	Manje tačaka
+	File Settings	Podešavanja datoteke
+	Fill	Popuna
+	Fill:	Popuna:
+	Filter for adjustment layers	Filtriraj korekcione slojeve
+	Filter for pixel layers	Filtriraj piksel slojeve
+	Filter for shape layers	Filtriraj slojeve oblika
+	Filter for smart objects	Filtriraj pametne objekte
+	Filter for type layers	Filtriraj tekstualne slojeve
+	Filter:	Filter:
+	Finger Painting	Slikanje prstom
+	Fisheye	Riblje oko
+	Fit	Uklopi
+	Fit Screen	Uklopi u ekran
+	Fill Screen	Popuni ekran
+	Fit in View	Uklopi u prikaz
+	Fixed	Fiksno
+	Fixed Ratio	Fiksni odnos
+	Fixed Size	Fiksna veličina
+	Flip	Okreni
+	Flip X	Okreni po X
+	Flip X Jitter	Kolebanje okretanja po X
+	Flip Y	Okreni po Y
+	Flip Y Jitter	Kolebanje okretanja po Y
+	Flow	Protok
+	Flow Jitter	Kolebanje protoka
+	Focal Length	Žižna daljina
+	Font	Font
+	Font Size:	Veličina fonta:
+	Font size	Veličina fonta
+	Foreground	Prednji plan
+	Foreground to Background	Od prednjeg plana do pozadine
+	Foreground/Background Jitter	Kolebanje prednjeg plana/pozadine
+	Format	Format
+	Frame from Layers…	Okvir od slojeva…
+	Free	Slobodno
+	Full Spherical	Potpuno sferno
+	Fuzziness:	Rasplinutost:
+	GPU	GPU
+	Gamma Correction	Korekcija game
+	Gamma:	Gama:
+	Global	Globalno
+	Glow Color	Boja sjaja
+	Gradient Map	Mapa gradijenta
+	Grain	Zrno
+	Gray	Siva
+	Gray Gamma 2.2	Siva gama 2.2
+	Green	Zelena
+	Group	Grupa
+	Hardness	Tvrdoća
+	Heart	Srce
+	Height	Visina
+	Height:	Visina:
+	Hide Auto Slices	Sakrij automatske isečke
+	Hide Properties	Sakrij svojstva
+	Highlight Compression	Kompresija svetlih tonova
+	Highlight Priority	Prioritet svetlih tonova
+	Highlights	Svetla
+	Home	Početna
+	Horizontal scale	Horizontalna razmera
+	Hue	Nijansa
+	Hue Jitter	Kolebanje nijanse
+	Hue/Saturation	Nijansa/zasićenost
+	Hyphenate	Deljenje reči na slogove
+	Ignore	Zanemari
+	Ignore All	Zanemari sve
+	Image Size	Veličina slike
+	Import Brushes…	Uvezi četkice…
+	Import brushes (.abr)	Uvezi četkice (.abr)
+	Import Presets	Uvezi šablone
+	Imported	Uvezeno
+	Indent First	Uvlačenje prvog reda
+	Indent Left	Levo uvlačenje
+	Indent Right	Desno uvlačenje
+	Indent first line	Uvuci prvi red
+	Indent left margin	Uvlačenje leve margine
+	Indent right margin	Uvlačenje desne margine
+	Input:	Ulaz:
+	Inside	Unutra
+	Interlaced	Isprepletano
+	Interpolation:	Interpolacija:
+	Intersect with selection  ({key})	Presek sa selekcijom  ({key})
+	Invert All	Invertuj sve
+	Invert has no settings.	Invertovanje nema podešavanja.
+	Italic	Kurziv
+	Join us on Discord	Pridružite nam se na Discordu
+	Justify all	Obostrano poravnaj sve redove
+	Justify last centered	Obostrano, poslednji red centriran
+	Justify last left	Obostrano, poslednji red levo
+	Justify last right	Obostrano, poslednji red desno
+	Kerning	Kerning
+	Keyboard Shortcuts	Prečice na tastaturi
+	Keyboard Shortcuts and Menus	Prečice na tastaturi i meniji
+	Kind	Vrsta
+	Label Size	Veličina oznake
+	Labels	Oznake
+	Lanczos (sharp)	Lanczos (oštro)
+	Landscape	Položeno
+	Last Document State	Poslednje stanje dokumenta
+	Layout	Raspored
+	Leading	Prored
+	Leading (set to the font size × auto-leading when Auto)	Prored (veličina fonta × automatski prored kada je Automatski)
+	Leave as is (don't color manage)	Ostavi kako jeste (bez upravljanja bojama)
+	Left align text	Poravnaj tekst levo
+	Length:	Dužina:
+	Level	Nivo
+	Levels	Nivoi
+	Lighten	Posvetljenje
+	Lightness	Svetlina
+	Lights	Svetli tonovi
+	Limits:	Granice:
+	Linear Gradient	Linearni gradijent
+	Link layers	Poveži slojeve
+	Link width and height	Poveži širinu i visinu
+	Liquify is not open	Tečno izobličavanje nije otvoreno
+	Load	Učitaj
+	Load 3D LUT…	Učitaj 3D LUT…
+	Load channel as selection	Učitaj kanal kao selekciju
+	Load…	Učitaj…
+	Localized Color Clusters	Lokalizovane grupe boja
+	Lock	Zaključaj
+	Lock all	Zaključaj sve
+	Lock image pixels	Zaključaj piksele slike
+	Lock layer	Zaključaj sloj
+	Lock position	Zaključaj položaj
+	Lock transparent pixels	Zaključaj providne piksele
+	Lock:	Zaključaj:
+	Logical Length:	Logička dužina:
+	Logical Units:	Logičke jedinice:
+	Luminance	Luminansa
+	Luminance Detail	Detalji luminanse
+	Magenta	Magenta
+	Magenta  ·  Green	Magenta  ·  zelena
+	Maintain aspect ratio	Zadrži odnos stranica
+	Marker Size	Veličina markera
+	Mask All	Maskiraj sve
+	Mask Options	Opcije maske
+	Masking	Maskiranje
+	Master	Glavno
+	Matte	Podloga
+	Median:	Medijana:
+	Menus	Meniji
+	Mesh Size	Veličina mrežice
+	Metadata	Metapodaci
+	Metrics	Metrika
+	Midpoint	Središnja tačka
+	Midtones	Srednji tonovi
+	Midtones from:	Srednji tonovi od:
+	Midtones to:	Srednji tonovi do:
+	Minimum Depth	Minimalna dubina
+	Minimum Diameter	Minimalni prečnik
+	Minimum Roundness	Minimalna zaobljenost
+	Mode:	Režim:
+	Monochrome	Jednobojno
+	More Points	Više tačaka
+	Move effect layer down	Pomeri sloj efekta nadole
+	Move effect layer up	Pomeri sloj efekta nagore
+	Move to	Premesti u
+	Name	Ime
+	Name:	Ime:
+	Nearest Neighbor	Najbliži sused
+	Nearest Neighbor (hard edges)	Najbliži sused (oštre ivice)
+	New Size	Nova veličina
+	New document…	Novi dokument…
+	New effect layer	Novi sloj efekta
+	New selection	Nova selekcija
+	Next frame	Sledeći kadar
+	Next note	Sledeća beleška
+	No Color	Bez boje
+	No Color Management	Bez upravljanja bojama
+	No Dither	Bez diterovanja
+	No author	Nema autora
+	No character style	Bez stila znakova
+	No document	Nema dokumenta
+	No matching commands	Nema odgovarajućih komandi
+	No presets for the current tool.	Nema šablona za tekuću alatku.
+	No presets of this type.	Nema šablona ove vrste.
+	No properties	Nema svojstava
+	No tool presets.	Nema šablona alatki.
+	Noise Reduction	Smanjenje šuma
+	Normal	Normalno
+	Not in Dictionary:	Nije u rečniku:
+	OK	U redu
+	Offset	Pomak
+	Only Web Colors	Samo veb boje
+	Opacity	Neprozirnost
+	Opacity Jitter	Kolebanje neprozirnosti
+	Opacity:	Neprozirnost:
+	Open a document to define variables.	Otvorite dokument da biste definisali promenljive.
+	Open a document to select a colour range.	Otvorite dokument da biste izabrali opseg boja.
+	Open a document to use the timeline.	Otvorite dokument da biste koristili vremensku liniju.
+	Optical	Optički
+	Optimized	Optimizovano
+	Option-click to define a source point to clone from	Option-klik da odredite izvornu tačku za kloniranje
+	Original	Original
+	Output Channel:	Izlazni kanal:
+	Output Levels:	Izlazni nivoi:
+	Output:	Izlaz:
+	Outside	Spolja
+	Overlay Color	Boja preklopa
+	Overlay Opacity	Neprozirnost preklopa
+	Overlay: Rule of Thirds	Preklop: pravilo trećina
+	Override Pressure	Nadjačaj pritisak
+	Override Rotation	Nadjačaj rotaciju
+	Override Tilt	Nadjačaj nagib
+	PRESET DETAILS	DETALJI ŠABLONA
+	PSD	PSD
+	Paint Overlay	Preklop za slikanje
+	Panel locations are saved in the workspace. Keyboard shortcuts, menus and toolbar are optional.	Položaji panela se čuvaju u radnom prostoru. Prečice na tastaturi, meniji i traka alatki su opcioni.
+	Paper	Papir
+	Path	Putanja
+	Pattern	Šara
+	Pattern Size	Veličina šare
+	Pause	Pauza
+	Percent	Procenat
+	Perceptual	Perceptivno
+	Perspective Warp is not active	Perspektivno krivljenje nije aktivno
+	Perspective Warp: draw planes along the image's perspective, then switch to Warp	Perspektivno krivljenje: nacrtajte ravni duž perspektive slike, a zatim pređite na krivljenje
+	Photo Filter	Foto-filter
+	PhotoCraft	PhotoCraft
+	PhotoCraft Manages Colors	PhotoCraft upravlja bojama
+	PhotoCraft — an open-source, native image editor written in Rust.	PhotoCraft — izvorni uređivač slika otvorenog koda, napisan u Rust-u.
+	Pin Depth:	Dubina čiode:
+	Pixel Length:	Dužina u pikselima:
+	Pixels/Centimeter	Piksela/centimetar
+	Pixels/Inch	Piksela/inč
+	Pixels:	Pikseli:
+	Play	Pusti
+	Play selection	Pusti izabrano
+	Portrait	Uspravno
+	Position	Položaj
+	Position and Size	Položaj i veličina
+	Posterize	Posterizacija
+	Preserve Details	Očuvaj detalje
+	Preserve Luminosity	Očuvaj osvetljenje
+	Preset	Šablon
+	Preset Type	Vrsta šablona
+	Preset:	Šablon:
+	Presets:	Šabloni:
+	Press keys…	Pritisnite tastere…
+	Pressure	Pritisak
+	Pressure for Opacity	Pritisak za neprozirnost
+	Pressure for Size	Pritisak za veličinu
+	Prevent auto-nesting in and out of Artboards and Frames	Spreči automatsko ugnežđavanje u radne table i okvire i izvlačenje iz njih
+	Preview	Pregled
+	Previous frame	Prethodni kadar
+	Previous note	Prethodna beleška
+	Print	Štampaj
+	Printer	Štampač
+	Printer Manages Colors	Štampač upravlja bojama
+	Printer Setup	Podešavanje štampača
+	Printing Marks	Oznake za štampu
+	Progressive	Progresivno
+	Promote	Unapredi
+	Protect Detail	Zaštiti detalje
+	Protect Foreground Color	Zaštiti boju prednjeg plana
+	Protect Tones	Zaštiti tonove
+	Proximity Match	Podudaranje po blizini
+	Pulled String Mode	Režim zategnute niti
+	Puppet Warp is not active	Lutkarsko krivljenje nije aktivno
+	Purity	Čistoća
+	Quality	Kvalitet
+	Quick Actions	Brze radnje
+	Quick Export As PNG	Brzi izvoz u PNG
+	Radial Gradient	Radijalni gradijent
+	Radius	Poluprečnik
+	Radius:	Poluprečnik:
+	Range:	Opseg:
+	Rate	Brzina
+	Recently Used	Nedavno korišćeno
+	Reconstruct	Rekonstruiši
+	Record ● a sequence of edits, then play ▶ it on any document.	Snimite ● niz izmena, a zatim ga pustite ▶ na bilo kom dokumentu.
+	Red	Crvena
+	Redefine style by current selection	Redefiniši stil prema tekućoj selekciji
+	Refine	Doteraj
+	Reflected Gradient	Reflektovani gradijent
+	Registration Marks	Oznake registracije
+	Regular	Obično
+	Relative	Relativno
+	Relative Colorimetric	Relativno kolorimetrijski
+	Remove	Ukloni
+	Remove All Pins	Ukloni sve čiode
+	Remove Background	Ukloni pozadinu
+	Remove Planes	Ukloni ravni
+	Remove Tool	Alatka za uklanjanje
+	Remove stop	Ukloni tačku
+	Remove variable	Ukloni promenljivu
+	Rename	Preimenuj
+	Rename Group…	Preimenuj grupu…
+	Rename Layer…	Preimenuj sloj…
+	Rename Tool Preset…	Preimenuj šablon alatke…
+	Rename…	Preimenuj…
+	Resample	Ponovo uzorkuj
+	Reset All to Defaults	Vrati sve na podrazumevano
+	Import Shortcuts…	Uvezi prečice…
+	Load a keyboard shortcut set saved as .kys	Učitaj skup prečica sačuvan kao .kys
+	Imported {n} shortcuts from {file}. Click OK to keep them.	Uvezeno {n} prečica iz {file}. Kliknite U redu da ih zadržite.
+	{n} commands are not in PhotoCraft.	{n} komandi ne postoji u PhotoCraft-u.
+	Keyboard shortcuts imported	Prečice na tastaturi su uvezene
+	Your keyboard shortcut set {set} is in use here: {n} shortcuts differ from the defaults. Edit › Keyboard Shortcuts shows them; Reset All to Defaults undoes this.	Ovde se koristi vaš skup prečica {set}: {n} prečica se razlikuje od podrazumevanih. Uređivanje › Prečice na tastaturi ih prikazuje; Vrati sve na podrazumevano poništava ovo.
+	Import keyboard shortcuts?	Uvesti prečice na tastaturi?
+	PhotoCraft found your keyboard shortcut set {set} from another image editor on this computer: {n} of its shortcuts differ from PhotoCraft's. Import it?	PhotoCraft je na ovom računaru pronašao vaš skup prečica {set} iz drugog uređivača slika: {n} prečica se razlikuje od PhotoCraft-ovih. Uvesti ga?
+	Edit › Keyboard Shortcuts › Reset All to Defaults undoes an import.	Uređivanje › Prečice na tastaturi › Vrati sve na podrazumevano poništava uvoz.
+	Don't Import	Nemoj uvesti
+	The keyboard shortcut set was not imported: {error}	Skup prečica nije uvezen: {error}
+	Reset Section	Resetuj odeljak
+	Reset Transform	Resetuj transformaciju
+	Reset to defaults	Vrati na podrazumevano
+	Resolution	Rezolucija
+	Resolution:	Rezolucija:
+	Restore All	Vrati sve
+	Restore Defaults	Vrati podrazumevano
+	Restrictive (Web)	Restriktivno (veb)
+	Right align text	Poravnaj tekst desno
+	Rigid	Kruto
+	Rotate:	Rotacija:
+	Rotation	Rotacija
+	Roughness	Hrapavost
+	Roundness	Zaobljenost
+	Roundness Jitter	Kolebanje zaobljenosti
+	Rulers & Grids	Lenjiri i mreže
+	Sample All Layers	Uzorkuj sve slojeve
+	Sample:	Uzorak:
+	Sampling: Background Swatch	Uzorkovanje: uzorak pozadine
+	Sampling: Continuous	Uzorkovanje: neprekidno
+	Sampling: Once	Uzorkovanje: jednom
+	Saturate	Zasiti
+	Saturation	Zasićenost
+	Saturation Jitter	Kolebanje zasićenosti
+	Save HTML and Images	Sačuvaj HTML i slike
+	Save as PDF	Sačuvaj kao PDF
+	Save selection as channel	Sačuvaj selekciju kao kanal
+	Save…	Sačuvaj…
+	Scale to Fit Media	Skaliraj prema medijumu
+	Scatter	Rasejavanje
+	Scratch disks	Radni diskovi
+	Search	Pretraga
+	Search commands	Pretraži komande
+	Search commands, tools and panels…	Pretraži komande, alatke i panele…
+	Search fonts	Pretraži fontove
+	Select All	Izaberi sve
+	Select Subject	Izaberi subjekat
+	Select a type layer or click into text to insert glyphs	Izaberite tekstualni sloj ili kliknite u tekst da umetnete glifove
+	Select text to apply a character style	Izaberite tekst da primenite stil znakova
+	Select:	Izaberi:
+	Selections	Selekcije
+	Selective	Selektivno
+	Selective Color	Selektivna boja
+	Send the selected pin backward	Pomeri izabranu čiodu nazad
+	Set additional smoothing options	Podesi dodatne opcije izglađivanja
+	Set background color	Postavi boju pozadine
+	Set foreground color	Postavi boju prednjeg plana
+	Set painting symmetry options	Podesi opcije simetrije slikanja
+	Symmetry Off	Simetrija isključena
+	Set shape fill type	Podesi vrstu popune oblika
+	Set shape stroke type	Podesi vrstu obruba oblika
+	Set the text color	Postavi boju teksta
+	Shadows	Senke
+	Shape:	Oblik:
+	Sharpening	Izoštravanje
+	Shift	Shift
+	Shortcut removed.	Prečica je uklonjena.
+	Show All Menu Items	Prikaži sve stavke menija
+	Show Backdrop	Prikaži podlogu
+	Show Guides	Prikaži vodilje
+	Show Mask	Prikaži masku
+	Show Mesh	Prikaži mrežicu
+	Show Overlay	Prikaži preklop
+	Show Transform Controls	Prikaži kontrole transformacije
+	Show or hide the Notes panel	Prikaži ili sakrij panel Beleške
+	Show:	Prikaži:
+	Sides	Stranice
+	Sides:	Stranice:
+	Size	Veličina
+	Size Jitter	Kolebanje veličine
+	Size:	Veličina:
+	Slice Options…	Opcije isečka…
+	Slices From Guides	Isečci od vodilja
+	Slices are locked (View › Lock Slices)	Isečci su zaključani (Prikaz › Zaključaj isečke)
+	Small Caps	Kapitalke
+	Smoothing	Izglađivanje
+	Space After	Razmak posle
+	Space Before	Razmak pre
+	Spacing	Razmak
+	Spell check complete.	Provera pravopisa je završena.
+	Split:	Podela:
+	Star ratio	Odnos zvezde
+	Stop playing/recording	Zaustavi puštanje/snimanje
+	Straighten	Ispravi
+	Straighten Layer	Ispravi sloj
+	Strength:	Jačina:
+	Strikethrough	Precrtano
+	Stroke	Obrub
+	Stroke Catch-up	Sustizanje poteza
+	Stroke:	Obrub:
+	Location:	Položaj:
+	Style	Stil
+	Style Options	Opcije stila
+	Style Options…	Opcije stila…
+	Style: Normal	Stil: normalno
+	Subtract from Sample	Oduzmi od uzorka
+	Subtract from selection  ({key})	Oduzmi od selekcije  ({key})
+	Suggestions:	Predlozi:
+	Swap colours (X)	Zameni boje (X)
+	Swaps height and width	Zamenjuje visinu i širinu
+	Switch between free transform and warp modes	Prebaci između režima slobodne transformacije i krivljenja
+	Switch theme	Promeni temu
+	Temperature	Temperatura
+	Tetrahedral	Tetraedarski
+	Text Position:	Položaj teksta:
+	Texture	Tekstura
+	Texture Each Tip	Tekstura za svaki vrh
+	Threshold	Prag
+	Threshold Level	Nivo praga
+	Thumbnail size (smallest: list)	Veličina sličica (najmanja: spisak)
+	Tilt X	Nagib X
+	Tilt Y	Nagib Y
+	Tint	Preliv
+	Toggle count group visibility	Uključi/isključi vidljivost grupe brojanja
+	Toggle text orientation	Promeni orijentaciju teksta
+	Tolerance	Tolerancija
+	Tolerance:	Tolerancija:
+	Tone:	Ton:
+	Toolbar	Traka alatki
+	Top	Gore
+	Total:	Ukupno:
+	Tracking	Razmak između slova
+	Tracking (1/1000 em)	Razmak između slova (1/1000 em)
+	Transparency	Providnost
+	Transparent	Providno
+	Trilinear	Trilinearno
+	Type Styles	Stilovi teksta
+	Type:	Vrsta:
+	Underline	Podvučeno
+	Untitled	Bez naslova
+	Untitled-1	Bez naslova-1
+	Update layer comp (visibility, position and appearance)	Ažuriraj kompoziciju slojeva (vidljivost, položaj i izgled)
+	Use Default	Koristi podrazumevano
+	Use Legacy	Koristi staro
+	Use Measurement Scale	Koristi razmeru merenja
+	Use the embedded profile (instead of the working space)	Koristi ugrađeni profil (umesto radnog prostora)
+	Variables bind a layer's visibility, text or pixels to a named data slot.	Promenljive vezuju vidljivost, tekst ili piksele sloja za imenovano polje podataka.
+	Vertical scale	Vertikalna razmera
+	Vibrance	Živost
+	View Options	Opcije prikaza
+	Vignetting	Vinjetiranje
+	Violet, Orange	Ljubičasta, narandžasta
+	Visibility	Vidljivost
+	Visible	Vidljivo
+	Warp:	Krivljenje:
+	Web Snap	Prianjanje uz veb boje
+	Weight	Debljina
+	Weight:	Debljina:
+	White	Bela
+	White Balance: As Shot	Balans bele: kao pri snimanju
+	Whites	Bele
+	Width	Širina
+	Slant	Iskošenost
+	Width:	Širina:
+	Work Path	Radna putanja
+	Yellow	Žuta
+	Yellow  ·  Blue	Žuta  ·  plava
+	Zoom	Zum
+	Zoom in	Uvećaj
+	Zoom out	Umanji
+	command or shortcut	komanda ili prečica
+	current	tekuće
+	image file path	putanja datoteke slike
+	modified	izmenjeno
+	name	ime
+	new	novo
+	{name} options	Opcije: {name}
+	↑↓ navigate   {key} run   esc close	↑↓ kretanje   {key} pokreni   esc zatvori
+	Version {version}	Verzija {version}
+	New Document	Novi dokument
+	New Document With Mask	Novi dokument sa maskom
+	New Layer With Mask	Novi sloj sa maskom
+	New Layer	Novi sloj
+	Preset Name	Ime šablona
+	No saved presets yet.	Još nema sačuvanih šablona.
+	Error	Greška
+	Command	Komanda
+	Adjustment layers have nothing to transform	Korekcioni slojevi nemaju ništa što bi se transformisalo
+	Altitude	Visina
+	Android 1080p	Android 1080p
+	Apple Watch 45mm	Apple Watch 45 mm
+	Aqua	Akva
+	Art & Illustration	Umetnost i ilustracija
+	ArtCraft	ArtCraft
+	Background Eraser Tool	Alatka gumica za pozadinu
+	Bevel & Emboss	Kosina i reljef
+	Blend Mode	Režim stapanja
+	Blues	Plave
+	Blur Tool	Alatka za zamućivanje
+	Bold	Podebljano
+	Brush	Četkica
+	Block	Blok
+	Brush Pose	Položaj četkice
+	Brush Tip Shape	Oblik vrha četkice
+	Brush Tool	Alatka četkica
+	Build-up	Nagomilavanje
+	Burn Tool	Alatka za zatamnjivanje
+	Centimeters	Centimetri
+	Choke	Sužavanje
+	Classic	Klasično
+	Click to add text	Kliknite da dodate tekst
+	Click to fill similar colours	Kliknite da popunite slične boje
+	Clone Stamp Tool	Alatka pečat za kloniranje
+	Color Burn	Zatamnjivanje boje
+	Color Dodge	Posvetljivanje boje
+	Color Dynamics	Dinamika boje
+	Color Overlay	Prekrivanje bojom
+	Comic Book	Strip
+	Conform	Usaglašeno
+	Content-Aware Fill needs a selection on a pixel layer	Popuna prema sadržaju zahteva selekciju na piksel sloju
+	Could not transform: the layer is empty	Transformacija nije moguća: sloj je prazan
+	Could not use Perspective Warp: the layer is empty	Perspektivno krivljenje nije moguće: sloj je prazan
+	Could not use Puppet Warp: no opaque pixels	Lutkarsko krivljenje nije moguće: nema neprozirnih piksela
+	Could not use Puppet Warp: the layer is empty	Lutkarsko krivljenje nije moguće: sloj je prazan
+	Crop Tool	Alatka za opsecanje
+	Crosswise	Unakrsno
+	Current Tool	Tekuća alatka
+	Custom Shape Tool	Alatka za prilagođeni oblik
+	Cyans	Cijan
+	Default PhotoCraft Size	Podrazumevana veličina PhotoCraft-a
+	Delete Workspace	Obriši radni prostor
+	Diamond	Romb
+	Dimensions:	Dimenzije:
+	Direction	Smer
+	Distance	Udaljenost
+	Document Dimensions	Dimenzije dokumenta
+	Document Profile	Profil dokumenta
+	Document Sizes	Veličine dokumenta
+	Dodge Tool	Alatka za posvetljivanje
+	Down	Nadole
+	Drag to draw a gradient	Prevucite da nacrtate gradijent
+	Drag to move the active layer	Prevucite da pomerite aktivni sloj
+	Drag to pan  ·  hold Space with any tool	Prevucite da pomerate prikaz  ·  držite razmaknicu uz bilo koju alatku
+	Drop Shadow	Bačena senka
+	Dual Brush	Dvostruka četkica
+	Edge	Ivica
+	Efficiency	Efikasnost
+	Efficiency: 100%	Efikasnost: 100%
+	Ellipse Tool	Alatka elipsa
+	Elliptical Marquee Tool	Alatka za eliptičnu selekciju
+	Single Row Marquee Tool	Alatka za selekciju jednog reda
+	Single Column Marquee Tool	Alatka za selekciju jedne kolone
+	Emboss	Reljef
+	Eraser	Gumica
+	Eraser Tool	Alatka gumica
+	ExtraBold	Ekstra podebljano
+	ExtraLight	Ekstra lagano
+	Eyedropper Tool	Alatka pipeta
+	Fade	Iščezavanje
+	Fill Opacity	Neprozirnost popune
+	Film & Video	Film i video
+	From	Od
+	General	Opšte
+	GitHub	GitHub
+	Gradient Overlay	Prekrivanje gradijentom
+	Gradient Tool	Alatka gradijent
+	Greens	Zelene
+	Hand Tool	Alatka ruka
+	Hard	Tvrdo
+	Hard Mix	Oštro mešanje
+	Healing Brush Tool	Alatka četkica za popravku
+	Highlights from:	Svetla od:
+	History Brush Tool	Alatka četkica istorije
+	Horizontal Type Tool	Alatka za horizontalni tekst
+	Horizontal Type Mask Tool	Alatka za horizontalnu masku teksta
+	Vertical Type Mask Tool	Alatka za vertikalnu masku teksta
+	Image Size:	Veličina slike:
+	Inches	Inči
+	Indexed	Indeksirano
+	Initial Direction	Početni smer
+	Inner Bevel	Unutrašnja kosina
+	Inner Glow	Unutrašnji sjaj
+	Inner Shadow	Unutrašnja senka
+	Lab	Lab
+	Landscape, 10 x 8	Položeno, 10 x 8
+	Landscape, 6 x 4	Položeno, 6 x 4
+	Landscape, 7 x 5	Položeno, 7 x 5
+	Lasso	Laso
+	Lasso Tool	Alatka laso
+	Layer Count	Broj slojeva
+	Layer Knocks Out Drop Shadow	Sloj izbija bačenu senku
+	Legal	Legal
+	Letter	Letter
+	Light	Svetlo
+	Line Tool	Alatka linija
+	Linear	Linearno
+	Linear Burn	Linearno zatamnjivanje
+	Linear Height	Linearna visina
+	Link with Layer	Poveži sa slojem
+	Lorem Ipsum	Lorem Ipsum
+	Magentas	Magenta
+	Magic Eraser Tool	Alatka čarobna gumica
+	Magic Wand Tool	Alatka čarobni štapić
+	Marquee	Okvirna selekcija
+	Mean:	Srednja vrednost:
+	Measurement Scale	Razmera merenja
+	Measurement Scale Marker	Oznaka razmere merenja
+	Millimeters	Milimetri
+	Mobile	Mobilni
+	Move Tool	Alatka za pomeranje
+	Could not use the move tool because the layer is locked.	Alatka za pomeranje ne može da se koristi jer je sloj zaključan.
+	Could not complete the Free Transform command because the layer is locked.	Komanda Slobodna transformacija ne može da se izvrši jer je sloj zaključan.
+	Multiply	Množenje
+	My Brushes	Moje četkice
+	Neutrals	Neutralne
+	New Workspace	Novi radni prostor
+	Note Tool	Alatka za beleške
+	Object Selection Tool	Alatka za selekciju objekta
+	Off	Isključeno
+	Open	Otvori
+	Orange	Narandžasta
+	Original Ratio	Originalni odnos
+	Out Of Gamut	Van gamuta
+	Outer Bevel	Spoljašnja kosina
+	Outer Glow	Spoljašnji sjaj
+	Overlay	Preklapanje
+	Paint Bucket Tool	Alatka kofica s bojom
+	Paints from the document's opening state	Slika iz stanja dokumenta pri otvaranju
+	Path Selection Tool	Alatka za selekciju putanje
+	Direct Selection Tool	Alatka za direktnu selekciju
+	Add Anchor Point Tool	Alatka za dodavanje sidrišne tačke
+	Delete Anchor Point Tool	Alatka za brisanje sidrišne tačke
+	Click a segment to add an anchor point · {alt}-click an anchor to delete it	Kliknite segment da dodate sidrišnu tačku · {alt}-klik na tačku da je obrišete
+	Click an anchor point to delete it · {alt}-click a segment to add one	Kliknite sidrišnu tačku da je obrišete · {alt}-klik na segment da dodate novu
+	Pattern Overlay	Prekrivanje šarom
+	Pen Pressure	Pritisak olovke
+	Pen Tilt	Nagib olovke
+	Pen Tool	Alatka pero
+	Convert Point Tool	Alatka za pretvaranje tačke
+	Photo	Fotografija
+	PhotoCraft website	Veb-sajt PhotoCraft-a
+	Picas	Pike
+	Pillow Emboss	Jastučasti reljef
+	Pixel Replacement	Zamena piksela
+	Pixels	Pikseli
+	Points	Tačke
+	Polygon Tool	Alatka mnogougao
+	Polygonal Lasso Tool	Alatka mnogougaoni laso
+	Portrait, 4 x 6	Uspravno, 4 x 6
+	Portrait, 5 x 7	Uspravno, 5 x 7
+	PostScript (72 points/inch)	PostScript (72 tačke/inč)
+	Postcard	Razglednica
+	Poster	Poster
+	Pro (Dark)	Pro (tamna)
+	Pro (Light)	Pro (svetla)
+	Pro (Light Gray)	Pro (svetlosiva)
+	Pro (Medium Gray)	Pro (srednje siva)
+	Protect Texture	Zaštiti teksturu
+	Purple	Ljubičasta
+	Quick Mask	Brza maska
+	Quick Selection Tool	Alatka za brzu selekciju
+	Radial	Radijalno
+	Rasterize Layer	Rasterizuj sloj
+	Rasterize Layers	Rasterizuj slojeve
+	Ratio	Odnos
+	Recent	Nedavno
+	Rectangle Tool	Alatka pravougaonik
+	Rectangular Marquee Tool	Alatka za pravougaonu selekciju
+	Reds	Crvene
+	Reflected	Reflektovano
+	Sample: foreground colour	Uzorak: boja prednjeg plana
+	Sampled Colors	Uzorkovane boje
+	Satin	Saten
+	Save Pixel Aspect Ratio	Sačuvaj odnos stranica piksela
+	Scattering	Rasejavanje
+	Scratch Sizes	Veličine radnog diska
+	Select Data Points	Izaberi tačke podataka
+	Selection	Selekcija
+	SemiBold	Polupodebljano
+	Shadows up to:	Senke do:
+	Shape Dynamics	Dinamika oblika
+	Sharpen Tool	Alatka za izoštravanje
+	Show Extras Options	Opcije prikaza dodatnih elemenata
+	Slice Select Tool	Alatka za izbor isečka
+	Slice Tool	Alatka za isecanje na isečke
+	Smart Filters	Pametni filteri
+	Smudge Tool	Alatka za razmazivanje
+	Soft	Meko
+	Soften	Omekšaj
+	Source	Izvor
+	Source: set	Izvor: postavljen
+	Sponge Tool	Alatka sunđer
+	Spot Healing Brush Tool	Alatka četkica za tačkastu popravku
+	Spread	Raširenost
+	Square, 12 x 12	Kvadrat, 12 x 12
+	Square, 5 x 5	Kvadrat, 5 x 5
+	Std Dev:	Std. devijacija:
+	Studio (Dark)	Studio (tamna)
+	Studio (Light)	Studio (svetla)
+	Stylus Wheel	Točkić olovke
+	Subtract	Oduzimanje
+	Tabloid	Tabloid
+	Text Replacement	Zamena teksta
+	Thin	Tanko
+	Traditional (72.27 points/inch)	Tradicionalno (72,27 tačaka/inč)
+	Transfer	Prenos
+	Triangle Tool	Alatka trougao
+	Unsaved changes	Nesačuvane izmene
+	Uses the foreground and background colours.	Koristi boje prednjeg plana i pozadine.
+	Web	Veb
+	Web Large	Veb, veliko
+	Web Minimum	Veb, minimum
+	Web Most Common	Veb, najčešće
+	WebP (lossless)	WebP (bez gubitaka)
+	Wet Edges	Vlažne ivice
+	Yellows	Žute
+	Zoom Tool	Alatka lupa
+	{name} Properties	Svojstva: {name}
+	Revert “{name}” to the last saved version? Your changes will be lost.	Vratiti „{name}“ na poslednju sačuvanu verziju? Vaše izmene će biti izgubljene.
+	Do you want to save the changes you made to “{name}” before quitting?	Želite li da sačuvate izmene u „{name}“ pre izlaska?
+	Do you want to save the changes you made to “{name}” before closing?	Želite li da sačuvate izmene u „{name}“ pre zatvaranja?
+	Doc: {flat}/{layered}	Dok.: {flat}/{layered}
+	Scratch: {size}	Radni disk: {size}
+	Untagged {mode}	{mode} bez oznake profila
+	{w} px x {h} px ({ppi} ppi)	{w} px x {h} px ({ppi} ppi)
+	{w} {unit} x {h} {unit} ({ppi} ppi)	{w} {unit} x {h} {unit} ({ppi} ppi)
+	Resolution: {dpi} pixels/inch	Rezolucija: {dpi} piksela/inč
+	Doc: {w} × {h} px	Dok.: {w} × {h} px
+	Frame {current} / {total}	Kadar {current} / {total}
+	Count: {n}	Broj: {n}
+	BLANK DOCUMENT PRESETS ({n})	ŠABLONI PRAZNIH DOKUMENATA ({n})
+	Constraints ({n})	Ograničenja ({n})
+	Align {what}	Poravnaj: {what}
+@plural	{n} Layer|{n} Layers	{n} sloj|{n} sloja|{n} slojeva
+@plural	{n} layer|{n} layers	{n} sloj|{n} sloja|{n} slojeva
+@plural	Group · {n} layer|Group · {n} layers	Grupa · {n} sloj|Grupa · {n} sloja|Grupa · {n} slojeva
+	Additional plugins folder	Dodatna fascikla za dodatke
+	Adobe	Adobe
+	Adobe rgb	Adobe RGB
+	Allow agent control	Dozvoli upravljanje agentima
+	Allow scripts to connect	Dozvoli skriptama da se povežu
+	Always	Uvek
+	Always create smart objects when placing	Uvek pravi pametne objekte pri postavljanju
+	Animated zoom	Animirano zumiranje
+	Apply auto tone	Primeni automatski ton
+	Ask	Pitaj
+	Ask before saving layered tiff	Pitaj pre čuvanja TIFF-a sa slojevima
+	Auto collapse icon panels	Automatski skupi panele sa ikonama
+	Auto show hidden panels	Automatski prikaži skrivene panele
+	Auto show home screen	Automatski prikaži početni ekran
+	Autosave	Automatsko čuvanje
+	Autosave minutes	Automatsko čuvanje (minuti)
+	Beep when done	Zvučni signal po završetku
+	Bicubic automatic	Bikubično automatski
+	Bicubic sharper	Bikubično oštrije
+	Bicubic smoother	Bikubično glađe
+	Bit depth	Dubina bita
+	Brush preview color	Boja pregleda četkice
+	Cache levels	Nivoi keša
+	Cache tile size	Veličina pločice keša
+	Camera Raw Defaults	Podrazumevana Camera Raw podešavanja
+	Canvas border	Ivica platna
+	Show canvas dots	Prikaži tačke na platnu
+	Canvas color	Boja platna
+	Canvas custom color	Prilagođena boja platna
+	Color picker	Birač boja
+	Color space	Prostor boja
+	Column width	Širina kolone
+	Concise	Sažeto
+	Control port	Kontrolni port
+	Convert to srgb	Pretvori u sRGB
+	Cursors	Kursori
+	Custom dark	Prilagođena tamna
+	Custom light	Prilagođena svetla
+	Dark	Tamna
+	Dark gray	Tamnosiva
+	Dashed lines	Isprekidane linije
+	Destination	Odredište
+	Detailed	Detaljno
+	Disks	Diskovi
+	Display p3	Display P3
+	Double click layer mask launches select and mask	Dvoklik na masku sloja otvara Izaberi i maskiraj
+	Drop shadow	Bačena senka
+	Dynamic color sliders	Dinamički klizači boja
+	East asian	Istočnoazijsko
+	Effect cache mb	Keš efekata (MB)
+	Enable flick panning	Omogući pomeranje prikaza zamahom
+	Enable floating document window docking	Omogući usidravanje plutajućih prozora dokumenata
+	Enable narrow options bar	Omogući usku traku opcija
+	Enabled	Omogućeno
+	Enhanced Controls	Napredne kontrole
+	Export clipboard	Izvezi ostavu
+	Extra large	Veoma velika
+	File Handling	Rukovanje datotekama
+	File path	Putanja datoteke
+	Fill new type layers with placeholder	Popuni nove tekstualne slojeve probnim tekstom
+	Font preview	Pregled fonta
+	Full size tip	Vrh pune veličine
+	Gamut warning color	Boja upozorenja o gamutu
+	Gamut warning opacity	Neprozirnost upozorenja o gamutu
+	Generator enabled	Generator je omogućen
+	Gif	GIF
+	Glossy	Sjajno
+	Grid color	Boja mreže
+	Grid colors	Boje mreže
+	Grid size	Veličina mreže
+	Grid style	Stil mreže
+	Grid unit	Jedinica mreže
+	Gridline every	Linija mreže na svakih
+	Guide color	Boja vodilja
+	Guide style	Stil vodilja
+	Guides, Grid & Slices	Vodilje, mreža i isečci
+	Gutter	Žleb
+	History Log	Dnevnik istorije
+	History states	Stanja istorije
+	Ignore exif profile tag	Zanemari EXIF oznaku profila
+	Image interpolation	Interpolacija slike
+	Image previews	Pregledi slika
+	Integrations	Integracije
+	Interface	Interfejs
+	Jpeg quality	JPEG kvalitet
+	Jpg	JPG
+	Language	Jezik
+	Large tabs	Velike kartice
+	Legacy compositing	Staro komponovanje
+	Light gray	Svetlosiva
+	Line	Linija
+	Lines	Linije
+	Lossless	Bez gubitaka
+	Lowercase extension	Ekstenzija malim slovima
+	Maximize psd compatibility	Maksimalna kompatibilnost PSD-a
+	Medium gray	Srednje siva
+	Memory usage mb	Korišćenje memorije (MB)
+	Low resolution previews	Pregledi niske rezolucije
+	Missing glyph protection	Zaštita od glifova koji nedostaju
+	Modern	Moderno
+	Nearest neighbor	Najbliži sused
+	Never	Nikad
+	Normal tip	Normalan vrh
+	Open as smart object	Otvori kao pametni objekat
+	Open in camera raw	Otvori u Camera Raw-u
+	Open documents as tabs	Otvaraj dokumente kao kartice
+	Overscroll	Pomeranje preko ivice
+	Performance	Performanse
+	Png	PNG
+	Point size	Veličina tačke
+	Precise	Precizno
+	Preserve details	Očuvaj detalje
+	Print resolution	Rezolucija štampe
+	Pro	Pro
+	Pro light	Pro svetla
+	Pro light gray	Pro svetlosiva
+	Pro medium	Pro srednja
+	Pro photo	ProPhoto
+	Quick export format	Format brzog izvoza
+	Quick export location	Lokacija brzog izvoza
+	Recent file count	Broj nedavnih datoteka
+	Recent files	Nedavne datoteke
+	Recent fonts	Nedavni fontovi
+	Recover on launch	Oporavi pri pokretanju
+	Remember workspace changes	Zapamti izmene radnog prostora
+	Resize image during place	Promeni veličinu slike pri postavljanju
+	Rotate view with trackpad	Rotiraj prikaz pomoću dodirne table
+	Same folder	Ista fascikla
+	Save in background	Čuvaj u pozadini
+	Scratch Disks	Radni diskovi
+	Screen	Ekran
+	Screen resolution	Rezolucija ekrana
+	Scrubby slider acceleration	Ubrzanje klizača prevlačenjem
+	Sessions only	Samo sesije
+	Sharpen for	Izoštri za
+	Show channels in color	Prikaži kanale u boji
+	Show crosshair in brush tip	Prikaži krstić u vrhu četkice
+	Show extension panels	Prikaži panele proširenja
+	Show font names in english	Prikaži imena fontova na engleskom
+	Show menu colors	Prikaži boje menija
+	Show only crosshair while painting	Prikaži samo krstić tokom slikanja
+	Show slice numbers	Prikaži brojeve isečaka
+	Show tooltips	Prikaži opise alatki
+	Enable animations	Omogući animacije
+	Show highlight on rollover	Istakni pri prelasku pokazivačem
+	Show transformation values	Prikaži vrednosti transformacije
+	Slice color	Boja isečka
+	Smart guide color	Boja pametnih vodilja
+	Smart quotes	Pametni navodnici
+	Snap vector tools and transforms to pixel grid	Prianjaj vektorske alatke i transformacije uz mrežu piksela
+	Srgb	sRGB
+	Standard	Standardno
+	Studio	Studio
+	Studio light	Studio svetla
+	Adwaita	Adwaita
+	Adwaita dark	Adwaita tamna
+	Subdivisions	Pododeljci
+	System	Sistem
+	Text engine	Mašina za tekst
+	Text file	Tekstualna datoteka
+	Tiny	Sićušno
+	Touch gestures	Pokreti na dodirnom ekranu
+	Transparency & Gamut	Providnost i gamut
+	Type units	Jedinice teksta
+	UI font size	Veličina fonta interfejsa
+	UI scale	Razmera interfejsa
+	Units & Rulers	Jedinice i lenjiri
+	Use additional plugins folder	Koristi dodatnu fasciklu za dodatke
+	Use esc to commit	Koristi Esc za potvrdu
+	Use gpu	Koristi GPU
+	Use legacy free transform	Koristi staru slobodnu transformaciju
+	Use shift key for tool switch	Koristi Shift za promenu alatke
+	Vary round brush hardness on hud	Menjaj tvrdoću okrugle četkice na HUD-u
+	Webp	WebP
+	World ready	Za sva pisma sveta
+	Zoom clicked point to center	Zumiraj tako da kliknuta tačka bude u centru
+	Zoom resizes windows	Zumiranje menja veličinu prozora
+	Zoom with scroll wheel	Zumiraj točkićem miša
+	Zoom with trackpad pinch	Zumiraj štipanjem na dodirnoj tabli
+	Pass Through	Propuštanje
+	Dissolve	Rastapanje
+	Darker Color	Tamnija boja
+	Linear Dodge (Add)	Linearno posvetljivanje (sabiranje)
+	Lighter Color	Svetlija boja
+	Soft Light	Meko svetlo
+	Hard Light	Oštro svetlo
+	Vivid Light	Živo svetlo
+	Linear Light	Linearno svetlo
+	Pin Light	Tačkasto svetlo
+	Exclusion	Isključenje
+	Divide	Deljenje
+	Luminosity	Svetlina tona
+@plural	{n} sample|{n} samples	{n} uzorak|{n} uzorka|{n} uzoraka
+	{added}, {removed} subtracted	{added}, oduzeto: {removed}
+	Adjustment Preview	Pregled korekcije
+	Airbrush: keeps depositing paint while the pointer rests.	Vazdušna četkica: nastavlja da nanosi boju dok pokazivač miruje.
+	Angle:	Ugao:
+	Blend If	Stapaj ako
+	Close Tab Group	Zatvori grupu kartica
+	Collapse	Skupi
+	Collapse All Groups	Skupi sve grupe
+	Collapse Panel Group	Skupi grupu panela
+	Collapse group  ({key}-click: all groups)	Skupi grupu  ({key}-klik: sve grupe)
+	Create new brush from the current settings	Napravi novu četkicu od tekućih podešavanja
+	Create new brush from these settings	Napravi novu četkicu od ovih podešavanja
+	Update the current brush with these settings	Ažuriraj tekuću četkicu ovim podešavanjima
+	Delete brush	Obriši četkicu
+	Drag the arrow to set the angle, the dots to set the roundness	Prevucite strelicu da podesite ugao, a tačke da podesite zaobljenost
+	Expand	Proširi
+	Expand Panel Group	Proširi grupu panela
+	Expand group  ({key}-click: all groups)	Proširi grupu  ({key}-klik: sve grupe)
+	Fade steps	Koraci iščezavanja
+	Hide the layer's effects  ({key}-click: all layers)	Sakrij efekte sloja  ({key}-klik: svi slojevi)
+	Import Brushes… (.abr)	Uvezi četkice… (.abr)
+	Move Group Down	Pomeri grupu nadole
+	Move Group Up	Pomeri grupu nagore
+	Reset the brush to the defaults	Vrati četkicu na podrazumevano
+	Restore original size	Vrati originalnu veličinu
+	Roundness:	Zaobljenost:
+	Search Brushes	Pretraži četkice
+	Show the layer's effects  ({key}-click: all layers)	Prikaži efekte sloja  ({key}-klik: svi slojevi)
+	Brush picker	Birač četkica
+	Erase	Briši
+	Right click with painting tools	Desni klik alatkama za slikanje
+	System Info…	Informacije o sistemu…
+	System Info	Informacije o sistemu
+	More panels	Više panela
+	More documents	Više dokumenata
+	These settings aren't available in PhotoCraft yet.	Ova podešavanja još nisu dostupna u PhotoCraft-u.
+	Graphics	Grafika
+	Reset GPU Backend	Resetuj GPU pozadinski sistem
+	Applies at next launch.	Primenjuje se pri sledećem pokretanju.
+	Click to sample the foreground colour  ·  {key}-click for background	Kliknite da uzorkujete boju prednjeg plana  ·  {key}-klik za pozadinu
+	{key}-click to set the source	{key}-klik da postavite izvor
+	{key} to subtract	{key} za oduzimanje
+	Clone source {n} ({key}-click with Clone Stamp to set)	Izvor kloniranja {n} ({key}-klik pečatom za kloniranje da postavite)
+	Source: not set ({key}-click with Clone Stamp)	Izvor: nije postavljen ({key}-klik pečatom za kloniranje)
+	Pixel Layer	Piksel sloj
+	Type Layer	Tekstualni sloj
+	Shape Layer	Sloj oblika
+	Group Layer	Sloj grupe
+	Fill Layer	Sloj popune
+	Smart Object Layer	Sloj pametnog objekta
+	Create Warped Text	Napravi iskrivljeni tekst
+	Rasterize Smart Object	Rasterizuj pametni objekat
+	Rasterize Fill Content	Rasterizuj sadržaj popune
+	Rasterize Layer Style	Rasterizuj stil sloja
+	Unlock: picking a preset replaces these settings	Otključaj: izbor šablona zamenjuje ova podešavanja
+	Lock: keep these settings when picking another preset	Zaključaj: zadrži ova podešavanja pri izboru drugog šablona
+	Diameter:	Prečnik:
+	Hardness:	Tvrdoća:
+	No brush presets	Nema šablona četkica
+	Toggle the Brush Settings panel  (F5)	Prikaži/sakrij panel Podešavanja četkice  (F5)
+	Create new brush preset from the current settings	Napravi novi šablon četkice od tekućih podešavanja
+	Brush Settings…  (F5): every option of this brush	Podešavanja četkice…  (F5): sve opcije ove četkice
+	Rename Brush…	Preimenuj četkicu…
+	Delete Brush	Obriši četkicu
+	New Brush Preset…	Novi šablon četkice…
+	Capture Brush Size in Preset	Sačuvaj veličinu četkice u šablonu
+	Include Tool Settings	Uključi podešavanja alatke
+	Include Color	Uključi boju
+	Enter a name for the brush preset	Unesite ime šablona četkice
+	A brush preset with this name already exists	Šablon četkice sa ovim imenom već postoji
+	Brush Preset Options	Opcije šablona četkice
+	Group name	Ime grupe
+	Brush name	Ime četkice
+	Brush Name	Ime četkice
+	Brush Stroke	Potez četkicom
+	Off: the speed of the pointer sets the spacing	Isključeno: brzina pokazivača određuje razmak
+	Tilt Scale	Razmera nagiba
+	Brush Projection	Projekcija četkice
+	Apply the pen's tilt and rotation to the tip shape	Primeni nagib i rotaciju olovke na oblik vrha
+	Mixer Brush	Četkica za mešanje
+	Wet	Vlažnost
+	Mix	Mešanje
+	Wetness Jitter	Kolebanje vlažnosti
+	Mix Jitter	Kolebanje mešanja
+	Show the layer mask as an overlay	Prikaži masku sloja kao preklop
+	Toggle visibility	Uključi/isključi vidljivost
+	Unlink the mask from the layer	Razveži masku od sloja
+	Link the mask to the layer	Poveži masku sa slojem
+	Gradient	Gradijent
+	Gradient Options	Opcije gradijenta
+	Align with layer	Poravnaj sa slojem
+	Reset Alignment	Resetuj poravnanje
+	Centre the gradient (offset 0, 0)	Centriraj gradijent (pomak 0, 0)
+# Gradient Editor window, opened from the options bar's gradient swatch.
+	Gradient Editor	Uređivač gradijenta
+	Gradient picker	Birač gradijenta
+	Save As Preset	Sačuvaj kao šablon
+	The gradient the Gradient tool paints with	Gradijent kojim slika alatka gradijent
+	Adds the current gradient to the Gradients panel	Dodaje tekući gradijent u panel Gradijenti
+	Gradient stops	Tačke gradijenta
+	Select a type layer to edit its character and paragraph settings.	Izaberite tekstualni sloj da biste uredili podešavanja znakova i pasusa.
+	Text color	Boja teksta
+	Type Options	Opcije teksta
+	Anti-aliasing method	Metod uglađivanja ivica
+	Horizontal type	Horizontalni tekst
+	Vertical type	Vertikalni tekst
+	Fill path with foreground color	Popuni putanju bojom prednjeg plana
+	Stroke path with brush	Ocrtaj putanju četkicom
+	Load path as a selection	Učitaj putanju kao selekciju
+	Make work path from selection	Napravi radnu putanju od selekcije
+	Add vector mask	Dodaj vektorsku masku
+	Create new path	Napravi novu putanju
+	Delete path	Obriši putanju
+	Delete vector mask	Obriši vektorsku masku
+	CPU (no GPU acceleration)	CPU (bez GPU ubrzanja)
+	DirectX 12	DirectX 12
+	GPU backend	GPU pozadinski sistem
+	Linux display server	Linux server prikaza
+	X11	X11
+	Metal	Metal
+	OpenGL	OpenGL
+	Use tablet pressure	Koristi pritisak na tabletu
+	Vulkan	Vulkan
+	Alt-click to define a source point to clone from	Alt-klik da odredite izvornu tačku za kloniranje
+	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Nema putanje od koje bi se napravila selekcija: nacrtajte je alatkom pero ili je izaberite u panelu Putanje.
+	Cancel opening	Otkaži otvaranje
+	Cancelled opening {name}	Otkazano otvaranje: {name}
+	The document “{name}” does not have an embedded {mode} profile.	Dokument „{name}“ nema ugrađeni {mode} profil.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Dokument „{name}“ ima ugrađeni profil boja koji se ne slaže sa trenutnim {mode} radnim prostorom.
+	Embedded: {embedded}	Ugrađeni: {embedded}
+	Working: {working}	Radni prostor: {working}
+	Developing {name}	Razvijanje: {name}
+	Cancelled {label}	Otkazano: {label}
+	Esc to cancel	Esc za otkazivanje
+	Opened {name}	Otvoreno: {name}
+	Opening {name}	Otvaranje: {name}
+	Saved {name}	Sačuvano: {name}
+	Saving {name}	Čuvanje: {name}
+	Saving {percent}	Čuvanje {percent}
+	A save to {name} is still running; try again when it finishes	Čuvanje u {name} je još u toku; pokušajte ponovo kada se završi
+	{label} is writing the file and can no longer be cancelled	{label}: datoteka se upisuje i više ne može da se otkaže
+	Opening {name}…	Otvaranje: {name}…
+	Opening…	Otvaranje…
+	Reading…	Čitanje…
+	Working…	Obrada…
+@id	select.all	Izaberi sve
+@id	edit.purge.undo	Podaci za opoziv
+	Delete Smart Filters	Obriši pametne filtere
+	Enable Smart Filters	Omogući pametne filtere
+	New Layer…	Novi sloj…
+	Delete Layer…	Obriši sloj…
+	Color Range	Opseg boja
+	Select Similar Colors	Izaberi slične boje
+	New Selection	Nova selekcija
+	Adaptive Wide Angle	Prilagodljivi široki ugao
+	Chalk & Charcoal	Kreda i ugalj
+	Charcoal	Ugalj
+	Chrome	Hrom
+	Conté Crayon	Konte krejon
+	Graphic Pen	Grafičko pero
+	Halftone Pattern	Polutonska šara
+	Note Paper	Papir za beleške
+	Photocopy	Fotokopija
+	Plaster	Gips
+	Reticulation	Retikulacija
+	Stamp	Pečat
+	Torn Edges	Pocepane ivice
+	Water Paper	Vodeni papir
+	Canvas rotation	Rotacija platna
+	Extensions	Proširenja
+	Libraries	Biblioteke
+	3D	3D
+	Toolbars	Trake alatki
+	Move	Pomeranje
+	Wand	Štapić
+	Pencil	Olovka
+	Clone Stamp	Pečat za kloniranje
+	Healing	Popravka
+	Dodge	Posvetljivanje
+	Burn	Zatamnjivanje
+	Pen	Pero
+	Hand	Ruka
+	Sampler	Uzorkivač
+	Note tool	Alatka za beleške
+	Quick Selection	Brza selekcija
+	Magnetic Lasso	Magnetni laso
+	History Brush	Četkica istorije
+	Art History Brush	Umetnička četkica istorije
+	Pattern Stamp	Pečat za šaru
+	Spot Healing	Tačkasta popravka
+	Red Eye	Crvene oči
+	Patch	Zakrpa
+	Content-Aware Move	Pomeranje prema sadržaju
+	Rotate View	Rotiraj prikaz
+	Perspective Crop	Perspektivno opsecanje
+	Color Replacement	Zamena boje
+	Dodge/Burn	Posvetljivanje/zatamnjivanje
+	Dynamics	Dinamika
+	Tilt	Nagib
+	Reset	Resetuj
+	Defaults restored.	Podrazumevana podešavanja su vraćena.
+	Stop	Zaustavi
+	Create new set	Napravi novi skup
+	Technology Previews	Probne tehnologije
+	New Group	Nova grupa
+	Layer Comp	Kompozicija slojeva
+	Create new layer	Napravi novi sloj
+	Group · {n} layer	Grupa · slojeva: {n}
+	General Blend	Opšte stapanje
+	Advanced Blending	Napredno stapanje
+	RGB	RGB
+	Alpha	Alfa
+	Spot Channel	Kanal spot boje
+	Working Gray Plate	Radna siva ploča
+	HSL/Grayscale	HSL/nijanse sive
+	Tone Curve	Tonska kriva
+	Split Toning	Podeljeno toniranje
+	Lens Corrections	Korekcije objektiva
+	Camera Calibration	Kalibracija fotoaparata
+	Snapshots	Snimci stanja
+	Recovery	Oporavak
+	Fill Light	Svetlo popune
+	Convert to Grayscale	Pretvori u nijanse sive
+	Sharpness	Oštrina
+	Color Noise Reduction	Smanjenje šuma boje
+	Luminance Smoothness	Glatkoća luminanse
+	Make	Proizvođač
+	Model	Model
+	Lens	Objektiv
+	F	F
+	ISO	ISO
+	Focal Length35mm	Žižna daljina (35 mm)
+	Aspect Ratio	Odnos stranica
+	Time	Vreme
+	Artist	Umetnik
+	Enter description…	Unesite opis…
+	ColorSync	ColorSync
+	ProPhoto	ProPhoto
+	sRGB	sRGB
+	ACES	ACES
+	Industry Standard	Industrijski standard
+	Uncoated CMYK	Nepremazani CMYK
+	Newspaper	Novinski papir
+	Working Spaces	Radni prostori
+	Color Management Policies	Pravila upravljanja bojama
+	Detect Faces	Prepoznaj lica
+	Localize Color Clusters	Lokalizuj grupe boja
+	Duplicated selection name	Ime duplirane selekcije
+	Operation	Operacija
+	New channel only	Samo novi kanal
+	Masked Areas	Maskirane oblasti
+	Selected Areas	Izabrane oblasti
+	Spot Color	Spot boja
+	Color indicates	Boja označava
+	Create Snapshot	Napravi snimak stanja
+	Delete Snapshot	Obriši snimak stanja
+	New Snapshot	Novi snimak stanja
+	Snapshot 1	Snimak stanja 1
+	Step Forward	Korak napred
+	Step Backward	Korak nazad
+	Nonlinear History	Nelinearna istorija
+	Set New Snapshot as Default	Postavi novi snimak stanja kao podrazumevani
+	Automatically Create First Snapshot	Automatski napravi prvi snimak stanja
+	Automatically Create New Snapshot When Saving	Automatski napravi novi snimak stanja pri čuvanju
+	Show New Snapshot Dialog by Default	Podrazumevano prikaži dijalog za novi snimak stanja
+	Clear History	Obriši istoriju
+	Panel Options…	Opcije panela…
+	View menu	Meni prikaza
+	Keep view in sync	Drži prikaz usklađenim
+	{zoom}%	{zoom}%
+	Mouse Controls	Kontrole mišem
+	Initial Direction of Stroke	Početni smer poteza
+	Direction of Stroke	Smer poteza
+	Humidity	Vlažnost vazduha
+	Auto Clean Brush	Automatski čisti četkicu
+	Spacing:	Razmak:
+	Brush Tip	Vrh četkice
+	New Layer from Brush	Novi sloj od četkice
+	New Brush	Nova četkica
+	New Tool Preset	Novi šablon alatke
+	Auto-Leading	Automatski prored
+	Scale Horizontally	Skaliraj horizontalno
+	Scale Vertically	Skaliraj vertikalno
+	Baseline Shift	Pomak osnovne linije
+	Mac LCD	Mac LCD
+	Mac Sharp	Mac oštro
+	Mac Crisp	Mac jasno
+	Mac Strong	Mac snažno
+	Mac Smooth	Mac glatko
+	Superscript	Eksponent
+	Subscript	Indeks
+	Ligature	Ligatura
+	Alternative	Alternativa
+	Roman	Uspravno
+	Bold Italic	Podebljani kurziv
+	Ultra Light	Ultra lagano
+	Extra Light	Ekstra lagano
+	Semi Bold	Polupodebljano
+	Extra Bold	Ekstra podebljano
+	Ultra Bold	Ultra podebljano
+	Condensed	Suženo
+	First Line Indent	Uvlačenje prvog reda
+	Hanging Punctuation	Viseća interpunkcija
+	Roman Hanging Punctuation	Viseća interpunkcija za latinicu
+	Avoid Widows/Orphans	Izbegavaj udovice/siročiće
+	Compose	Slaganje
+	Adobe Single-line Composer	Adobe slagač pojedinačnih redova
+	Adobe Every-line Composer	Adobe slagač svih redova
+	Justification	Obostrano poravnanje
+	Word Spacing	Razmak između reči
+	Letter Spacing	Razmak između slova
+	Glyph Scaling	Skaliranje glifova
+	Auto-leading %	Automatski prored %
+	Single Word Justification	Obostrano poravnanje jedne reči
+	Alignment	Poravnanje
+	Justify	Poravnaj obostrano
+	Glyph	Glif
+	Alternates for Current Selection	Alternative za tekuću selekciju
+	Digits	Cifre
+	Symbols	Simboli
+	Punctuation	Interpunkcija
+	Path:	Putanja:
+	Path to Illustrator…	Putanja u Illustrator…
+	Make Work Path	Napravi radnu putanju
+	Make Selection	Napravi selekciju
+	Fill Path	Popuni putanju
+	Stroke Path	Ocrtaj putanju
+	Clipping Path	Putanja isecanja
+	New Path	Nova putanja
+	Duplicate Path	Dupliraj putanju
+	Delete Path	Obriši putanju
+	Auto-Hide	Automatski sakrij
+	W	Š
+	H	V
+	X	X
+	Y	Y
+	Frame Sync	Sinhronizacija kadrova
+	Quick Sync	Brza sinhronizacija
+	Audio	Zvuk
+	Frame Duration	Trajanje kadra
+	Loop	Petlja
+	Split at Playhead	Podeli na mestu glave za reprodukciju
+	Flatten Frames Into Clips	Spljošti kadrove u klipove
+	Flatten Frames Into Layers	Spljošti kadrove u slojeve
+	Convert Frames > Video Layers	Pretvori kadrove > video slojevi
+	New Video Layer	Novi video sloj
+	New Video Group	Nova video grupa
+	Limit Playback	Ograniči reprodukciju
+	Enable Timeline Quick Config	Omogući brzo podešavanje vremenske linije
+	Set Start Timecode…	Postavi početni vremenski kod…
+	Timecode	Vremenski kod
+	30 fps	30 fps
+	25 fps	25 fps
+	24 fps	24 fps
+	15 fps	15 fps
+	10 fps	10 fps
+	Current Time	Trenutno vreme
+	Out	Izlaz
+	In	Ulaz
+	Duration	Trajanje
+	Repeat	Ponavljaj
+	Play Once	Pusti jednom
+	Info Options…	Opcije informacija…
+	First Color Readout	Prvo očitavanje boje
+	Second Color Readout	Drugo očitavanje boje
+	Actual Color	Stvarna boja
+	Grayscale Slider	Klizač nijansi sive
+	Web Color	Veb boja
+	HSB Color	HSB boja
+	Total Ink	Ukupno mastilo
+	Opacity Mask	Maska neprozirnosti
+	Ruler	Lenjir
+	Document Size	Veličina dokumenta
+	Timing	Vreme izvršavanja
+	Status Information	Statusne informacije
+	Saved Multichannel	Sačuvano višekanalno
+	Mouse Coordinates	Koordinate miša
+	Ruler Units	Jedinice lenjira
+	Hide	Sakrij
+	New Layer Comp	Nova kompozicija slojeva
+	Duplicate Layer Comp	Dupliraj kompoziciju slojeva
+	Rename Layer Comp	Preimenuj kompoziciju slojeva
+	Apply Layer Comp	Primeni kompoziciju slojeva
+	Update Layer Comp	Ažuriraj kompoziciju slojeva
+	Restore last viewed comp	Vrati poslednju prikazanu kompoziciju
+	Method	Metod
+	Select All Layers	Izaberi sve slojeve
+	Keep proportions	Zadrži proporcije
+	Interpolation	Interpolacija
+	Author	Autor
+	Caption	Natpis
+	Caption Credits	Zasluge za natpis
+	Keywords	Ključne reči
+	Copyright Info URL	URL informacija o autorskim pravima
+	Copyright Status	Status autorskih prava
+	Copyrighted	Zaštićeno autorskim pravima
+	Public Domain	Javno dobro
+	Unknown	Nepoznato
+	Credit	Zasluge
+	Transmission Reference	Referenca prenosa
+	Urgency	Hitnost
+	High	Visoko
+	Low	Nisko
+	Category	Kategorija
+	Supplemental Categories	Dodatne kategorije
+	Object Name / Title	Ime objekta / naslov
+	Date Created	Datum nastanka
+	City	Grad
+	Location	Lokacija
+	Province / State	Pokrajina / država
+	Country	Zemlja
+	Byline	Potpis autora
+	Byline Title	Zvanje autora
+	Phone	Telefon
+	Email	E-pošta
+	URLs	URL adrese
+	Last Modified	Poslednja izmena
+	EXIF	EXIF
+	GPS	GPS
+	Camera Data	Podaci fotoaparata
+	Camera Model	Model fotoaparata
+	Camera Make	Proizvođač fotoaparata
+	EXIF Version	EXIF verzija
+	Exposure Program	Program ekspozicije
+	Aperture	Otvor blende
+	Shutter Speed	Brzina zatvarača
+	Metering Mode	Režim merenja svetla
+	Light Source	Izvor svetla
+	Flash	Blic
+	Lens Info	Podaci o objektivu
+	ISO Speed	ISO osetljivost
+	Subject Distance	Udaljenost objekta
+	DateTime Original	Izvorni datum i vreme
+	Create Date	Datum kreiranja
+	Modify Date	Datum izmene
+	Software	Softver
+	Raw Data	Neobrađeni podaci
+	Advanced	Napredno
+	Import…	Uvezi…
+	PDF Presentation…	PDF prezentacija…
+	Create Multiple Picture Packages	Napravi više paketa slika
+	Picture Package…	Paket slika…
+	Web Photo Gallery…	Veb galerija fotografija…
+	Choose…	Izaberi…
+	Select Folder…	Izaberi fasciklu…
+	Override Action "Save" Commands	Nadjačaj komande „Sačuvaj“ u radnji
+	File Naming	Imenovanje datoteka
+	Compatibility	Kompatibilnost
+	Mac OS	Mac OS
+	Unix	Unix
+	Include ICC Profile	Uključi ICC profil
+	Error File	Datoteka grešaka
+	Stop For Errors	Zaustavi se kod grešaka
+	Log Errors To File	Beleži greške u datoteku
+	Errors	Greške
+	Settings	Podešavanja
+	Settings:	Podešavanja:
+	Working Space	Radni prostor boja
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Gray:	Siva:
+	Spot:	Spot:
+	Advanced Controls	Napredne kontrole
+	Desaturate Monitor Colors By	Smanji zasićenost boja monitora za
+	Blend RGB Colors Using Gamma 1.0	Stapaj RGB boje pomoću game 1.0
+	Profile Mismatches: Ask When Opening	Neslaganje profila: pitaj pri otvaranju
+	Ask When Pasting	Pitaj pri lepljenju
+	Missing Profiles: Ask When Opening	Profili koji nedostaju: pitaj pri otvaranju
+	Embed profiles	Ugradi profile
+	Ask Before Saving Saved Embedded	Pitaj pre čuvanja sa ugrađenim profilom
+	Coerce to sRGB	Prinudno pretvori u sRGB
+	sRGB IEC61966-2.1	sRGB IEC61966-2.1
+	Adobe RGB (1998)	Adobe RGB (1998)
+	ProPhoto RGB	ProPhoto RGB
+	ColorMatch RGB	ColorMatch RGB
+	Wide Gamut RGB	Wide Gamut RGB
+	Apple RGB	Apple RGB
+	NTSC (1953)	NTSC (1953)
+	PAL/SECAM	PAL/SECAM
+	SMPTE C	SMPTE C
+	HDTV (Rec. 709)	HDTV (Rec. 709)
+	CIE RGB	CIE RGB
+	Graphic and web	Grafika i veb
+	Minimalistic	Minimalistički
+	Expand All Groups	Proširi sve grupe
+	Photo (2 × 3 in)	Fotografija (2 × 3 in)
+	Photo (4 × 6 in)	Fotografija (4 × 6 in)
+	Photo (5 × 7 in)	Fotografija (5 × 7 in)
+	Photo (8 × 10 in)	Fotografija (8 × 10 in)
+	Recent Items	Nedavne stavke
+	Save Preset…	Sačuvaj šablon…
+	Delete Preset…	Obriši šablon…
+	Preset Name:	Ime šablona:
+	Width and Height	Širina i visina
+	Color Profile	Profil boja
+	Units	Jedinice
+	Columns	Kolone
+	Create new count group	Napravi novu grupu brojanja
+	Adjustment Layer	Korekcioni sloj
+	Pencil Tool	Alatka olovka
+	Pixel	Piksel
+	Adjustment	Korekcija
+	Drag (lasso) or click points (polygonal) · {add} add · {sub} subtract	Prevucite (laso) ili kliknite tačke (mnogougao) · {add} dodaje · {sub} oduzima
+	Drag a crop box · drag inside to move · edges resize ({ratio} ratio, {centre} centre) · Space moves while drawing · arrows nudge · X swaps orientation · {commit} commits · Esc cancels	Prevucite okvir za opsecanje · prevlačenje unutra pomera · ivice menjaju veličinu ({ratio} odnos, {centre} centar) · razmaknica pomera tokom crtanja · strelice pomeraju malo · X menja orijentaciju · {commit} potvrđuje · Esc otkazuje
+	{mode} Color · {bits} bit	{mode} boje · {bits} bita
+	Drag to move the layer	Prevucite da pomerite sloj
+	Scrubby Zoom	Zumiranje prevlačenjem
+	Auto Erase	Automatsko brisanje
+	Color Adaptation	Prilagođavanje boja
+	Preserve Transparency	Očuvaj providnost
+	shortcut	prečica
+	Go to Layer	Idi na sloj
+	Saved	Sačuvano
+	After (X)	Posle (X)
+	Current	Tekuće
+	Reference point location	Položaj referentne tačke
+	Toggle reference point	Uključi/isključi referentnu tačku
+	Arc	Luk
+	Arch	Svod
+	Bulge	Ispupčenje
+	Shell Lower	Školjka dole
+	Shell Upper	Školjka gore
+	Flag	Zastava
+	Fish	Riba
+	Wave	Talas
+	Rise	Uzdizanje
+	Inflate	Naduvavanje
+	Twist	Zavrtanje
+	Squeeze	Stiskanje
+	Add Pins	Dodaj čiode
+	Delete Pins	Obriši čiode
+	Rotate Auto	Automatska rotacija
+	Rotate Fixed	Fiksna rotacija
+	Create Plane	Napravi ravan
+	Edit Plane	Uredi ravan
+	Select Plane	Izaberi ravan
+	Measure	Meri
+	Heal	Popravka
+	Heal Off	Popravka isključena
+	Heal On	Popravka uključena
+	Heal Auto	Automatska popravka
+	Blend	Stapanje
+	Brush Size	Veličina četkice
+	Heal Color	Popravka boje
+	Mask	Maska
+	Channel	Kanal
+	Rectangle	Pravougaonik
+	Result	Rezultat
+	New Channel	Novi kanal
+	Save Selection	Sačuvaj selekciju
+	Load Selection	Učitaj selekciju
+	Duplicate	Dupliraj
+	Fast	Brzo
+	Accurate	Precizno
+	Add to	Dodaj u
+	Subtract from	Oduzmi od
+	Intersect with	Presek sa
+	Capture Comp	Zabeleži kompoziciju
+	No Layer Comps	Nema kompozicija slojeva
+	Adobe PDF Presets…	Adobe PDF šabloni…
+	3D…	3D…
+	Technology Previews…	Probne tehnologije…
+	Background from Layer	Pozadina od sloja
+	Add a mask  (from the selection; ⌥ inverts)	Dodaj masku  (iz selekcije; ⌥ invertuje)
+	Add to selection  (⇧)	Dodaj u selekciju  (⇧)
+	Airbrush: keeps painting while the pointer rests.	Vazdušna četkica: nastavlja da slika dok pokazivač miruje.
+	Click the first point or press ↵ to close · Esc cancels	Kliknite prvu tačku ili pritisnite ↵ da zatvorite · Esc otkazuje
+	Click to add a point · drag off or ⌘/Ctrl-click or Delete to remove	Kliknite da dodate tačku · prevucite van, ⌘/Ctrl-klik ili Delete da uklonite
+	Click to apply, ⌥-click to clear overrides, double-click for Style Options	Kliknite da primenite, ⌥-klik da uklonite nadjačavanja, dvoklik za opcije stila
+	Click to zoom in  ·  ⌥-click to zoom out	Kliknite da uvećate  ·  ⌥-klik da umanjite
+	Click: corner · Drag: smooth · Click first point: close · ↩ finish · Esc cancel	Klik: ugao · Prevlačenje: glatko · Klik na prvu tačku: zatvori · ↩ završi · Esc otkaži
+	Commit Perspective Warp (↩)	Potvrdi perspektivno krivljenje (↩)
+	Commit Puppet Warp (↩)	Potvrdi lutkarsko krivljenje (↩)
+	Commit any current edits (⌘↩)	Potvrdi sve tekuće izmene (⌘↩)
+	Commit current crop operation  (↵)	Potvrdi tekuće opsecanje  (↵)
+	Commit transform (↩)	Potvrdi transformaciju (↩)
+	Commit warp (↩)	Potvrdi krivljenje (↩)
+	Create a new layer  (⇧⌘N)	Napravi novi sloj  (⇧⌘N)
+	Custom pattern	Prilagođena šara
+	General Brushes	Opšte četkice
+	Grid  (⌘')	Mreža  (⌘')
+	Intersect with selection  (⇧⌥)	Presek sa selekcijom  (⇧⌥)
+	New document…     ⌘N	Novi dokument…     ⌘N
+	Open…     ⌘O	Otvori…     ⌘O
+	Rulers  (⌘R)	Lenjiri  (⌘R)
+	Search commands (⌘K)	Pretraži komande (⌘K)
+	Show Guides  (⌘;)	Prikaži vodilje  (⌘;)
+	Subtract from selection  (⌥)	Oduzmi od selekcije  (⌥)
+	Uses the foreground and background colors.	Koristi boje prednjeg plana i pozadine.
+	↑↓ navigate   ↵ run   esc close	↑↓ kretanje   ↵ pokreni   esc zatvori
+	Adds grain to the soft edges of the brush tip.	Dodaje zrno mekim ivicama vrha četkice.
+	Keeps the current texture when switching presets.	Zadržava tekuću teksturu pri promeni šablona.
+	Watercolour look: lighter interior, darker rims.	Izgled akvarela: svetlija unutrašnjost, tamniji rubovi.
+	Collapse group  (⌥-click: all groups)	Skupi grupu  (⌥-klik: sve grupe)
+	Expand group  (⌥-click: all groups)	Proširi grupu  (⌥-klik: sve grupe)
+	Hide the layer's effects  (⌥-click: all layers)	Sakrij efekte sloja  (⌥-klik: svi slojevi)
+	Show the layer's effects  (⌥-click: all layers)	Prikaži efekte sloja  (⌥-klik: svi slojevi)
+
+# Copy transforms, layer navigation and cancellable opening (from PR #582 by neko233-com).
+	New from Clipboard	Novo iz ostave
+	Free Transform a Copy	Slobodna transformacija kopije
+	Transform Again on a Copy	Ponovi transformaciju na kopiji
+	Select Layer Above	Izaberi sloj iznad
+	Select Layer Below	Izaberi sloj ispod
+	Select Top Layer	Izaberi gornji sloj
+	Select Bottom Layer	Izaberi donji sloj
+	Add Layer Above to Selection	Dodaj sloj iznad u izbor
+	Add Layer Below to Selection	Dodaj sloj ispod u izbor
+
+# Labels added on main after this catalog (depth labels, Wayland drop, profiles, rendering mode)
+	8 bit	8 bita
+	Integer	Celobrojno
+	16 bit	16 bita
+	32 bit (float)	32 bita (pokretni zarez)
+	Floating point	Pokretni zarez
+	Use Global Light	Koristi globalno svetlo
+	Native file drag-and-drop is unavailable	Izvorno prevlačenje i otpuštanje datoteka nije dostupno
+	Native file drag-and-drop is not supported on Wayland yet. Use File › Open, or copy the image in your file manager and paste it with {paste}.	Izvorno prevlačenje i otpuštanje datoteka još nije podržano na Wayland-u. Koristite Datoteka › Otvori ili kopirajte sliku u menadžeru datoteka i nalepite je pomoću {paste}.
+	To drop files, start PhotoCraft under XWayland: `{command}`	Da biste otpuštali datoteke, pokrenite PhotoCraft pod XWayland-om: `{command}`
+	Or set Preferences › Performance › Linux display server to X11: PhotoCraft then always starts under XWayland.	Ili postavite Podešavanja › Performanse › Linux server prikaza na X11: PhotoCraft će se tada uvek pokretati pod XWayland-om.
+	Edit › Paste	Uređivanje › Nalepi
+	Use File › Open, or paste a copied image with {paste}.	Koristite Datoteka › Otvori ili nalepite kopiranu sliku pomoću {paste}.
+	Mixer Brush Tool	Alatka četkica za mešanje
+	Color Replacement Tool	Alatka za zamenu boje
+	Invalid {mode} profile	Neispravan {mode} profil
+	Unnamed {mode} profile	Neimenovani {mode} profil
+	Show bounding box when dragging layer	Prikaži granični okvir pri prevlačenju sloja
+	System title bar	Sistemska naslovna traka
+	Freeze Lasso: drag to freeze an area, Alt-drag to thaw it (L)	Laso za zamrzavanje: prevucite da zamrznete oblast, Alt-prevlačenje da je odmrznete (L)
+	Rendering Mode	Režim renderovanja
+	Automatic (recommended)	Automatski (preporučeno)
+	CPU / Compatibility	CPU / kompatibilnost
+	Automatic uses GPU acceleration when available and falls back to CPU rendering on errors.	Automatski režim koristi GPU ubrzanje kada je dostupno, a u slučaju grešaka prelazi na renderovanje procesorom.
+	Switched to CPU rendering	Prebačeno na renderovanje procesorom
+	GPU acceleration could not continue. Your documents are unchanged.	GPU ubrzanje nije moglo da se nastavi. Vaši dokumenti su nepromenjeni.
+	PhotoCraft is using the CPU image compositor. The window may still use your graphics adapter.	PhotoCraft koristi CPU kompozitor slike. Prozor i dalje može da koristi vaš grafički adapter.
+	Retry GPU requires a restart. Save your work first.	Ponovni pokušaj sa GPU-om zahteva ponovno pokretanje. Prvo sačuvajte svoj rad.
+	Keep Using CPU	Nastavi sa CPU-om
+	Retry GPU	Ponovo pokušaj sa GPU-om
+	GPU Backend	GPU pozadinski sistem
+	Details	Detalji
+	Rendering mode	Režim renderovanja
+
+# Camera Raw scopes and the Patch tool
+	Shadow Clipping Warning (U)	Upozorenje o odsecanju senki (U)
+	Highlight Clipping Warning (O)	Upozorenje o odsecanju svetla (O)
+	Show Lab Color Readouts	Prikaži Lab očitavanja boja
+	Show Vectorscope	Prikaži vektorskop
+	Show Red at 3 o'clock	Prikaži crvenu na poziciji 3 sata
+	Show Skin Tone Indicator	Prikaži indikator tona kože
+	Tone Histogram	Tonski histogram
+	Show Selected Region	Prikaži izabranu oblast
+cameraRaw	Light	Svetlo
+	Camera Raw Filter ({layer})	Camera Raw filter ({layer})
+	Camera Raw ({name})	Camera Raw ({name})
+cameraRaw	Lights	Svetli tonovi
+cameraRaw	Darks	Tamni tonovi
+cameraRaw	Blacks	Crne
+cameraRaw	Amount	Količina
+cameraRaw	Tint	Preliv
+cameraRaw	Masking	Maskiranje
+cameraRaw	Blending	Stapanje
+	Patch Tool	Alatka zakrpa
+	Patch:	Zakrpa:
+	Lasso around an area, then drag the selection	Zaokružite oblast lasom, a zatim prevucite selekciju
+	Transform On Drop	Transformiši pri otpuštanju
+	Scale or rotate the moved area, then press {key}	Skalirajte ili rotirajte pomerenu oblast, a zatim pritisnite {key}
+	Now drag the selection onto another area	Sada prevucite selekciju na drugu oblast
+
+# Warp grid presets (#388)
+	3 x 3	3 x 3
+	4 x 4	4 x 4
+	5 x 5	5 x 5
+	Grid:	Mreža:
+	Edit Type	Uredi tekst
+
+	New Style…	Novi stil…
+	Style {name} saved	Stil {name} je sačuvan
+
+	Create new style (from the selected type)	Napravi novi stil (od izabranog teksta)
+	Create new style from the selected layer	Napravi novi stil od izabranog sloja
+
+	Make Default	Postavi kao podrazumevano
+	Reset to Default	Vrati na podrazumevano
+	Full-resolution preview unavailable	Pregled u punoj rezoluciji nije dostupan
+	No patterns	Nema šara
+	Enable {name}	Omogući {name}
+	Hold Alt while drawing for straight segments	Držite Alt tokom crtanja za prave segmente
+	Drag or click polygon points · hold Alt during lasso for straight segments · {add} add · {sub} before drawing subtracts	Prevucite ili kliknite tačke mnogougla · držite Alt tokom crtanja lasom za prave segmente · {add} dodaje · {sub} pre crtanja oduzima
+	Extend	Proširi
+	Structure:	Struktura:
+	Content-Aware Move Tool	Alatka za pomeranje prema sadržaju
+	TIFF Options	TIFF opcije
+	Targa Options	Targa opcije
+	24 bits/pixel	24 bita/piksel
+	32 bits/pixel	32 bita/piksel
+	Including layers will increase file size.	Uključivanje slojeva povećaće veličinu datoteke.
+	Discard Layers and Save a Copy	Odbaci slojeve i sačuvaj kopiju
+	Don't show again	Ne prikazuj ponovo
+	Save failed: {error}	Čuvanje nije uspelo: {error}
+	Save cancelled	Čuvanje je otkazano
+	Couldn't place {name}: {error}	Postavljanje {name} nije uspelo: {error}
+	Magnetic Lasso Tool	Alatka magnetni laso
+	Frequency	Frekvencija
+	Use tablet pressure to change pen width	Koristi pritisak na tabletu za promenu širine pera
+
+# About ▸ Contributors / Models (credits, craftrules standards/contributors.md)
+	About	O programu
+	Contributors	Saradnici
+	Models	Modeli
+	Sort	Sortiraj
+	Username	Korisničko ime
+	Display name	Prikazno ime
+	Real name	Pravo ime
+	Reverse the order	Obrni redosled
+	Grab bag	Mešavina
+	Table	Tabela
+	Name (A–Z)	Ime (A–Z)
+	Merged PRs	Spojeni PR-ovi
+	Commits	Komitovi
+	Lines added	Dodate linije
+	Lines deleted	Obrisane linije
+	Line delta	Razlika u linijama
+	Binary assets added	Dodati binarni resursi
+	Binary assets removed	Uklonjeni binarni resursi
+	First commit	Prvi komit
+	First	Prvi
+	Last commit	Poslednji komit
+	Last	Poslednji
+	Contributors: {contributors} · Commits: {commits}	Saradnici: {contributors} · Komitovi: {commits}
+	No contributor data was built into this copy.	U ovu kopiju nisu ugrađeni podaci o saradnicima.
+	No model credits were built into this copy.	U ovu kopiju nisu ugrađene zasluge modela.
+	Company	Kompanija
+	Version	Verzija
+	% of all commits	% svih komitova
+	Lines +/−	Linije +/−
+	@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{binAdded} / −{binDeleted} binary assets, {first} – {last}	@{login}: PR-ova: {prs}, komitova: {commits}, linija: +{added} / −{deleted} (Δ {delta}), binarnih resursa: +{binAdded} / −{binDeleted}, {first} – {last}
+
+# Swatches panel
+	Create new swatch	Napravi novi uzorak boje
+	New Swatch…	Novi uzorak boje…
+	New Swatch Group…	Nova grupa uzoraka boja…
+	Import Swatches…	Uvezi uzorke boja…
+	Replace Swatches…	Zameni uzorke boja…
+	Export Swatches…	Izvezi uzorke boja…
+	Export Swatches for Exchange…	Izvezi uzorke boja za razmenu…
+	Reset Swatches	Resetuj uzorke boja
+	Add to Swatches	Dodaj u uzorke boja
+# Layer Style > Blending Options (Advanced Blending)
+	Blend If:	Stapaj ako:
+	Channels:	Kanali:
+	Knockout	Izbijanje
+	Apply At Canvas Bounds	Primeni na granicama platna
+
+# Shared screen eyedropper and text Color Picker (#1128).
+	Color Picker (Text Color)	Birač boja (boja teksta)
+	Color Picker ({name})	Birač boja ({name})
+	Color Picker (Fill Color)	Birač boja (boja popune)
+	Fill color	Boja popune
+	Color Picker (Stroke Color)	Birač boja (boja obruba)
+	Stroke color	Boja obruba
+	Pick screen color	Uzmi boju sa ekrana
+	Sample a pixel anywhere on the screen	Uzorkujte piksel bilo gde na ekranu
+	Click to pick · Esc to cancel	Kliknite da uzmete boju · Esc za otkazivanje
+	Pick a screen pixel or press Esc to cancel	Izaberite piksel na ekranu ili pritisnite Esc da otkažete
+	Scroll to zoom	Pomerajte točkić za zumiranje
+	Show/Hide All Panels	Prikaži/sakrij sve panele
+	Show/Hide Panels	Prikaži/sakrij panele
+	Could not open	Otvaranje nije uspelo
+	{path}: the path is not valid Unicode; rename the file and open it again.	{path}: putanja nije ispravan Unicode; preimenujte datoteku i ponovo je otvorite.
+
+# Fill dialog, layer style contours and Image Size
+	Contents:	Sadržaj:
+	Custom Pattern:	Prilagođena šara:
+	Foreground Color	Boja prednjeg plana
+	Color…	Boja…
+	50% Gray	50% siva
+	{size} (was {old})	{size} (bilo je {old})
+	Cone	Kupa
+	Cone (Inverted)	Kupa (obrnuta)
+	Domed	Kupola
+	Domed (Inverted)	Kupola (obrnuta)
+	Diagonal (Descending)	Dijagonala (opadajuća)
+	Contour Editor	Uređivač konture
+	Anti-aliased	Uglađeno
+	Corner	Ugao
+	Gloss Contour	Kontura sjaja
+	Contour	Kontura
+	Cone - Inverted	Kupa - obrnuta
+	Cove - Deep	Udubljenje - duboko
+	Cove - Shallow	Udubljenje - plitko
+	Gaussian	Gausova
+	Half Round	Polukrug
+	Ring	Prsten
+	Ring - Double	Prsten - dvostruki
+	Rolling Slope - Descending	Talasasta kosina - opadajuća
+	Rounded Steps	Zaobljeni stepenici
+	Sawtooth 1	Testera 1
+
+	Red Eye Tool	Alatka za crvene oči
+	Pupil Size	Veličina zenice
+	Darken Amount	Količina zatamnjenja
+	Click a red pupil to neutralize it	Kliknite crvenu zenicu da je neutrališete
+	open source	otvoreni kod
+	…and {n} more	…i još {n}
+
+	Eyedroppers:	Pipete:
+	Set Black Point	Postavi crnu tačku
+	Set Neutral Gray Point	Postavi tačku neutralne sive
+	Set White Point	Postavi belu tačku
+	Unavailable in this color mode	Nedostupno u ovom režimu boja
+	Selection Preview:	Pregled selekcije:
+	Black Matte	Crna podloga
+	White Matte	Bela podloga
+
+# Layer colour labels.
+	Seafoam	Morska pena
+	Indigo	Indigo
+	Fuchsia	Fuksija
+	Violet	Ljubičasta
+	Large document: redrawing on the CPU	Veliki dokument: ponovno iscrtavanje procesorom
+	This redraw took {seconds} s on the CPU.	Ovo iscrtavanje je trajalo {seconds} s na procesoru.
+	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Izmene koje menjaju ceo dokument, kao što su režim stapanja, neprozirnost ili vidljivost sloja, ponovo iscrtavaju ceo dokument.
+	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Njegovi slojevi ne staju u budžet GPU memorije. Povećanje vrednosti Korišćenje memorije u Podešavanja › Performanse povećava budžet, do četvrtine memorije ovog računara.
+	The GPU compositor wasn't used: {reason}	GPU kompozitor nije korišćen: {reason}
+fontWeight	Thin	Tanko
+fontWeight	ExtraLight	Ekstra lagano
+fontWeight	Light	Lagano
+fontWeight	Regular	Obično
+fontWeight	Medium	Srednje
+fontWeight	SemiBold	Polupodebljano
+fontWeight	Bold	Podebljano
+fontWeight	ExtraBold	Ekstra podebljano
+fontWeight	Black	Crno
+fontWeight	Italic	Kurziv
+
+# Pattern Stamp tool
+	Pattern Stamp Tool	Alatka pečat za šaru
+	Impressionist	Impresionistički
+	Rotate View Tool	Alatka za rotiranje prikaza
+	Reset View	Resetuj prikaz
+	Drag around the centre to rotate the view  ·  Shift constrains to 15°	Prevlačite oko centra da rotirate prikaz  ·  Shift ograničava na korake od 15°
+
+# Painting symmetry presets.
+	Dual Axis	Dvostruka osa
+	Diagonal	Dijagonala
+	Transform Symmetry	Transformiši simetriju
+
+# Eyedropper Sample Size and Sample (#1649).
+	Point Sample	Uzorak tačke
+	3 by 3 Average	Prosek 3 x 3
+	5 by 5 Average	Prosek 5 x 5
+	11 by 11 Average	Prosek 11 x 11
+	31 by 31 Average	Prosek 31 x 31
+	51 by 51 Average	Prosek 51 x 51
+	101 by 101 Average	Prosek 101 x 101
+	Sample Size:	Veličina uzorka:
+	All Layers No Adjustments	Svi slojevi bez korekcija
+	Current & Below No Adjustments	Tekući i ispod bez korekcija
+	Show Sampling Ring	Prikaži prsten uzorkovanja
+
+# Color Picker warnings
+	Out of gamut for printing: click for the nearest printable colour	Van gamuta za štampu: kliknite za najbližu boju koja može da se odštampa
+	Not a web colour: click for the nearest web colour	Nije veb boja: kliknite za najbližu veb boju
+	Color to Alpha…	Boja u alfu…
+	Transparency Threshold	Prag providnosti
+	Opacity Threshold	Prag neprozirnosti
+	PhotoCraft — Screen Color Picker	PhotoCraft — birač boja sa ekrana
+
+	Rasterize svg groups deeper than	Rasterizuj SVG grupe dublje od
+	0 turns this threshold off; SVG groups nested deeper than 100 levels are always rasterized.	0 isključuje ovaj prag; SVG grupe ugnežđene dublje od 100 nivoa uvek se rasterizuju.
+	Rule of Thirds	Pravilo trećina
+	Triangle	Trougao
+	Golden Ratio	Zlatni presek
+	Golden Spiral	Zlatna spirala
+	Auto Show Overlay	Automatski prikaži preklop
+	Always Show Overlay	Uvek prikaži preklop
+	Never Show Overlay	Nikad ne prikazuj preklop
+	Cycle Overlay	Smenjuj preklope
+	Cycle Orientation	Smenjuj orijentaciju
+	Set the overlay options for the Crop tool	Podesi opcije preklopa za alatku za opsecanje
+	Alt-click went to the desktop, which moves windows with Alt-drag. Set its window-move key to Super, or latch Alt in Window › Modifier Keys.	Alt-klik je preuzelo radno okruženje, koje pomera prozore Alt-prevlačenjem. Postavite taster za pomeranje prozora u njemu na Super ili zaključajte Alt u Prozor › Modifikatorski tasteri.
+
+# Shared Layer Style color picker
+	Color Picker (Layer Style Color)	Birač boja (boja stila sloja)
+	Auto Hide Notifications	Automatski sakrij obaveštenja
+	Notification Duration (seconds)	Trajanje obaveštenja (sekunde)
+	Appearance Mode	Režim izgleda
+	Presentation	Prikaz
+	Dark Theme	Tamna tema
+	Light Theme	Svetla tema
+	Pro Medium	Pro srednja
+	Studio Light	Studio svetla
+	Next Appearance Mode	Sledeći režim izgleda
+	Sync with system	Usklađeno sa sistemom
+	Active	Aktivno
+	Color Picker (Solid Color)	Birač boja (puna boja)
+	Straighten the image by drawing a line on it	Ispravite sliku tako što ćete povući liniju preko nje
+	Set additional Crop options	Podesi dodatne opcije opsecanja
+	Show Cropped Area	Prikaži isečenu oblast
+	Enable Crop Shield	Omogući zaštitni sloj opsecanja
+	Match Canvas	Uskladi sa platnom
+	Auto Adjust Opacity	Automatski podesi neprozirnost
+	Crop Shield color	Boja zaštitnog sloja opsecanja
+	Color Picker (Crop Shield Color)	Birač boja (boja zaštitnog sloja opsecanja)
+	From Center	Od centra
+	Link radii	Poveži poluprečnike
+	Star Ratio:	Odnos zvezde:
+	Create Rectangle	Napravi pravougaonik
+	Create Ellipse	Napravi elipsu
+	Create Triangle	Napravi trougao
+	Create Polygon	Napravi mnogougao
+	Pressure curve	Kriva pritiska
+	Click to add a point, right-click to remove	Kliknite da dodate tačku, desni klik da je uklonite
+	Some brush presets could not be loaded	Neki šabloni četkica nisu mogli da se učitaju
+	Retry saving presets	Ponovo pokušaj čuvanje šablona
+	Brush preset changes are not saved: {error}	Izmene šablona četkica nisu sačuvane: {error}
+	Keep this tab open to retain your brushes.	Držite ovu karticu otvorenom da biste zadržali svoje četkice.
+	Browser storage is unavailable; brushes are session-only. Keep this tab open to retain them.	Skladište pregledača nije dostupno; četkice važe samo za ovu sesiju. Držite ovu karticu otvorenom da biste ih zadržali.
+	Saving brush presets… Keep this tab open until saving finishes.	Čuvanje šablona četkica… Držite ovu karticu otvorenom dok se čuvanje ne završi.
+	Reflect	Refleksija
+	Glow	Sjaj
+	Negation	Negacija
+	XOR	XOR
+	Color Burn (Paint.NET)	Zatamnjivanje boje (Paint.NET)
+	Color Dodge (Paint.NET)	Posvetljivanje boje (Paint.NET)
+	Stroke Options	Opcije obruba
+	Solid	Puna
+	Dashed	Isprekidana
+	Dotted	Tačkasta
+	Caps	Završeci
+	Butt / Flat	Ravno / tupo
+	Corners	Uglovi
+	Miter	Šiljato
+	Round	Zaobljeno
+	Bevel	Zakošeno
+	Miter limit	Granica šiljatosti
+	Dashed line	Isprekidana linija
+	Dash	Crtica
+	Gap	Razmak
+	Dash / gap lengths × stroke width	Dužine crtica / razmaka × širina obruba
+	Add pair	Dodaj par
+	Remove pair	Ukloni par
+	Dash offset	Pomak crtica
+	Open paths use centered strokes	Otvorene putanje koriste centrirani obrub
+	Use finite lengths and a positive pattern total	Koristite konačne dužine i pozitivan ukupni zbir šablona
+	No subject found — try Object Selection or the Lasso	Subjekat nije pronađen — probajte selekciju objekta ili laso
+	Quick Selection found nothing there	Brza selekcija tu nije ništa pronašla
+	Object Selection found nothing there — try a tighter rectangle	Selekcija objekta tu nije ništa pronašla — probajte uži pravougaonik
+	No subject found — try a rectangle around the object	Subjekat nije pronađen — probajte pravougaonik oko objekta
+	Click the first point or press {key} to close · {del} removes a point · Esc cancels	Kliknite prvu tačku ili pritisnite {key} da zatvorite · {del} uklanja tačku · Esc otkazuje
+	Click, then move along an edge · click to fasten a point · {alt}-click for a straight segment · double-click to close	Kliknite, pa se pomerajte duž ivice · kliknite da pričvrstite tačku · {alt}-klik za pravi segment · dvoklik za zatvaranje
+	Follows only edges this close to the pointer ([ and ] change it)	Prati samo ivice na ovoj udaljenosti od pokazivača ([ i ] je menjaju)
+	Higher values follow only edges that contrast sharply with their surroundings	Veće vrednosti prate samo ivice koje su u oštrom kontrastu sa okolinom
+	How often fastening points are placed by themselves	Koliko se često tačke pričvršćivanja postavljaju same
+	Appearance Settings…	Podešavanja izgleda…
+	Add to favorites	Dodaj u omiljene
+	Remove from favorites	Ukloni iz omiljenih
+# File Info ▸ Camera Data (read-only EXIF fields; "Make" is the camera maker, not the verb).
+cameraData	Make	Proizvođač
+cameraData	Model	Model
+cameraData	Date Taken	Datum snimanja
+cameraData	Exposure	Ekspozicija
+cameraData	F-Stop	F-broj
+cameraData	ISO Speed	ISO osetljivost
+cameraData	Focal Length	Žižna daljina
+cameraData	Focal Length (35 mm)	Žižna daljina (35 mm)
+cameraData	Lens	Objektiv
+# Shared panel docking
+	Activate Panel	Aktiviraj panel
+	Change Panel Group	Promeni grupu panela
+	Change Panel Layout	Promeni raspored panela
+	Close Panel	Zatvori panel
+	Dock Panel	Usidri panel
+	Float Panel	Odvoji panel
+	Move Panel	Premesti panel
+	Group with	Grupiši sa
+	Panel menu	Meni panela
+	Resize panel window	Promeni veličinu prozora panela
+	Resize panels	Promeni veličinu panela
+	Use Classic Mode	Koristi klasični režim
+	Auto Center Preview	Automatski centriraj pregled
+	Next Document	Sledeći dokument
+	Previous Document	Prethodni dokument
+	W x H x Resolution	Š x V x rezolucija
+	Front Image	Prednja slika
+	Frame Tool	Alatka okvir
+	Create a new rectangular frame	Napravi novi pravougaoni okvir
+	Create a new elliptical frame	Napravi novi eliptični okvir
+	Include in playback	Uključi u reprodukciju
+	Perspective Crop Tool	Alatka za perspektivno opsecanje
+	Show Grid	Prikaži mrežu
+	Drag a box or click four corners · drag the corners onto the edges of a skewed shape · {commit} commits · Esc cancels	Prevucite okvir ili kliknite četiri ugla · prevucite uglove na ivice iskošenog oblika · {commit} potvrđuje · Esc otkazuje
+	Artboard Tool	Alatka radna tabla
+	Make Portrait	Postavi uspravno
+	Make Landscape	Postavi položeno
+	Add New Artboard	Dodaj novu radnu tablu
+	Freeform Pen Tool	Alatka slobodno pero
+	Curvature Pen Tool	Alatka pero za krive
+	Curve Fit:	Prilagođavanje krive:
+	Drag: draw freehand · {alt}-click: straight segment · Release on the start point: close	Prevlačenje: crtanje slobodnom rukom · {alt}-klik: pravi segment · Otpuštanje na početnoj tački: zatvori
+	Click: smooth point · Double-click: corner · Drag a point: move · Click first point: close · {key} finish	Klik: glatka tačka · Dvoklik: ugao · Prevlačenje tačke: pomeri · Klik na prvu tačku: zatvori · {key} završi
+	New Crop Preset…	Novi šablon opsecanja…
+	Delete Crop Preset…	Obriši šablon opsecanja…
+	Select the crop presets to delete:	Izaberite šablone opsecanja za brisanje:
+	Select the crop presets to delete	Izaberite šablone opsecanja za brisanje
+	Enter a name for the crop preset	Unesite ime šablona opsecanja
+	There is no crop size or ratio to save	Nema veličine ili odnosa opsecanja za čuvanje
+	Scale:	Razmera:
+	Snap to Origin	Prianjaj uz ishodište
+	Search settings…	Pretraži podešavanja…
+	No matching settings	Nema odgovarajućih podešavanja
+	Loading fonts…	Učitavanje fontova…
+	Tool	Alatka
+	Simulate Pressure	Simuliraj pritisak
+	Stroke Path…	Ocrtaj putanju…
+	Background Eraser	Gumica za pozadinu
+	Healing Brush	Četkica za popravku
+	Spot Healing Brush	Četkica za tačkastu popravku
+	Smudge	Razmazivanje
+	Sponge	Sunđer
+	Amount:	Količina:
+	Protect:	Zaštiti:
+	Protect skin tones	Zaštiti tonove kože
+	Edit points to modify the curve	Uredite tačke da izmenite krivu
+	Draw to modify the curve	Crtajte da izmenite krivu
+curves	Smooth	Izgladi
+	Smooth the curve values	Izgladi vrednosti krive
+	Drag to draw the curve · {key}-click draws a straight line	Prevucite da nacrtate krivu · {key}-klik crta pravu liniju
+	Grid Size:	Veličina mreže:
+	Vanishing Point: click four corners to create a plane	Tačka nestajanja: kliknite četiri ugla da napravite ravan
+	Vanishing Point is not active	Tačka nestajanja nije aktivna
+	Apply Vanishing Point ({key})	Primeni tačku nestajanja ({key})
+	Fix the red plane first: its corners must form a convex quad	Prvo ispravite crvenu ravan: njeni uglovi moraju činiti konveksan četvorougao
+# Select and Mask view modes (#1754)
+	Onion Skin	Prozirni prikaz
+	Marching Ants	Pokretne crtice
+	On Black	Na crnoj
+	On White	Na beloj
+	On Layers	Na slojevima
+	Show Edge	Prikaži ivicu
+	Show Original	Prikaži original
+	F cycles the views; hold X to see the image	F smenjuje prikaze; držite X da vidite sliku
+# Select and Mask Refine Edge Brush (#2972)
+	Refine Edge Brush (R)	Četkica za doterivanje ivice (R)
+	Expand Detection Area	Proširi oblast detekcije
+	Restore Original Edge	Vrati originalnu ivicu
+	Paint over hair or fur on the image; Alt paints the other mode	Slikajte preko kose ili krzna na slici; Alt slika u drugom režimu
+	Clear Brush Strokes	Obriši poteze četkicom
+	Show rulers	Prikaži lenjire
+
+# Color Sampler (added with the i18n coverage repair)
+	Click to place · Alt-click or drag off-canvas to remove	Kliknite da postavite · Alt-klik ili prevlačenje van platna da uklonite
+	No document open	Nijedan dokument nije otvoren
+	{n} of {max} sample points	{n} od {max} tačaka uzorkovanja
+# Print dialog (#2697)
+	Emulsion Down	Emulzija nadole
+	Functions	Funkcije
+	Print Resolution:	Rezolucija štampe:
+	Use Previous Layer to Create Clipping Mask	Koristi prethodni sloj za pravljenje maske isecanja
+	Fill with {mode}-neutral color (white)	Popuni neutralnom bojom za {mode} (bela)
+	Fill with {mode}-neutral color (black)	Popuni neutralnom bojom za {mode} (crna)
+	Fill with {mode}-neutral color (50% gray)	Popuni neutralnom bojom za {mode} (50% siva)
+	(No neutral color exists for {mode} mode.)	(Za režim {mode} ne postoji neutralna boja.)
+	Apply mask to layer before removing?	Primeniti masku na sloj pre uklanjanja?
+	The layer or its mask changed. Drag the mask onto the Trash again.	Sloj ili njegova maska su se promenili. Ponovo prevucite masku u kantu.
+	Delete the vector mask?	Obrisati vektorsku masku?
+# View › Guides › New Guide… › Color
+	Light Blue	Svetloplava
+	Light Red	Svetlocrvena
+	Medium Blue	Srednje plava
+	Light Gray	Svetlosiva
+	Remove after each stroke	Ukloni posle svakog poteza
+	Apply the removal ({key})	Primeni uklanjanje ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Potezi za uklanjanje: {n} (Enter primenjuje, Esc otkazuje)
+
+# Gradient Editor window, opened from the options bar's gradient swatch.
+	The current gradient (pick one in Window › Gradients)	Tekući gradijent (izaberite ga u Prozor › Gradijenti)
+
+# Camera Raw: contextual controls and window title
+cameraRaw	Red	Crvena
+cameraRaw	Orange	Narandžasta
+cameraRaw	Yellow	Žuta
+cameraRaw	Green	Zelena
+cameraRaw	Aqua	Akva
+cameraRaw	Blue	Plava
+cameraRaw	Purple	Ljubičasta
+cameraRaw	Magenta	Magenta
+cameraRaw	Temperature	Temperatura
+
+# Counted status messages and labels (Serbian: one | few | many)
+@plural	Exported {n} swatch to {file}|Exported {n} swatches to {file}	Izvezen je {n} uzorak boje u {file}|Izvezena su {n} uzorka boja u {file}|Izvezeno je {n} uzoraka boja u {file}
+@plural	Imported {n} brush from {group}|Imported {n} brushes from {group}	Uvezena je {n} četkica iz {group}|Uvezene su {n} četkice iz {group}|Uvezeno je {n} četkica iz {group}
+@plural	Imported {n} swatch from {file}|Imported {n} swatches from {file}	Uvezen je {n} uzorak boje iz {file}|Uvezena su {n} uzorka boja iz {file}|Uvezeno je {n} uzoraka boja iz {file}
+@plural	Played {n} step|Played {n} steps	Izvršen je {n} korak|Izvršena su {n} koraka|Izvršeno je {n} koraka
+@plural	Updated {n} linked smart object changed on disk|Updated {n} linked smart objects changed on disk	Ažuriran je {n} povezani pametni objekat izmenjen na disku|Ažurirana su {n} povezana pametna objekta izmenjena na disku|Ažurirano je {n} povezanih pametnih objekata izmenjenih na disku
+@plural	Saved for Web: {n} file|Saved for Web: {n} files	Sačuvano za veb: {n} datoteka|Sačuvano za veb: {n} datoteke|Sačuvano za veb: {n} datoteka
+@plural	{n} layer recorded by this comp was deleted. Update the comp, or clear the warning.|{n} layers recorded by this comp were deleted. Update the comp, or clear the warning.	{n} sloj zabeležen u ovoj kompoziciji je obrisan. Ažurirajte kompoziciju ili uklonite upozorenje.|{n} sloja zabeležena u ovoj kompoziciji su obrisana. Ažurirajte kompoziciju ili uklonite upozorenje.|{n} slojeva zabeleženih u ovoj kompoziciji je obrisano. Ažurirajte kompoziciju ili uklonite upozorenje.
+@plural	{n} plane|{n} planes	{n} ravan|{n} ravni|{n} ravni
+@plural	{n} preset|{n} presets	{n} šablon|{n} šablona|{n} šablona
+@plural	{n} sample point removed|{n} sample points removed	Uklonjena je {n} tačka uzorkovanja|Uklonjene su {n} tačke uzorkovanja|Uklonjeno je {n} tačaka uzorkovanja
+@plural	{n} slice|{n} slices	{n} isečak|{n} isečka|{n} isečaka
+@plural	{n} step|{n} steps	{n} korak|{n} koraka|{n} koraka
+@plural	{warning} (+{n} more brush preset warning)|{warning} (+{n} more brush preset warnings)	{warning} (+ još {n} upozorenje za šablone četkica)|{warning} (+ još {n} upozorenja za šablone četkica)|{warning} (+ još {n} upozorenja za šablone četkica)
+@plural	{what} with {n} warning|{what} with {n} warnings	{what} sa {n} upozorenjem|{what} sa {n} upozorenja|{what} sa {n} upozorenja
+
+# Dynamic labels (filter and adjustment parameters, Camera Raw, panels, dialogs)
+@id	edit.stroke	Ocrtaj…
+@id	edit.transform.scale	Skaliranje
+cameraRaw	Luminance	Luminansa
+cameraRaw	Color	Boja
+cameraRaw	Vibrance	Živost
+cameraRaw	Color Grading	Gradacija boja
+cameraRaw	Global	Globalno
+cameraRaw	Hue	Nijansa
+cameraRaw	Luminance Detail	Detalji luminanse
+cameraRaw	Color Detail	Detalji boje
+cameraRaw	Roughness	Hrapavost
+cameraRaw	Whites	Bele
+layerLabel	No Color	Bez boje
+	Preferences…	Podešavanja…
+	Actual Pixels	Stvarni pikseli
+	Clipping Mask	Maska isecanja
+	Tool Options	Opcije alatke
+	Color Picker	Birač boja
+	Color Swatches	Uzorci boja
+	Linear Dodge	Linearno posvetljivanje
+	Preview Image	Pregled slike
+	Save As	Sačuvaj kao
+	Remove All	Ukloni sve
+	Unlock	Otključaj
+	Enable	Omogući
+	Disable	Onemogući
+	On	Uključeno
+	Clear Selection	Ukloni selekciju
+	Invert Selection	Invertuj selekciju
+	Select Inverse	Izaberi inverzno
+	Contract	Suzi
+	Sample Size	Veličina uzorka
+	Strength	Jačina
+	Gamma	Gama
+	Input	Ulaz
+	Input Levels	Ulazni nivoi
+	Output Levels	Izlazni nivoi
+	Layer Styles	Stilovi slojeva
+	Blending Mode	Režim stapanja
+	Fill Color	Boja popune
+	Stroke Color	Boja obruba
+	Stroke Width	Širina obruba
+	Shadow	Senka
+	Adjustment Layers	Korekcioni slojevi
+	Text Layer	Tekstualni sloj
+	Documents	Dokumenti
+	File Name	Ime datoteke
+	File Format	Format datoteke
+	Compression	Kompresija
+	Artboards	Radne table
+	Snap to Grid	Prianjaj uz mrežu
+	Full Screen	Ceo ekran
+	Fullscreen	Ceo ekran
+	Workspaces	Radni prostori
+	Show All	Prikaži sve
+	Hidden	Skriveno
+	Duplicate Layer	Dupliraj sloj
+	Ungroup	Razgrupiši
+	Lock Transparent Pixels	Zaključaj providne piksele
+	Lock Image Pixels	Zaključaj piksele slike
+	Lock Position	Zaključaj položaj
+	Lock All	Zaključaj sve
+	Show Rulers	Prikaži lenjire
+	Guide Layout…	Raspored vodilja…
+	Page Setup…	Podešavanje stranice…
+	Reset Preferences	Resetuj podešavanja
+	Documentation	Dokumentacija
+	Check for Updates	Proveri ažuriranja
+	Loading…	Učitavanje…
+	Processing…	Obrađivanje…
+	Saving…	Čuvanje…
+	Exporting…	Izvoz u toku…
+	Please wait…	Sačekajte…
+	No selection	Nema selekcije
+	No layers	Nema slojeva
+	No recent files	Nema nedavnih datoteka
+	Unsupported file format	Nepodržan format datoteke
+	Failed to open file	Otvaranje datoteke nije uspelo
+	Failed to save file	Čuvanje datoteke nije uspelo
+	Operation canceled	Operacija je otkazana
+	Changes have not been saved.	Izmene nisu sačuvane.
+	Are you sure?	Da li ste sigurni?
+	Discard Changes	Odbaci izmene
+	Recent Files	Nedavne datoteke
+	Open File	Otvori datoteku
+	Save File	Sačuvaj datoteku
+	Save Changes	Sačuvaj izmene
+	Rendering…	Renderovanje…
+	Importing…	Uvoz u toku…
+	Ready	Spremno
+	Failed	Neuspešno
+	Warning	Upozorenje
+	Information	Informacija
+	Retry	Pokušaj ponovo
+	Continue	Nastavi
+	Skip	Preskoči
+	Resume	Nastavi
+	Reset All	Resetuj sve
+	Defaults	Podrazumevano
+	Apply to All	Primeni na sve
+	Confirm	Potvrdi
+	Finish	Završi
+	Back	Nazad
+	Next	Sledeće
+	Previous	Prethodno
+	More	Više
+	Less	Manje
+	Manual	Ručno
+	Disabled	Onemogućeno
+	Locked	Zaključano
+	Unlocked	Otključano
+	Delete…	Obriši…
+	Create…	Napravi…
+	Edit…	Uredi…
+	Change…	Promeni…
+	Transformation	Transformacija
+	Scaling	Skaliranje
+	Canvas Size	Veličina platna
+	Percentage	Procenat
+	Degrees	Stepeni
+	Middle	Sredina
+	Diameter	Prečnik
+	Intensity	Intenzitet
+	Sensitivity	Osetljivost
+	Softness	Mekoća
+	Feather Radius	Poluprečnik omekšavanja
+	Library	Biblioteka
+	Layer Properties	Svojstva sloja
+	Groups	Grupe
+	Masks	Maske
+	Add Mask	Dodaj masku
+	Delete Mask	Obriši masku
+	Invert Mask	Invertuj masku
+	Enable Mask	Omogući masku
+	Disable Mask	Onemogući masku
+	Apply Mask	Primeni masku
+	Import Settings	Uvezi podešavanja
+	Export Settings	Izvezi podešavanja
+	Shortcut	Prečica
+	Shortcuts	Prečice
+	Keyboard	Tastatura
+	Mouse	Miš
+	Tablet	Tablet
+	Display	Ekran
+	Panel	Panel
+	Hide Grid	Sakrij mrežu
+	Fit to Window	Uklopi u prozor
+	Live Preview	Pregled uživo
+	Before	Pre
+	After	Posle
+	Compare	Uporedi
+	File Size	Veličina datoteke
+	Filename	Ime datoteke
+	Folder	Fascikla
+	Open Folder	Otvori fasciklu
+	Choose Folder	Izaberi fasciklu
+	Browse	Pregledaj
+	Find	Pronađi
+	Replace	Zameni
+	Date	Datum
+	Learn More	Saznajte više
+	Report a Bug	Prijavi grešku
+	Updates	Ažuriranja
+	Update	Ažuriraj
+	Restart Required	Potrebno je ponovno pokretanje
+	Restart	Ponovo pokreni
+	Quit	Izađi
+	Quit PhotoCraft	Izađi iz PhotoCraft-a
+	Close Window	Zatvori prozor
+	New Window	Novi prozor
+	Open Image	Otvori sliku
+	Save Image	Sačuvaj sliku
+	Export Image	Izvezi sliku
+	Import Image	Uvezi sliku
+	Export As	Izvezi kao
+	Export to	Izvezi u
+	Export Options	Opcije izvoza
+	Import Options	Opcije uvoza
+	No Selection	Nema selekcije
+	No Document	Nema dokumenta
+	No Image	Nema slike
+	No Layers	Nema slojeva
+	No Results	Nema rezultata
+	No Results Found	Nije pronađen nijedan rezultat
+	Nothing to Undo	Nema šta da se opozove
+	Nothing to Redo	Nema šta da se ponovi
+	Changes Saved	Izmene su sačuvane
+	Unsaved Changes	Nesačuvane izmene
+	Save before closing?	Sačuvati pre zatvaranja?
+	Are you sure you want to quit?	Da li zaista želite da izađete?
+	The file could not be opened.	Datoteka nije mogla da se otvori.
+	The file could not be saved.	Datoteka nije mogla da se sačuva.
+	Unsupported format	Nepodržan format
+	Out of memory	Nema dovoljno memorije
+	Permission denied	Pristup je odbijen
+	File not found	Datoteka nije pronađena
+	Operation failed	Operacija nije uspela
+	Operation completed	Operacija je završena
+	Operation cancelled	Operacija je otkazana
+	Sharpen Amount	Količina izoštravanja
+	Sharpen Radius	Poluprečnik izoštravanja
+	Sharpen Detail	Detalji izoštravanja
+	Sharpen Masking	Maskiranje izoštravanja
+	Noise Luminance	Šum luminanse
+	Noise Luminance Detail	Detalji šuma luminanse
+	Noise Color	Šum boje
+	Noise Color Detail	Detalji šuma boje
+	Grain Amount	Količina zrna
+	Grain Size	Veličina zrna
+	Grain Roughness	Hrapavost zrna
+	Vignette Roundness	Zaobljenost vinjete
+	Vignette Feather	Omekšavanje vinjete
+	Vignette Highlights	Svetla vinjete
+	Vignette Style	Stil vinjete
+	Planes	Ravni
+	Plane	Ravan
+	Shadow Amount	Količina senki
+	Shadow Tone	Ton senki
+	Shadow Radius	Poluprečnik senki
+	Highlight Amount	Količina svetla
+	Highlight Tone	Ton svetla
+	Highlight Radius	Poluprečnik svetla
+	Midtone	Srednji ton
+	Black Clip	Odsecanje crne
+	White Clip	Odsecanje bele
+	Fuzziness	Rasplinutost
+	Source Layer	Izvorni sloj
+	Neutralize	Neutrališi
+	Use Selection In Source	Koristi selekciju u izvoru
+	Use Selection In Target	Koristi selekciju u cilju
+	Flame Type	Vrsta plamena
+	Randomize Length	Nasumična dužina
+	Interval	Interval
+	Adjust Interval For Loops	Prilagodi interval za petlje
+	Use Custom Color	Koristi prilagođenu boju
+	Flame Lines	Linije plamena
+	Flame Bottom Alignment	Poravnanje dna plamena
+	Flame Style	Stil plamena
+	Flame Shape	Oblik plamena
+	Randomize Shapes	Nasumični oblici
+	Frame	Okvir
+	Arrangement	Raspored
+	Thickness	Debljina
+	Vine Color	Boja loze
+	Flower Color	Boja cveta
+	Leaf Color	Boja lista
+	Base Tree Type	Osnovna vrsta drveta
+	Light Direction	Smer svetla
+	Leaves Amount	Količina lišća
+	Leaves Size	Veličina lišća
+	Branches Height	Visina grana
+	Branches Thickness	Debljina grana
+	Default Leaves	Podrazumevano lišće
+	Leaves Color	Boja lišća
+	Custom Branch Color	Prilagođena boja grana
+	Branches Color	Boja grana
+	Flat Shading	Ravno senčenje
+	Date and Time	Datum i vreme
+	Scale Units	Jedinice razmere
+	Scale Factor	Faktor razmere
+	Area	Površina
+	Perimeter	Obim
+	Circularity	Kružnost
+	Gray Value (Minimum)	Vrednost sive (minimum)
+	Gray Value (Maximum)	Vrednost sive (maksimum)
+	Gray Value (Mean)	Vrednost sive (srednja vrednost)
+	Gray Value (Median)	Vrednost sive (medijana)
+	Integrated Density	Integrisana gustina
+	Length	Dužina
+	In Black	Ulazna crna
+	In White	Ulazna bela
+	Out Black	Izlazna crna
+	Out White	Izlazna bela
+	Tint Color	Boja preliva
+	Stops	Tačke
+	Center X	Centar X
+	Center Y	Centar Y
+	Distribution	Raspodela
+	Monochromatic	Jednobojno
+	Cell Size	Veličina ćelije
+	Generators	Generatori
+	Wavelength Min	Talasna dužina, min.
+	Wavelength Max	Talasna dužina, maks.
+	Amplitude Min	Amplituda, min.
+	Amplitude Max	Amplituda, maks.
+	Undefined Areas	Nedefinisane oblasti
+	Preserve	Očuvaj
+	Max Radius	Maks. poluprečnik
+	Depth Mode	Režim dubine
+	Solid Front Faces	Pune prednje strane
+	Mask Incomplete Blocks	Maskiraj nepotpune blokove
+	Stylization	Stilizacija
+	Cleanliness	Čistoća
+	Bristle Detail	Detalji čekinja
+	Lighting	Osvetljenje
+	Shine	Sjaj
+	Max Offset	Maks. pomak
+	Map Document	Dokument mape
+	Map Path	Putanja mape
+	Map Layer	Sloj mape
+	Ridges	Grebeni
+	Light Type	Vrsta svetla
+	Light X	Svetlo X
+	Light Y	Svetlo Y
+	Light Z	Svetlo Z
+	Target X	Cilj X
+	Target Y	Cilj Y
+	Hotspot	Žarište
+	Elevation	Elevacija
+	Ambient	Ambijentalno
+	Warmth	Toplina
+	Gloss	Sjajnost
+	Metallic	Metalnost
+	Ambience	Ambijent
+	White Is High	Bela je visoko
+	Reduce Color Noise	Smanji šum boje
+	Sharpen Details	Izoštri detalje
+	Remove Jpeg Artifact	Ukloni JPEG artefakte
+	Blade Curvature	Zakrivljenost lamela
+	Depth Map	Mapa dubine
+	Focal Distance	Žižna udaljenost
+	Focus	Fokus
+	Transition	Prelaz
+	Radius X	Poluprečnik X
+	Radius Y	Poluprečnik Y
+	Pins	Čiode
+	Blur Angle	Ugao zamućenja
+	Speed	Brzina
+	Taper	Sužavanje kraja
+	Start X	Početak X
+	Start Y	Početak Y
+	End X	Kraj X
+	End Y	Kraj Y
+	Kernel	Jezgro
+	Input Mode	Režim ulaza
+	Row Order	Redosled redova
+	Eliminate	Eliminiši
+	Create By	Napravi pomoću
+	List	Spisak
+	Pencil Width	Širina olovke
+	Stroke Pressure	Pritisak poteza
+	Paper Brightness	Osvetljenost papira
+	Number Of Levels	Broj nivoa
+	Edge Simplicity	Jednostavnost ivica
+	Edge Fidelity	Vernost ivica
+	Brush Detail	Detalji četkice
+	Highlight Area	Oblast svetla
+	Glow Size	Veličina sjaja
+	Glow Brightness	Osvetljenost sjaja
+	Brush Type	Vrsta četkice
+	Stroke Size	Veličina poteza
+	Stroke Detail	Detalji poteza
+	Highlight Strength	Jačina svetla
+	Smoothness	Glatkoća
+	Edge Thickness	Debljina ivica
+	Edge Intensity	Intenzitet ivica
+	Posterization	Posterizacija
+	Stroke Length	Dužina poteza
+	Relief	Reljef
+	Definition	Definicija
+	Texture Coverage	Pokrivenost teksturom
+	Shadow Intensity	Intenzitet senki
+	Edge Width	Širina ivica
+	Edge Brightness	Osvetljenost ivica
+	Direction Balance	Balans smera
+	Black Intensity	Intenzitet crne
+	White Intensity	Intenzitet bele
+	Dark Intensity	Intenzitet tamnih tonova
+	Custom Pixel Aspect Ratio	Prilagođeni odnos stranica piksela
+	32-bit Preview Options	Opcije 32-bitnog pregleda
+	New Guide	Nova vodilja
+	Join the ArtCraft Discord	Pridružite se ArtCraft Discord zajednici
+	Report an Issue	Prijavi problem
+	Load Files into Stack	Učitaj datoteke u stek
+	Statistics	Statistika
+	Duplicate Layers	Dupliraj slojeve
+	Edit Toolbar	Uredi traku alatki
+	Import Brushes	Uvezi četkice
+	Load 3D LUT	Učitaj 3D LUT
+	New document	Novi dokument
+	Press keys	Pritisnite tastere
+	Rename Group	Preimenuj grupu
+	Rename Tool Preset	Preimenuj šablon alatke
+	Search commands, tools and panels	Pretraži komande, alatke i panele
+	Slice Options	Opcije isečka
+	Rename Brush	Preimenuj četkicu
+	Opening	Otvaranje
+	Reading	Čitanje
+	Working	Obrada
+	Accented Edges	Naglašene ivice
+	Angled Strokes	Kosi potezi
+	Anisotropic	Anizotropno
+	Around Center	Oko centra
+	Artistic	Umetnički
+	Bamboo	Bambus
+	Bas Relief	Bareljef
+	Berries	Bobice
+	Blast	Udar
+	Bleach Bypass	Preskočeno beljenje
+	Blocks	Blokovi
+	Brick	Cigla
+	Brush Strokes	Potezi četkicom
+	Burlap	Juta
+	Candle Light	Svetlost sveće
+	Circle	Krug
+	Clumped	Zgrudvano
+	Coarse Dots	Krupne tačke
+	Colored Pencil	Bojica
+	Contrasty	Kontrastno
+	Cool	Hladno
+	Craquelure	Krakelir
+	Cross	Krst
+	Cross Process	Unakrsna obrada
+	Crosshatch	Unakrsno šrafiranje
+	Cutout	Isečak od papira
+	Daisies	Bele rade
+	Dark Rough	Tamno grubo
+	Dark Strokes	Tamni potezi
+	Darken Only	Samo zatamni
+	Day For Night	Dan za noć
+	Deep Blue	Tamnoplava
+	Deep Emerald	Tamni smaragd
+	Deep Red	Tamnocrvena
+	Deep Yellow	Tamnožuta
+	Dot	Tačka
+	Double Line	Dvostruka linija
+	Draft	Nacrt
+	Dry Brush	Suva četkica
+	Duplication	Dupliranje
+	Edge Extension	Proširenje ivica
+	Edge Only	Samo ivice
+	Enlarged	Uvećano
+	Even Fields	Parni poluslikovi
+	Faded Film	Izbledeli film
+	Film Grain	Filmsko zrno
+	Fine	Fino
+	Fine Dots	Fine tačke
+	Flat	Ravno
+	Fresco	Freska
+	From Left	Sleva
+	From Right	Zdesna
+	Frosted	Mat staklo
+	Generic	Opšte
+	Glass	Staklo
+	Glowing Edges	Svetleće ivice
+	Grainy Dots	Zrnaste tačke
+	Hearts	Srca
+	Heptagon	Sedmougao
+	Hexagon	Šestougao
+	Horizontal Only	Samo horizontalno
+	Infinite	Beskonačno
+	Ink Outlines	Obrisi mastilom
+	Ivy	Bršljan
+	Left Diagonal	Leva dijagonala
+	Level Based	Prema nivoima
+	Light Rough	Svetlo grubo
+	Lighten Only	Samo posvetli
+	Long Lines	Duge linije
+	Long Strokes	Dugi potezi
+	Lower	Donje
+	Medium Dots	Srednje tačke
+	Medium Lines	Srednje linije
+	Medium Strokes	Srednji potezi
+	Mono Contrast	Jednobojni kontrast
+	Mosaic Tiles	Mozaik pločice
+	Multiple Flames Along Path	Više plamenova duž putanje
+	Multiple Flames One Direction	Više plamenova u jednom smeru
+	Multiple Flames Path Directions	Više plamenova u smerovima putanje
+	Multiple Flames Various Length	Više plamenova različite dužine
+	Octagon	Osmougao
+	Odd Fields	Neparni poluslikovi
+	One Flame Along Path	Jedan plamen duž putanje
+	Out From Center	Od centra ka spolja
+	Oval	Oval
+	Overlay Edge	Ivica preklopa
+	Palette Knife	Slikarska špahtla
+	Parallel	Paralelno
+	Patchwork	Mozaik od krpica
+	Pentagon	Petougao
+	Point	Tačka
+	Pointed	Šiljato
+	Pond Ripples	Talasići na jezeru
+	Pyramids	Piramide
+	Random	Nasumično
+	Right Diagonal	Desna dijagonala
+	Rope	Konopac
+	Roses	Ruže
+	Sandstone	Peščar
+	Scallops	Festoni
+	Sepia	Sepija
+	Short Lines	Kratke linije
+	Short Strokes	Kratki potezi
+	Simple	Jednostavno
+	Light Intensity	Intenzitet svetla
+	Spray Radius	Poluprečnik raspršivanja
+	Stroke Direction	Smer poteza
+	Graininess	Zrnastost
+	Glow Amount	Količina sjaja
+	Clear Amount	Količina čistoće
+	Distortion	Izobličenje
+	Ripple Size	Veličina talasića
+	Ripple Magnitude	Jačina talasića
+	Charcoal Area	Oblast uglja
+	Chalk Area	Oblast krede
+	Charcoal Thickness	Debljina uglja
+	Light Dark Balance	Balans svetlog i tamnog
+	Foreground Level	Nivo prednjeg plana
+	Background Level	Nivo pozadine
+	Pattern Type	Vrsta šare
+	Image Balance	Balans slike
+	Darkness	Tama
+	Fiber Length	Dužina vlakana
+	Crack Spacing	Razmak pukotina
+	Crack Depth	Dubina pukotina
+	Crack Brightness	Osvetljenost pukotina
+	Grain Type	Vrsta zrna
+	Tile Size	Veličina pločice
+	Grout Width	Širina fuge
+	Lighten Grout	Posvetli fugu
+	Square Size	Veličina kvadrata
+	Border Thickness	Debljina oboda
+	Correct Distortion	Ispravi izobličenje
+	Correct Vignette	Ispravi vinjetiranje
+	Correct C A	Ispravi hromatsku aberaciju
+	Auto Scale	Automatsko skaliranje
+	Red Cyan	Crvena–cijan
+	Blue Yellow	Plava–žuta
+	Vignette Amount	Količina vinjete
+	Vignette Midpoint	Središte vinjete
+	Constraints	Ograničenja
+	Curve Highlights	Kriva: svetla
+	Curve Lights	Kriva: svetli tonovi
+	Curve Darks	Kriva: tamni tonovi
+	Curve Shadows	Kriva: senke
+	Curve Splits	Kriva: podele
+	Point Curve	Tačkasta kriva
+	Point Curve Red	Tačkasta kriva, crvena
+	Point Curve Green	Tačkasta kriva, zelena
+	Point Curve Blue	Tačkasta kriva, plava
+	Hsl Hue	HSL nijansa
+	Hsl Sat	HSL zasićenost
+	Hsl Lum	HSL svetlina
+	Grade Shadows	Gradacija: senke
+	Grade Midtones	Gradacija: srednji tonovi
+	Grade Highlights	Gradacija: svetla
+	Grade Global	Gradacija: globalno
+	Grade Blending	Gradacija: stapanje
+	Grade Balance	Gradacija: balans
+	Sine	Sinusoida
+	Sketch	Skica
+	Snowflakes	Pahuljice
+	Sparkle	Iskrenje
+	Spatter	Prskanje
+	Speckle	Pegavost
+	Spin	Okretanje
+	Sprinkles	Mrvice
+	Squareness	Četvrtastost
+	Stagger	Smaknuto
+	Stained Glass	Vitraž
+	Star	Zvezda
+	Stars	Zvezde
+	Stippled	Tačkasto
+	Stretch	Rastegni
+	Teal Orange	Tirkizno-narandžasto
+	Tiny Lens	Sićušni objektiv
+	To Center	Ka centru
+	Unaltered	Neizmenjeno
+	Underpainting	Podslika
+	Underwater	Pod vodom
+	Uniform	Ravnomerno
+	Upper	Gornje
+	Vertical Only	Samo vertikalno
+	Vine With Flowers	Loza sa cvećem
+	Vine With Leaves	Loza sa lišćem
+	Violent	Silovito
+	Warm	Toplo
+	Watercolor	Akvarel
+	Waves	Talasi
+	Wide Blurry	Široko zamućeno
+	Wide Sharp	Široko oštro
+	Wrap	Obmotavanje
+	Zigzag	Cik-cak
+	Wetness	Vlažnost
+	AI Integrations	AI integracije
+	Add Noise	Dodaj šum
+	Apply Data Set	Primeni skup podataka
+	Apply Image	Primeni sliku
+	Arbitrary	Proizvoljno
+	Artboard from Group	Radna tabla od grupe
+	Artboard from Layers	Radna tabla od slojeva
+	Artboards to Files	Radne table u datoteke
+	Artboards to PDF	Radne table u PDF
+	Assign Profile	Dodeli profil
+	At	Na
+	Auto-Align Layers	Automatski poravnaj slojeve
+	Auto-Blend Layers	Automatski stopi slojeve
+	Batch	Grupna obrada
+	Border	Obod
+	Box Blur	Pravougaono zamućenje
+	Calculations	Proračuni
+	Camera Raw	Camera Raw
+	Camera Raw Filter	Camera Raw filter
+	Channel1	Kanal 1
+	Channel2	Kanal 2
+	Channel3	Kanal 3
+	Channel4	Kanal 4
+	Clone	Kloniraj
+	Color Decontaminate	Dekontaminacija boja
+	Color Halftone	Polutonski raster u boji
+	Color Lookup Tables	Tabele preslikavanja boja
+	Color Settings	Podešavanja boja
+	Color Table	Tabela boja
+	Conditional Mode Change	Uslovna promena režima
+	Content-Aware Fill	Popuna prema sadržaju
+	Convert to Linked	Pretvori u povezani
+	Convert to Profile	Pretvori u profil
+	Crystallize	Kristalizacija
+	Data	Podaci
+	Data Sets as Files	Skupovi podataka kao datoteke
+	De-Interlace	Uklanjanje preplitanja
+	Define Brush Preset	Definiši šablon četkice
+	Define Custom Shape	Definiši prilagođeni oblik
+	Define Pattern	Definiši šaru
+	Defringe	Ukloni rub
+	Diffuse	Rasipanje
+	Diffuse Glow	Difuzni sjaj
+	Displace	Premeštanje
+	Do you want to save you made to “{name}” before quitting?	Želite li da sačuvate izmene u „{name}“ pre izlaska?
+	Dust & Scratches	Prašina i ogrebotine
+	Export Contents	Izvezi sadržaj
+	Export Preferences	Podešavanja izvoza
+	Export/Import Presets	Izvoz/uvoz šablona
+	Extrude	Istiskivanje
+	Fibers	Vlakna
+	Field Blur	Zamućenje polja
+	File Info	Informacije o datoteci
+	Filter Gallery	Galerija filtera
+	Find and Replace Text	Pronađi i zameni tekst
+	Fit Image	Uklopi sliku
+	Flame	Plamen
+	Focus Area	Oblast fokusa
+	Gaussian Blur	Gausovo zamućenje
+	Global Light	Globalno svetlo
+	Group from Layers	Grupa od slojeva
+	HDR Toning	HDR toniranje
+	High Pass	Visokopropusni filter
+	Highlight	Svetlo
+	Image Processor	Obrada slika
+	Install Plug-in	Instaliraj dodatak
+	Interpret Footage	Tumači snimak
+	Iris Blur	Iris zamućenje
+	Jag	Nazubljenost
+	Label	Oznaka
+	Layer Comps to Files	Kompozicije slojeva u datoteke
+	Layer Content Options	Opcije sadržaja sloja
+	Layer From Background	Sloj od pozadine
+	Layer from Background	Sloj od pozadine
+	Layers to Files	Slojevi u datoteke
+	Legacy	Staro
+	Lens Blur	Zamućenje objektiva
+	Lens Correction	Korekcija objektiva
+	Lens Flare	Odsjaj objektiva
+	Lighting Effects	Efekti osvetljenja
+	Liquify	Tečno izobličavanje
+	Lock Layers	Zaključaj slojeve
+	Lum	Svet.
+	Match Color	Uskladi boje
+	Merge to HDR Pro	Spoji u HDR Pro
+	Mezzotint	Mecotinta
+	Mosaic	Mozaik
+	Motion Blur	Zamućenje pokreta
+	Native file drag-and-drop is not supported on Wayland yet. Use File › Open, or run PhotoCraft under XWayland with `WAYLAND_DISPLAY= photocraft`.	Izvorno prevlačenje i otpuštanje datoteka još nije podržano na Wayland-u. Koristite Datoteka › Otvori ili pokrenite PhotoCraft pod XWayland-om pomoću `WAYLAND_DISPLAY= photocraft`.
+	Neon Glow	Neonski sjaj
+	New Guide Layout	Novi raspored vodilja
+	New Video Layer from File	Novi video sloj iz datoteke
+	Ocean Ripple	Okeanski talasi
+	Oil Paint	Uljana boja
+	Open As	Otvori kao
+	Package	Spakuj
+	Paint Daubs	Mrlje boje
+	Path Blur	Zamućenje duž putanje
+	Paths to Illustrator	Putanje u Illustrator
+	Photomerge	Spajanje fotografija
+	Picture Frame	Ram za sliku
+	Pinch	Skupljanje
+	Place Embedded	Postavi ugrađeno
+	Place Linked	Postavi povezano
+	Place Scale Marker	Postavi oznaku razmere
+	Plastic Wrap	Plastična folija
+	Pointillize	Poentilizam
+	Polar Coordinates	Polarne koordinate
+	Polar To Rectangular	Iz polarnih u pravougle
+	Poster Edges	Posterske ivice
+	Preset Manager	Upravljač šablonima
+	Profile	Profil
+	Radial Blur	Radijalno zamućenje
+	Raw Defaults	Podrazumevana Raw podešavanja
+	Rectangular To Polar	Iz pravouglih u polarne
+	Reduce Noise	Smanji šum
+	Relink to File	Ponovo poveži sa datotekom
+	Render Video	Renderuj video
+	Replace Color	Zameni boju
+	Replace Contents	Zameni sadržaj
+	Replace Footage	Zameni snimak
+	Resolve Missing Fonts	Razreši fontove koji nedostaju
+	Ripple	Talasanje
+	Rough Pastels	Grube pastele
+	Sat	Zas.
+	Save a Copy	Sačuvaj kopiju
+	Save for Web (Legacy)	Sačuvaj za veb (staro)
+	Scale Effects	Skaliraj efekte
+	Script Events Manager	Upravljač događajima skripti
+	Search menus	Pretraži menije
+	Seed	Seme
+	Select and Mask	Izaberi i maskiraj
+	Set Measurement Scale	Postavi razmeru merenja
+	Shadows/Highlights	Senke/svetla
+	Shape Blur	Zamućenje oblikom
+	Shear	Smicanje
+	Smart Blur	Pametno zamućenje
+	Smart Sharpen	Pametno izoštravanje
+	Smudge Stick	Štapić za razmazivanje
+	Solid Color	Puna boja
+	Spherize	Sferizacija
+	Spin Blur	Rotaciono zamućenje
+	Spot	Reflektor
+	Sprayed Strokes	Raspršeni potezi
+	Strokes	Potezi
+	Sumi-e	Sumi-e
+	Surface Blur	Površinsko zamućenje
+	Texturizer	Teksturizer
+	Tiles	Pločice
+	Tilt-Shift	Tilt-shift
+	Trace Contour	Praćenje konture
+	Trap	Trepovanje
+	Tree	Drvo
+	Trim	Odseci ivice
+	Turbulent	Turbulentno
+	Twirl	Uvrtanje
+	Unsharp Mask	Maska neoštrine
+	Use File › Open to open an image.	Koristite Datoteka › Otvori da otvorite sliku.
+	Vanishing Point	Tačka nestajanja
+	Variable Data Sets	Promenljivi skupovi podataka
+	Video Frames to Layers	Video kadrovi u slojeve
+	WIA Support	WIA podrška
+	Warp Text	Krivljenje teksta
+	Wind	Vetar
+	ZigZag	Cik-cak
+	Vertical Type Tool	Alatka za vertikalni tekst
+	About {app}	O programu {app}
+	Hide {app}	Sakrij {app}
+	Quit {app}	Zatvori {app}
+	Services	Usluge
+	Hide Others	Sakrij ostale
+	Lut	LUT
+	Cooling L B B	Hlađenje (LBB)
+	Cooling80	Hlađenje (80)
+	Cooling82	Hlađenje (82)
+	Hsb	HSB
+	Hsl	HSL
+	Movie Prime	Filmski fiksni objektiv
+	Prime105	Fiksni objektiv 105
+	Prime35	Fiksni objektiv 35
+	Rgb	RGB
+	Warming L B A	Zagrevanje (LBA)
+	Warming81	Zagrevanje (81)
+	Warming85	Zagrevanje (85)
+@id	filter.sharpen.sharpen	Izoštri
+	Good	Dobro
+	Best	Najbolje
+	Adjustment Properties	Svojstva korekcije
+	Default Foreground and Background Colors	Podrazumevane boje prednjeg plana i pozadine
+	Move Layer	Pomeri sloj
+	Rectangular Selection	Pravougaona selekcija
+	Reorder Layer	Promeni redosled sloja
+	Select Layer	Izaberi sloj
+	Set Colors	Postavi boje
+	Switch Foreground and Background Colors	Zameni boje prednjeg plana i pozadine
+	Target	Cilj
+
+# Path, channel, layer style, status and System Info labels the Czech catalog added
+	Make Work Path…	Napravi radnu putanju…
+	Create Vector Mask	Napravi vektorsku masku
+	Make Selection…	Napravi selekciju…
+	Fill Path…	Popuni putanju…
+	Clipping Path…	Putanja isecanja…
+	Free Transform Path	Slobodna transformacija putanje
+	Unite Shapes at Overlap	Ujedini oblike na preklapanju
+	Subtract Shapes at Overlap	Oduzmi oblike na preklapanju
+	Copy Fill	Kopiraj popunu
+	Copy Complete Stroke	Kopiraj kompletan obrub
+	Paste Fill	Nalepi popunu
+	Paste Complete Stroke	Nalepi kompletan obrub
+	Make Symmetry Path	Napravi putanju simetrije
+	Disable Symmetry Path	Onemogući putanju simetrije
+	Dark Gray	Tamnosiva
+	Medium Gray	Srednje siva
+	Select Custom Color…	Izaberi prilagođenu boju…
+	Color Picker (Custom Canvas Color)	Birač boja (prilagođena boja platna)
+	Duplicate Channel	Dupliraj kanal
+	Delete Channel	Obriši kanal
+	Rename Channel…	Preimenuj kanal…
+	Merge Spot Channel	Spoji kanal spot boje
+	Convert to Alpha Channel	Pretvori u alfa kanal
+	Exit Quick Mask	Izađi iz brze maske
+	New Channel…	Novi kanal…
+	New Spot Channel…	Novi kanal spot boje…
+	Split Channels	Razdvoji kanale
+	Merge Channels…	Spoji kanale…
+	Color Indicates Masked Areas	Boja označava maskirane oblasti
+	Color Indicates Selected Areas	Boja označava izabrane oblasti
+	✓ Color Indicates Masked Areas	✓ Boja označava maskirane oblasti
+	✓ Color Indicates Selected Areas	✓ Boja označava izabrane oblasti
+	Up	Nagore
+	To	Do
+	Shallow	Plitko
+	Deep	Duboko
+	Blend Interior Effects as Group	Stapaj unutrašnje efekte kao grupu
+	Blend Clipped Layers as Group	Stapaj isečene slojeve kao grupu
+	Transparency Shapes Layer	Providnost oblikuje sloj
+	Layer Mask Hides Effects	Maska sloja skriva efekte
+	Vector Mask Hides Effects	Vektorska maska skriva efekte
+	General Blending	Opšte stapanje
+	This Layer:	Ovaj sloj:
+	Underlying Layer:	Sloj ispod:
+	Nothing to paste: the clipboard holds no image	Nema šta da se nalepi: u ostavi nema slike
+	Preferences saved	Podešavanja su sačuvana
+	Invalid panel layout; restored the default dock	Neispravan raspored panela; vraćen je podrazumevani raspored
+	Preferences were reset: {error}	Podešavanja su resetovana: {error}
+	Recovered {name}	Oporavljeno: {name}
+	Couldn't save preferences: {error}. Retrying…	Čuvanje podešavanja nije uspelo: {error}. Ponovni pokušaj…
+	Autosave failed: {error}	Automatsko čuvanje nije uspelo: {error}
+	Exported presets to {path}	Šabloni su izvezeni u {path}
+	Ran script {name}	Pokrenuta skripta {name}
+	Sent to the printer ({spooler})	Poslato na štampač ({spooler})
+	Printed to {path}	Odštampano u {path}
+	Exported {path} ({size})	Izvezeno: {path} ({size})
+	Exported {path}	Izvezeno: {path}
+	Added swatch {name}	Dodat uzorak boje {name}
+	Step {step} ({id}) failed: {error}	Korak {step} ({id}) nije uspeo: {error}
+	Could not rename the action: {error}	Preimenovanje radnje nije uspelo: {error}
+	Action playback failed: {error}	Izvršavanje radnje nije uspelo: {error}
+	Clone source set at {x}, {y}	Izvor kloniranja postavljen na {x}, {y}
+	Color management: {error}	Upravljanje bojama: {error}
+	Opened {url}	Otvoreno: {url}
+	No custom shape "{name}": pick one in the options bar or Window › Shapes	Nema prilagođenog oblika „{name}“: izaberite jedan na traci opcija ili u Prozor › Oblici
+	Saved a copy as {path}	Kopija je sačuvana kao {path}
+	Exported contents to {path}	Sadržaj je izvezen u {path}
+	{label} is not available: {reason}	{label} nije dostupno: {reason}
+	Saved {path}; image assets: {n} in {dir}	Sačuvano: {path}; slikovni resursi: {n} u {dir}
+	{message} (notes: {n}; {warning})	{message} (beleške: {n}; {warning})
+	Preferences can't be saved	Podešavanja ne mogu da se sačuvaju
+	PhotoCraft keeps retrying; until a save succeeds, preference changes are lost when it closes.	PhotoCraft nastavlja da pokušava; dok čuvanje ne uspe, izmene podešavanja se gube pri zatvaranju.
+	GPU retry scheduled	Zakazan je ponovni pokušaj sa GPU-om
+	Save your work and restart PhotoCraft to retry GPU acceleration. CPU rendering remains active for this session.	Sačuvajte svoj rad i ponovo pokrenite PhotoCraft da biste ponovo pokušali GPU ubrzanje. Renderovanje procesorom ostaje aktivno do kraja ove sesije.
+	GPU device was lost; using the CPU renderer.	GPU uređaj je izgubljen; koristi se renderovanje procesorom.
+	GPU error; using the CPU renderer.	Greška GPU-a; koristi se renderovanje procesorom.
+	Couldn't open {name}: {error}	Otvaranje {name} nije uspelo: {error}
+	Toggle the Brush Settings panel	Prikaži/sakrij panel Podešavanja četkice
+	New Brush Preset	Novi šablon četkice
+	Grid view	Prikaz mreže sličica
+	List view	Prikaz spiska
+	{verb} {mask} {layer}	{verb} {mask} ({layer})
+	Unlink	Razveži
+	Link	Poveži
+	layer mask	masku sloja
+	vector mask	vektorsku masku
+	Commit transform	Potvrdi transformaciju
+	Cancel transform	Otkaži transformaciju
+	Scroll menu up	Pomeri meni nagore
+	Scroll menu down	Pomeri meni nadole
+	This type layer must be rasterized before proceeding. Its text will no longer be editable. Rasterize the type?	Ovaj tekstualni sloj mora da se rasterizuje pre nastavka. Njegov tekst više neće moći da se uređuje. Rasterizovati tekst?
+	This shape layer must be rasterized before proceeding. It will no longer be editable as a shape. Rasterize the shape?	Ovaj sloj oblika mora da se rasterizuje pre nastavka. Više neće moći da se uređuje kao oblik. Rasterizovati oblik?
+	This Smart Object must be rasterized before proceeding. Its contents will no longer be editable. Rasterize the Smart Object?	Ovaj pametni objekat mora da se rasterizuje pre nastavka. Njegov sadržaj više neće moći da se uređuje. Rasterizovati pametni objekat?
+	This fill layer must be rasterized before proceeding. Its fill content will no longer be editable. Rasterize the layer?	Ovaj sloj popune mora da se rasterizuje pre nastavka. Njegov sadržaj popune više neće moći da se uređuje. Rasterizovati sloj?
+	This layer must be rasterized before proceeding.	Ovaj sloj mora da se rasterizuje pre nastavka.
+	Color Picker (Background Color)	Birač boja (boja pozadine)
+	Color Picker (Foreground Color)	Birač boja (boja prednjeg plana)
+	Adwaita (Light)	Adwaita (svetla)
+	Adwaita (Dark)	Adwaita (tamna)
+	Breeze Light	Breeze svetla
+	Breeze Dark	Breeze tamna
+	Solarized Dark	Solarized tamna
+	Open Recent is unavailable on the web	Otvori nedavno nije dostupno na vebu
+	Graphics adapter: {adapter}	Grafički adapter: {adapter}
+	Backend: {backend} ({type})	Pozadinski sistem: {backend} ({type})
+	Driver: {driver}	Upravljački program: {driver}
+	GPU backend preference: {backend}	Željeni GPU pozadinski sistem: {backend}
+	Selected at launch: {backend}	Izabrano pri pokretanju: {backend}
+	Image compositor: {processor}	Kompozitor slike: {processor}
+	Fallback: {reason}	Rezervno rešenje: {reason}
+	This session: {reason}	Ova sesija: {reason}
+	Window renderer: {renderer}	Renderer prozora: {renderer}
+	Software adapter	Softverski adapter
+	Graphics adapter	Grafički adapter
+	unknown	nepoznato
+	unknown type	nepoznata vrsta
+	auto	automatski
+	Platform: {os} {arch}	Platforma: {os} {arch}
+	previous reading kept; the last re-read failed: {reason}	zadržano je prethodno očitavanje; poslednje ponovno očitavanje nije uspelo: {reason}
+	Monitor profile: {profile}	Profil monitora: {profile}
+	Display profiles: {reason}	Profili ekrana: {reason}
+	Monitor profile in use on {display}: {profile}	Profil monitora u upotrebi na {display}: {profile}
+	Monitor profile in use: {profile}	Profil monitora u upotrebi: {profile}
+	The canvas is shown as sRGB. Choose a monitor profile in Edit › Color Settings.	Platno se prikazuje kao sRGB. Izaberite profil monitora u Uređivanje › Podešavanja boja.
+	The canvas on {display} is shown as sRGB. Choose a monitor profile in Edit › Color Settings.	Platno na {display} se prikazuje kao sRGB. Izaberite profil monitora u Uređivanje › Podešavanja boja.
+	Display profile not used	Profil ekrana se ne koristi
+	Monitor profile on {display} (main window): {profile}	Profil monitora na {display} (glavni prozor): {profile}
+	Monitor profile on {display}: {profile}	Profil monitora na {display}: {profile}
+	manual	ručno
+	fallback	rezervno
+	The document does not have an embedded colour profile. Working space: {working}.	Dokument nema ugrađen profil boja. Radni prostor: {working}.
+	The document has an embedded colour profile that does not match the working space.\nEmbedded: {embedded}\nWorking: {working}	Dokument ima ugrađen profil boja koji se ne slaže sa radnim prostorom.\nUgrađeni: {embedded}\nRadni: {working}
+	Importing {what} from {file}…	Uvoz ({what}) iz {file}…
+	brushes	četkice
+	gradients	gradijenti
+@plural	Imported {n} brush from {file}|Imported {n} brushes from {file}	Uvezena je {n} četkica iz {file}|Uvezene su {n} četkice iz {file}|Uvezeno je {n} četkica iz {file}
+@plural	Imported {n} gradient from {file}|Imported {n} gradients from {file}	Uvezen je {n} gradijent iz {file}|Uvezena su {n} gradijenta iz {file}|Uvezeno je {n} gradijenata iz {file}
+	Data Set: {name}  ({index}/{total})	Skup podataka: {name}  ({index}/{total})
+	(none)	(nijedan)
+navigator	Zoom	Uvećanje
+	Apply {option}: {state}	Primeni {option}: {state}
+	on	uključeno
+	off	isključeno
+	This adjustment ({key}) is kept as imported and can't be edited yet.	Ova korekcija ({key}) je zadržana onakva kakva je uvezena i još ne može da se uređuje.
+	Join the ArtCraft Discord ({url})	Pridružite se ArtCraft Discord zajednici ({url})
+	{index} of {total}	{index} od {total}
+	{shortcut} assigned.	{shortcut} je dodeljena.
+	{shortcut} is already in use by {commands} and will be removed from it when you click OK.	{shortcut} već koristi {commands} i biće uklonjena odatle kada kliknete U redu.
+
+# Command-id overrides where the plain key is also a dialog button
+@id	file.close	Zatvori
+@id	layer.layerMask.apply	Primeni
+@id	edit.clear	Obriši
+
+# Layer colour labels distinct from channel and ink names
+layerLabel	Red	Crvena
+layerLabel	Magenta	Magenta
+
+	Drag: draw freehand · Release on the start point: close	Prevlačenje: crtanje slobodnom rukom · Otpuštanje na početnoj tački: zatvori
+	Drag a crop box · drag inside to move · edges resize ({ratio} ratio, {centre} centre) · Space moves while drawing · {commit} commits · Esc cancels	Prevucite okvir za opsecanje · prevlačenje unutra pomera · ivice menjaju veličinu ({ratio} odnos, {centre} centar) · razmaknica pomera tokom crtanja · {commit} potvrđuje · Esc otkazuje
+
+# Character, Paragraph and Glyphs panels
+	Kerning: Metrics, Optical or a value in 1/1000 em (Alt+←/→ at the caret)	Kerning: metrički, optički ili vrednost u 1/1000 em (Alt+←/→ kod kursora)
+	Basic Latin	Osnovna latinica
+	Latin 1	Latinica 1
+	Latin Extended-A	Proširena latinica A
+	Latin Extended-B	Proširena latinica B
+	Greek	Grčko pismo
+	Cyrillic	Ćirilica
+	Numbers	Brojevi
+	Currency	Valute
+	Math Symbols	Matematički simboli
+	Arrows	Strelice
+
+	Save Path	Sačuvaj putanju
+
+# Camera Raw labels
+cameraRaw	Highlights	Svetla
+cameraRaw	Shadows	Senke
+
+# Keyboard Shortcuts and Menus editor
+	All shortcuts reset to Photoshop defaults.	Sve prečice su vraćene na podrazumevane vrednosti Photoshop-a.
+	Temporary	Privremeno
+	none	nijedna
+	red	crvena
+	orange	narandžasta
+	yellow	žuta
+	green	zelena
+	blue	plava
+	violet	ljubičasta
+	gray	siva
+
+# Color Settings dialog
+	Working Rgb	Radni RGB
+	Working Cmyk	Radni CMYK
+	Working Gray	Radna siva
+	Policy Rgb	Pravilo za RGB
+	Policy Cmyk	Pravilo za CMYK
+	Policy Gray	Pravilo za sivu
+	Convert	Pretvori
+	Ask On Mismatch	Pitaj pri neslaganju
+	Ask On Paste	Pitaj pri lepljenju
+	Ask On Missing	Pitaj kada profil nedostaje
+	Intent	Način konverzije
+	Bpc	Kompenzacija crne tačke
+	Blend Text Gamma	Gama za stapanje teksta
+	Monitor Profile	Profil monitora
+	Display-p3	Display P3
+	Adobe-rgb-compat	Adobe RGB (kompatibilno)
+	Prophoto-compat	ProPhoto RGB (kompatibilno)
+	Linear-srgb	Linearni sRGB
+	Rec2020	Rec. 2020
+	Coated-cmyk	Premazani CMYK
+	Sgray	sGray
+	Gray-gamma-2.2	Siva gama 2.2
+
+	Import Photoshop brushes (.abr)	Uvezi Photoshop četkice (.abr)
+
+# Camera Raw chrome, tone, curve, color mixer, grading, detail and effects
+cameraRaw	Effects	Efekti
+cameraRaw	Exposure	Ekspozicija
+cameraRaw	Contrast	Kontrast
+cameraRaw	Texture	Tekstura
+cameraRaw	Clarity	Jasnoća
+cameraRaw	Dehaze	Uklanjanje izmaglice
+cameraRaw	Saturation	Zasićenost
+cameraRaw	Curve	Kriva
+cameraRaw	Color Mixer	Mešač boja
+cameraRaw	Midtones	Srednji tonovi
+cameraRaw	Balance	Balans
+cameraRaw	Detail	Detalji
+cameraRaw	Radius	Poluprečnik
+cameraRaw	Feather	Omekšavanje
+cameraRaw	Midpoint	Središte
+cameraRaw	Roundness	Zaobljenost
+cameraRaw	Size	Veličina
+
+# New Document, Home and Image Size
+	Default Photoshop Size	Podrazumevana Photoshop veličina
+document	Orientation	Orijentacija
+
+# Warp, Liquify, Perspective and Puppet
+	Arc Lower	Donji luk
+	Arc Upper	Gornji luk
+	Forward Warp	Guranje napred
+	Twirl Clockwise	Uvrtanje udesno
+	Twirl Counterclockwise	Uvrtanje ulevo
+	Pucker	Skupljanje
+	Bloat	Naduvavanje
+	Push Left	Guranje ulevo
+	Freeze Mask	Zamrzni masku
+	Thaw Mask	Odmrzni masku
+	Freeze Lasso	Laso za zamrzavanje
+	Reconstruct All	Rekonstruiši sve
+	Mask None	Bez maske
+
+# Contextual labels
+colorRange	Invert	Invertuj
+layers	Fill	Popuna
+layers	Fill:	Popuna:
+shape	Appearance	Izgled
+
+# Added on merge with main (spelling, Camera Raw settings files, printing, Object Finder, brush
+# controls, actions, gradient presets, Pen Auto Add/Delete)
+	Add to Dictionary	Dodaj u rečnik
+	No Spelling Suggestions	Nema predloga za pravopis
+	Save Settings…	Sačuvaj podešavanja…
+	Load Settings…	Učitaj podešavanja…
+	Save these settings as a Camera Raw .xmp file	Sačuvaj ova podešavanja kao Camera Raw .xmp datoteku
+	Load settings from a Camera Raw .xmp file	Učitaj podešavanja iz Camera Raw .xmp datoteke
+	Loaded Camera Raw settings from {file}	Camera Raw podešavanja su učitana iz {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Camera Raw podešavanja su učitana iz {file} (nije podržano: {n})
+	Manage submitted jobs in the system print queue	Upravljajte poslatim poslovima u sistemskom redu za štampu
+	Pick Color From Image	Uzmi boju sa slike
+	Drag to pan · Scroll to zoom · Double-click to fit	Prevucite za pomeranje · Skrolujte za zumiranje · Dvaput kliknite za uklapanje
+	Object Finder	Pronalazač objekata
+	No object found there — drag a rectangle around it	Tu nije pronađen nijedan objekat — prevucite pravougaonik oko njega
+	Clear Brush Controls	Obriši kontrole četkice
+	Reset All Locked Settings	Vrati sva zaključana podešavanja
+	Copy Texture to Other Tools	Kopiraj teksturu u druge alatke
+	Load Actions…	Učitaj radnje…
+	Save Actions…	Sačuvaj radnje…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Učitana je {n} radnja iz {file}|Učitane su {n} radnje iz {file}|Učitano je {n} radnji iz {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} korak još nema ekvivalent u PhotoCraftu|{n} koraka još nemaju ekvivalent u PhotoCraftu|{n} koraka još nema ekvivalent u PhotoCraftu
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Sačuvana je {n} radnja u {file}|Sačuvane su {n} radnje u {file}|Sačuvano je {n} radnji u {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Izostavljen je {n} korak bez ekvivalenta u Photoshopu|Izostavljena su {n} koraka bez ekvivalenta u Photoshopu|Izostavljeno je {n} koraka bez ekvivalenta u Photoshopu
+	Insert Stop…	Umetni zaustavljanje…
+	Save Set…	Sačuvaj skup…
+	Message:	Poruka:
+	Allow Continue	Dozvoli nastavak
+	Show dialog during playback	Prikaži dijalog tokom puštanja
+	Select an action first	Prvo izaberite radnju
+	Action playback stopped	Puštanje radnje je zaustavljeno
+	Step {step} is waiting for its dialog	Korak {step} čeka svoj dijalog
+@plural	{n} action|{n} actions	{n} radnja|{n} radnje|{n} radnji
+	Gradient Preset Options	Opcije šablona gradijenta
+	Import .GRD	Uvezi .GRD
+	Choose a gradient file (.grd).	Izaberite datoteku gradijenta (.grd).
+	Auto Add/Delete	Automatsko dodavanje/brisanje
+
+# Custom print paper (#3820)
+	Paper Width	Širina papira
+	Paper Height	Visina papira
+	ICO is limited to 256 × 256 pixels	ICO je ograničen na 256 × 256 piksela
+
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Boja kanala
+	Color Indicates:	Boja označava:
+	Ink Characteristics	Karakteristike mastila
+	Solidity:	Punoća:
+	Redrawing	Ponovno iscrtavanje
diff --git a/crates/ui-egui/src/i18n/system.rs b/crates/ui-egui/src/i18n/system.rs
index 4fb0404f66..49bc3bc79b 100644
--- a/crates/ui-egui/src/i18n/system.rs
+++ b/crates/ui-egui/src/i18n/system.rs
@@ -96,6 +96,10 @@ mod tests {
             (vec!["pt-PT"], "pt-br"),
             (vec!["it-IT", "en-US"], "it"),
             (vec!["nl-BE", "fr-BE"], "nl"),
+            (vec!["hu-HU", "en-US"], "hu"),
+            (vec!["tr-TR", "en-US"], "tr"),
+            (vec!["sr-Latn-RS", "en-US"], "sr"),
+            (vec!["sv-SE", "sr_RS@latin", "ru-RU"], "sr"),
             (vec![], "en"),
         ] {
             with_system_tags(&tags, || assert_eq!(system_lang().code(), expected));
diff --git a/crates/ui-egui/src/i18n/tr.tsv b/crates/ui-egui/src/i18n/tr.tsv
new file mode 100644
index 0000000000..948c967467
--- /dev/null
+++ b/crates/ui-egui/src/i18n/tr.tsv
@@ -0,0 +1,3871 @@
+# Turkish (tr) catalog. Columns, separated by a TAB:  context <TAB> source <TAB> translation
+# (the format is described in ja.tsv).
+#
+# Clean-room: every entry was written from the plain meaning of the English label using ordinary
+# Turkish computing vocabulary (katman, seçim, maske, ayar katmanı, fırça, degrade ...). No
+# proprietary localisation resource, string table or product UI was consulted or copied; add
+# entries the same way. Product and technology names (PhotoCraft, ArtCraft, OpenType, CMYK, Lab ...)
+# stay as they are; the trailing "…" of dialog commands is kept.
+#
+# Custom paper dimensions in Print Settings.
+	Paper Width	Kağıt Genişliği
+	Paper Height	Kağıt Yüksekliği
+
+	Rows	Satırlar
+	Number	Sayı
+	Top:	Üst:
+	Left:	Sol:
+	Bottom:	Alt:
+	Right:	Doğru:
+	Target:	Hedef:
+	Selected Artboards	Seçilen Çalışma Yüzeyleri
+	Center Columns	Merkezi Sütunlar
+	Clear Existing Guides	Mevcut Kılavuzları Temizle
+	Invalid guide layout	Geçersiz kılavuz düzeni
+	Leave empty for automatic size	Otomatik boyut için boş bırakın
+	5 Columns, 3 Rows	5 Sütun, 3 Satır
+	8 Columns	8 Sütun
+	12 Columns	12 Sütun
+	File	Dosya
+	Edit	Düzen
+	Image	Görüntü
+	Layer	Katman
+	Type	Metin
+	Select	Seç
+	Scope	Kapsam
+	Top Left	Sol Üst
+	Top Right	Sağ Üst
+	Bottom Left	Sol Alt
+	Bottom Right	Sağ Alt
+	Filter	Filtre
+	View	Görünüm
+	Window	Pencere
+	Help	Yardım
+	(coming soon)	(yakında)
+	New…	Yeni…
+	New from Clipboard	Pano'dan yeni
+	Open…	Aç…
+	Open As…	Farklı Aç…
+	Open EXR Parts…	EXR Parçalarını açın…
+	Add beauty precomp from the AOVs	AOV'lerden güzellik ön kompozisyonu ekleyin
+	Both	Her ikisi de
+	Left	Sol
+	Right	Sağ
+	Open Recent	Son Kullanılanları Aç
+	Clear Recent Files	Son Dosyaları Temizle
+	Remove from Recent	En Son'dan kaldır
+	Remove {name} from Recent	{name} öğesini En Son'dan kaldır
+	Close	Kapat
+	Minimize	Küçült
+	Maximize	Büyüt
+	Restore	Geri yükle
+	Close All	Tümünü Kapat
+	Close Others	Diğerlerini Kapat
+	Save	Kaydet
+	Save As…	Farklı Kaydet…
+	Save a Copy…	Bir Kopyasını Kaydet…
+	{name} can't keep everything in this document	{name} bu belgedeki her şeyi koruyamaz
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Photoshop (PSD) gibi her şeyi koruyan bir biçim seçin ya da bir kopyasını kaydedin.
+	Revert	Geri Döndür
+	Export	Dışa Aktar
+	Quick Export as PNG	PNG Olarak Hızlı Dışa Aktarma
+	Export As…	Farklı Dışa Aktar…
+	Export Preferences…	Dışa Aktarma Tercihleri…
+	Save for Web (Legacy)…	Web İçin Kaydet (Eski)…
+	Artboards to Files…	Çalışma Yüzeylerinden Dosyalara…
+	Artboards to PDF…	Çalışma yüzeylerinden PDF'ye…
+	Layers to Files…	Katmanlardan Dosyalara…
+	Layer Comps to Files…	Dosyalara Katman Kompozisyonları…
+	Color Lookup Tables…	Renk Arama Tabloları…
+	Data Sets as Files…	Dosya Olarak Veri Kümeleri…
+	Paths to Illustrator…	İllüstratöre Giden Yollar…
+	Render Video…	Videoyu Oluştur…
+	Generate	Oluştur
+	Image Assets	Resim Varlıkları
+	Place Embedded…	Gömülü Olarak Yerleştir…
+	Place Linked…	Bağlantılı Olarak Yerleştir…
+	Package…	Paketle…
+	Automate	Otomatikleştir
+	Batch…	Toplu…
+	Create Droplet…	Damlacık oluştur…
+	Crop and Straighten Photos	Fotoğrafları Kırp ve Düzelt
+	Contact Sheet II…	İletişim Sayfası II…
+	Conditional Mode Change…	Koşullu Mod Değişikliği…
+	Fit Image…	Resmi Sığdır…
+	Lens Correction…	Mercek Düzeltme…
+	Merge to HDR Pro…	HDR Pro'ya Birleştir…
+	Photomerge…	Fotoğraf Birleştir…
+	Scripts	Komut dosyaları
+	Image Processor…	Görüntü İşlemcisi…
+	Delete All Empty Layers	Tüm Boş Katmanları Sil
+	Flatten All Layer Effects	Tüm Katman Efektlerini Düzleştir
+	Flatten All Masks	Tüm Maskeleri Düzleştir
+	Script Events Manager…	Komut Dosyası Olay Yöneticisi…
+	Import	İthalat
+	Browse…	Göz at…
+	Source Files	Kaynak Dosyalar
+	Use:	Kullan:
+	Files	Dosyalar
+	Add Open Files	Açık Dosyaları Ekle
+	Sort By Name	Ada Göre Sırala
+	Attempt to Automatically Align Source Images	Kaynak Görüntüleri Otomatik Hizalamayı Dene
+	Create Smart Object after Loading Layers	Katmanları Yükledikten Sonra Akıllı Nesne Oluştur
+	Reveal in Finder	Finder'da Göster
+	Show in Explorer	Explorer'da Göster
+	Show in Folder	Klasörde Göster
+	File Info…	Dosya Bilgileri…
+	Print…	Yazdır…
+	Print One Copy	Bir Kopya Yazdır
+	Exit	Çıkış
+	Undo	Geri Al
+	Redo	Yinele
+	Toggle Last State	Son Durumu Değiştir
+	Fade…	Solmaya…
+	Cut	Kes
+	Copy	Kopyala
+	Copy Merged	Birleştirilmiş Olarak Kopyala
+	Paste	Yapıştır
+	Paste Special	Özel Yapıştır
+	Paste in Place	Yerine Yapıştır
+	Paste Into	İçine Yapıştır
+	Paste Outside	Dışına Yapıştır
+	Paste Lorem Ipsum	Lorem Ipsum'u Yapıştır
+	Clear	Temizle
+	Search…	Ara…
+	Check Spelling…	Yazımı Denetle…
+	Find and Replace Text…	Metni Bul ve Değiştir…
+	Add to Dictionary	Sözlüğe Ekle
+	No Spelling Suggestions	Yazım Önerisi Yok
+	Fill…	Doldur…
+	Stroke…	Kontur…
+	Content-Aware Fill…	İçeriğe Uygun Dolgu…
+	Delete and Fill Selection	Seçimi Sil ve Doldur
+	Content-Aware Scale	İçeriğe Uygun Ölçek
+	Puppet Warp	Kukla Çözgü
+	Perspective Warp	Perspektif Çarpıtma
+	Free Transform	Serbest Dönüştürme
+	Free Transform a Copy	Bir Kopyayı Ücretsiz Dönüştürme
+	Transform	Dönüştür
+	Again	Yinele
+	Transform Again on a Copy	Bir Kopyada Yeniden Dönüştür
+	Scale	Ölçekle
+	Rotate	Döndür
+	Set horizontal skew	Yatay eğmeyi ayarla
+	Set vertical skew	Dikey eğmeyi ayarla
+	Skew	Eğ
+	Distort	Çarpıt
+	Perspective	Perspektif
+	Warp	Deforme Et
+	Flip Horizontal	Yatay Çevir
+	Flip Vertical	Dikey Çevir
+	Rotate 180°	180° Döndür
+	Rotate 90° Clockwise	90° Saat Yönünde Döndür
+	Rotate 90° Counter Clockwise	90° Saat Yönünün Tersine Döndür
+	180°	180°
+	90° Clockwise	90° Saat Yönünde
+	90° Counter Clockwise	90° Saat Yönünün Tersine
+	Arbitrary…	Keyfi…
+	Auto-Align Layers…	Katmanları Otomatik Hizala…
+	Auto-Blend Layers…	Katmanları Otomatik Karıştır…
+	Define Brush Preset…	Fırça Ön Ayarını Tanımla…
+	Define Pattern…	Deseni Tanımla…
+	Define Custom Shape…	Özel Şekil Tanımlayın…
+	Purge	Temizle
+	Clipboard	Pano
+	Histories	Geçmiş
+	Video Cache	Video Önbelleği
+	All	Tümü
+	Presets	Ön ayarlar
+	Preset Manager…	Ön Ayar Yöneticisi…
+	Migrate Presets	Ön Ayarları Taşı
+	Export/Import Presets…	Ön Ayarları Dışa/İçe Aktar…
+	Color Settings…	Renk Ayarları…
+	Assign Profile…	Profil Ata…
+	Convert to Profile…	Profile Dönüştür…
+	Keyboard Shortcuts…	Klavye Kısayolları…
+	Menus…	Menüler…
+	Toolbar…	Araç Çubuğu…
+	Preferences	Tercihler
+	General…	Genel…
+	Interface…	Arayüz…
+	Workspace…	Çalışma alanı…
+	Tools…	Araçlar…
+	History Log…	Geçmiş Günlüğü…
+	File Handling…	Dosya İşleme…
+	Export…	İhracat…
+	Performance…	Performans…
+	Scratch Disks…	Kazı Diskleri…
+	Cursors…	İmleçler…
+	Transparency & Gamut…	Şeffaflık ve Gamut…
+	Units & Rulers…	Birimler ve Cetveller…
+	Guides, Grid & Slices…	Kılavuzlar, Izgaralar ve Dilimler…
+	Plug-ins…	Eklentiler…
+	Type…	Tür…
+	Enhanced Controls…	Gelişmiş Kontroller…
+	Camera Raw…	Kamera Raw…
+	Raw Defaults…	Ham Varsayılanlar…
+	Integrations…	Entegrasyonlar…
+	AI Integrations…	Yapay Zeka Entegrasyonları…
+	Install Plug-in…	Eklentiyi Yükle…
+	Language Options	Dil Seçenekleri
+	Settings…	Ayarlar…
+	Mode	Mod
+	Bitmap	Bit eşlem
+	Grayscale	Gri tonlamalı
+	Duotone	Çift tonlu
+	Indexed Color	İndekslenmiş Renk
+	RGB Color	RGB Rengi
+	CMYK Color	CMYK Rengi
+	Lab Color	Laboratuvar Rengi
+	Multichannel	Çok kanallı
+	8 Bits/Channel	8 Bit/Kanal
+	8 bit	8 bitlik
+	Integer	Tamsayı
+	16 Bits/Channel	16 Bit/Kanal
+	16 bit	16 bitlik
+	32 Bits/Channel	32 Bit/Kanal
+	32 bit (float)	32 bitlik (kayan noktalı)
+	Floating point	Kayan nokta
+	Color Table…	Renk Tablosu…
+	Bitmap…	Bit eşlem…
+	Duotone…	Çift tonlu…
+	Indexed Color…	İndekslenmiş Renk…
+	Adjustments	Ayarlamalar
+	Brightness/Contrast…	Parlaklık/Kontrast…
+	Levels…	Düzeyler…
+	Curves…	Eğriler…
+	Exposure…	Pozlama…
+	Vibrance…	Titreşim…
+	Hue/Saturation…	Renk Tonu/Doygunluk…
+	Color Balance…	Renk Dengesi…
+	Black & White…	Siyah ve Beyaz…
+	Photo Filter…	Fotoğraf Filtresi…
+	Channel Mixer…	Kanal Karıştırıcı…
+	Color Lookup…	Renk Arama…
+	Invert	Tersine Çevir
+	Posterize…	Posterleştir…
+	Threshold…	Eşik…
+	Gradient Map…	Degrade Eşlemesi…
+	Selective Color…	Seçici Renk…
+	Shadows/Highlights…	Gölgeler/Vurgular…
+	HDR Toning…	HDR Tonlama…
+	Desaturate	Doygunluğu Azalt
+	Match Color…	Rengi Eşleştir…
+	Replace Color…	Rengi Değiştir…
+	Equalize	Eşitle
+	Auto Tone	Otomatik Ton
+	Auto Contrast	Otomatik Kontrast
+	Auto Color	Otomatik Renk
+	Image Size…	Görüntü Boyutu…
+	Canvas Size…	Tuval Boyutu…
+	Image Rotation	Görüntü Döndürme
+	Flip Canvas Horizontal	Kanvası Yatay Çevir
+	Flip Canvas Vertical	Kanvası Dikey Çevir
+	Crop	Kırp
+	Trim…	Kırp (Kenar)…
+	Reveal All	Tümünü Göster
+	Duplicate…	Çoğalt…
+	Apply Image…	Resmi Uygula…
+	Calculations…	Hesaplamalar…
+	Variables	Değişkenler
+	Define…	Tanımla…
+	Data Sets…	Veri Setleri…
+	Apply Data Set…	Veri Kümesini Uygula…
+	Variable Data Sets…	Değişken Veri Setleri…
+	Trap…	Tuzak…
+	Analysis	Analiz
+	Set Measurement Scale…	Ölçüm Ölçeğini Ayarla…
+	Select Data Points…	Veri Noktalarını Seçin…
+	Record Measurements	Ölçümleri Kaydet
+	Ruler Tool	Cetvel Aracı
+	Count Tool	Sayma Aracı
+	Place Scale Marker…	Ölçek İşaretçisini Yerleştirin…
+	Custom…	Özel…
+	New	Yeni
+	Layer…	Katman…
+	Group…	Grup…
+	Group from Layers…	Katmanlardan Grup…
+	Artboard…	Çalışma yüzeyi…
+	Artboard from Group…	Gruptan çalışma yüzeyi…
+	Artboard from Layers…	Katmanlardan Çalışma Yüzeyi…
+	Layer via Copy	Kopyalama yoluyla katman
+	Layer via Cut	Kesim Yoluyla Katman
+	Layer From Background…	Arka Plandan Katman…
+	Layer from Background…	Arka Plandan Katman…
+	Background From Layer	Katmandan Arka Plan
+	New Shape Layer	Yeni Şekil Katmanı
+	New Type Layer	Yeni Tip Katmanı
+	New Fill Layer	Yeni Dolgu Katmanı
+	New Adjustment Layer	Yeni Ayarlama Katmanı
+	New Layer Based Slice	Yeni Katman Tabanlı Dilim
+	New Smart Object via Copy	Kopyalama Yoluyla Yeni Akıllı Nesne
+	New Blank Video Layer	Yeni Boş Video Katmanı
+	New Video Layer from File…	Dosyadan Yeni Video Katmanı…
+	Duplicate Layer…	Katmanı Çoğalt…
+	Delete Layer	Katmanı Sil
+	Delete	Sil
+	Rename Layer	Katmanı Yeniden Adlandır
+	Create Layer	Katman Oluştur
+	Layer Style	Katman Stili
+	Blending Options…	Karışım Seçenekleri…
+	Bevel & Emboss…	Eğim ve Kabartma…
+	Use Global Light	Global Light'ı kullanın
+	Inner Shadow…	İç Gölge…
+	Inner Glow…	İç Işıma…
+	Satin…	Saten…
+	Color Overlay…	Renk Kaplama…
+	Gradient Overlay…	Degrade Kaplama…
+	Pattern Overlay…	Desen Kaplama…
+	Outer Glow…	Dış Işıma…
+	Drop Shadow…	Alt Gölge…
+	Copy Layer Style	Katman Stilini Kopyala
+	Paste Layer Style	Katman Stilini Yapıştır
+	Clear Layer Style	Katman Stilini Temizle
+	Global Light…	Küresel Işık…
+	Hide All Effects	Tüm Efektleri Gizle
+	Scale Effects…	Ölçek Etkileri…
+	Smart Filter	Akıllı Filtre
+	Convert for Smart Filters	Akıllı Filtreler için Dönüştürme
+	Clear Smart Filters	Akıllı Filtreleri Temizle
+	Disable Smart Filters	Akıllı Filtreleri Devre Dışı Bırak
+	Delete Filter Mask	Filtre Maskesini Sil
+	Disable Filter Mask	Filtre Maskesini Devre Dışı Bırak
+	Solid Color…	Düz Renk…
+	Gradient…	Gradyan…
+	Pattern…	Desen…
+	Layer Mask	Katman Maskesi
+	Vector Mask	vektör maskesi
+	Reveal Selection	Seçimi Göster
+	Hide Selection	Seçimi Gizle
+	Hide All	Tümünü Gizle
+	From Transparency	Şeffaflıktan
+	Delete Vector Mask	Vektör Maskesini Sil
+	Enable Layer Mask	Katman Maskesini Etkinleştir
+	Disable Layer Mask	Katman Maskesini Devre Dışı Bırak
+	Enable Vector Mask	Vektör Maskesini Etkinleştir
+	Link Layer Mask	Bağlantı Katmanı Maskesi
+	Unlink Layer Mask	Katman Maskesinin Bağlantısını Kaldır
+	Link Vector Mask	Bağlantı Vektör Maskesi
+	Add Vector Mask	Vektör Maskesi Ekle
+	Vector Mask from Current Path	Geçerli Yoldan Vektör Maskesi
+	Create Clipping Mask	Kırpma Maskesi Oluştur
+	Release Clipping Mask	Kırpma Maskesini Serbest Bırakın
+	Smart Objects	Akıllı Nesneler
+	Smart Object	Akıllı Nesne
+	Convert to Smart Object	Akıllı Nesneye Dönüştür
+	Convert to Embedded	Gömülüye Dönüştür
+	Convert to Layers	Katmanlara Dönüştür
+	Convert to Linked…	Bağlantılıya Dönüştür…
+	Edit Contents	İçeriği Düzenle
+	Replace Contents…	İçeriği Değiştir…
+	Relink to File…	Dosyaya Yeniden Bağla…
+	Export Contents…	İçeriği Dışa Aktar…
+	Update Modified Content	Değiştirilen İçeriği Güncelle
+	Update All Modified Content	Değiştirilen Tüm İçeriği Güncelle
+	Stack Mode	Yığın Modu
+	Choose Stack Mode:	Yığın Modunu Seçin:
+	Entropy	Entropi
+	Kurtosis	Basıklık
+	Maximum	Maksimum
+	Mean	ortalama
+	Median	Medyan
+	Minimum	Asgari
+	Range	Aralık
+	Skewness	çarpıklık
+	Standard Deviation	Standart Sapma
+	Summation	Toplama
+	Variance	Varyans
+	Video Layers	Video Katmanları
+	Interpret Footage…	Görüntüyü Yorumla…
+	Replace Footage…	Görüntüyü Değiştir…
+	Reload Frame	Çerçeveyi Yeniden Yükle
+	Show Altered Video	Değiştirilen Videoyu Göster
+	Restore Frame	Çerçeveyi Geri Yükle
+	Restore All Frames	Tüm Çerçeveleri Geri Yükle
+	Insert Blank Frame	Boş Çerçeve Ekle
+	Delete Frame	Çerçeveyi Sil
+	Duplicate Frame	Çerçeveyi Çoğalt
+	Frame from Layers	Katmanlardan Çerçeve
+	Video Frames to Layers…	Video Karelerinden Katmanlara…
+	Rasterize	Rasterleştir
+	Rasterize Type	Rasterleştirme Türü
+	Rasterize Type Layer	Tip Katmanını Rasterleştir
+	Rasterize Shape	Şekli Rasterleştir
+	New Guide Layout…	Yeni Kılavuz Düzeni…
+	New Guides From Shape	Shape'den Yeni Kılavuzlar
+	Lock Layers…	Katmanları Kilitle…
+	Link Layers	Katmanları Bağla
+	Select Linked Layers	Bağlantılı Katmanları Seçin
+	Merge Layers	Katmanları Birleştir
+	Merge Down	Aşağı Birleştir
+	Merge Visible	Görünürleri Birleştir
+	Stamp Visible	Damga Görünür
+	Select Layer Above	Yukarıdaki Katmanı Seçin
+	Select Layer Below	Aşağıdaki Katmanı Seçin
+	Select Top Layer	Üst Katmanı Seçin
+	Select Bottom Layer	Alt Katmanı Seçin
+	Add Layer Above to Selection	Seçime Yukarıdaki Katmanı Ekle
+	Add Layer Below to Selection	Aşağıdaki Katmanı Seçime Ekle
+	Stamp Down	Damgalama
+	Flatten Image	Görüntüyü Düzleştir
+	Matting	Paspas
+	Color Decontaminate…	Renkli Dekontamine…
+	Remove Black Matte	Siyah Matı Kaldır
+	Remove White Matte	Beyaz Matı Kaldır
+	Defringe…	Borcu kaldır…
+	Group Layers	Grup Katmanları
+	Ungroup Layers	Katmanların Grubunu Çöz
+	Hide Layers	Katmanları Gizle
+	Arrange	Sırala
+	Bring to Front	En Öne Getir
+	Bring Forward	Öne Getir
+	Send Backward	Arkaya Gönder
+	Send to Back	En Arkaya Gönder
+	Reverse	Ters
+	Combine Shapes	Şekilleri Birleştir
+	Unite Shapes	Şekilleri Birleştir
+	Subtract Front Shape	Ön Şekli Çıkart
+	Intersect Shape Areas	Şekil Alanlarını Kesiş
+	Exclude Overlapping Shapes	Çakışan Şekilleri Hariç Tut
+	Merge Shape Components	Şekil Bileşenlerini Birleştir
+	Align	Hizala
+	Top Edges	Üst Kenarlar
+	Vertical Centers	Dikey Merkezler
+	Bottom Edges	Alt Kenarlar
+	Left Edges	Sol Kenarlar
+	Horizontal Centers	Yatay Merkezler
+	Right Edges	Sağ Kenarlar
+	Distribute	Dağıt
+	Vertically	Dikey olarak
+	Horizontally	Yatay olarak
+	Layer Edges	Katman Kenarları
+	Isolate Layers	Katmanları Yalıt
+	Layer Content Options…	Katman İçerik Seçenekleri…
+	Fill Content	İçeriği Doldur
+	Deselect Layers	Katmanların Seçimini Kaldır
+	Find Layers	Katmanları Bul
+	Layer Comps	Katman Kompozisyonları
+	Layers	Katmanlar
+	All Layers	Tüm Katmanlar
+	Hidden Layers	Gizli Katmanlar
+	Mask All Objects	Tüm Nesneleri Maskele
+	Subject	Konu
+	Sky	Gökyüzü
+	Panels	Paneller
+	Character Panel	Karakter Paneli
+	Paragraph Panel	Paragraf Paneli
+	Character Styles Panel	Karakter Stilleri Paneli
+	Paragraph Styles Panel	Paragraf Stilleri Paneli
+	Glyphs Panel	Glifler Paneli
+	Anti-Alias	Kenar Yumuşatma
+	Sharp	Keskin
+	Crisp	Çıtır
+	Strong	Güçlü
+	Smooth	Pürüzsüz
+	Windows LCD	Windows LCD'si
+	Windows	Windows
+	Orientation	Oryantasyon
+	Horizontal	Yatay
+	Vertical	Dikey
+	OpenType	OpenType
+	Standard Ligatures	Standart Bitişik Harfler
+	Contextual Alternates	Bağlamsal Alternatifler
+	Discretionary Ligatures	İsteğe Bağlı Bitişik Harfler
+	Swash	çalkalama
+	Oldstyle	Eski tarz
+	Stylistic Alternates	Stilistik Alternatifler
+	Titling Alternates	Başlık Alternatifleri
+	Ornaments	Süsler
+	Ordinals	Sıra Sayıları
+	Fractions	Kesirler
+	Create Work Path	İş Yolu Oluştur
+	Convert to Shape	Şekle Dönüştür
+	Warp Text…	Metni Çözgü…
+	Convert to Point Text	Nokta Metnine Dönüştür
+	Convert to Paragraph Text	Paragraf Metnine Dönüştür
+	Default Features	Varsayılan Özellikler
+	East Asian Features	Doğu Asya Özellikleri
+	Middle Eastern Features	Orta Doğu Özellikleri
+	Middle Eastern & South Asian Composer	Orta Doğulu ve Güney Asyalı Besteci
+	Update All Text Layers	Tüm Metin Katmanlarını Güncelle
+	Replace All Missing Fonts	Tüm Eksik Yazı Tiplerini Değiştir
+	Resolve Missing Fonts…	Eksik Yazı Tiplerini Çözün…
+	Font Preview Size	Yazı Tipi Önizleme Boyutu
+	None	Yok
+	Small	Küçük
+	Medium	Orta
+	Large	Büyük
+	Extra Large	Ekstra Büyük
+	Huge	Devasa
+	Load Default Type Styles	Varsayılan Yazım Stillerini Yükle
+	Save Default Type Styles	Varsayılan Yazım Stillerini Kaydet
+	Deselect	Seçimi Kaldır
+	Reselect	Yeniden Seç
+	Inverse	Ters Çevir
+	Inverse Selection	Ters Seçim
+	Similar	Benzer
+	Color Range…	Renk Aralığı…
+	Focus Area…	Odaklanma Alanı…
+	Select and Mask…	Seç ve Maskele…
+	Smart Radius	Akıllı Yarıçap
+	Shift Edge	Kenarı Kaydır
+	Decontaminate	Dekontaminasyon
+	Refine Edge	Kenarı İyileştir
+	Modify	Değiştir
+	Border…	Kenarlık…
+	Smooth…	Düzelt…
+	Expand…	Genişlet…
+	Contract…	Daralt…
+	Feather…	Geçiş Yumuşatma…
+	Grow	Büyüt
+	Transform Selection	Seçimi Dönüştür
+	Edit in Quick Mask Mode	Hızlı Maske Modunda Düzenleme
+	Load Selection…	Seçimi Yükle…
+	Save Selection…	Seçimi Kaydet…
+	Match All	Tümünü Eşleştir
+	Last Filter	Son Filtre
+	Filter Gallery…	Galeriyi Filtrele…
+	Adaptive Wide Angle…	Uyarlanabilir Geniş Açı…
+	Camera Raw Filter…	Camera Raw Filtresi…
+	Liquify…	Sıvılaştır…
+	Vanishing Point…	Ufuk Noktası…
+	Blur	Bulanıklaştırma
+	Blur Gallery	Bulanıklaştırma Galerisi
+	Field Blur…	Alan Bulanıklığı…
+	No pin selected	Seçili pim yok
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Pim eklemek için görüntüye tıklayın; taşımak için pimi, bulanıklığını değiştirmek için halkasını sürükleyin. Delete seçili pimi siler.
+	Iris Blur…	İris Bulanıklığı…
+	Tilt-Shift…	Tilt-Shift…
+	Path Blur…	Yol Bulanıklığı…
+	Spin Blur…	Döndürme Bulanıklığı…
+	Blur More	Daha Fazla Bulanıklaştır
+	Box Blur…	Kutu Bulanıklığı…
+	Gaussian Blur…	Gauss Bulanıklığı…
+	Lens Blur…	Mercek Bulanıklığı…
+	Motion Blur…	Hareket Bulanıklığı…
+	Radial Blur…	Radyal Bulanıklık…
+	Shape Blur…	Şekil Bulanıklığı…
+	Smart Blur…	Akıllı Bulanıklaştırma…
+	Surface Blur…	Yüzey Bulanıklığı…
+	Average	Ortalama
+	Displace…	Yer değiştir…
+	Pinch…	Tut…
+	Polar Coordinates…	Kutupsal Koordinatlar…
+	Ripple…	Dalgalanma…
+	Shear…	Kesme…
+	Spherize…	Küreselleştir…
+	Twirl…	Döndür…
+	Wave…	Dalga…
+	ZigZag…	ZigZag…
+	Noise	Gürültü
+	Add Noise…	Gürültü Ekle…
+	Despeckle	Benek giderme
+	Dust & Scratches…	Toz ve Çizikler…
+	Median…	Medyan…
+	Reduce Noise…	Gürültüyü Azaltın…
+	Pixelate	Pikselleştir
+	Color Halftone…	Renk Yarım Tonu…
+	Crystallize…	Kristalleşin…
+	Facet	Faset
+	Fragment	Parça
+	Mezzotint…	Mezzotint…
+	Mosaic…	Mozaik…
+	Pointillize…	Noktalaştırın…
+	Render	İşleme
+	Clouds	Bulutlar
+	Difference Clouds	Fark Bulutları
+	Fibers…	Lifler…
+	Flame…	Alev…
+	Lens Flare…	Mercek Parlaması…
+	Lighting Effects…	Aydınlatma Efektleri…
+	Relight…	Yeniden aydınlat…
+	Picture Frame…	Resim Çerçevesi…
+	Tree…	Ağaç…
+	Sharpen	Keskinleştir
+	Sharpen Edges	Kenarları Keskinleştirin
+	Sharpen More	Daha Fazla Keskinleştir
+	Smart Sharpen…	Akıllı Keskinleştirme…
+	Unsharp Mask…	Keskinliği Azaltma Maskesi…
+	High Pass…	Yüksek Geçiş…
+	Stylize	Stilize Et
+	Diffuse…	Yaygın…
+	Emboss…	Kabartma…
+	Extrude…	Ekstrüzyon…
+	Find Edges	Kenarları Bul
+	Oil Paint…	Yağlı Boya…
+	Solarize	Solarizasyon
+	Tiles…	Fayans…
+	Trace Contour…	Konturu İzle…
+	Wind…	Rüzgar…
+	Video	video
+	De-Interlace…	Taramasızlaştırma…
+	NTSC Colors	NTSC Renkleri
+	Other	Diğer
+	Maximum…	Maksimum…
+	Minimum…	Asgari…
+	Offset…	Ofset…
+	Plug-ins	Eklentiler
+	Proof Setup	Prova Kurulumu
+	Proof Colors	Prova Renkleri
+	Gamut Warning	Gamut Uyarısı
+	Working CMYK	CMYK'de çalışıyor
+	Working Cyan Plate	Çalışan Camgöbeği Plaka
+	Working Magenta Plate	Çalışan Macenta Plaka
+	Working Yellow Plate	Sarı Plaka Çalışması
+	Working Black Plate	Siyah Plaka Çalışma
+	Working CMY Plate	Çalışan CMY Plakası
+	Legacy Macintosh RGB	Eski Macintosh RGB
+	Internet Standard RGB	İnternet Standardı RGB
+	Monitor RGB	RGB'yi izleyin
+	Color Blindness — Protanopia-type	Renk Körlüğü — Protanopi tipi
+	Color Blindness — Deuteranopia-type	Renk Körlüğü – Döteranopi tipi
+	Zoom In	Yakınlaştır
+	Zoom Out	Uzaklaştır
+	Fit on Screen	Ekrana Sığdır
+	Fit Layer(s) on Screen	Katmanları Ekrana Sığdır
+	Fit Artboard on Screen	Çalışma Yüzeyini Ekrana Sığdır
+	100%	100%
+	200%	200%
+	Print Size	Baskı Boyutu
+	Pixel Aspect Ratio	Piksel En Boy Oranı
+	Pixel Aspect Ratio Correction	Piksel En Boy Oranı Düzeltme
+	Custom Pixel Aspect Ratio…	Özel Piksel En Boy Oranı…
+	Square	Kare
+	D1/DV NTSC (0.91)	D1/DV NTSC (0,91)
+	D1/DV NTSC Widescreen (1.21)	D1/DV NTSC Geniş Ekran (1.21)
+	D1/DV PAL (1.09)	D1/DV PAL (1,09)
+	D1/DV PAL Widescreen (1.46)	D1/DV PAL Geniş Ekran (1,46)
+	Anamorphic 2:1 (2)	Anamorfik 2:1 (2)
+	HDV 1080/DVCPRO HD 720 (1.33)	HDV 1080/DVCPRO HD 720 (1,33)
+	DVCPRO HD 1080/HDV 1080 (1.5)	DVCPRO HD 1080/HDV 1080 (1,5)
+	32-bit Preview Options…	32-bit Önizleme Seçenekleri…
+	Screen Mode	Ekran Modu
+	Standard Screen Mode	Standart Ekran Modu
+	Full Screen Mode With Menu Bar	Menü Çubuklu Tam Ekran Modu
+	Full Screen Mode	Tam Ekran Modu
+	Cycle Screen Mode	Döngü Ekranı Modu
+	Show	Göster
+	Extras	Ekstralar
+	Selection Edges	Seçim Kenarları
+	Target Path	Hedef Yolu
+	Current Path	Geçerli Yol
+	Grid	Izgara
+	Guides	Kılavuzlar
+	Canvas Guides	Kanvas Kılavuzları
+	Artboard Guides	Çalışma Yüzeyi Kılavuzları
+	Count	Sayım
+	Smart Guides	Akıllı Kılavuzlar
+	Slices	Dilimler
+	Notes	Notlar
+	Pixel Grid	Piksel Izgarası
+	Pixel Art	Piksel Sanatı
+	Pixel Art Preview	Piksel Sanat Önizlemesi
+	Pattern Preview	Desen Önizlemesi
+	Brush Preview	Fırça Önizlemesi
+	Mesh	ağ
+	Edit Pins	Pinleri Düzenle
+	Document Bounds	Belge Sınırları
+	Show Extras Options…	Ekstra Seçeneklerini Göster…
+	Rulers	Cetveller
+	Snap	Yapış
+	Snap To	Şuna Yapış
+	Lock Guides	Kılavuzları Kilitle
+	Clear Guides	Kılavuzları Temizle
+	Clear Selected Artboard Guides	Seçilen Çalışma Yüzeyi Kılavuzlarını Temizle
+	Clear Canvas Guides	Şeffaf Kanvas Kılavuzları
+	New Guide…	Yeni Kılavuz…
+	Lock Slices	Dilimleri Kilitle
+	Clear Slices	Dilimleri Temizle
+	Match Zoom	Yakınlaştırmayı Eşleştir
+	Match Location	Eşleşme Konumu
+	Match Rotation	Maç Rotasyonu
+	Cascade	Çağlayan
+	Tile	Fayans
+	Tile All Horizontally	Tümünü Yatay Olarak Döşe
+	Tile All Vertically	Tümünü Dikey Olarak Döşe
+	2-up Horizontal	2'li Yatay
+	2-up Vertical	2'li Dikey
+	3-up Horizontal	3'lü Yatay
+	3-up Stacked	3'lü Yığılmış
+	3-up Vertical	3'lü Dikey
+	4-up	4'lü
+	6-up	6'lı
+	Consolidate All to Tabs	Tümünü Sekmelerde Birleştir
+	Float in Window	Pencerede Kaydır
+	Float All in Windows	Tümünü Windows'ta Kaydır
+	New Window for Document	Belge için Yeni Pencere
+	Workspace	Çalışma alanı
+	Essentials	Temel bilgiler
+	Graphic and Web	Grafik ve Web
+	Painting	Boyama
+	Photography	Fotoğrafçılık
+	New Workspace…	Yeni Çalışma Alanı…
+	Delete Workspace…	Çalışma Alanını Sil…
+	Reset Workspace	Çalışma Alanını Sıfırla
+	Reset Tool	Aracı Sıfırla
+	Reset All Tools	Tüm Araçları Sıfırla
+	Reset all tools to their default settings?	Tüm araçlar varsayılan ayarlarına sıfırlansın mı?
+	Lock Workspace	Çalışma Alanını Kilitle
+	Theme	Tema
+	Pro Theme	Profesyonel Tema
+	Pro Medium Gray Theme	Pro Orta Gri Tema
+	Pro Light Gray Theme	Pro Açık Gri Tema
+	Pro Light Theme	Profesyonel Işık Teması
+	Studio Theme	Stüdyo Teması
+	Studio Light Theme	Stüdyo Işık Teması
+	Classic Theme	Klasik Tema
+	Solarized dark	Solarize karanlık
+	Solarized Dark Theme	Solarize Karanlık Tema
+	Breeze dark	Esinti karanlık
+	Breeze Dark Theme	Esinti Koyu Tema
+	Breeze light	Esinti ışığı
+	Breeze Light Theme	Esinti Işık Teması
+	Soft dark	Yumuşak koyu
+	Soft light	Yumuşak açık
+	Soft Dark Theme	Yumuşak koyu tema
+	Soft Light Theme	Yumuşak açık tema
+	Adwaita Light Theme	Adwaita Işık Teması
+	Adwaita Dark Theme	Adwaita Karanlık Tema
+	Adwaita	Adwaita
+	Adwaita dark	Adwaita karanlık
+	Next Theme	Sonraki Tema
+	Actions	Eylemler
+	Brush Settings	Fırça Ayarları
+	Brushes	Fırçalar
+	Channels	Kanallar
+	Character	Karakter
+	Character Styles	Karakter Stilleri
+	Clone Source	Klon Kaynağı
+	Color	Renk
+	Glyphs	Glifler
+	Gradients	Degradeler
+	Histogram	Histogram
+	History	Tarih
+	Info	Bilgi
+	Measurement Log	Ölçüm Günlüğü
+	Modifier Keys	Değiştirici Tuşlar
+	Navigator	Gezgin
+	Options	Seçenekler
+	Paragraph	Paragraf
+	Paragraph Styles	Paragraf Stilleri
+	Paths	Yollar
+	Patterns	Desenler
+	Properties	Özellikler
+	Shapes	Şekiller
+	Styles	Stiller
+	Swatches	Renk Örnekleri
+	Timeline	Zaman çizelgesi
+	Tool Presets	Araç Ön Ayarları
+	Tools	Araçlar
+	About PhotoCraft	PhotoCraft Hakkında
+	PhotoCraft Website	PhotoCraft Web Sitesi
+	PhotoCraft on GitHub	GitHub'da PhotoCraft
+	ArtCraft Website	ArtCraft Web Sitesi
+	Join the ArtCraft Discord…	ArtCraft Discord'una katılın…
+	Report an Issue…	Bir Sorun Bildirin…
+	WIA Support…	WIA Desteği…
+	Apply	Uygula
+	HSB/HSL	HSB/HSL
+	Invert…	Ters çevir…
+	Load Files into Stack…	Dosyaları Yığına Yükle…
+	Motion	Hareket
+	Notes…	Notlar…
+	Other…	Diğer…
+	Remove Warp Split	Warp Split'i Kaldır
+	Shape	Şekil
+	Split Warp Crosswise	Çözgüyü Çapraz Olarak Böl
+	Split Warp Horizontally	Çözgüyü Yatay Olarak Böl
+	Split Warp Vertically	Çözgüyü Dikey Olarak Böl
+	Statistics…	İstatistikler…
+	Refine Strokes	Konturları İyileştir
+@plural	{n} item|{n} items	{n} öğe
+	Auto	Otomatik
+	(print to the printer)	(yazıcıya yazdırın)
+	+ Add variable	+ Değişken ekle
+	30 frames @ 30 fps	30 kare @ 30 fps
+	3D LUT File	3D LUT Dosyası
+	Absolute	Mutlak
+	Absolute Colorimetric	Mutlak Kolorimetrik
+	Action	Eylem
+	Adaptive	Uyarlanabilir
+	Adaptive Wide Angle isn't open	Uyarlanabilir Geniş Açı açık değil
+	Add	Ekle
+	Add Layer Mask	Katman Maskesi Ekle
+	Add Stop	Durak Ekle
+	Add a layer style	Katman stili ekleme
+	Add a mask  (from the selection; {key} inverts)	Bir maske ekleyin (seçimden; {key} tersine çevirir)
+	Add an adjustment	Düzenleme ekle
+	Add disk	Disk ekle
+	Add space after paragraph	Paragraftan sonra boşluk ekle
+	Add space before paragraph	Paragraftan önce boşluk ekleyin
+	Add to Sample	Örneğe Ekle
+	Add to selection  ({key})	Seçime ekle ({key})
+	Adjust for Zoom	Yakınlaştırma için Ayarlama
+	Adjustment visible	Ayar görünür
+	Adobe RGB (1998) compatible	Adobe RGB (1998) uyumlu
+	Align and Distribute	Hizala ve Dağıt
+	Align and distribute	Hizala ve dağıt
+	Align horizontal centers	Yatay merkezleri hizalayın
+	Align left edges	Sol kenarları hizala
+	Align right edges	Sağ kenarları hizalayın
+	Aligned	Hizalı
+	All Caps	Tamamı Büyük Harf
+	All Slices	Tüm Dilimler
+	All User Slices	Tüm Kullanıcı Dilimleri
+	All shortcuts reset to PhotoCraft defaults.	Tüm kısayollar PhotoCraft varsayılanlarına sıfırlanır.
+	Alt	Alternatif
+	Always use pressure for opacity	Opaklık için her zaman baskıyı kullanın
+	Always use pressure for size	Her zaman boyuta göre baskı kullanın
+	Amount	Miktar
+	Anchor:	Çapa:
+	Angle	Açı
+	Angle Gradient	Açı Gradyanı
+	Angle Jitter	Açı Değişimi
+	Answer the unsaved-changes prompt first	Önce kaydedilmemiş değişiklikler istemini yanıtlayın
+	Anti-alias	Kenar yumuşatma
+	Appearance	Görünüm
+	Appearance (Layer Style)	Görünüm (Katman Stili)
+	Apply Layer Mask	Katman Maskesini Uygula
+	Add Mask to Selection	Maskeyi Seçime Ekle
+	Subtract Mask from Selection	Maskeyi Seçimden Çıkar
+	Intersect Mask with Selection	Maskeyi Seçimle Kesiştir
+	Apply Per Tip	İpucu Başına Uygula
+	Apply next selected layer comp	Sonraki seçilen katman kompozisyonunu uygula
+	Apply previous selected layer comp	Önceki seçilen katman kompozisyonunu uygula
+	Artboard	Çalışma yüzeyi
+	Artboard Background Color	Çalışma Yüzeyi Arka Plan Rengi
+	Assign working space	Çalışma alanı atayın
+	Author:	Yazar:
+	Auto Hide	Otomatik Gizle
+	Auto-Select:	Otomatik Seç:
+	Automatically level near-horizontal line segments	Yataya yakın çizgi bölümlerini otomatik olarak hizalayın
+	Automatically straighten and level	Otomatik olarak düzeltin ve seviyelendirin
+	Automatically straighten near-vertical line segments	Dikeye yakın çizgi bölümlerini otomatik olarak düzelt
+	Background	Arka plan
+	Background Color	Arka Plan Rengi
+	Background Contents	Arka Plan İçeriği
+	Custom background color	Özel Arka Plan Rengi
+	Balance	Bakiye
+	Baseline	Temel
+	Baseline shift	Taban çizgisi kayması
+	Basic	Temel
+	Before (Y)	Önce (Y)
+	Begin recording	Kaydı başlat
+	Bend:	Bükülme:
+	Bicubic	Bikübik
+	Bicubic (smooth gradients)	Bikübik (düzgün degradeler)
+	Bicubic Smoother (enlargement)	Bikübik Pürüzsüzleştirici (büyütme)
+	Bicubic Sharper (reduction)	Bikübik Daha Keskin (azaltma)
+	Bilinear	Çift doğrusal
+	Black	Siyah
+	Black & White	Siyah Beyaz
+	Black Point Compensation	Kara Nokta Telafisi
+	Black, White	Siyah, Beyaz
+	Blacks	Siyahlar
+	Blending	Karıştırma
+	Blending Options	Karıştırma Seçenekleri
+	Blue	Mavi
+	Blue, Red, Yellow	Mavi, Kırmızı, Sarı
+	Both Axes	Her İki Eksen
+	Bottom	Alt
+	Brightness	Parlaklık
+	Brightness Jitter	Parlaklık Değişimi
+	Brightness/Contrast	Parlaklık/Kontrast
+	Bring the selected pin forward	Seçilen pini öne getir
+	Brush Preset picker	Fırça Ön Ayarı seçici
+	Brush Reconstruct Options	Fırçayla Yeniden Yapılandırma Seçenekleri
+	Brush Tool Options	Fırça Aracı Seçenekleri
+	Cache Level:	Önbellek Düzeyi:
+	Camera Raw isn't open	Camera Raw açık değil
+	Cancel	İptal
+	Reset	Sıfırla
+	Cancel (Esc)	İptal (Esc)
+	Manage submitted jobs in the system print queue	Gönderilen işleri sistem yazdırma kuyruğunda yönetin
+	Cancel any current edits (Esc)	Mevcut düzenlemeleri iptal et (Esc)
+	Cancel current crop operation  (Esc)	Geçerli kırpma işlemini iptal et (Esc)
+	Cancel transform (Esc)	Dönüşümü iptal et (Esc)
+	Cancel warp (Esc)	Çözgüyü iptal et (Esc)
+	Canvas	Kanvas
+	Canvas extension color:	Kanvas uzatma rengi:
+	Capture	Yakala
+	Capture the visibility, position and style of every layer with + below, then switch between versions.	Aşağıdaki + ile her katmanın görünürlüğünü, konumunu ve stilini yakalayın, ardından sürümler arasında geçiş yapın.
+	Catch-up on Stroke End	Strok Sonunda Yakalama
+	Center	Merkez
+	Center Crop Marks	Orta Kırpma İşaretleri
+	Center text	Metni ortala
+	Change	Değiştir
+	Change All	Tümünü Değiştir
+	Change Screen Mode  (F)	Ekran Modunu Değiştir (F)
+	Change To:	Şuna Değiştir:
+	Channel Mixer	Kanal Mikseri
+	Channel:	Kanal:
+	Check All Layers	Tüm Katmanları Kontrol Et
+	Check Spelling	Yazımı Kontrol Et
+	Clarity	Netlik
+	Clear All	Tümünü Temizle
+	Clear Override	Geçersiz Kılmayı Temizle
+	Clear Samples	Örnekleri Temizle
+	Click sets foreground · right-click sets background	Ön planı ayarlar'a tıklayın · arka planı sağ tıklayın
+	Click the first point or press {key} to close · Esc cancels	Kapatmak için ilk noktayı tıklayın veya {key} tuşuna basın · Esc iptal eder
+	Click to add a point · drag off or {key}-click or Delete to remove	Nokta eklemek için tıklayın · sürükleyin veya {key} tuşuna basıp tıklayın veya kaldırmak için Sil
+	Click to apply, {key}-click to clear overrides, double-click for Style Options	Uygulamak için tıklayın, geçersiz kılmaları temizlemek için {key}-tıklayın, Stil Seçenekleri için çift tıklayın
+	Click to edit the gradient	Degradeyi düzenlemek için tıklayın
+	Click to restore the current colour	Mevcut rengi geri yüklemek için tıklayın
+	Click to zoom in  ·  {key}-click to zoom out  ·  drag right/left to zoom in/out	Yakınlaştırmak için tıklayın · {key}-uzaklaştırmak için tıklayın · yakınlaştırmak/uzaklaştırmak için sağa/sola sürükleyin
+	Click with the Note tool to add a note.	Not eklemek için Not aracıyla tıklayın.
+	Click: corner · Drag: smooth · Click first point: close · {key} finish · Esc cancel	Tıklayın: köşe · Sürükleyin: pürüzsüz · İlk noktaya tıklayın: kapat · {key} bitiş · Esc iptal
+	Click: corner · Drag: smooth · {alt}-drag: break handle · Click or drag first point: close · {key} finish · Esc cancel	Tıklayın: köşe · Sürükleyin: pürüzsüz · {alt}-sürükleyin: tutamacı kırın · İlk noktayı tıklayın veya sürükleyin: kapat · {key} bitiş · Esc iptal
+	Clip to layer below	Aşağıdaki katmana klip
+	Clipped	Kırpılmış
+	Close Style Options	Stil Seçeneklerini Kapat
+	Cmd	Komut
+	Coated CMYK	Kaplamalı CMYK
+	Color & Swatches	Renk ve Renk Örnekleri
+	Color Balance	Renk Dengesi
+	Color Detail	Renk Detayı
+	Color Grading	Renk Derecelendirmesi
+	Color Lookup	Renk Arama
+	Color Management	Renk Yönetimi
+	Color Mixer	Renk Karıştırıcı
+	Color Mode	Renk Modu
+	Color Priority	Renk Önceliği
+	Color Range preview	Renk Aralığı önizlemesi
+	Color:	Renk:
+	Colorize	Renklendir
+	Colors	Renkler
+	Commit Perspective Warp ({key})	Perspektif Çarpıtma İşlemi ({key})
+	Commit Puppet Warp ({key})	Kukla Çarpıtma İşlemi ({key})
+	Commit any current edits ({key})	Mevcut düzenlemeleri tamamlayın ({key})
+	Commit current crop operation  ({key})	Geçerli kırpma işlemini gerçekleştir ({key})
+	Commit transform ({key})	Dönüşümü kaydet ({key})
+	Commit warp ({key})	Çözgü gerçekleştir ({key})
+	Constant	Sabit
+	Constrain proportions	Oranları sınırla
+	Contact Sheet II	İletişim Sayfası II
+	Content-Aware	İçeriğe Duyarlı
+	Contiguous	Bitişik
+	Contrast	Kontrast
+	Control:	Kontrol:
+	Convert document's colors to the working space	Belgenin renklerini çalışma alanına dönüştürün
+	Convert to sRGB	sRGB'ye dönüştür
+	Copies	Kopyalar
+	Copper	Bakır
+	Copyright	Telif hakkı
+	Copyright and Contact Info	Telif Hakkı ve İletişim Bilgileri
+	Corner Crop Marks	Köşe Kırpma İşaretleri
+	Corner radius	Köşe yarıçapı
+	Correction	Düzeltme
+	Count Jitter	Titreşimi say
+	Create	Oluştur
+	Create Droplet	Damlacık Oluştur
+	Create Texture	Doku Oluştur
+	Create Video Timeline	Video Zaman Çizelgesi Oluşturun
+	Create a new count group	Yeni bir sayım grubu oluşturun
+	Create a new document or open an existing file.	Yeni bir belge oluşturun veya mevcut bir dosyayı açın.
+	Create a new group	Yeni bir grup oluştur
+	Create a new layer	Yeni bir katman oluştur
+	Create new action	Yeni eylem oluştur
+	Create new channel	Yeni kanal oluştur
+	Create new document from current state	Mevcut durumdan yeni belge oluştur
+	Create new fill or adjustment layer	Yeni dolgu veya ayarlama katmanı oluştur
+	Create new gradient	Yeni degrade oluştur
+	Create new group	Yeni grup oluştur
+	Create new layer comp	Yeni katman kompozisyonu oluştur
+	Create new pattern from the selection	Seçimden yeni desen oluştur
+	Create new shape from the current path	Geçerli yoldan yeni şekil oluştur
+	Create new snapshot	Yeni anlık görüntü oluştur
+	Create new style (from the selected type)	Yeni stil oluştur (seçilen türden)
+	Create new style from the selected layer	Seçilen katmandan yeni stil oluştur
+	Create new tool preset	Yeni araç ön ayarı oluştur
+	Crop Factor	Mahsul Faktörü
+	Ctrl	Ctrl
+	Current & Below	Güncel ve Aşağıda
+	Current Layer	Geçerli Katman
+	Current Size	Mevcut Boyut
+	Current Tool Only	Yalnızca Geçerli Araç
+	Curve	Eğri
+	Curves	Eğriler
+	Custom	Özel
+	Custom Shapes	Özel Şekiller
+	Cyan	Camgöbeği
+	Cyan  ·  Red	Camgöbeği · Kırmızı
+	Darken	Koyulaştır
+	Darks	Karanlıklar
+	Data Sets	Veri Setleri
+	Default	Varsayılan
+	Default colours (D)	Varsayılan renkler (D)
+	Default printer	Varsayılan yazıcı
+	Default restored.	Varsayılan geri yüklendi.
+	Define	Tanımla
+	Define at least one variable first.	İlk önce en az bir değişken tanımlayın.
+	Dehaze	Buğu giderme
+	Delete Cropped Pixels	Kırpılmış Pikselleri Sil
+	Delete Group	Grubu Sil
+	Delete Layer Mask	Katman Maskesini Sil
+	Delete Layers	Katmanları Sil
+	Delete Shortcut	Kısayolu Sil
+	Delete Timeline	Zaman Çizelgesini Sil
+	Delete Tool Preset	Araç Ön Ayarını Sil
+	Delete count group	Sayım grubunu sil
+	Delete current channel	Mevcut kanalı sil
+	Delete current state	Mevcut durumu sil
+	Delete effect layer	Efekt katmanını sil
+	Delete layer ‘{name}’?	'{name}' katmanı silinsin mi?
+	Delete {count} layers? {names}	{count} katman silinsin mi? {names}
+	Delete layer?	Katman silinsin mi?
+	The document is closed	Belge kapatıldı
+	The document or selected layers changed. Please request deletion again.	Belge veya seçilen katmanlar değişti. Lütfen tekrar silme talebinde bulunun.
+	Missing delete command	Silme komutu eksik
+	Invalid delete command	Geçersiz silme komutu
+	Layer deleted, but confirmation preference could not be saved: {error}	Katman silindi ancak onay tercihi kaydedilemedi: {error}
+	Delete layer	Katmanı sil
+	Delete layer comp	Katman kompozisyonunu sil
+	Delete note	Notu sil
+	Delete selected measurements	Seçilen ölçümleri sil
+	Delete style	Stili sil
+	Delete tool preset	Araç ön ayarını sil
+	Density	Yoğunluk
+	Density:	Yoğunluk:
+	Depth	Derinlik
+	Depth Jitter	Derinlik Değişimi
+	Description	Açıklama
+	Deselect All	Tümünün Seçimini Kaldır
+	Detail	Detay
+	Diamond Gradient	Elmas Degrade
+	Difference	Fark
+	Diffusion	Difüzyon
+	Discard the embedded profile (don't color manage)	Gömülü profili atın (renk yönetimi yapmayın)
+	Discontiguous	bitişik değil
+	Discord	Discord
+	Dismiss	Reddet
+	Display P3	Display P3
+	Display Text	Metni Görüntüle
+	Dither	Titreşim
+	Divide…	Böl…
+	Document	Belge
+	Don't Save	Kaydetme
+	No	Hayır
+	Yes	Evet
+	Done	Bitti
+	Dots	Noktalar
+	Drag a rectangle around the object	Nesnenin çevresine bir dikdörtgen sürükleyin
+	Drag on the image to add a constraint; Shift for horizontal/vertical; right-click to delete.	Kısıtlama eklemek için resmin üzerine sürükleyin; Yatay/dikey için kaydırma; silmek için sağ tıklayın.
+	Drag to move the active shape's path or the Work Path	Etkin şeklin yolunu veya Çalışma Yolunu taşımak için sürükleyin
+	Click: select anchor · Drag: move anchor, handle or segment · {shift}-click: add · {alt}-click: whole subpath	Tıklayın: çapayı seçin · Sürükleyin: çapayı, tutamacı veya parçayı taşıyın · {shift}-tıklayın: ekleyin · {alt}-tıklayın: alt yolun tamamı
+	Draw with the Pen tool (P) or make a work path from a selection.	Kalem aracıyla (P) çizim yapın veya seçimden bir çalışma yolu oluşturun.
+	Drop an image or PSD anywhere to open it.	Açmak için bir görüntüyü veya PSD'yi herhangi bir yere bırakın.
+	Native file drag-and-drop is unavailable	Yerel dosya sürükle ve bırak özelliği kullanılamıyor
+	Native file drag-and-drop is not supported on Wayland yet. Use File › Open, or copy the image in your file manager and paste it with {paste}.	Yerel dosya sürükle ve bırak özelliği henüz Wayland'de desteklenmiyor. Dosyayı Kullan › Aç veya resmi dosya yöneticinize kopyalayıp {paste} ile yapıştırın.
+	To drop files, start PhotoCraft under XWayland: `{command}`	Dosyaları bırakmak için XWayland altında PhotoCraft'ı başlatın: `{command}`
+	Or set Preferences › Performance › Linux display server to X11: PhotoCraft then always starts under XWayland.	Veya Tercihler › Performans › Linux görüntüleme sunucusunu X11: PhotoCraft olarak ayarlayın, ardından her zaman XWayland altında başlar.
+	Edit › Paste	Düzenle › Yapıştır
+	Duplicate Layers…	Katmanları Çoğalt…
+	Duplicate style	Yinelenen stil
+	Edit Toolbar…	Araç Çubuğunu Düzenle…
+	Use File › Open, or paste a copied image with {paste}.	Dosya › Aç'ı kullanın veya kopyalanan görüntüyü {paste} ile yapıştırın.
+	Edit in Quick Mask Mode  (Q)	Hızlı Maske Modunda Düzenleme (Q)
+	Edit in Standard Mode  (Q)	Standart Modda Düzenleme (Q)
+	Effects	Efektler
+	Embed Color Profile	Renk Profilini Göm
+	Embedded Profile Mismatch	Gömülü Profil Uyuşmazlığı
+	Enable airbrush-style build-up effects	Airbrush stili oluşturma efektlerini etkinleştirin
+	Enhance Edge	Kenarı Geliştir
+	Entire Font	Yazı Tipinin Tamamı
+	Exact	tam
+	Expansion:	Genişleme:
+	Export Presets	Ön Ayarları Dışa Aktarma
+	Export selected measurements (CSV)	Seçilen ölçümleri dışa aktar (CSV)
+	Exposure	Pozlama
+	Exposure and Gamma	Pozlama ve Gama
+	Exposure:	Pozlama:
+	Eyedropper	Damlalık
+	Factor:	Faktör:
+	Faux Bold	Sahte Kalın
+	Faux Italic	Sahte İtalik
+	Feather	Tüy
+	Fewer Points	Daha Az Puan
+	File Settings	Dosya Ayarları
+	Fill	Doldur
+	Fill:	Doldurun:
+	Filter for adjustment layers	Ayarlama katmanları için filtre
+	Filter for pixel layers	Piksel katmanları için filtre
+	Filter for shape layers	Şekil katmanları için filtre
+	Filter for smart objects	Akıllı nesneler için filtre
+	Filter for type layers	Yazım katmanları için filtre
+	Filter:	Filtre:
+	Finger Painting	Parmak Boyama
+	Fisheye	Balıkgözü
+	Fit	Uygun
+	Fit Screen	Ekrana Sığdır
+	Fill Screen	Doldurma Ekranı
+	Fit in View	Görünüme Sığdır
+	Fixed	Sabit
+	Fixed Ratio	Sabit Oran
+	Fixed Size	Sabit Boyut
+	Flip	Çevir
+	Flip X	X'i Çevir
+	Flip X Jitter	X Değişimini Çevir
+	Flip Y	Y Çevirme
+	Flip Y Jitter	Çevir Y Titreşimi
+	Flow	Akış
+	Flow Jitter	Akış Değişimi
+	Focal Length	Odak Uzunluğu
+	Font	Yazı tipi
+	Font Size:	Yazı Tipi Boyutu:
+	Font size	Yazı tipi boyutu
+	Foreground	Ön plan
+	Foreground to Background	Ön Plandan Arka Plana
+	Foreground/Background Jitter	Ön Plan/Arka Plan Değişimi
+	Format	Biçim
+	Frame from Layers…	Katmanlardan Çerçeve…
+	Free	Ücretsiz
+	Full Spherical	Tam Küresel
+	Fuzziness:	Bulanıklık:
+	GPU	GPU
+	Gamma Correction	Gama Düzeltmesi
+	Gamma:	Gama:
+	Global	Küresel
+	Glow Color	Parıltılı Renk
+	Gradient Map	Gradyan Haritası
+	Grain	Tahıl
+	Gray	Gri
+	Gray Gamma 2.2	Gri Gama 2.2
+	Green	Yeşil
+	Group	Grup
+	Hardness	Sertlik
+	Heart	Kalp
+	Height	Yükseklik
+	Height:	Yükseklik:
+	Hide Auto Slices	Otomatik Dilimleri Gizle
+	Hide Properties	Özellikleri Gizle
+	Highlight Compression	Sıkıştırmayı Vurgula
+	Highlight Priority	Önceliği Vurgula
+	Highlights	Öne Çıkanlar
+	Home	Ana sayfa
+	Horizontal scale	Yatay ölçek
+	Hue	Renk Tonu
+	Hue Jitter	Ton Değişimi
+	Hue/Saturation	Ton/Doygunluk
+	Hyphenate	Tireleme
+	Ignore	Yoksay
+	Ignore All	Tümünü Yoksay
+	Image Size	Resim Boyutu
+	Import Brushes…	Fırçaları İçe Aktar…
+	Import brushes (.abr)	Fırçaları içe aktar (.abr)
+	Import Presets	Ön Ayarları İçe Aktar
+	Imported	İthal
+	Indent First	Önce Girintiyi Girin
+	Indent Left	Sola Girinti
+	Indent Right	Sağa Girinti
+	Indent first line	İlk satıra girinti koy
+	Indent left margin	Sol kenar boşluğunu girintile
+	Indent right margin	Sağ kenar boşluğuna girinti
+	Input:	Giriş:
+	Inside	İçeride
+	Interlaced	Taramalı
+	Interpolation:	Enterpolasyon:
+	Intersect with selection  ({key})	Seçimle kesiştir ({key})
+	Invert All	Tümünü Ters Çevir
+	Invert has no settings.	Tersine çevirmenin hiçbir ayarı yoktur.
+	Italic	italik
+	Join us on Discord	Discord'da bize katılın
+	Justify all	Hepsini gerekçelendir
+	Justify last centered	Son ortayı iki yana yasla
+	Justify last left	Son sola yasla
+	Justify last right	Son sağa yasla
+	Kerning	Karakter Aralığı
+	Keyboard Shortcuts	Klavye Kısayolları
+	Keyboard Shortcuts and Menus	Klavye Kısayolları ve Menüler
+	Kind	tür
+	Label Size	Etiket Boyutu
+	Labels	Etiketler
+	Lanczos (sharp)	Lanczos (keskin)
+	Landscape	Manzara
+	Last Document State	Son Belge Durumu
+	Layout	Düzen
+	Leading	Lider
+	Leading (set to the font size × auto-leading when Auto)	Satır Aralığı (Otomatik olduğunda yazı tipi boyutu × otomatik satır aralığına ayarlanır)
+	Leave as is (don't color manage)	Olduğu gibi bırakın (renk yönetimi yapmayın)
+	Left align text	Metni sola hizala
+	Length:	Uzunluk:
+	Level	Seviye
+	Levels	Seviyeler
+	Lighten	Açıklaştır
+	Lightness	hafiflik
+	Lights	Işıklar
+	Limits:	Sınırlar:
+	Linear Gradient	Doğrusal Degrade
+	Link layers	Katmanları bağlayın
+	Link width and height	Bağlantı genişliği ve yüksekliği
+	Liquify is not open	Sıvılaştırma açık değil
+	Load	Yükle
+	Load 3D LUT…	3D LUT'u yükleyin…
+	Load channel as selection	Kanalı seçim olarak yükle
+	Load…	Yükle…
+	Localized Color Clusters	Yerelleştirilmiş Renk Kümeleri
+	Lock	Kilit
+	Lock all	Tümünü kilitle
+	Lock image pixels	Resim piksellerini kilitle
+	Lock layer	Katmanı kilitle
+	Lock position	Kilit konumu
+	Lock transparent pixels	Şeffaf pikselleri kilitle
+	Lock:	Kilit:
+	Logical Length:	Mantıksal Uzunluk:
+	Logical Units:	Mantıksal Birimler:
+	Luminance	parlaklık
+	Luminance Detail	Parlaklık Detayı
+	Magenta	Macenta
+	Magenta  ·  Green	Macenta · Yeşil
+	Maintain aspect ratio	En boy oranını koru
+	Marker Size	İşaretleyici Boyutu
+	Mask All	Tümünü Maskele
+	Mask Options	Maske Seçenekleri
+	Masking	Maskeleme
+	Master	Usta
+	Matte	Mat
+	Median:	Medyan:
+	Menus	Menüler
+	Mesh Size	Örgü Boyutu
+	Metadata	Meta veriler
+	Metrics	Metrikler
+	Midpoint	Orta nokta
+	Midtones	Orta tonlar
+	Midtones from:	Orta tonlar:
+	Midtones to:	Orta tonlar:
+	Minimum Depth	Minimum Derinlik
+	Minimum Diameter	Minimum Çap
+	Minimum Roundness	Minimum Yuvarlaklık
+	Mode:	Mod:
+	Monochrome	Tek renkli
+	More Points	Daha Fazla Puan
+	Move effect layer down	Efekt katmanını aşağı taşı
+	Move effect layer up	Efekt katmanını yukarı taşı
+	Move to	Şuraya taşı:
+	Name	Ad
+	Name:	Ad:
+	Nearest Neighbor	En Yakın Komşu
+	Nearest Neighbor (hard edges)	En Yakın Komşu (sert kenarlar)
+	New Size	Yeni Boyut
+	New document…	Yeni belge…
+	New effect layer	Yeni efekt katmanı
+	New selection	Yeni seçim
+	Next frame	Sonraki kare
+	Next note	Sonraki not
+	No Color	Renk Yok
+	No Color Management	Renk Yönetimi Yok
+	No Dither	Titreşim Yok
+	No author	Yazar yok
+	No character style	Karakter stili yok
+	No document	Belge yok
+	No matching commands	Eşleşen komut yok
+	No presets for the current tool.	Geçerli araç için ön ayar yok.
+	No presets of this type.	Bu türden ön ayar yok.
+	No properties	Mülk yok
+	No tool presets.	Araç ön ayarı yok.
+	Noise Reduction	Gürültü Azaltma
+	Normal	Normal
+	Not in Dictionary:	Sözlükte Yok:
+	OK	Tamam
+	Offset	Ofset
+	Only Web Colors	Yalnızca Web Renkleri
+	Opacity	Opaklık
+	Opacity Jitter	Opaklık Değişimi
+	Opacity:	Opaklık:
+	Open a document to define variables.	Değişkenleri tanımlamak için bir belge açın.
+	Open a document to select a colour range.	Bir renk aralığı seçmek için bir belge açın.
+	Open a document to use the timeline.	Zaman çizelgesini kullanmak için bir belge açın.
+	Optical	Optik
+	Optimized	Optimize edilmiş
+	Option-click to define a source point to clone from	Kopyalanacak bir kaynak noktası tanımlamak için Option tuşunu basılı tutarak tıklayın
+	Original	Orijinal
+	Output Channel:	Çıkış Kanalı:
+	Output Levels:	Çıkış Seviyeleri:
+	Output:	Çıkış:
+	Outside	Dışarıda
+	Overlay Color	Kaplama Rengi
+	Overlay Opacity	Kaplama Opaklığı
+	Overlay: Rule of Thirds	Kaplama: Üçte Bir Kuralı
+	Override Pressure	Basıncı Geçersiz Kıl
+	Override Rotation	Döndürmeyi Geçersiz Kıl
+	Override Tilt	Eğimi Geçersiz Kıl
+	PRESET DETAILS	ÖN AYAR DETAYLARI
+	PSD	PSD
+	Paint Overlay	Boya Kaplaması
+	Panel locations are saved in the workspace. Keyboard shortcuts, menus and toolbar are optional.	Panel konumları çalışma alanına kaydedilir. Klavye kısayolları, menüler ve araç çubuğu isteğe bağlıdır.
+	Paper	Kağıt
+	Path	Yol
+	Pattern	Desen
+	Pattern Size	Desen Boyutu
+	Pause	Duraklat
+	Percent	Yüzde
+	Perceptual	algısal
+	Perspective Warp is not active	Perspektif Çarpıtma etkin değil
+	Perspective Warp: draw planes along the image's perspective, then switch to Warp	Perspektif Çarpıtma: görüntünün perspektifi boyunca düzlemler çizin, ardından Çarpıtma'ya geçin
+	Photo Filter	Fotoğraf Filtresi
+	PhotoCraft	PhotoCraft
+	PhotoCraft Manages Colors	PhotoCraft Renkleri Yönetir
+	PhotoCraft — an open-source, native image editor written in Rust.	PhotoCraft — Rust'ta yazılmış açık kaynaklı, yerel bir resim düzenleyici.
+	Pin Depth:	Pim Derinliği:
+	Pixel Length:	Piksel Uzunluğu:
+	Pixels/Centimeter	Piksel/Santimetre
+	Pixels/Inch	Piksel/İnç
+	Pixels:	Piksel:
+	Play	Oyna
+	Play selection	Seçimi oynat
+	Portrait	Portre
+	Position	Pozisyon
+	Position and Size	Konum ve Boyut
+	Posterize	Posterleştir
+	Preserve Details	Ayrıntıları Koru
+	Preserve Luminosity	Parlaklığı Koru
+	Preset	Ön ayar
+	Preset Type	Ön Ayar Türü
+	Preset:	Ön ayar:
+	Presets:	Ön ayarlar:
+	Press keys…	Tuşlara basın…
+	Pressure	Basınç
+	Pressure for Opacity	Opaklık Basıncı
+	Pressure for Size	Boyuta Göre Basınç
+	Prevent auto-nesting in and out of Artboards and Frames	Çalışma Yüzeyleri ve Çerçevelerin içine ve dışına otomatik yerleştirmeyi önleyin
+	Preview	Önizleme
+	Previous frame	Önceki çerçeve
+	Previous note	Önceki not
+	Print	Yazdır
+	Printer	Yazıcı
+	Printer Manages Colors	Yazıcı Renkleri Yönetir
+	Printer Setup	Yazıcı Kurulumu
+	Printing Marks	Baskı İşaretleri
+	Progressive	Aşamalı
+	Promote	Tanıt
+	Protect Detail	Detayı Koruyun
+	Protect Foreground Color	Ön Plan Rengini Koruyun
+	Protect Tones	Tonları Koruyun
+	Proximity Match	Yakınlık Eşleşmesi
+	Pulled String Mode	Çekilmiş Dize Modu
+	Puppet Warp is not active	Kukla Çarpıtma etkin değil
+	Purity	saflık
+	Quality	Kalite
+	Quick Actions	Hızlı Eylemler
+	Quick Export As PNG	PNG Olarak Hızlı Dışa Aktarma
+	Radial Gradient	Radyal Gradyan
+	Radius	Yarıçap
+	Radius:	Yarıçap:
+	Range:	Aralık:
+	Rate	Oran
+	Recently Used	Son Kullanılanlar
+	Reconstruct	Yeniden inşa et
+	Record ● a sequence of edits, then play ▶ it on any document.	Bir dizi düzenlemeyi kaydedin ● ve ardından herhangi bir belgede oynatın.
+	Red	Kırmızı
+	Redefine style by current selection	Stili geçerli seçime göre yeniden tanımlayın
+	Refine	Hassaslaştır
+	Reflected Gradient	Yansıyan Degrade
+	Registration Marks	Tescil İşaretleri
+	Regular	Düzenli
+	Relative	akraba
+	Relative Colorimetric	Bağıl Kolorimetrik
+	Remove	Kaldır
+	Remove All Pins	Tüm Pinleri Kaldır
+	Remove Background	Arka Planı Kaldır
+	Remove Planes	Uçakları Kaldır
+	Remove stop	Durağı kaldır
+	Remove variable	Değişkeni kaldır
+	Rename	Yeniden adlandır
+	Rename Group…	Grubu Yeniden Adlandır…
+	Rename Layer…	Katmanı Yeniden Adlandır…
+	Rename Tool Preset…	Araç Ön Ayarını Yeniden Adlandır…
+	Rename…	Yeniden adlandır…
+	Resample	Yeniden örnekle
+	Reset All to Defaults	Tümünü Varsayılanlara Sıfırla
+	Import Shortcuts…	Kısayolları İçe Aktar…
+	Load a keyboard shortcut set saved as .kys	.kys olarak kaydedilen bir klavye kısayolu kümesi yükleyin
+	Imported {n} shortcuts from {file}. Click OK to keep them.	{n} kısayolları {file} adresinden içe aktarıldı. Bunları saklamak için Tamam'ı tıklayın.
+	{n} commands are not in PhotoCraft.	{n} komutları PhotoCraft'ta değil.
+	Keyboard shortcuts imported	İçe aktarılan klavye kısayolları
+	Your keyboard shortcut set {set} is in use here: {n} shortcuts differ from the defaults. Edit › Keyboard Shortcuts shows them; Reset All to Defaults undoes this.	{set} klavye kısayol grubunuz burada kullanılıyor: {n} kısayolları varsayılanlardan farklı. Düzenle › Klavye Kısayolları bunları gösterir; Tümünü Varsayılanlara Sıfırla bu işlemi geri alır.
+	Import keyboard shortcuts?	Klavye kısayolları içe aktarılsın mı?
+	PhotoCraft found your keyboard shortcut set {set} from another image editor on this computer: {n} of its shortcuts differ from PhotoCraft's. Import it?	PhotoCraft, {set} klavye kısayol setinizi bu bilgisayardaki başka bir resim düzenleyicide buldu: {n} kısayolları PhotoCraft'ınkilerden farklı. İçe aktarılsın mı?
+	Edit › Keyboard Shortcuts › Reset All to Defaults undoes an import.	Düzenle › Klavye Kısayolları › Tümünü Varsayılanlara Sıfırla, içe aktarma işlemini geri alır.
+	Don't Import	İçe Aktarma
+	The keyboard shortcut set was not imported: {error}	Klavye kısayol seti içe aktarılmadı: {error}
+	Reset Section	Bölümü Sıfırla
+	Reset Transform	Dönüşümü Sıfırla
+	Reset to defaults	Varsayılanlara sıfırla
+	Resolution	Çözünürlük
+	Resolution:	Çözünürlük:
+	Restore All	Tümünü Geri Yükle
+	Restore Defaults	Varsayılanları Geri Yükle
+	Restrictive (Web)	Kısıtlayıcı (Web)
+	Right align text	Metni sağa hizala
+	Rigid	Sert
+	Rotate:	Döndür:
+	Rotation	Döndürme
+	Roughness	Pürüzlülük
+	Roundness	Yuvarlaklık
+	Roundness Jitter	Yuvarlaklık Değişimi
+	Rulers & Grids	Cetveller ve Izgaralar
+	Sample All Layers	Tüm Katmanları Örnekle
+	Sample:	Örnek:
+	Sampling: Background Swatch	Örnekleme: Arka Plan Renk Örneği
+	Sampling: Continuous	Örnekleme: Sürekli
+	Sampling: Once	Örnekleme: Bir kez
+	Saturate	Doygunluk
+	Saturation	Doygunluk
+	Saturation Jitter	Doygunluk Değişimi
+	Save HTML and Images	HTML ve Görselleri Kaydet
+	Save as PDF	PDF olarak kaydet
+	Save selection as channel	Seçimi kanal olarak kaydet
+	Save…	Kaydet…
+	Scale to Fit Media	Medyaya Sığacak Şekilde Ölçeklendirin
+	Scatter	Dağılım
+	Scratch disks	Kazıma diskleri
+	Search	Ara
+	Search commands	Arama komutları
+	Search commands, tools and panels…	Komutları, araçları ve panelleri arayın…
+	Search fonts	Yazı tiplerini arayın
+	Select All	Tümünü Seç
+	Select Subject	Konuyu Seçin
+	Select a type layer or click into text to insert glyphs	Bir yazım katmanı seçin veya glif eklemek için metne tıklayın
+	Select text to apply a character style	Karakter stili uygulamak için metni seçin
+	Select:	Seçin:
+	Selections	Seçimler
+	Selective	seçici
+	Selective Color	Seçici Renk
+	Send the selected pin backward	Seçilen pini geriye gönder
+	Set additional smoothing options	Ek yumuşatma seçeneklerini ayarlayın
+	Set background color	Arka plan rengini ayarla
+	Set foreground color	Ön plan rengini ayarla
+	Set painting symmetry options	Boyama simetrisi seçeneklerini ayarlama
+	Symmetry Off	Simetri Kapalı
+	Set shape fill type	Şekil doldurma türünü ayarla
+	Set shape stroke type	Şekil kontur türünü ayarlama
+	Set the text color	Metin rengini ayarlama
+	Shadows	Gölgeler
+	Shape:	Şekil:
+	Sharpening	Bileme
+	Shift	Shift
+	Shortcut removed.	Kısayol kaldırıldı.
+	Show All Menu Items	Tüm Menü Öğelerini Göster
+	Show Backdrop	Arka Planı Göster
+	Show Guides	Kılavuzları Göster
+	Show Mask	Maskeyi Göster
+	Show Mesh	Mesh'i Göster
+	Show Overlay	Kaplamayı Göster
+	Show Transform Controls	Dönüştürme Kontrollerini Göster
+	Show or hide the Notes panel	Notlar panelini gösterme veya gizleme
+	Show:	Göster:
+	Sides	Taraflar
+	Sides:	Taraflar:
+	Size	Boyut
+	Size Jitter	Boyut Değişimi
+	Size:	Boyut:
+	Slice Options…	Dilim Seçenekleri…
+	Slices From Guides	Kılavuzlardan Dilimler
+	Slices are locked (View › Lock Slices)	Dilimler kilitlidir (Görünüm › Dilimleri Kilitle)
+	Small Caps	Küçük Büyük Harfler
+	Smoothing	Pürüzsüzleştirme
+	Space After	Sonraki Boşluk
+	Space Before	Önceki Boşluk
+	Spacing	Aralık
+	Spell check complete.	Yazım denetimi tamamlandı.
+	Split:	Bölünmüş:
+	Star ratio	Yıldız oranı
+	Stop playing/recording	Oynatmayı/kaydetmeyi durdur
+	Straighten	Düzelt
+	Straighten Layer	Katmanı Düzleştir
+	Strength:	Güç:
+	Strikethrough	Üstü çizili
+	Stroke	Kontur
+	Stroke Catch-up	İnme Yakalama
+	Stroke:	İnme:
+	Style	Stil
+	Style Options	Stil Seçenekleri
+	Style Options…	Stil Seçenekleri…
+	Style: Normal	Tarz: Normal
+	Subtract from Sample	Örnekten Çıkart
+	Subtract from selection  ({key})	Seçimden çıkar ({key})
+	Suggestions:	Öneriler:
+	Swap colours (X)	Renkleri değiştir (X)
+	Swaps height and width	Yüksekliği ve genişliği değiştirir
+	Switch between free transform and warp modes	Serbest dönüştürme ve çarpıtma modları arasında geçiş yapın
+	Switch theme	Temayı değiştir
+	Temperature	Sıcaklık
+	Tetrahedral	dörtyüzlü
+	Text Position:	Metin Konumu:
+	Texture	Doku
+	Texture Each Tip	Her Ucu Doku
+	Threshold	Eşik
+	Threshold Level	Eşik Seviyesi
+	Thumbnail size (smallest: list)	Küçük resim boyutu (en küçük: liste)
+	Tilt X	X'i yatır
+	Tilt Y	Y Eğimi
+	Tint	Renk tonu
+	Toggle count group visibility	Sayım grubu görünürlüğünü değiştir
+	Toggle text orientation	Metin yönünü değiştir
+	Tolerance	Tolerans
+	Tolerance:	Tolerans:
+	Tone:	Ton:
+	Toolbar	Araç Çubuğu
+	Top	Üst
+	Total:	Toplam:
+	Tracking	Takip
+	Tracking (1/1000 em)	Takip (1/1000 em)
+	Transparency	Şeffaflık
+	Transparent	Şeffaf
+	Trilinear	Üç çizgili
+	Type Styles	Tip Stilleri
+	Type:	Tür:
+	Underline	Altı çizili
+	Untitled	İsimsiz
+	Untitled-1	İsimsiz-1
+	Update layer comp (visibility, position and appearance)	Katman kompozisyonunu güncelleyin (görünürlük, konum ve görünüm)
+	Use Default	Varsayılanı Kullan
+	Use Legacy	Eskiyi Kullan
+	Use Measurement Scale	Ölçüm Ölçeğini Kullan
+	Use the embedded profile (instead of the working space)	Gömülü profili kullanın (çalışma alanı yerine)
+	Variables bind a layer's visibility, text or pixels to a named data slot.	Değişkenler bir katmanın görünürlüğünü, metnini veya piksellerini adlandırılmış bir veri yuvasına bağlar.
+	Vertical scale	Dikey ölçek
+	Vibrance	Canlılık
+	View Options	Seçenekleri Görüntüle
+	Vignetting	Kenar ayrıntısı kaybı
+	Violet, Orange	Menekşe, Turuncu
+	Visibility	Görünürlük
+	Visible	Görünür
+	Warp:	Çözgü:
+	Web Snap	Web Snap
+	Weight	Ağırlık
+	Weight:	Ağırlık:
+	White	Beyaz
+	White Balance: As Shot	Beyaz Dengesi: Çekildiği Gibi
+	Whites	Beyazlar
+	Width	Genişlik
+	Slant	Eğimli
+	Width:	Genişlik:
+	Work Path	Çalışma Yolu
+	Yellow	Sarı
+	Yellow  ·  Blue	Sarı · Mavi
+	Zoom	Yakınlaştır
+	Zoom in	Yakınlaştır
+	Zoom out	Uzaklaştır
+	command or shortcut	komut veya kısayol
+	current	akım
+	image file path	resim dosyası yolu
+	modified	değiştirilmiş
+	name	isim
+	new	yeni
+	{name} options	{name} seçenekler
+	↑↓ navigate   {key} run   esc close	↑↓ gezin {key} çalıştır esc kapat
+	Version {version}	Sürüm {version}
+	New Document	Yeni Belge
+	New Document With Mask	Maskeli Yeni Belge
+	New Layer With Mask	Maskeli Yeni Katman
+	Save Preset…	Ön Ayarı Kaydet…
+	Preset Name	Ön Ayar Adı
+	No saved presets yet.	Henüz kayıtlı ön ayar yok.
+	Error	Hata
+	Command	Komut
+	Adjustment layers have nothing to transform	Ayarlama katmanlarının dönüştürülecek hiçbir şeyi yok
+	Altitude	Rakım
+	Android 1080p	Android1080p
+	Apple Watch 45mm	Apple Watch 45mm
+	Aqua	Su
+	Art & Illustration	Sanat ve İllüstrasyon
+	ArtCraft	ArtCraft
+	Background Eraser Tool	Arka Plan Silgisi Aracı
+	Bevel & Emboss	Eğim Ver ve Kabart
+	Blend Mode	Karışım Modu
+	Blues	Blues
+	Blur Tool	Bulanıklık Aracı
+	Bold	Kalın
+	Brush	Fırça
+	Block	Blok
+	Brush Pose	Fırça Duruşu
+	Brush Tip Shape	Fırça Ucu Şekli
+	Brush Tool	Fırça Aracı
+	Build-up	İnşaat
+	Burn Tool	Koyulaştırma Aracı
+	Centimeters	Santimetre
+	Choke	Şok
+	Classic	Klasik
+	Click to add text	Metin eklemek için tıklayın
+	Click to fill similar colours	Benzer renkleri doldurmak için tıklayın
+	Clone Stamp Tool	Klonlama Damgası Aracı
+	Color Burn	Renk Yanması
+	Color Dodge	Renk Soldurma
+	Color Dynamics	Renk Dinamiği
+	Color Overlay	Renk Kaplaması
+	Comic Book	Çizgi Roman
+	Conform	Uygun
+	Content-Aware Fill needs a selection on a pixel layer	İçeriğe Uygun Dolgu, piksel katmanında seçim yapılmasını gerektirir
+	Could not transform: the layer is empty	Dönüştürülemedi: katman boş
+	Could not use Perspective Warp: the layer is empty	Perspektif Çarpıtma kullanılamadı: katman boş
+	Could not use Puppet Warp: no opaque pixels	Puppet Warp kullanılamadı: opak piksel yok
+	Could not use Puppet Warp: the layer is empty	Puppet Warp kullanılamadı: katman boş
+	Crop Tool	Kırpma Aracı
+	Crosswise	Çapraz olarak
+	Current Tool	Güncel Araç
+	Custom Shape Tool	Özel Şekil Aracı
+	Cyans	Camgöbeği
+	Default PhotoCraft Size	Varsayılan PhotoCraft Boyutu
+	Delete Workspace	Çalışma Alanını Sil
+	Diamond	Elmas
+	Dimensions:	Boyutlar:
+	Direction	Yön
+	Distance	Uzaklık
+	Document Dimensions	Belge Boyutları
+	Document Profile	Belge Profili
+	Document Sizes	Belge Boyutları
+	Dodge Tool	Açıklaştırma Aracı
+	Down	Aşağı
+	Drag to draw a gradient	Degrade çizmek için sürükleyin
+	Drag to move the active layer	Etkin katmanı taşımak için sürükleyin
+	Drag to pan  ·  hold Space with any tool	Kaydırmak için sürükleyin · herhangi bir araçla Space tuşunu basılı tutun
+	Drop Shadow	Alt Gölge
+	Dual Brush	Çift Fırça
+	Edge	Kenar
+	Efficiency	Verimlilik
+	Efficiency: 100%	Verimlilik: %100
+	Ellipse Tool	Elips Aracı
+	Elliptical Marquee Tool	Eliptik İşaretleme Aracı
+	Single Row Marquee Tool	Tek Satır İşaretleme Aracı
+	Single Column Marquee Tool	Tek Sütun İşaretleme Aracı
+	Emboss	Kabartma
+	Eraser	Silgi
+	Eraser Tool	Silgi Aracı
+	ExtraBold	Ekstra Kalın
+	ExtraLight	Ekstra Hafif
+	Eyedropper Tool	Damlalık Aracı
+	Fade	Solmaya
+	Fill Opacity	Dolgu Opaklığı
+	Film & Video	Film ve Video
+	From	Gönderen
+	General	Genel
+	GitHub	GitHub
+	Gradient Overlay	Degrade Yerleşimi
+	Gradient Tool	Degrade Aracı
+	Greens	Yeşiller
+	Hand Tool	El Aracı
+	Hard	Sert
+	Hard Mix	Sert Karışım
+	Healing Brush Tool	Düzeltme Fırçası Aracı
+	Highlights from:	Öne çıkanlar:
+	History Brush Tool	Geçmiş Fırçası Aracı
+	Horizontal Type Tool	Yatay Metin Aracı
+	Horizontal Type Mask Tool	Yatay Metin Maskesi Aracı
+	Vertical Type Mask Tool	Dikey Metin Maskesi Aracı
+	Image Size:	Resim Boyutu:
+	Inches	İnç
+	Indexed	Dizine eklendi
+	Initial Direction	Başlangıç Yönü
+	Inner Bevel	İç Eğim
+	Inner Glow	İç Işıma
+	Inner Shadow	İç Gölge
+	Lab	Lab
+	Landscape, 10 x 8	Yatay, 10 x 8
+	Landscape, 6 x 4	Yatay, 6 x 4
+	Landscape, 7 x 5	Yatay, 7 x 5
+	Lasso	Kement
+	Lasso Tool	Kement Aracı
+	Layer Count	Katman Sayısı
+	Layer Knocks Out Drop Shadow	Katman Alt Gölgeyi Ortadan Kaldırır
+	Legal	Yasal
+	Letter	Mektup
+	Light	Işık
+	Line Tool	Çizgi Aracı
+	Linear	Doğrusal
+	Linear Burn	Doğrusal Yanma
+	Linear Height	Doğrusal Yükseklik
+	Link with Layer	Katmanla Bağlantı
+	Lorem Ipsum	Lorem İpsum
+	Magentas	Macentalar
+	Magic Eraser Tool	Sihirli Silgi Aracı
+	Magic Wand Tool	Sihirli Değnek Aracı
+	Marquee	Seçim Çerçevesi
+	Mean:	Anlamı:
+	Measurement Scale	Ölçüm Ölçeği
+	Measurement Scale Marker	Ölçüm Ölçeği İşaretleyicisi
+	Millimeters	Milimetre
+	Mobile	Mobil
+	Move Tool	Taşıma Aracı
+	Could not use the move tool because the layer is locked.	Katman kilitli olduğundan taşıma aracı kullanılamadı.
+	Could not complete the Free Transform command because the layer is locked.	Katman kilitli olduğundan Serbest Dönüştürme komutu tamamlanamadı.
+	Multiply	Çoğalt
+	My Brushes	Fırçalarım
+	Neutrals	Nötrler
+	New Workspace	Yeni Çalışma Alanı
+	Note Tool	Not Aracı
+	Object Selection Tool	Nesne Seçme Aracı
+	Off	Kapalı
+	Open	Aç
+	Orange	Turuncu
+	Original Ratio	Orijinal Oran
+	Out Of Gamut	Gamut Dışı
+	Outer Bevel	Dış Eğim
+	Outer Glow	Dış Parıltı
+	Overlay	Kaplama
+	Paint Bucket Tool	Boya Kovası Aracı
+	Paints from the document's opening state	Belgenin açılış durumundaki boyalar
+	Path Selection Tool	Yol Seçimi Aracı
+	Direct Selection Tool	Doğrudan Seçim Aracı
+	Add Anchor Point Tool	Bağlantı Noktası Ekleme Aracı
+	Delete Anchor Point Tool	Bağlantı Noktası Silme Aracı
+	Click a segment to add an anchor point · {alt}-click an anchor to delete it	Bağlantı noktası eklemek için bir segmenti tıklayın · {alt}-silmek için bir bağlantıyı tıklayın
+	Click an anchor point to delete it · {alt}-click a segment to add one	Silmek için bir bağlantı noktasını tıklayın · {alt}-bir parça eklemek için bir parçayı tıklayın
+	Pattern Overlay	Desen Yerleşimi
+	Pen Pressure	Kalem Basıncı
+	Pen Tilt	Kalem Eğimi
+	Pen Tool	Kalem Aracı
+	Convert Point Tool	Nokta Dönüştürme Aracı
+	Photo	Fotoğraf
+	PhotoCraft website	PhotoCraft web sitesi
+	Picas	Pikalar
+	Pillow Emboss	Yastık Kabartma
+	Pixel Replacement	Piksel Değiştirme
+	Pixels	Piksel
+	Points	Puanlar
+	Polygon Tool	Çokgen Aracı
+	Polygonal Lasso Tool	Çokgen Kement Aracı
+	Portrait, 4 x 6	Portre, 4 x 6
+	Portrait, 5 x 7	Portre, 5 x 7
+	PostScript (72 points/inch)	PostScript (72 nokta/inç)
+	Postcard	Kartpostal
+	Poster	Poster
+	Pro (Dark)	Pro (Koyu)
+	Pro (Light)	Pro (Hafif)
+	Pro (Light Gray)	Pro (Açık Gri)
+	Pro (Medium Gray)	Pro (Orta Gri)
+	Protect Texture	Dokuyu Koruyun
+	Purple	Mor
+	Quick Mask	Hızlı Maske
+	Quick Selection Tool	Hızlı Seçim Aracı
+	Radial	Radyal
+	Rasterize Layer	Katmanı Rasterleştir
+	Rasterize Layers	Katmanları Rasterleştir
+	Ratio	Oran
+	Recent	Son
+	Rectangle Tool	Dikdörtgen Aracı
+	Rectangular Marquee Tool	Dikdörtgen İşaretleme Aracı
+	Reds	Kırmızılar
+	Reflected	Yansıyan
+	Sample: foreground colour	Örnek: ön plan rengi
+	Sampled Colors	Örneklenen Renkler
+	Satin	Saten
+	Save Pixel Aspect Ratio	Piksel En Boy Oranını Kaydet
+	Scattering	Saçılma
+	Scratch Sizes	Çizik Boyutları
+	Select Data Points	Veri Noktalarını Seçin
+	Selection	Seçim
+	SemiBold	Yarı Kalın
+	Shadows up to:	Şuna kadar gölgeler:
+	Shape Dynamics	Şekil Dinamiği
+	Sharpen Tool	Keskinleştirme Aracı
+	Show Extras Options	Ekstra Seçeneklerini Göster
+	Slice Select Tool	Dilim Seçme Aracı
+	Slice Tool	Dilim Aracı
+	Smart Filters	Akıllı Filtreler
+	Smudge Tool	Leke Aracı
+	Soft	Yumuşak
+	Soften	Yumuşat
+	Source	Kaynak
+	Source: set	Kaynak: ayarlandı
+	Sponge Tool	Sünger Aracı
+	Spot Healing Brush Tool	Nokta Düzeltme Fırçası Aracı
+	Spread	Yayılma
+	Square, 12 x 12	Kare, 12x12
+	Square, 5 x 5	Kare, 5x5
+	Std Dev:	Standart Geliştirme:
+	Studio (Dark)	Stüdyo (Karanlık)
+	Studio (Light)	Stüdyo (Işık)
+	Stylus Wheel	Kalem Tekerleği
+	Subtract	Çıkar
+	Tabloid	Tabloid
+	Text Replacement	Metin Değiştirme
+	Thin	İnce
+	Traditional (72.27 points/inch)	Geleneksel (72,27 nokta/inç)
+	Transfer	Aktarım
+	Triangle Tool	Üçgen Aracı
+	Unsaved changes	Kaydedilmemiş değişiklikler
+	Uses the foreground and background colours.	Ön plan ve arka plan renklerini kullanır.
+	Web	ağ
+	Web Large	Web Büyük
+	Web Minimum	Web Minimumu
+	Web Most Common	Web En Yaygın
+	WebP (lossless)	WebP (kayıpsız)
+	Wet Edges	Islak Kenarlar
+	Yellows	Sarılar
+	Zoom Tool	Yakınlaştırma Aracı
+	{name} Properties	{name} Özellikler
+	Revert “{name}” to the last saved version? Your changes will be lost.	“{name}” son kaydedilen sürüme döndürülsün mü? Değişiklikleriniz kaybolacak.
+	Do you want to save the changes you made to “{name}” before quitting?	Çıkmadan önce “{name}” öğesinde yaptığınız değişiklikleri kaydetmek istiyor musunuz?
+	Do you want to save the changes you made to “{name}” before closing?	Kapatmadan önce “{name}” üzerinde yaptığınız değişiklikleri kaydetmek istiyor musunuz?
+	Doc: {flat}/{layered}	Doküman: {flat}/{layered}
+	Scratch: {size}	Çizik: {size}
+	Untagged {mode}	Etiketlenmemiş {mode}
+	Invalid {mode} profile	Geçersiz {mode} profili
+	Unnamed {mode} profile	Adsız {mode} profili
+	{w} px x {h} px ({ppi} ppi)	{w} px x {h} px ({ppi} ppi)
+	{w} {unit} x {h} {unit} ({ppi} ppi)	{w} {unit} x {h} {unit} ({ppi} ppi)
+	Resolution: {dpi} pixels/inch	Çözünürlük: {dpi} piksel/inç
+	Doc: {w} × {h} px	Doküman: {w} × {h} piksel
+	Frame {current} / {total}	Çerçeve {current} / {total}
+	Count: {n}	Sayım: {n}
+	BLANK DOCUMENT PRESETS ({n})	BOŞ BELGE ÖN AYARLARI ({n})
+	Constraints ({n})	Kısıtlamalar ({n})
+	Align {what}	{what} hizala
+@plural	{n} Layer|{n} Layers	{n} Katman
+@plural	{n} layer|{n} layers	{n} katman
+@plural	Group · {n} layer|Group · {n} layers	Grup · {n} katman
+	Additional plugins folder	Ek eklentiler klasörü
+	Adobe	Adobe
+	Adobe rgb	Adobe rgb
+	Allow agent control	Aracı kontrolüne izin ver
+	Allow scripts to connect	Komut dosyalarının bağlanmasına izin ver
+	Always	Her zaman
+	Always create smart objects when placing	Yerleştirirken daima akıllı nesneler yaratın
+	Animated zoom	Animasyonlu yakınlaştırma
+	Apply auto tone	Otomatik tonu uygula
+	Ask	Sor
+	Ask before saving layered tiff	Katmanlı tiff'i kaydetmeden önce sor
+	Auto collapse icon panels	Simge panellerini otomatik daralt
+	Auto show hidden panels	Gizli panelleri otomatik göster
+	Auto show home screen	Ana ekranı otomatik göster
+	Autosave	Otomatik kaydetme
+	Autosave minutes	Dakikaları otomatik kaydet
+	Beep when done	Bittiğinde bip sesi
+	Bicubic automatic	Bikübik otomatik
+	Bicubic sharper	Bikübik daha keskin
+	Bicubic smoother	Bikübik daha pürüzsüz
+	Bit depth	Bit derinliği
+	Brush preview color	Fırça önizleme rengi
+	Cache levels	Önbellek düzeyleri
+	Cache tile size	Önbellek kutucuğu boyutu
+	Camera Raw Defaults	Camera Raw Varsayılanları
+	Canvas border	Kanvas kenarlığı
+	Show canvas dots	Kanvas noktalarını göster
+	Canvas color	Kanvas rengi
+	Canvas custom color	Kanvas özel rengi
+	Color picker	Renk seçici
+	Color space	Renk alanı
+	Column width	Sütun genişliği
+	Concise	Kısa
+	Control port	Kontrol portu
+	Convert to srgb	srgb'ye dönüştür
+	Cursors	İmleçler
+	Custom dark	Özel koyu
+	Custom light	Özel ışık
+	Dark	Karanlık
+	Dark gray	Koyu gri
+	Dashed lines	Kesikli çizgiler
+	Destination	Hedef
+	Detailed	Detaylı
+	Disks	Diskler
+	Display p3	Ekran p3
+	Double click layer mask launches select and mask	Çift tıklama katman maskesi seçme ve maskelemeyi başlatır
+	Drop shadow	Alt gölge
+	Dynamic color sliders	Dinamik renk kaydırıcıları
+	East asian	Doğu Asya
+	Effect cache mb	Efekt önbelleği mb
+	Enable flick panning	Hızlı kaydırmayı etkinleştir
+	Enable floating document window docking	Kayan belge penceresi yerleştirmeyi etkinleştir
+	Enable narrow options bar	Dar seçenekler çubuğunu etkinleştir
+	Enabled	Etkin
+	Enhanced Controls	Gelişmiş Kontroller
+	Export clipboard	Panoyu dışa aktar
+	Extra large	Ekstra büyük
+	File Handling	Dosya İşleme
+	File path	Dosya yolu
+	Fill new type layers with placeholder	Yeni yazı katmanlarını yer tutucuyla doldurma
+	Font preview	Yazı tipi önizlemesi
+	Full size tip	Tam boyutlu uç
+	Gamut warning color	Gamut uyarı rengi
+	Gamut warning opacity	Gamut uyarı opaklığı
+	Generator enabled	Jeneratör etkin
+	Gif	Gif
+	Glossy	parlak
+	Grid color	Izgara rengi
+	Grid colors	Izgara renkleri
+	Grid size	Izgara boyutu
+	Grid style	Izgara stili
+	Grid unit	Izgara ünitesi
+	Gridline every	Kılavuz çizgisi her
+	Guide color	Kılavuz rengi
+	Guide style	Kılavuz stili
+	Guides, Grid & Slices	Kılavuzlar, Izgaralar ve Dilimler
+	Gutter	Oluk
+	History Log	Geçmiş Günlüğü
+	History states	Tarih durumları
+	Ignore exif profile tag	Exif profil etiketini yoksay
+	Image interpolation	Görüntü enterpolasyonu
+	Image previews	Resim önizlemeleri
+	Integrations	Entegrasyonlar
+	Interface	Arayüz
+	Jpeg quality	JPEG kalitesi
+	Jpg	Jpg
+	Language	Dil
+	Large tabs	Büyük sekmeler
+	Legacy compositing	Eski birleştirme
+	Light gray	Açık gri
+	Line	Hat
+	Lines	çizgiler
+	Lossless	Kayıpsız
+	Lowercase extension	Küçük harf uzantısı
+	Maximize psd compatibility	PSD uyumluluğunu en üst düzeye çıkarın
+	Medium gray	Orta gri
+	Memory usage mb	Bellek kullanımı mb
+	Low resolution previews	Düşük çözünürlüklü önizlemeler
+	Missing glyph protection	Glif koruması eksik
+	Modern	Çağdaş
+	Nearest neighbor	En yakın komşu
+	Never	Asla
+	Normal tip	Normal uç
+	Open as smart object	Akıllı nesne olarak aç
+	Open in camera raw	Camera raw'da aç
+	Open documents as tabs	Belgeleri sekmeler halinde aç
+	Overscroll	Aşırı kaydırma
+	Performance	Performans
+	Png	png
+	Point size	Nokta boyutu
+	Precise	Hassas
+	Preserve details	Ayrıntıları koru
+	Print resolution	Yazdırma çözünürlüğü
+	Pro	Profesyonel
+	Pro light	Profesyonel ışık
+	Pro light gray	Pro açık gri
+	Pro medium	Profesyonel orta
+	Pro photo	Profesyonel fotoğraf
+	Quick export format	Hızlı dışa aktarma formatı
+	Quick export location	Hızlı dışa aktarma konumu
+	Recent file count	Son dosya sayısı
+	Recent files	Son dosyalar
+	Recent fonts	En yeni yazı tipleri
+	Recover on launch	Başlatıldığında kurtar
+	Remember workspace changes	Çalışma alanı değişikliklerini hatırla
+	Resize image during place	Yerleştirme sırasında resmi yeniden boyutlandır
+	Rotate view with trackpad	İzleme dörtgeniyle görünümü döndürme
+	Same folder	Aynı klasör
+	Save in background	Arka planda kaydet
+	Scratch Disks	Kazı Diskleri
+	Screen	Ekran
+	Screen resolution	Ekran çözünürlüğü
+	Scrubby slider acceleration	Temiz kaydırıcı hızlandırması
+	Sessions only	Yalnızca oturumlar
+	Sharpen for	Şunun için keskinleştir:
+	Show channels in color	Kanalları renkli göster
+	Show crosshair in brush tip	Fırça ucunda artı işaretini göster
+	Show extension panels	Uzatma panellerini göster
+	Show font names in english	İngilizce yazı tipi adlarını göster
+	Show menu colors	Menü renklerini göster
+	Show only crosshair while painting	Boyama sırasında yalnızca artı işaretini göster
+	Show slice numbers	Dilim numaralarını göster
+	Show tooltips	Araç ipuçlarını göster
+	Show highlight on rollover	Rollover sırasında vurgulamayı göster
+	Show bounding box when dragging layer	Katmanı sürüklerken sınırlayıcı kutuyu göster
+	System title bar	Sistem başlık çubuğu
+	Show transformation values	Dönüşüm değerlerini göster
+	Slice color	Dilim rengi
+	Smart guide color	Akıllı kılavuz rengi
+	Smart quotes	Akıllı tırnaklar
+	Snap vector tools and transforms to pixel grid	Vektör araçlarını tutturun ve piksel ızgarasına dönüştürün
+	Srgb	Srgb
+	Standard	Standart
+	Studio	Stüdyo
+	Studio light	Stüdyo ışığı
+	Subdivisions	Alt bölümler
+	System	Sistem
+	Text engine	Metin motoru
+	Text file	Metin dosyası
+	Tiny	minik
+	Touch gestures	Dokunma hareketleri
+	Transparency & Gamut	Şeffaflık ve Gamut
+	Type units	Tip birimleri
+	UI font size	kullanıcı arayüzü yazı tipi boyutu
+	UI scale	Kullanıcı arayüzü ölçeği
+	Units & Rulers	Birimler ve Cetveller
+	Use additional plugins folder	Ek eklentiler klasörünü kullan
+	Use esc to commit	Taahhüt etmek için esc kullanın
+	Use gpu	GPU'yu kullan
+	Use legacy free transform	Eski ücretsiz dönüşümü kullanın
+	Use shift key for tool switch	Araç anahtarı için Shift tuşunu kullanın
+	Vary round brush hardness on hud	Hud üzerinde yuvarlak fırça sertliğini değiştirin
+	Webp	Webp
+	World ready	Dünya hazır
+	Zoom clicked point to center	Tıklanan noktayı merkeze yakınlaştır
+	Zoom resizes windows	Yakınlaştırma pencereleri yeniden boyutlandırır
+	Zoom with scroll wheel	Kaydırma tekerleği ile yakınlaştırma
+	Zoom with trackpad pinch	İzleme dörtgeni tutamıyla yakınlaştırma
+	Pass Through	Geçirgen
+	Dissolve	Eritme
+	Darker Color	Daha Koyu Renk
+	Linear Dodge (Add)	Doğrusal Soldurma (Ekle)
+	Lighter Color	Daha Açık Renk
+	Soft Light	Yumuşak Işık
+	Hard Light	Sert Işık
+	Vivid Light	Canlı Işık
+	Linear Light	Doğrusal Işık
+	Pin Light	Nokta Işığı
+	Exclusion	Dışlama
+	Divide	Böl
+	Luminosity	Parlaklık
+@plural	{n} sample|{n} samples	{n} örnek
+	{added}, {removed} subtracted	{added}, {removed} çıkarıldı
+	Adjustment Preview	Ayar Önizlemesi
+	Airbrush: keeps depositing paint while the pointer rests.	Airbrush: İşaretçi dururken boyayı bırakmaya devam eder.
+	Angle:	Açı:
+	Blend If	Eğer karıştır
+	Close Tab Group	Sekme Grubunu Kapat
+	Collapse	Daralt
+	Collapse All Groups	Tüm Grupları Daralt
+	Collapse Panel Group	Panel Grubunu Daralt
+	Collapse group  ({key}-click: all groups)	Grubu daralt ({key}-tıklama: tüm gruplar)
+	Create new brush from the current settings	Mevcut ayarlardan yeni fırça oluştur
+	Create new brush from these settings	Bu ayarlardan yeni fırça oluşturun
+	Update the current brush with these settings	Mevcut fırçayı bu ayarlarla güncelleyin
+	Delete brush	Fırçayı sil
+	Drag the arrow to set the angle, the dots to set the roundness	Açıyı ayarlamak için oku, yuvarlaklığı ayarlamak için noktaları sürükleyin
+	Expand	Genişlet
+	Expand Panel Group	Panel Grubunu Genişlet
+	Expand group  ({key}-click: all groups)	Grubu genişlet ({key}-tıklayın: tüm gruplar)
+	Fade steps	Adımları soldur
+	Hide the layer's effects  ({key}-click: all layers)	Katmanın efektlerini gizle ({key}-tıklama: tüm katmanlar)
+	Import Brushes… (.abr)	Fırçaları İçe Aktar… (.abr)
+	Move Group Down	Grubu Aşağı Taşı
+	Move Group Up	Grubu Yukarı Taşı
+	Reset the brush to the defaults	Fırçayı varsayılanlara sıfırlayın
+	Restore original size	Orijinal boyutu geri yükle
+	Roundness:	Yuvarlaklık:
+	Search Brushes	Fırçalarda Ara
+	Show the layer's effects  ({key}-click: all layers)	Katmanın efektlerini göster ({key}-tıklama: tüm katmanlar)
+	Brush picker	Fırça seçici
+	Erase	Sil
+	Right click with painting tools	Boyama araçlarıyla sağ tıklayın
+	System Info…	Sistem Bilgisi…
+	System Info	Sistem Bilgisi
+	More panels	Daha fazla panel
+	More documents	Daha fazla belge
+	These settings aren't available in PhotoCraft yet.	Bu ayarlar henüz PhotoCraft'ta mevcut değildir.
+	Graphics	Grafik
+	Reset GPU Backend	GPU Arka Uçunu Sıfırla
+	Applies at next launch.	Bir sonraki açılışta geçerlidir.
+	Click to sample the foreground colour  ·  {key}-click for background	Ön plan rengini örneklemek için tıklayın · {key}-arka plan için tıklayın
+	{key}-click to set the source	{key}-kaynağı ayarlamak için tıklayın
+	{key} to subtract	{key} çıkarmak için
+	Clone source {n} ({key}-click with Clone Stamp to set)	Kaynağı kopyala {n} ({key}-ayarlamak için Klonlama Damgası ile tıklayın)
+	Source: not set ({key}-click with Clone Stamp)	Kaynak: ayarlanmadı ({key}-Klon Damgası ile tıklayın)
+	Pixel Layer	Piksel Katmanı
+	Type Layer	Tip Katmanı
+	Shape Layer	Şekil Katmanı
+	Group Layer	Grup Katmanı
+	Fill Layer	Dolgu Katmanı
+	Smart Object Layer	Akıllı Nesne Katmanı
+	Create Warped Text	Çarpık Metin Oluştur
+	Rasterize Smart Object	Akıllı Nesneyi Rasterleştir
+	Rasterize Fill Content	Dolgu İçeriğini Rasterleştir
+	Rasterize Layer Style	Katman Stilini Rasterleştir
+	Unlock: picking a preset replaces these settings	Kilidi aç: bir ön ayarın seçilmesi bu ayarların yerini alır
+	Lock: keep these settings when picking another preset	Kilitle: başka bir ön ayar seçerken bu ayarları koruyun
+	Diameter:	Çap:
+	Hardness:	Sertlik:
+	No brush presets	Fırça ön ayarı yok
+	Toggle the Brush Settings panel  (F5)	Fırça Ayarları panelini açın/kapatın (F5)
+	Create new brush preset from the current settings	Geçerli ayarlardan yeni fırça hazır ayarı oluşturun
+	Brush Settings…  (F5): every option of this brush	Fırça Ayarları… (F5): bu fırçanın tüm seçenekleri
+	Rename Brush…	Fırçayı Yeniden Adlandır…
+	Delete Brush	Fırçayı Sil
+	New Brush Preset…	Yeni Fırça Ön Ayarı…
+	Capture Brush Size in Preset	Fırça Boyutunu Ön Ayara Kaydet
+	Include Tool Settings	Araç Ayarlarını Dahil Et
+	Include Color	Rengi Dahil Et
+	Enter a name for the brush preset	Fırça ön ayarı için bir ad girin
+	A brush preset with this name already exists	Bu adda bir fırça ön ayarı zaten var
+	Brush Preset Options	Fırça Ön Ayarı Seçenekleri
+	Group name	Grup adı
+	Brush name	Fırça adı
+	Brush Name	Fırça Adı
+	Off: the speed of the pointer sets the spacing	Kapalı: işaretçinin hızı aralığı belirler
+	Tilt Scale	Eğim Ölçeği
+	Brush Projection	Fırça Projeksiyonu
+	Apply the pen's tilt and rotation to the tip shape	Kalemin eğimini ve dönüşünü uç şekline uygulayın
+	Mixer Brush	Karıştırıcı Fırça
+	Mixer Brush Tool	Karıştırıcı Fırça Aracı
+	Color Replacement Tool	Renk Değiştirme Aracı
+	Wet	Islaklık
+	Mix	Karışım
+	Wetness Jitter	Islaklık Titreme
+	Mix Jitter	Karıştırma Titreşimi
+	Show the layer mask as an overlay	Katman maskesini kaplama olarak göster
+	Toggle visibility	Görünürlüğü aç/kapat
+	Unlink the mask from the layer	Maskenin katmanla bağlantısını kaldırın
+	Link the mask to the layer	Maskeyi katmana bağlama
+	Gradient	Gradyan
+	Gradient Options	Degrade Seçenekleri
+	Align with layer	Katmanla hizala
+	Reset Alignment	Hizalamayı Sıfırla
+	Centre the gradient (offset 0, 0)	Degradeyi ortalayın (kaydırma 0, 0)
+	Gradient Editor	Degrade Düzenleyici
+	Gradient picker	Degrade seçici
+	Gradient stops	Gradyan durakları
+	Save As Preset	Ön Ayar Olarak Kaydet
+	The gradient the Gradient tool paints with	Degrade aracının boyadığı degrade
+	Adds the current gradient to the Gradients panel	Geçerli degradeyi Degradeler paneline ekler
+	The current gradient (pick one in Window › Gradients)	Geçerli degrade (Pencere › Degradeler'den birini seçin)
+	Select a type layer to edit its character and paragraph settings.	Karakter ve paragraf ayarlarını düzenlemek için bir yazı katmanı seçin.
+	Text color	Metin rengi
+	Type Options	Tip Seçenekleri
+	Anti-aliasing method	Kenar yumuşatma yöntemi
+	Horizontal type	Yatay tip
+	Vertical type	Dikey tip
+	Fill path with foreground color	Yolu ön plan rengiyle doldur
+	Stroke path with brush	Fırçayla kontur yolu
+	Load path as a selection	Yolu seçim olarak yükle
+	Make work path from selection	Seçimden iş yolunu yap
+	Add vector mask	Vektör maskesi ekle
+	Create new path	Yeni yol oluştur
+	Delete path	Yolu sil
+	Delete vector mask	Vektör maskesini sil
+	CPU (no GPU acceleration)	CPU (GPU hızlandırması yok)
+	DirectX 12	DirectX 12
+	GPU backend	GPU arka ucu
+	Linux display server	Linux görüntü sunucusu
+	X11	X11
+	Metal	Metal
+	OpenGL	OpenGL
+	Use tablet pressure	Tablet basıncını kullan
+	Vulkan	Vulkan
+	Alt-click to define a source point to clone from	Kopyalanacak kaynak noktayı tanımlamak için Alt tuşuna basarak tıklayın
+	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Seçim yapılabilecek yol yok: Kalem aracıyla bir yol çizin veya Yollar panelinden birini seçin.
+	Cancel opening	Açılışı iptal et
+	Cancelled opening {name}	{name} açılışı iptal edildi
+	The document “{name}” does not have an embedded {mode} profile.	'{name}' belgesinde gömülü bir {mode} profili yok.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	'{name}' belgesinin gömülü renk profili geçerli {mode} çalışma alanıyla eşleşmiyor.
+	Embedded: {embedded}	Gömülü: {embedded}
+	Working: {working}	Çalışma alanı: {working}
+	Developing {name}	{name} geliştiriliyor
+	Cancelled {label}	{label} iptal edildi
+	Esc to cancel	İptal etmek için Esc
+	Opened {name}	{name} tarihinde açıldı
+	Opening {name}	{name} açılıyor
+	Saved {name}	{name} kaydedildi
+	Saving {name}	{name} kaydediliyor
+	A save to {name} is still running; try again when it finishes	{name} konumuna kaydetme işlemi hâlâ devam ediyor; bittiğinde tekrar dene
+	{label} is writing the file and can no longer be cancelled	{label} dosyayı yazıyor ve artık iptal edilemez
+	Opening {name}…	{name} açılıyor…
+	Opening…	Açılıyor…
+	Reading…	Okunuyor…
+	Working…	Çalışıyor…
+	Color Range	Renk Aralığı
+	Adaptive Wide Angle	Uyarlanabilir Geniş Açı
+	Chalk & Charcoal	Tebeşir ve Kömür
+	Charcoal	Kömür
+	Chrome	Krom
+	Conté Crayon	Conte Crayon
+	Graphic Pen	Grafik Kalemi
+	Halftone Pattern	Noktalı Resim Deseni
+	Note Paper	Not Kağıdı
+	Photocopy	Fotokopi
+	Plaster	Alçı
+	Reticulation	Retikülasyon
+	Stamp	Damga
+	Torn Edges	Yırtık Kenarlar
+	Water Paper	Su Kağıdı
+	Move	Taşı
+	Pencil	Kalem
+	Clone Stamp	Klon Damgası
+	Dodge	Dodge
+	Burn	Yanık
+	Quick Selection	Hızlı Seçim
+	History Brush	Tarih Fırçası
+	Color Replacement	Renk Değiştirme
+	New Group	Yeni Grup
+	Layer Comp	Katman Kompozisyonu
+	Alpha	Alfa
+	Make	Yap
+	Model	Modeli
+	F	F
+	Artist	Sanatçı
+	Spot Color	Nokta Rengi
+	Roman	Roma
+	Bold Italic	Kalın İtalik
+	Justification	Gerekçe
+	Symbols	Semboller
+	Punctuation	Noktalama işaretleri
+	Make Work Path	İş Yolu Yap
+	Make Selection	Seçim Yap
+	Fill Path	Yolu Doldur
+	Stroke Path	Kontur Yolu
+	Delete Path	Yolu Sil
+	W	W
+	H	H
+	Ruler	Cetvel
+	New Layer Comp	Yeni Katman Kompozisyonu
+	Duplicate Layer Comp	Yinelenen Katman Kompozisyonu
+	Rename Layer Comp	Katman Kompozisyonunu Yeniden Adlandırın
+	Apply Layer Comp	Katman Kompozisyonunu Uygula
+	Update Layer Comp	Katman Kompozisyonunu Güncelle
+	Method	Yöntem
+	Author	Yazar
+	Software	Yazılım
+	Pencil Tool	Kurşun Kalem Aracı
+	Pixel	Piksel
+	Adjustment	Ayarlama
+	Drag (lasso) or click points (polygonal) · {add} add · {sub} subtract	Noktaları sürükleyin (kement) veya tıklayın (çokgen) · {add} ekle · {sub} çıkar
+	Drag a crop box · drag inside to move · edges resize ({ratio} ratio, {centre} centre) · Space moves while drawing · arrows nudge · X swaps orientation · {commit} commits · Esc cancels	Kırpma kutusunu sürükleyin · taşımak için içeriye sürükleyin · kenarları yeniden boyutlandırın ({ratio} oranı, {centre} merkez) · Çizim sırasında boşluk hareket eder · oklar iter · X yönünü değiştirir · {commit} gerçekleştirir · Esc iptal eder
+	{mode} Color · {bits} bit	{mode} Renkli · {bits} bit
+	Scrubby Zoom	Süpürge Yakınlaştırma
+	Auto Erase	Otomatik Silme
+	Color Adaptation	Renk Uyarlaması
+	Preserve Transparency	Şeffaflığı Koruyun
+	New Style…	Yeni Stil…
+	shortcut	kısayol
+	Saved	Kaydedildi
+	Arc	Yay
+	Arch	Kemer
+	Bulge	çıkıntı
+	Shell Lower	Kabuk Alt Kısmı
+	Shell Upper	Kabuk Üstü
+	Flag	Bayrak
+	Fish	Balık
+	Wave	Dalga
+	Rise	Yüksel
+	Inflate	Şişir
+	Twist	Büküm
+	Squeeze	Sıkıştır
+	Mask	Maske
+	Channel	Kanal
+	Rectangle	Dikdörtgen
+	New Channel	Yeni Kanal
+	Save Selection	Seçimi Kaydet
+	Load Selection	Yük Seçimi
+@id	edit.purge.undo	Geri Al
+	Rendering Mode	İşleme Modu
+	Automatic (recommended)	Otomatik (önerilen)
+	CPU / Compatibility	CPU / Uyumluluk
+	Automatic uses GPU acceleration when available and falls back to CPU rendering on errors.	Otomatik, mümkün olduğunda GPU hızlandırmayı kullanır ve hatalarda CPU oluşturmaya geri döner.
+	Switched to CPU rendering	CPU oluşturmaya geçildi
+	GPU acceleration could not continue. Your documents are unchanged.	GPU hızlandırması devam edemedi. Belgeleriniz değişmedi.
+	PhotoCraft is using the CPU image compositor. The window may still use your graphics adapter.	PhotoCraft, CPU görüntü düzenleyicisini kullanıyor. Pencere hala grafik bağdaştırıcınızı kullanıyor olabilir.
+	Retry GPU requires a restart. Save your work first.	GPU'yu yeniden dene, yeniden başlatma gerektirir. Öncelikle çalışmanızı kaydedin.
+	Keep Using CPU	CPU'yu Kullanmaya Devam Edin
+	Retry GPU	GPU'yu yeniden dene
+	Advanced	Gelişmiş
+	GPU Backend	GPU Arka Ucu
+	Details	Ayrıntılar
+	Rendering mode	Oluşturma modu
+	Freeze Lasso: drag to freeze an area, Alt-drag to thaw it (L)	Kementi Dondur: Bir alanı dondurmak için sürükleyin, buzunu çözmek için Alt tuşuna basarak sürükleyin (L)
+	3 x 3	3 x 3
+	4 x 4	4 x 4
+	5 x 5	5 x 5
+	Camera Raw Filter ({layer})	Camera Raw Filtresi ({layer})
+	Camera Raw ({name})	Camera Raw ({name})
+	Edit Type	Türü Düzenle
+	Grid:	Izgara:
+	Highlight Clipping Warning (O)	Kırpılma Uyarısını Vurgula (O)
+	Lasso around an area, then drag the selection	Bir alanı kementle çevreleyin, ardından seçimi sürükleyin
+	Patch:	Yama:
+	Shadow Clipping Warning (U)	Gölge Kırpılması Uyarısı (U)
+	Show Lab Color Readouts	Laboratuvar Renk Okumalarını Göster
+	Show Red at 3 o'clock	Kırmızıyı saat 3 yönünde göster
+	Show Selected Region	Seçilen Bölgeyi Göster
+	Show Skin Tone Indicator	Cilt Tonu Göstergesini Göster
+	Show Vectorscope	Vectorscope'u göster
+	Tone Histogram	Ton Histogramı
+	75%	75%
+	80%	80%
+	85%	85%
+	90%	90%
+	95%	95%
+	125%	125%
+	150%	150%
+	175%	175%
+	250%	250%
+	300%	300%
+	No patterns	Desen yok
+	Enable {name}	{name}'yi etkinleştir
+	Hold Alt while drawing for straight segments	Düz parçalar çizerken Alt tuşunu basılı tutun
+	Drag or click polygon points · hold Alt during lasso for straight segments · {add} add · {sub} before drawing subtracts	Çokgen noktalarını sürükleyin veya tıklayın · düz parçalar için kement sırasında Alt tuşunu basılı tutun · {add} ekleyin · çizim çıkarmadan önce {sub}
+	Extend	Uzat
+	Structure:	Yapı:
+	Content-Aware Move Tool	İçeriğe Uygun Taşıma Aracı
+	TIFF Options	TIFF Seçenekleri
+	Targa Options	Targa Seçenekleri
+	24 bits/pixel	24 bit/piksel
+	32 bits/pixel	32 bit/piksel
+	Including layers will increase file size.	Katmanların eklenmesi dosya boyutunu artıracaktır.
+	Discard Layers and Save a Copy	Katmanları Atın ve Bir Kopyasını Kaydedin
+	Don't show again	Bir daha gösterme
+	Save failed: {error}	Kaydetme başarısız oldu: {error}
+	Save cancelled	Kaydetme iptal edildi
+	Style {name} saved	{name} stili kaydedildi
+	Make Default	Varsayılan Yap
+	Reset to Default	Varsayılana Sıfırla
+	Couldn't place {name}: {error}	{name} yerleştirilemedi: {error}
+	Full-resolution preview unavailable	Tam çözünürlüklü önizleme kullanılamıyor
+	Magnetic Lasso Tool	Manyetik Kement Aracı
+	Frequency	Frekans
+	Use tablet pressure to change pen width	Kalem genişliğini değiştirmek için tablet basıncını kullanın
+	About	Hakkında
+	Contributors	Katkıda Bulunanlar
+	Models	Modeller
+	Sort	Sırala
+	Username	Kullanıcı adı
+	Display name	Görünen ad
+	Real name	Gerçek isim
+	Reverse the order	Sırayı tersine çevir
+	Grab bag	Çantayı al
+	Table	Tablo
+	Name (A–Z)	Ad (A–Z)
+	Merged PRs	Birleştirilmiş PR'ler
+	Commits	Taahhütler
+	Lines added	Satırlar eklendi
+	Lines deleted	Satırlar silindi
+	Line delta	Çizgi deltası
+	Binary assets added	İkili varlıklar eklendi
+	Binary assets removed	İkili varlıklar kaldırıldı
+	First commit	İlk taahhüt
+	First	İlk
+	Last commit	Son taahhüt
+	Last	Son
+	Contributors: {contributors} · Commits: {commits}	Katkıda Bulunanlar: {contributors} · Taahhütler: {commits}
+	No contributor data was built into this copy.	Bu kopyaya hiçbir katkıda bulunan verisi eklenmedi.
+	No model credits were built into this copy.	Bu kopyaya hiçbir model kredisi eklenmemiştir.
+	Company	Şirket
+	Version	Sürüm
+	% of all commits	Tüm taahhütlerin yüzdesi
+	Lines +/−	Çizgiler +/−
+	@{login}: {prs} PRs, {commits} commits, +{added} / −{deleted} lines (Δ {delta}), +{binAdded} / −{binDeleted} binary assets, {first} – {last}	@{login}: {prs} PR'ler, {commits} taahhütler, +{added} / −{deleted} satırlar (Δ {delta}), +{binAdded} / −{binDeleted} ikili varlıklar, {first} – {last}
+	Create new swatch	Yeni renk örneği oluştur
+	New Swatch…	Yeni Swatch…
+	New Swatch Group…	Yeni Swatch Grubu…
+	Import Swatches…	Renk Örneklerini İçe Aktar…
+	Replace Swatches…	Renk Örneklerini Değiştirin…
+	Export Swatches…	Renk Örneklerini Dışa Aktar…
+	Export Swatches for Exchange…	Değişim için Renk Örneklerini Dışa Aktar…
+	Reset Swatches	Renk Örneklerini Sıfırla
+	Add to Swatches	Renk Örneklerine Ekle
+	Blend If:	Eğer Karışım:
+	Channels:	Kanallar:
+	Knockout	Nakavt
+	Apply At Canvas Bounds	Kanvas Sınırlarında Uygula
+	Color Picker (Text Color)	Renk Seçici (Metin Rengi)
+	Color Picker ({name})	Renk Seçici ({name})
+	Color Picker (Fill Color)	Renk Seçici (Dolgu Rengi)
+	Fill color	Rengi doldur
+	Color Picker (Stroke Color)	Renk Seçici (Kontur Rengi)
+	Stroke color	Kontur rengi
+	Pick screen color	Ekran rengini seç
+	Pick Color From Image	Görüntüden Renk Seç
+	Sample a pixel anywhere on the screen	Ekranın herhangi bir yerinde bir pikseli örnekleyin
+	Click to pick · Esc to cancel	Seçmek için tıklayın · İptal etmek için Esc
+	Pick a screen pixel or press Esc to cancel	Bir ekran pikseli seçin veya iptal etmek için Esc tuşuna basın
+	Scroll to zoom	Yakınlaştırmak için kaydırın
+	Show/Hide All Panels	Tüm Panelleri Göster/Gizle
+	Show/Hide Panels	Panelleri Göster/Gizle
+	Could not open	Açılamadı
+	{path}: the path is not valid Unicode; rename the file and open it again.	{path}: yol geçerli bir Unicode değil; dosyayı yeniden adlandırın ve tekrar açın.
+	Contents:	İçerik:
+	Custom Pattern:	Özel Desen:
+	Foreground Color	Ön Plan Rengi
+	Color…	Renk…
+	50% Gray	%50 Gri
+	{size} (was {old})	{size} ({old} idi)
+	Cone	Koni
+	Cone (Inverted)	Koni (Ters Çevrilmiş)
+	Domed	Kubbeli
+	Domed (Inverted)	Kubbeli (Ters)
+	Diagonal (Descending)	Çapraz (Azalan)
+	Contour Editor	Kontur Düzenleyici
+	Anti-aliased	Kenar yumuşatma
+	Corner	Köşe
+	Gloss Contour	Parlak Kontur
+	Contour	Kontur
+	Cone - Inverted	Koni - Ters
+	Cove - Deep	Koy - Derin
+	Cove - Shallow	Koy - Sığ
+	Half Round	Yarım Yuvarlak
+	Ring - Double	Yüzük - Çift Kişilik
+	Rolling Slope - Descending	Yuvarlanan Eğim - Azalan
+	Rounded Steps	Yuvarlak Adımlar
+	Sawtooth 1	Testere dişi 1
+	Red Eye Tool	Kırmızı Göz Aracı
+	Red Eye	Kırmızı Göz
+	Pupil Size	Öğrenci Boyutu
+	Darken Amount	Koyulaştırma Miktarı
+	Click a red pupil to neutralize it	Nötrleştirmek için kırmızı bir gözbebeğine tıklayın
+	open source	açık kaynak
+	…and {n} more	…ve {n} daha
+	Eyedroppers:	Damlalıklar:
+	Set Black Point	Siyah Noktayı Ayarla
+	Set Neutral Gray Point	Nötr Gri Noktayı Ayarla
+	Set White Point	Beyaz Noktayı Ayarla
+	Unavailable in this color mode	Bu renk modunda kullanılamaz
+	Selection Preview:	Seçim Önizlemesi:
+	Black Matte	Siyah Mat
+	White Matte	Beyaz Mat
+layerLabel	No Color	Renk Yok
+	Seafoam	Deniz köpüğü
+	Indigo	Çivit mavisi
+	Fuchsia	Fuşya
+	Violet	Menekşe
+	Large document: redrawing on the CPU	Büyük belge: CPU'da yeniden çizim
+	This redraw took {seconds} s on the CPU.	Bu yeniden çizim CPU'da {seconds} saniye sürdü.
+	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Bir katmanın karışım modu, opaklığı veya görünürlüğü gibi belgenin tamamını değiştiren düzenlemeler, belgenin tamamını yeniden çizer.
+	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Katmanları GPU bellek bütçesine uymuyor. Tercihler'de Bellek kullanımını artırma › Performans, bütçeyi bu bilgisayarın belleğinin dörtte birine kadar artırır.
+	The GPU compositor wasn't used: {reason}	GPU dizgicisi kullanılmadı: {reason}
+cameraRaw	Light	Açık Tonlar
+fontWeight	Thin	İnce
+fontWeight	ExtraLight	Ekstra İnce
+fontWeight	Light	Hafif
+fontWeight	Regular	Normal
+fontWeight	Medium	Orta
+fontWeight	SemiBold	Yarı Kalın
+fontWeight	Bold	Kalın
+fontWeight	ExtraBold	Ekstra Kalın
+fontWeight	Black	En Kalın
+fontWeight	Italic	İtalik
+	Pattern Stamp Tool	Desen Damgası Aracı
+	Pattern Stamp	Desen Damgası
+	Impressionist	Empresyonist
+	Rotate View	Görünümü Döndür
+	Rotate View Tool	Görünümü Döndürme Aracı
+	Reset View	Görünümü Sıfırla
+	Drag around the centre to rotate the view  ·  Shift constrains to 15°	Görünümü döndürmek için merkezin etrafında sürükleyin · Kaydırma 15° ile sınırlandırılır
+@id	select.all	Tümünü Seç
+@id	edit.stroke	Kontur…
+@id	edit.transform.scale	Ölçekle
+cameraRaw	Red	Kırmızı
+cameraRaw	Orange	Turuncu
+cameraRaw	Yellow	Sarı
+cameraRaw	Green	Yeşil
+cameraRaw	Aqua	Camgöbeği
+cameraRaw	Blue	Mavi
+cameraRaw	Purple	Mor
+cameraRaw	Magenta	Macenta
+cameraRaw	Blending	Karışım
+cameraRaw	Luminance	Parlaklık
+cameraRaw	Temperature	Sıcaklık
+cameraRaw	Color	Renk
+	Patch Tool	Yama Aracı
+	Preferences…	Tercihler…
+	Settings	Ayarlar
+	Duplicate	Çoğalt
+	Actual Pixels	Gerçek Pikseller
+	Hide	Gizle
+	New Layer…	Yeni Katman…
+	Clipping Mask	Kırpma Maskesi
+	Tool Options	Araç Seçenekleri
+	Color Picker	Renk Seçici
+	Color Swatches	Renk Örnekleri
+	Linear Dodge	Doğrusal Soldurma
+	Preview Image	Resmin Önizlemesi
+	Automatic	Otomatik
+	Save As	Farklı Kaydet
+	Import…	İçe aktar…
+	Remove All	Tümünü Kaldır
+	Unlock	Kilidi aç
+	Enable	Etkinleştir
+	Enable animations	Animasyonları etkinleştir
+	Disable	Devre dışı bırak
+	On	Açık
+	Selected	Seçilen
+	Clear Selection	Seçimi Temizle
+	Invert Selection	Seçimi Ters Çevir
+	Select Inverse	Tersini Seç
+	Contract	Sözleşme
+	Sample Size	Örnek Boyutu
+	Strength	Güç
+	Gamma	Gama
+	Input	Giriş
+	Output	Çıkış
+	Input Levels	Giriş Seviyeleri
+	Output Levels	Çıkış Seviyeleri
+	Layer Styles	Katman Stilleri
+	Blending Mode	Karıştırma Modu
+	Fill Color	Dolgu Rengi
+	Stroke Color	Kontur Rengi
+	Stroke Width	Kontur Genişliği
+	Shadow	Gölge
+	Adjustment Layer	Ayarlama Katmanı
+	Adjustment Layers	Ayarlama Katmanları
+	Text Layer	Metin Katmanı
+	Documents	Belgeler
+	File Name	Dosya Adı
+	File Format	Dosya Formatı
+	Compression	Sıkıştırma
+	Artboards	Çalışma yüzeyleri
+	Snap to Grid	Izgaraya Yasla
+	Full Screen	Tam Ekran
+	Fullscreen	Tam ekran
+	Workspaces	Çalışma alanları
+	Alignment	Hizalama
+	Step Backward	Geri Adım
+	Step Forward	İleri Adım
+	Show All	Tümünü Göster
+	Hidden	Gizli
+	New Layer	Yeni Katman
+	Duplicate Layer	Katmanı Çoğalt
+	Ungroup	Grubu çöz
+	Lock Transparent Pixels	Şeffaf Pikselleri Kilitle
+	Lock Image Pixels	Görüntü Piksellerini Kilitle
+	Lock Position	Kilit Konumu
+	Lock All	Tümünü Kilitle
+	Show Rulers	Cetvelleri Göster
+	Show Grid	Izgarayı Göster
+	Guide Layout…	Kılavuz Düzeni…
+	Page Setup…	Sayfa Yapısı…
+	Reset Preferences	Tercihleri Sıfırla
+	Documentation	Dokümantasyon
+	Check for Updates	Güncellemeleri Kontrol Et
+	Loading…	Yükleniyor…
+	Processing…	İşleniyor…
+	Saving…	Kaydediliyor…
+	Exporting…	Dışa aktarılıyor…
+	Please wait…	Lütfen bekleyin…
+	No document open	Hiçbir belge açık değil
+	No selection	Seçim yok
+	No layers	Katman yok
+	No recent files	Yeni dosya yok
+	Unsupported file format	Desteklenmeyen dosya biçimi
+	Failed to open file	Dosya açılamadı
+	Failed to save file	Dosya kaydedilemedi
+	Operation canceled	İşlem iptal edildi
+	Changes have not been saved.	Değişiklikler kaydedilmedi.
+	Are you sure?	Emin misin?
+	Discard Changes	Değişiklikleri İptal Et
+	Recent Files	Son Dosyalar
+	Open File	Dosyayı Aç
+	Save File	Dosyayı Kaydet
+	Save Changes	Değişiklikleri Kaydet
+	Rendering…	Oluşturuluyor…
+	Importing…	İçe aktarılıyor…
+	Ready	Hazır
+	Failed	Başarısız
+	Warning	Uyarı
+	Information	Bilgi
+	Errors	Hatalar
+	Retry	Yeniden dene
+	Continue	Devam et
+	Skip	Atla
+	Stop	Durdur
+	Resume	Devam et
+	Reset All	Tümünü Sıfırla
+	Defaults	Varsayılanlar
+	Apply to All	Tümüne Uygula
+	Confirm	Onayla
+	Finish	Bitiş
+	Back	Geri
+	Next	Sonraki
+	Previous	Önceki
+	More	Daha Fazla
+	Less	Daha az
+	Manual	Manuel
+	Disabled	Devre dışı
+	Locked	Kilitli
+	Unlocked	Kilitli değil
+	Delete…	Sil…
+	Create…	Oluştur…
+	Edit…	Düzenle…
+	Change…	Değiştir…
+	Transformation	Dönüşüm
+	Scaling	Ölçeklendirme
+	Canvas Size	Kanvas Boyutu
+	Percentage	Yüzde
+	Degrees	Dereceler
+	Middle	Orta
+	Location	Konum
+	Location:	Konum:
+	Diameter	Çap
+	Intensity	Yoğunluk
+	Sensitivity	Hassasiyet
+	Softness	Yumuşaklık
+	Feather Radius	Tüy Yarıçapı
+	Color Profile	Renk Profili
+	Library	Kütüphane
+	Libraries	Kütüphaneler
+	Layer Properties	Katman Özellikleri
+	Groups	Gruplar
+	Masks	Maskeler
+	Add Mask	Maske Ekle
+	Delete Mask	Maskeyi Sil
+	Invert Mask	Maskeyi Ters Çevir
+	Enable Mask	Maskeyi Etkinleştir
+	Disable Mask	Maskeyi Devre Dışı Bırak
+	Apply Mask	Maske Uygula
+	Import Settings	Ayarları İçe Aktarma
+	Export Settings	Ayarları Dışa Aktarma
+	Shortcut	Kısayol
+	Shortcuts	Kısayollar
+	Keyboard	Klavye
+	Mouse	Fare
+	Tablet	tablet
+	Display	Ekran
+	Panel	Paneli
+	Hide Grid	Izgarayı Gizle
+	Fit to Window	Pencereye Sığdır
+	Dark Theme	Koyu Tema
+	Light Theme	Işık Teması
+	Live Preview	Canlı Önizleme
+	Before	önce
+	After	Sonra
+	Compare	Karşılaştır
+	File Size	Dosya Boyutu
+	Filename	Dosya adı
+	Folder	Klasör
+	Open Folder	Klasörü Aç
+	Choose Folder	Klasör Seçin
+	Browse	Göz at
+	Find	Bul
+	Replace	Değiştir
+	Category	Kategori
+	Date	Tarih
+	Time	Zaman
+	Learn More	Daha Fazla Bilgi Edinin
+	Report a Bug	Hata Bildir
+	Updates	Güncellemeler
+	Update	Güncelleme
+	Restart Required	Yeniden Başlatma Gerekli
+	Restart	Yeniden başlat
+	Quit	Çıkış
+	Quit PhotoCraft	PhotoCraft'tan Çık
+	Close Window	Pencereyi Kapat
+	New Window	Yeni Pencere
+	Open Image	Resmi Aç
+	Save Image	Resmi Kaydet
+	Export Image	Görüntüyü Dışa Aktar
+	Import Image	Görüntüyü İçe Aktar
+	Export As	Farklı Dışa Aktar
+	Export to	Şuraya aktar:
+	Export Options	Dışa Aktarma Seçenekleri
+	Import Options	İçe Aktarma Seçenekleri
+	No Selection	Seçim Yok
+	No Document	Belge Yok
+	No Image	Resim Yok
+	No Layers	Katman Yok
+	No Results	Sonuç Yok
+	No Results Found	Sonuç Bulunamadı
+	Nothing to Undo	Geri Alınacak Bir Şey Yok
+	Nothing to Redo	Tekrarlanacak bir şey yok
+	Changes Saved	Değişiklikler Kaydedildi
+	Unsaved Changes	Kaydedilmemiş Değişiklikler
+	Save before closing?	Kapatmadan önce kaydet?
+	Are you sure you want to quit?	Vazgeçmek istediğinden emin misin?
+	The file could not be opened.	Dosya açılamadı.
+	The file could not be saved.	Dosya kaydedilemedi.
+	Unsupported format	Desteklenmeyen biçim
+	Out of memory	Bellek yetersiz
+	Permission denied	İzin reddedildi
+	File not found	Dosya bulunamadı
+	Operation failed	İşlem başarısız oldu
+	Operation completed	İşlem tamamlandı
+	Operation cancelled	İşlem iptal edildi
+	Camera Calibration	Kamera Kalibrasyonu
+	Snapshots	Anlık görüntüler
+	Recovery	Kurtarma
+	Fill Light	Işık Doldur
+	Convert to Grayscale	Gri Tonlamaya Dönüştür
+	Sharpness	Keskinlik
+	Color Noise Reduction	Renk Gürültü Azaltma
+	Luminance Smoothness	Parlaklık Pürüzsüzlüğü
+	Focal Length35mm	Odak Uzunluğu35mm
+	Aspect Ratio	En Boy Oranı
+	Enter description…	Açıklamayı girin…
+	Industry Standard	Endüstri Standardı
+	Uncoated CMYK	Kaplamasız CMYK
+	Working Spaces	Çalışma Alanları
+	Color Management Policies	Renk Yönetimi Politikaları
+	Detect Faces	Yüzleri Algıla
+	Localize Color Clusters	Renk Kümelerini Yerelleştirin
+	Duplicated selection name	Yinelenen seçim adı
+	New channel only	Yalnızca yeni kanal
+	Masked Areas	Maskelenmiş Alanlar
+	Selected Areas	Seçilen Alanlar
+	Color indicates	Renk şunu gösterir:
+	Create Snapshot	Anlık Görüntü Oluştur
+	Delete Snapshot	Anlık Görüntüyü Sil
+	New Snapshot	Yeni Anlık Görüntü
+	Snapshot 1	Anlık Görüntü 1
+	Nonlinear History	Doğrusal Olmayan Geçmiş
+	Set New Snapshot as Default	Yeni Anlık Görüntüyü Varsayılan Olarak Ayarla
+	Automatically Create First Snapshot	İlk Anlık Görüntüyü Otomatik Olarak Oluştur
+	Automatically Create New Snapshot When Saving	Kaydederken Otomatik Olarak Yeni Anlık Görüntü Oluştur
+	Show New Snapshot Dialog by Default	Yeni Anlık Görüntü İletişim Kutusunu Varsayılan Olarak Göster
+	Clear History	Geçmişi Temizle
+	Panel Options…	Panel Seçenekleri…
+	View menu	Menüyü görüntüle
+	Keep view in sync	Görünümü senkronize tutun
+	Mouse Controls	Fare Kontrolleri
+	Initial Direction of Stroke	Başlangıç Strok Yönü
+	Direction of Stroke	İnme Yönü
+	Humidity	Nem
+	Auto Clean Brush	Otomatik Temizleme Fırçası
+	Brush Tip	Fırça Ucu
+	New Layer from Brush	Brush'tan Yeni Katman
+	New Brush	Yeni Fırça
+	New Tool Preset	Yeni Araç Ön Ayarı
+	Auto-Leading	Otomatik Satır Aralığı
+	Scale Horizontally	Yatay Olarak Ölçeklendir
+	Scale Vertically	Dikey Ölçeklendir
+	Baseline Shift	Taban Çizgisi Kayması
+	Superscript	Üst simge
+	Subscript	Abonelik
+	Ligature	Ligatür
+	Alternative	Alternatif
+	Extra Light	Ekstra Işık
+	Extra Bold	Ekstra Kalın
+	Sharpen Amount	Keskinleştirme Miktarı
+	Sharpen Radius	Yarıçapı Keskinleştir
+	Sharpen Detail	Detayı Keskinleştir
+	Sharpen Masking	Maskelemeyi Keskinleştir
+	Noise Luminance	Gürültü Parlaklığı
+	Noise Luminance Detail	Gürültü Parlaklığı Ayrıntısı
+	Noise Color	Gürültü Rengi
+	Noise Color Detail	Gürültü Rengi Ayrıntısı
+	Grain Amount	Tane Miktarı
+	Grain Size	Tane Boyutu
+	Grain Roughness	Tahıl Pürüzlülüğü
+	Vignette Roundness	Vinyet Yuvarlaklığı
+	Vignette Feather	Vinyet Tüyü
+	Vignette Highlights	Vinyet Öne Çıkanlar
+	Vignette Style	Vinyet Stili
+	Planes	Uçaklar
+	Corners	Köşeler
+	Plane	Uçak
+	Shadow Amount	Gölge Miktarı
+	Shadow Tone	Gölge Tonu
+	Shadow Radius	Gölge Yarıçapı
+	Highlight Amount	Vurgu Miktarı
+	Highlight Tone	Vurgu Tonu
+	Highlight Radius	Yarıçapı Vurgula
+	Midtone	Orta ton
+	Black Clip	Siyah Klip
+	White Clip	Beyaz Klip
+	Fuzziness	bulanıklık
+	Source Layer	Kaynak Katmanı
+	Neutralize	Nötrleştir
+	Use Selection In Source	Kaynaktaki Seçimi Kullan
+	Use Selection In Target	Hedefteki Seçimi Kullan
+	Flame Type	Alev Tipi
+	Randomize Length	Uzunluğu Rastgeleleştir
+	Interval	Aralık
+	Adjust Interval For Loops	Döngüler İçin Aralığı Ayarla
+	Use Custom Color	Özel Renk Kullan
+	Flame Lines	Alev Hatları
+	Flame Bottom Alignment	Alev Alt Hizalaması
+	Flame Style	Alev Stili
+	Flame Shape	Alev Şekli
+	Randomize Shapes	Şekilleri Rastgeleleştir
+	Frame	Çerçeve
+	Margin	Marj
+	Arrangement	Düzenleme
+	Thickness	Kalınlık
+	Vine Color	Asma Rengi
+	Flower Color	Çiçek Rengi
+	Leaf Color	Yaprak Rengi
+	Base Tree Type	Temel Ağaç Türü
+	Light Direction	Işık Yönü
+	Leaves Amount	Yaprak Miktarı
+	Leaves Size	Yaprak Boyutu
+	Branches Height	Dal Yüksekliği
+	Branches Thickness	Dal Kalınlığı
+	Default Leaves	Varsayılan İzinler
+	Leaves Color	Yaprak Rengi
+	Custom Branch Color	Özel Şube Rengi
+	Branches Color	Dal Rengi
+	Flat Shading	Düz Gölgeleme
+	Enable Timeline Quick Config	Zaman Çizelgesi Hızlı Yapılandırmasını Etkinleştir
+	Set Start Timecode…	Başlangıç Zaman Kodunu Ayarla…
+	Timecode	Zaman kodu
+	Current Time	Güncel Saat
+	Duration	Süre
+	Repeat	Tekrarla
+	Play Once	Bir Kez Oyna
+	Info Options…	Bilgi Seçenekleri…
+	First Color Readout	İlk Renk Okuması
+	Second Color Readout	İkinci Renk Okuması
+	Actual Color	Gerçek Renk
+	Grayscale Slider	Gri Tonlama Kaydırıcısı
+	Web Color	Web Rengi
+	Total Ink	Toplam Mürekkep
+	Opacity Mask	Opaklık Maskesi
+	Document Size	Belge Boyutu
+	Timing	Zamanlama
+	Status Information	Durum Bilgileri
+	Mouse Coordinates	Fare Koordinatları
+	Ruler Units	Cetvel Birimleri
+	Restore last viewed comp	Son görüntülenen kompozisyonu geri yükle
+	Select All Layers	Tüm Katmanları Seç
+	Keep proportions	Oranları koruyun
+	Interpolation	Enterpolasyon
+	Caption	Başlık
+	Caption Credits	Altyazı Kredisi
+	Keywords	Anahtar Kelimeler
+	Copyright Info URL	Telif Hakkı Bilgisi URL'si
+	Copyright Status	Telif Hakkı Durumu
+	Copyrighted	Telif hakkıyla korunuyor
+	Public Domain	Kamu Alanı
+	Unknown	Bilinmiyor
+	Credit	Kredi
+	Transmission Reference	İletim Referansı
+	Urgency	Aciliyet
+	High	Yüksek
+	Low	Düşük
+	Supplemental Categories	Tamamlayıcı Kategoriler
+	Object Name / Title	Nesne Adı / Başlığı
+	Date Created	Oluşturulma Tarihi
+	City	Şehir
+	Province / State	İl / Eyalet
+	Country	Ülke
+	Byline	Yazar yazısı
+	Byline Title	Yazar Başlığı
+	Phone	Telefon
+	Email	E-posta
+	Last Modified	Son Değiştirilme
+	Camera Data	Kamera Verileri
+	Camera Model	Kamera Modeli
+	Camera Make	Kamera Markası
+	EXIF Version	EXIF Sürümü
+	Exposure Program	Maruziyet Programı
+	Aperture	Diyafram
+	Shutter Speed	Enstantane Hızı
+	Metering Mode	Ölçüm Modu
+	Light Source	Işık Kaynağı
+	Flash	Flaş
+	Create Multiple Picture Packages	Çoklu Resim Paketleri Oluşturun
+	Choose…	Seç…
+	Select Folder…	Klasör Seç…
+	Override Action "Save" Commands	Eylem "Kaydet" Komutlarını Geçersiz Kıl
+	File Naming	Dosya Adlandırma
+	Compatibility	Uyumluluk
+	Include ICC Profile	ICC Profilini Ekle
+	Error File	Hata Dosyası
+	Stop For Errors	Hatalar İçin Durdur
+	Log Errors To File	Hataları Dosyaya Günlüğe Kaydet
+	Settings:	Ayarlar:
+	Working Space	Çalışma Alanı
+	Advanced Controls	Gelişmiş Kontroller
+	Desaturate Monitor Colors By	Monitör Renklerinin Doygunluğunu Azaltma
+	Blend RGB Colors Using Gamma 1.0	Gama 1.0 Kullanarak RGB Renklerini Karıştırın
+	Profile Mismatches: Ask When Opening	Profil Uyuşmazlıkları: Açarken Sor
+	Ask When Pasting	Yapıştırırken Sor
+	Missing Profiles: Ask When Opening	Eksik Profiller: Açarken Sor
+	Embed profiles	Profilleri yerleştir
+	Coerce to sRGB	sRGB'ye baskı yapın
+	Graphic and web	Grafik ve web
+	Minimalistic	Minimalist
+	Expand All Groups	Tüm Grupları Genişlet
+	Recent Items	Son Öğeler
+	Delete Preset…	Ön Ayarı Sil…
+	Preset Name:	Ön Ayar Adı:
+	Width and Height	Genişlik ve Yükseklik
+	Units	Birimler
+	Columns	Sütunlar
+	Create new count group	Yeni sayım grubu oluştur
+	Drag to move the layer	Katmanı taşımak için sürükleyin
+	Go to Layer	Katmana Git
+	Current	Mevcut
+	Reference point location	Referans noktası konumu
+	Toggle reference point	Referans noktasını değiştir
+	Heal Off	İyileşme
+	Heal On	İyileşme
+	Heal Auto	Otomatik İyileştirme
+	Brush Size	Fırça Boyutu
+	Heal Color	Rengi İyileştir
+	Result	Sonuç
+	Fast	Hızlı
+	Accurate	Doğru
+	Add to	Ekle
+	Subtract from	Şundan çıkar:
+	Intersect with	İle kesiştir
+	Capture Comp	Comp'ı Yakala
+	No Layer Comps	Katman Kompozisyonu Yok
+	Add to selection  (⇧)	Seçime ekle (⇧)
+	Click to zoom in  ·  ⌥-click to zoom out	Yakınlaştırmak için tıklayın · Uzaklaştırmak için ⌥-tıklayın
+	Commit Perspective Warp (↩)	Perspektif Çarpıtma İşlemi (↩)
+	Commit Puppet Warp (↩)	Kukla Çarpıtma İşlemi (↩)
+	Commit any current edits (⌘↩)	Mevcut düzenlemeleri taahhüt et (⌘↩)
+	Commit current crop operation  (↵)	Mevcut kırpma işlemini gerçekleştir (↵)
+	Commit transform (↩)	Dönüşümü kaydet (↩)
+	Commit warp (↩)	Çözgü gerçekleştir (↩)
+	Create a new layer  (⇧⌘N)	Yeni bir katman oluştur (⇧⌘N)
+	Custom pattern	Özel desen
+	General Brushes	Genel Fırçalar
+	New document…     ⌘N	Yeni belge… ⌘N
+	Open…     ⌘O	Aç… ⌘O
+	Search commands (⌘K)	Arama komutları (⌘K)
+	Uses the foreground and background colors.	Ön plan ve arka plan renklerini kullanır.
+	Collapse group  (⌥-click: all groups)	Grubu daralt (⌥ tuşuna basarak tıklayın: tüm gruplar)
+	Expand group  (⌥-click: all groups)	Grubu genişlet (⌥ tuşuna basarak tıklayın: tüm gruplar)
+	Date and Time	Tarih ve Saat
+	Scale Units	Ölçek Birimleri
+	Scale Factor	Ölçek Faktörü
+	Area	Alan
+	Perimeter	Çevre
+	Circularity	Dairesellik
+	Gray Value (Minimum)	Gri Değeri (Minimum)
+	Gray Value (Maximum)	Gri Değeri (Maksimum)
+	Gray Value (Mean)	Gri Değeri (Ortalama)
+	Gray Value (Median)	Gri Değeri (Medyan)
+	Integrated Density	Entegre Yoğunluk
+	Length	Uzunluk
+	In Black	Siyah
+	In White	Beyaz
+	Out Black	Siyah
+	Out White	Beyaz Dışı
+	Tint Color	Ton Rengi
+	Stops	Duraklar
+	Center X	Merkez X
+	Center Y	Merkez Y
+	Distribution	Dağıtım
+	Monochromatic	Tek renkli
+	Cell Size	Hücre Boyutu
+	Generators	Jeneratörler
+	Wavelength Min	Dalga Boyu Min
+	Wavelength Max	Maksimum Dalga Boyu
+	Amplitude Min	Genlik Min
+	Amplitude Max	Genlik Maksimum
+	Undefined Areas	Tanımsız Alanlar
+	Preserve	Koru
+	Max Radius	Maksimum Yarıçap
+	Depth Mode	Derinlik Modu
+	Solid Front Faces	Katı Ön Yüzler
+	Mask Incomplete Blocks	Tamamlanmamış Blokları Maskele
+	Stylization	Stilizasyon
+	Cleanliness	Temizlik
+	Bristle Detail	Kıl Detayı
+	Lighting	Aydınlatma
+	Shine	Parıltı
+	Max Offset	Maksimum Ofset
+	Map Document	Harita Belgesi
+	Map Path	Harita Yolu
+	Map Layer	Harita Katmanı
+	Ridges	Sırtlar
+	Light Type	Işık Tipi
+	Light X	Işık X
+	Light Y	Işık Y
+	Light Z	Açık Z
+	Target X	Hedef X
+	Target Y	Hedef Y
+	Hotspot	Sıcak nokta
+	Elevation	Yükseklik
+	Ambient	Ortam
+	Warmth	sıcaklık
+	Gloss	parlaklık
+	Metallic	metalik
+	Ambience	ortam
+	White Is High	Beyaz Yüksek
+	Reduce Color Noise	Renk Gürültüsünü Azaltın
+	Sharpen Details	Ayrıntıları Keskinleştir
+	Remove Jpeg Artifact	Jpeg Yapısını Kaldır
+	Remove Tool	Aracı Kaldır
+	Blade Curvature	Bıçak Eğrisi
+	Depth Map	Derinlik Haritası
+	Focal Distance	Odak Mesafesi
+	Focus	Odaklanma
+	Transition	Geçiş
+	Radius X	Yarıçap X
+	Radius Y	Y Yarıçapı
+	Pins	Pimler
+	Blur Angle	Bulanıklık Açısı
+	Speed	Hız
+	Taper	Konik
+	Start X	X'i başlat
+	Start Y	Y'yi başlat
+	End X	X'in sonu
+	End Y	Y Sonu
+	Kernel	çekirdek
+	Input Mode	Giriş Modu
+	Row Order	Satır Sırası
+	Eliminate	Ortadan kaldır
+	Create By	Oluşturan
+	List	Liste
+	Pencil Width	Kalem Genişliği
+	Stroke Pressure	Strok Basıncı
+	Paper Brightness	Kağıt Parlaklığı
+	Number Of Levels	Seviye Sayısı
+	Edge Simplicity	Kenar Sadeliği
+	Edge Fidelity	Kenar Doğruluğu
+	Brush Detail	Fırça Detayı
+	Highlight Area	Alanı Vurgula
+	Glow Size	Parıltı Boyutu
+	Glow Brightness	Parıltı Parlaklığı
+	Brush Type	Fırça Tipi
+	Stroke Size	Kontur Boyutu
+	Stroke Detail	Kontur Detayı
+	Highlight Strength	Gücü Vurgula
+	Smoothness	Pürüzsüzlük
+	Edge Thickness	Kenar Kalınlığı
+	Edge Intensity	Kenar Yoğunluğu
+	Posterization	Posterleştirme
+	Stroke Length	Strok Uzunluğu
+	Relief	Rahatlama
+	Definition	Tanım
+	Texture Coverage	Doku Kapsamı
+	Shadow Intensity	Gölge Yoğunluğu
+	Edge Width	Kenar Genişliği
+	Edge Brightness	Kenar Parlaklığı
+	Direction Balance	Yön Dengesi
+	Black Intensity	Siyah Yoğunluğu
+	White Intensity	Beyaz Yoğunluğu
+	Dark Intensity	Karanlık Yoğunluk
+	Custom Pixel Aspect Ratio	Özel Piksel En Boy Oranı
+	32-bit Preview Options	32 bit Önizleme Seçenekleri
+	New Guide	Yeni Kılavuz
+	Join the ArtCraft Discord	ArtCraft Discord'una katılın
+	Report an Issue	Sorun Bildir
+	Load Files into Stack	Dosyaları Yığına Yükle
+	Statistics	İstatistikler
+	Duplicate Layers	Katmanları Çoğalt
+	Edit Toolbar	Araç Çubuğunu Düzenle
+	Import Brushes	Fırçaları İçe Aktar
+	Load 3D LUT	3D LUT'u yükleyin
+	New document	Yeni belge
+	Press keys	Tuşlara basın
+	Rename Group	Grubu Yeniden Adlandır
+	Rename Tool Preset	Araç Ön Ayarını Yeniden Adlandır
+	Search commands, tools and panels	Komutları, araçları ve panelleri arayın
+	Slice Options	Dilim Seçenekleri
+	Rename Brush	Fırçayı Yeniden Adlandır
+	Opening	Açılış
+	Reading	Okuma
+	Working	Çalışma
+	Accented Edges	Vurgulu Kenarlar
+	Angled Strokes	Açılı Vuruşlar
+	Anisotropic	Anizotropik
+	Around Center	Merkez Çevresi
+	Artistic	Sanatsal
+	Bamboo	Bambu
+	Bas Relief	Bas Rölyef
+	Berries	Meyveler
+	Blast	Patlama
+	Bleach Bypass	Ağartma Baypası
+	Blocks	Bloklar
+	Brick	Tuğla
+	Brush Strokes	Fırça Darbeleri
+	Burlap	Çuval bezi
+	Candle Light	Mum Işığı
+	Circle	daire
+	Clumped	Topaklanmış
+	Coarse Dots	Kaba Noktalar
+	Colored Pencil	Renkli Kalem
+	Contrasty	Kontrastlı
+	Cool	Harika
+	Craquelure	Küçük çatlak
+	Cross	Çapraz
+	Cross Process	Çapraz Süreç
+	Crosshatch	Çapraz tarama
+	Cutout	Kesim
+	Daisies	Papatyalar
+	Dark Rough	Karanlık Sert
+	Dark Strokes	Karanlık Vuruşlar
+	Darken Only	Yalnızca Koyulaştır
+	Day For Night	Gündüz Gece
+	Deep Blue	Derin Mavi
+	Deep Emerald	Derin Zümrüt
+	Deep Red	Koyu Kırmızı
+	Deep Yellow	Koyu Sarı
+	Dot	Nokta
+	Double Line	Çift Hat
+	Draft	Taslak
+	Dry Brush	Kuru Fırça
+	Duplication	Çoğaltma
+	Edge Extension	Kenar Uzantısı
+	Edge Only	Yalnızca Kenar
+	Enlarged	Büyütülmüş
+	Even Fields	Çift Alanlar
+	Faded Film	Solmuş Film
+	Film Grain	Film Tahıl
+	Fine	iyi
+	Fine Dots	İnce Noktalar
+	Flat	Düz
+	Fresco	Fresk
+	From Left	Soldan
+	From Right	Sağdan
+	Frosted	Buzlu
+	Generic	jenerik
+	Glass	Cam
+	Glowing Edges	Parlayan Kenarlar
+	Grainy Dots	Grenli Noktalar
+	Hearts	Kalpler
+	Heptagon	Yedigen
+	Hexagon	Altıgen
+	Horizontal Only	Yalnızca Yatay
+	Infinite	Sonsuz
+	Ink Outlines	Mürekkep Ana Hatları
+	Ivy	sarmaşık
+	Left Diagonal	Sol Çapraz
+	Level Based	Seviyeye Dayalı
+	Light Rough	Hafif Kaba
+	Lighten Only	Yalnızca Açıklaştır
+	Long Lines	Uzun Çizgiler
+	Long Strokes	Uzun Vuruşlar
+	Lower	Daha düşük
+	Medium Dots	Orta Noktalar
+	Medium Lines	Orta Çizgiler
+	Medium Strokes	Orta Vuruşlar
+	Mono Contrast	Mono Kontrast
+	Mosaic Tiles	Mozaik Fayans
+	Multiple Flames Along Path	Yol Boyunca Çoklu Alevler
+	Multiple Flames One Direction	Çoklu Alevler Tek Yön
+	Multiple Flames Path Directions	Çoklu Alev Yolu Yönleri
+	Multiple Flames Various Length	Çoklu Alevler Çeşitli Uzunluklar
+	Octagon	sekizgen
+	Odd Fields	Tek Alanlar
+	One Flame Along Path	Yol Boyunca Bir Alev
+	Out From Center	Merkezden Dışarı
+	Oval	oval
+	Overlay Edge	Kaplama Kenarı
+	Palette Knife	Palet Bıçağı
+	Parallel	paralel
+	Patchwork	yama işi
+	Pentagon	Pentagon
+	Point	Nokta
+	Pointed	Sivri
+	Pond Ripples	Gölet Dalgaları
+	Pyramids	Piramitler
+	Random	Rastgele
+	Right Diagonal	Sağ Diyagonal
+	Ring	Yüzük
+	Rope	Halat
+	Roses	Güller
+	Sandstone	Kumtaşı
+	Scallops	tarak
+	Sepia	Sepya
+	Short Lines	Kısa Çizgiler
+	Short Strokes	Kısa Vuruşlar
+	Simple	Basit
+	Light Intensity	Işık Yoğunluğu
+	Spray Radius	Püskürtme Yarıçapı
+	Stroke Direction	Strok Yönü
+	Graininess	Taneciklilik
+	Glow Amount	Işıma Miktarı
+	Clear Amount	Temizleme Miktarı
+	Distortion	Bozulma
+	Ripple Size	Dalgalanma Boyutu
+	Ripple Magnitude	Dalgalanma Büyüklüğü
+	Charcoal Area	Kömür Alanı
+	Chalk Area	Tebeşir Alanı
+	Charcoal Thickness	Kömür Kalınlığı
+	Light Dark Balance	Açık Karanlık Dengesi
+	Foreground Level	Ön Plan Seviyesi
+	Background Level	Arka Plan Düzeyi
+	Pattern Type	Desen Türü
+	Image Balance	Görüntü Dengesi
+	Darkness	Karanlık
+	Fiber Length	Elyaf Uzunluğu
+	Crack Spacing	Çatlak Aralığı
+	Crack Depth	Çatlak Derinliği
+	Crack Brightness	Çatlak Parlaklığı
+	Grain Type	Tahıl Türü
+	Tile Size	Döşeme Boyutu
+	Grout Width	Derz Genişliği
+	Lighten Grout	Harcı hafifletmek
+	Square Size	Kare Boyutu
+	Border Thickness	Kenar Kalınlığı
+	Correct Distortion	Bozulmanın Düzeltilmesi
+	Correct Vignette	Doğru Vinyet
+	Correct C A	Doğru CA
+	Auto Scale	Otomatik Ölçeklendirme
+	Red Cyan	Kırmızı Camgöbeği
+	Blue Yellow	Mavi Sarı
+	Vignette Amount	Vinyet Miktarı
+	Vignette Midpoint	Vinyet Orta Noktası
+	Constraints	Kısıtlamalar
+	Curve Highlights	Eğrinin Öne Çıkan Noktaları
+	Curve Lights	Eğri Işıkları
+	Curve Darks	Eğri Koyuları
+	Curve Shadows	Eğri Gölgeleri
+	Curve Splits	Eğri Bölmeleri
+	Point Curve	Nokta Eğrisi
+	Point Curve Red	Nokta Eğrisi Kırmızı
+	Point Curve Green	Nokta Eğrisi Yeşil
+	Point Curve Blue	Nokta Eğrisi Mavi
+	Hsl Hue	Hsl Ton
+	Hsl Sat	HSL Cumartesi
+	Hsl Lum	Hsl Lum
+	Grade Shadows	Sınıf Gölgeleri
+	Grade Midtones	Derece Orta Tonları
+	Grade Highlights	Notun Öne Çıkan Noktaları
+	Grade Global	Küresel Sınıf
+	Grade Blending	Sınıf Harmanlama
+	Grade Balance	Not Dengesi
+	Sine	sinüs
+	Sketch	Eskiz
+	Snowflakes	Kar taneleri
+	Sparkle	ışıltı
+	Spatter	Sıçrama
+	Speckle	Benek
+	Spin	Döndürme
+	Sprinkles	serpintiler
+	Squareness	Karelik
+	Stagger	Sendeleme
+	Stained Glass	Vitray
+	Star	Yıldız
+	Stars	Yıldızlar
+	Stippled	noktalanmış
+	Stretch	Streç
+	Teal Orange	turkuaz turuncu
+	Tiny Lens	Minik Mercek
+	To Center	Merkeze
+	Triangle	Üçgen
+	Unaltered	değiştirilmemiş
+	Underpainting	Alt boyama
+	Underwater	Sualtı
+	Uniform	Üniforma
+	Upper	Üst
+	Vertical Only	Yalnızca Dikey
+	Vine With Flowers	Çiçekli Asma
+	Vine With Leaves	Yapraklı Asma
+	Violent	Şiddet içeren
+	Warm	Sıcak
+	Watercolor	Suluboya
+	Waves	Dalgalar
+	Wide Blurry	Geniş Bulanık
+	Wide Sharp	Geniş Keskin
+	Wrap	Sarma
+	Zigzag	Zikzak
+	Wetness	ıslaklık
+	Delete Smart Filters	Akıllı Filtreleri Sil
+	Enable Smart Filters	Akıllı Filtreleri Etkinleştir
+	Delete Layer…	Katmanı Sil…
+	Select Similar Colors	Benzer Renkleri Seçin
+	New Selection	Yeni Seçim
+	Click the first point or press ↵ to close · Esc cancels	Kapatmak için ilk noktayı tıklayın veya ↵ tuşuna basın · Esc iptal eder
+	Click to add a point · drag off or ⌘/Ctrl-click or Delete to remove	Nokta eklemek için tıklayın · sürükleyin veya kaldırmak için ⌘/Ctrl tuşuna basarak tıklayın veya Sil
+	Click to apply, ⌥-click to clear overrides, double-click for Style Options	Uygulamak için tıklayın, geçersiz kılmaları temizlemek için ⌥-tıklayın, Stil Seçenekleri için çift tıklayın
+	Click: corner · Drag: smooth · Click first point: close · ↩ finish · Esc cancel	Tıklayın: köşe · Sürükleyin: pürüzsüz · İlk noktaya tıklayın: kapat · ↩ bitir · Esc iptal
+	Rulers  (⌘R)	Cetveller (⌘R)
+	Show Guides  (⌘;)	Kılavuzları Göster (⌘;)
+	Grid  (⌘')	Izgara (⌘')
+	PDF Presentation…	PDF Sunumu…
+	Picture Package…	Resim Paketi…
+	Web Photo Gallery…	Web Fotoğraf Galerisi…
+	Gray:	Gri:
+	Spot:	Nokta:
+	Technology Previews…	Teknoloji Önizlemeleri…
+	3D…	3 boyutlu…
+	AI Integrations	Yapay Zeka Entegrasyonları
+	Add Noise	Gürültü Ekle
+	Add Pins	Pin Ekle
+	Add a mask  (from the selection; ⌥ inverts)	Bir maske ekleyin (seçimden; ⌥ tersine çevirir)
+	Adds grain to the soft edges of the brush tip.	Fırça ucunun yumuşak kenarlarına gren ekler.
+	Adobe PDF Presets…	Adobe PDF Hazır Ayarları…
+	Advanced Blending	Gelişmiş Harmanlama
+	After (X)	(X)'ten sonra
+	Airbrush: keeps painting while the pointer rests.	Airbrush: İşaretçi dururken boyamaya devam eder.
+	Alternates for Current Selection	Mevcut Seçimin Alternatifleri
+	Apply Data Set	Veri Kümesini Uygula
+	Apply Image	Resmi Uygula
+	Arbitrary	keyfi
+	Artboard from Group	Gruptan çalışma yüzeyi
+	Artboard from Layers	Katmanlardan Çalışma Yüzeyi
+	Artboards to Files	Çalışma Yüzeylerinden Dosyalara
+	Artboards to PDF	Çalışma yüzeylerini PDF'ye dönüştürme
+	Ask Before Saving Saved Embedded	Kaydedilen Gömülü Kaydetmeden Önce Sor
+	Assign Profile	Profil Ata
+	At	Şu tarihte:
+	Audio	Ses
+	Auto-Align Layers	Katmanları Otomatik Hizala
+	Auto-Blend Layers	Katmanları Otomatik Karıştır
+	Auto-Hide	Otomatik Gizle
+	Auto-leading %	Otomatik satır aralığı %
+	Avoid Widows/Orphans	Dul/Yetimlerden Kaçının
+	Background from Layer	Katmandan Arka Plan
+	Batch	Toplu
+	Blend	Karışım
+	Border	Sınır
+	Box Blur	Kutu Bulanıklığı
+	Calculations	Hesaplamalar
+	Camera Raw	Camera Raw
+	Camera Raw Filter	Camera Raw Filtresi
+	Canvas rotation	Kanvas döndürme
+	Channel1	Kanal1
+	Channel2	Kanal2
+	Channel3	Kanal3
+	Channel4	Kanal4
+	Clipping Path	Kırpma Yolu
+	Clone	Klon
+	Color Decontaminate	Renkli Dekontaminasyon
+	Color Halftone	Renk Noktalı Resim
+	Color Lookup Tables	Renk Arama Tabloları
+	Color Settings	Renk Ayarları
+	Color Table	Renk Tablosu
+	Compose	Oluştur
+	Condensed	Yoğunlaştırılmış
+	Conditional Mode Change	Koşullu Mod Değişikliği
+	Content-Aware Fill	İçeriğe Uygun Dolgu
+	Convert Frames > Video Layers	Çerçeveleri Dönüştür > Video Katmanları
+	Convert to Linked	Bağlantılıya Dönüştür
+	Convert to Profile	Profile Dönüştür
+	Create Date	Tarih Oluştur
+	Create Plane	Düzlem Oluştur
+	Create new layer	Yeni katman oluştur
+	Create new set	Yeni grup oluştur
+	Crystallize	Kristalleş
+	Data	Veri
+	Data Sets as Files	Dosya Olarak Veri Kümeleri
+	DateTime Original	TarihSaat Orijinal
+	De-Interlace	Taramasızlaştırma
+	Defaults restored.	Varsayılanlar geri yüklendi.
+	Define Brush Preset	Fırça Ön Ayarını Tanımla
+	Define Custom Shape	Özel Şekli Tanımla
+	Define Pattern	Deseni Tanımla
+	Defringe	Bordürleri kaldır
+	Delete Pins	Pinleri Sil
+	Diffuse	Yaygın
+	Diffuse Glow	Yaygın Parıltı
+	Digits	Rakamlar
+	Displace	Yer değiştir
+	Do you want to save you made to “{name}” before quitting?	Çıkmadan önce yaptığınız işi “{name}” konumuna kaydetmek istiyor musunuz?
+	Dodge/Burn	Soldurma/Yakma
+	Duplicate Path	Yinelenen Yol
+	Dust & Scratches	Toz ve Çizikler
+	Dynamics	Dinamik
+	Edit Plane	Düzlemi Düzenle
+	Export Contents	İçeriği Dışa Aktar
+	Export Preferences	Dışa Aktarma Tercihleri
+	Export/Import Presets	Ön Ayarları Dışa Aktarma/İçe Aktarma
+	Extensions	Uzantılar
+	Extrude	Ekstrüzyon
+	Fibers	Lifler
+	Field Blur	Alan Bulanıklığı
+	File Info	Dosya Bilgileri
+	Filter Gallery	Filtre Galerisi
+	Find and Replace Text	Metni Bul ve Değiştir
+	First Line Indent	İlk Satır Girintisi
+	Fit Image	Resmi Sığdır
+	Flame	Alev
+	Flatten Frames Into Clips	Çerçeveleri Klipsler halinde Düzleştirin
+	Flatten Frames Into Layers	Çerçeveleri Katmanlara Düzleştirin
+	Focus Area	Odak Alanı
+	Follows only edges this close to the pointer ([ and ] change it)	Yalnızca işaretçiye bu kadar yakın olan kenarları takip eder ([ ve ] bunu değiştirir)
+	Frame Duration	Kare Süresi
+	Frame Sync	Çerçeve Senkronizasyonu
+	Gaussian	Gaussian
+	Gaussian Blur	Gauss Bulanıklığı
+	General Blend	Genel Karışım
+	Global Light	Küresel Işık
+	Glyph	Glif
+	Glyph Scaling	Glif Ölçekleme
+	Group from Layers	Katmanlardan Gruplandır
+	Group · {n} layer	Grup · {n} katman
+	HDR Toning	HDR Tonlama
+	HSB Color	HSB Rengi
+	HSL/Grayscale	HSL/Gri tonlamalı
+	Hanging Punctuation	Asılı Noktalama İşaretleri
+	Heal	İyileşmek
+	Healing	Şifa
+	Hide the layer's effects  (⌥-click: all layers)	Katmanın efektlerini gizleyin (⌥ tuşuna basarak tıklayın: tüm katmanlar)
+	High Pass	Yüksek Geçiş
+	Higher values follow only edges that contrast sharply with their surroundings	Daha yüksek değerler yalnızca çevreleriyle keskin bir kontrast oluşturan kenarları takip eder
+	Highlight	Vurgula
+	How often fastening points are placed by themselves	Sabitleme noktalarının kendi başlarına ne sıklıkla yerleştirildiği
+	ISO Speed	ISO Hızı
+	Image Processor	Görüntü İşlemcisi
+	In	içinde
+	Install Plug-in	Eklentiyi Yükle
+	Interpret Footage	Görüntüyü Yorumlama
+	Intersect with selection  (⇧⌥)	Seçimle kesiştir (⇧⌥)
+	Iris Blur	İris Bulanıklığı
+	Jag	Jag
+	Justify	Gerekçelendir
+	Keeps the current texture when switching presets.	Ön ayarları değiştirirken mevcut dokuyu korur.
+	Label	Etiket
+	Layer Comps to Files	Dosyalara Katman Kompozisyonları
+	Layer Content Options	Katman İçeriği Seçenekleri
+	Layer From Background	Arka Plandan Katman
+	Layer from Background	Arka Plandan Katman
+	Layers to Files	Dosyalara Katmanlar
+	Legacy	Eski
+	Lens	Objektif
+	Lens Blur	Mercek Bulanıklığı
+	Lens Correction	Mercek Düzeltme
+	Lens Corrections	Mercek Düzeltmeleri
+	Lens Flare	Mercek Parlaması
+	Lens Info	Objektif Bilgisi
+	Letter Spacing	Harf Aralığı
+	Lighting Effects	Aydınlatma Efektleri
+	Limit Playback	Oynatmayı Sınırla
+	Liquify	Sıvılaştır
+	Lock Layers	Katmanları Kilitle
+	Loop	Döngü
+	Lum	Lum
+	Match Color	Rengi Eşleştir
+	Measure	Ölçü
+	Merge to HDR Pro	HDR Pro'ya Birleştir
+	Mezzotint	Mezotint
+	Modify Date	Tarihi Değiştir
+	Mosaic	Mozaik
+	Motion Blur	Hareket Bulanıklığı
+	Native file drag-and-drop is not supported on Wayland yet. Use File › Open, or run PhotoCraft under XWayland with `WAYLAND_DISPLAY= photocraft`.	Yerel dosya sürükle ve bırak özelliği henüz Wayland'de desteklenmiyor. Dosya › Aç'ı kullanın veya PhotoCraft'ı XWayland altında `WAYLAND_DISPLAY= photocraft` ile çalıştırın.
+	Neon Glow	Neon Parıltı
+	New Guide Layout	Yeni Kılavuz Düzeni
+	New Path	Yeni Yol
+	New Video Group	Yeni Video Grubu
+	New Video Layer	Yeni Video Katmanı
+	New Video Layer from File	Dosyadan Yeni Video Katmanı
+	Newspaper	Gazete
+	Ocean Ripple	Okyanus Dalgalanması
+	Oil Paint	Yağlı Boya
+	Open As	Farklı Aç
+	Operation	Operasyon
+	Out	Dışarı
+	Package	Paket
+	Paint Daubs	Boya Lekeleri
+	Path Blur	Yol Bulanıklığı
+	Path to Illustrator…	İllüstratöre Giden Yol…
+	Path:	Yol:
+	Paths to Illustrator	Illustrator'a Giden Yollar
+	Photomerge	Fotoğraf Birleştir
+	Picture Frame	Resim Çerçevesi
+	Pinch	Tutam
+	Place Embedded	Gömülü Yer
+	Place Linked	Bağlantılı Yer
+	Place Scale Marker	Ölçek İşaretçisini Yerleştirin
+	Plastic Wrap	Plastik Sarma
+	Pointillize	Noktalaştır
+	Polar Coordinates	Kutupsal Koordinatlar
+	Polar To Rectangular	Polar'dan Dikdörtgen'e
+	Poster Edges	Poster Kenarları
+	Preset Manager	Ön Ayar Yöneticisi
+	Profile	Profil
+	Quick Sync	Hızlı Senkronizasyon
+	Radial Blur	Radyal Bulanıklık
+	Raw Data	Ham Veri
+	Raw Defaults	Ham Varsayılanlar
+	Rectangular To Polar	Dikdörtgenden Polar'a
+	Reduce Noise	Gürültüyü Azaltın
+	Relink to File	Dosyaya Yeniden Bağlan
+	Render Video	Videoyu Oluştur
+	Replace Color	Rengi Değiştir
+	Replace Contents	İçeriği Değiştir
+	Replace Footage	Görüntüyü Değiştir
+	Resolve Missing Fonts	Eksik Yazı Tiplerini Çözün
+	Ripple	Dalgalanma
+	Roman Hanging Punctuation	Roma Asılı Noktalama İşaretleri
+	Rotate Auto	Otomatik Döndür
+	Rotate Fixed	Sabit Döndür
+	Rough Pastels	Kaba Pastel
+	Sat	Cumartesi
+	Save a Copy	Bir Kopyasını Kaydet
+	Save for Web (Legacy)	Web için Kaydet (Eski)
+	Saved Multichannel	Çok Kanallı Kaydedildi
+	Scale Effects	Ölçek Efektleri
+	Script Events Manager	Komut Dosyası Olay Yöneticisi
+	Search menus	Arama menüleri
+	Seed	tohum
+	Select Plane	Düzlem Seç
+	Select and Mask	Seç ve Maskele
+	Semi Bold	Yarı Kalın
+	Set Measurement Scale	Ölçüm Ölçeğini Ayarla
+	Shadows/Highlights	Gölgeler/Vurgular
+	Shape Blur	Şekil Bulanıklığı
+	Shear	Kesme
+	Show the layer's effects  (⌥-click: all layers)	Katmanın efektlerini göster (⌥ tuşuna basarak tıklayın: tüm katmanlar)
+	Single Word Justification	Tek Kelime Gerekçesi
+	Smart Blur	Akıllı Bulanıklaştırma
+	Smart Sharpen	Akıllı Keskinleştirme
+	Smudge Stick	Leke Çubuğu
+	Solid Color	Düz Renk
+	Spacing:	Aralık:
+	Spherize	Küreselleştir
+	Spin Blur	Döndürme Bulanıklığı
+	Split Toning	Bölünmüş Tonlama
+	Split at Playhead	Oynatma Kafasında Böl
+	Spot	nokta
+	Spot Channel	Spot Kanal
+	Sprayed Strokes	Püskürtülmüş Vuruşlar
+	Strokes	Vuruşlar
+	Subject Distance	Konu Mesafesi
+	Subtract from selection  (⌥)	Seçimden çıkar (⌥)
+	Sumi-e	Sumi-e
+	Surface Blur	Yüzey Bulanıklığı
+	Technology Previews	Teknoloji Önizlemeleri
+	Texturizer	Dokulaştırıcı
+	Tiles	Fayans
+	Tilt	Eğim
+	Tilt-Shift	Tilt-Shift
+	Tone Curve	Ton Eğrisi
+	Tool	Araç
+	Toolbars	Araç Çubukları
+	Trace Contour	Konturu İzle
+	Trap	Tuzak
+	Tree	Ağaç
+	Trim	Kırpma
+	Turbulent	Çalkantılı
+	Twirl	Burgu
+	Ultra Bold	Ultra Kalın
+	Ultra Light	Ultra Hafif
+	Unsharp Mask	Keskinliği Azaltma Maskesi
+	Use File › Open to open an image.	Bir resmi açmak için Dosya › Aç'ı kullanın.
+	Vanishing Point	Ufuk Noktası
+	Variable Data Sets	Değişken Veri Setleri
+	Video Frames to Layers	Video Karelerinden Katmanlara
+	WIA Support	WIA Desteği
+	Warp Text	Metni Çözgü
+	Watercolour look: lighter interior, darker rims.	Suluboya görünümü: daha açık iç kısım, daha koyu jantlar.
+	Wind	Rüzgâr
+	Word Spacing	Kelime Aralığı
+	Working Gray Plate	Gri Çalışma Plakası
+	ZigZag	ZigZag
+	↑↓ navigate   ↵ run   esc close	↑↓ gezin ↵ çalıştır esc kapat
+cameraRaw	Amount	Miktar
+cameraRaw	Blacks	Siyahlar
+cameraRaw	Color Detail	Renk Detayı
+cameraRaw	Color Grading	Renk Derecelendirme
+cameraRaw	Darks	Koyular
+cameraRaw	Global	Genel
+cameraRaw	Hue	Ton
+cameraRaw	Lights	Açıklar
+cameraRaw	Luminance Detail	Parlaklık Detayı
+cameraRaw	Masking	Maskeleme
+cameraRaw	Roughness	Pürüzlülük
+cameraRaw	Tint	Renk Tonu
+cameraRaw	Vibrance	Titreşim
+cameraRaw	Whites	Beyazlar
+	Wand	Değnek
+	Note tool	Not aracı
+	Magnetic Lasso	Manyetik Kement
+	Art History Brush	Sanat Tarihi Fırçası
+	Spot Healing	Nokta Şifası
+	Content-Aware Move	İçeriğe Uygun Taşıma
+	Vertical Type Tool	Dikey Metin Aracı
+	Click the first point or press {key} to close · {del} removes a point · Esc cancels	İlk noktayı tıklayın veya kapatmak için {key} tuşuna basın · {del} bir noktayı kaldırır · Esc iptal eder
+	Click, then move along an edge · click to fasten a point · {alt}-click for a straight segment · double-click to close	Tıklayın, ardından bir kenar boyunca hareket edin · bir noktayı sabitlemek için tıklayın · düz bir parça için {alt}-tıklayın · kapatmak için çift tıklayın
+	About {app}	{app} Hakkında
+	Hide {app}	{app}'ı gizle
+	Quit {app}	{app}'dan çık
+	Services	Hizmetler
+	Hide Others	Diğerlerini Gizle
+	3D	3D
+	Pen	Kalem
+	Hand	El
+	Sampler	Örnekleyici
+	Patch	Yama
+	Perspective Crop	Perspektif Kırpma
+	RGB	RGB
+	ISO	ISO
+	ColorSync	Renk Senkronizasyonu
+	ProPhoto	ProFotoğraf
+	sRGB	sRGB
+	ACES	ACES
+	{zoom}%	%{zoom}
+	Mac LCD	Mac LCD'si
+	Mac Sharp	Mac Keskin
+	Mac Crisp	Mac Çıtır
+	Mac Strong	Mac Güçlü
+	Mac Smooth	Mac Pürüzsüz
+	Adobe Single-line Composer	Adobe Tek Satır Oluşturucu
+	Adobe Every-line Composer	Adobe Her Satır Oluşturucusu
+	X	X
+	Y	Y
+	30 fps	30 fps
+	25 fps	25 fps
+	24 fps	24 fps
+	15 fps	15 fps
+	10 fps	10 fps
+	URLs	URLs
+	EXIF	EXIF
+	GPS	GPS
+	Mac OS	Mac OS
+	Unix	Unix
+	RGB:	RGB:
+	CMYK:	CMYK:
+	sRGB IEC61966-2.1	sRGB IEC61966-2.1
+	Adobe RGB (1998)	Adobe RGB (1998)
+	ProPhoto RGB	ProPhoto RGB
+	ColorMatch RGB	ColorMatch RGB
+	Wide Gamut RGB	Wide Gamut RGB
+	Apple RGB	Apple RGB
+	NTSC (1953)	NTSC (1953)
+	PAL/SECAM	PAL/SECAM
+	SMPTE C	SMPTE-C
+	HDTV (Rec. 709)	HDTV (Kayıt 709)
+	CIE RGB	CIE RGB
+	Photo (2 × 3 in)	Fotoğraf (2 × 3 inç)
+	Photo (4 × 6 in)	Fotoğraf (4 × 6 inç)
+	Photo (5 × 7 in)	Fotoğraf (5 × 7 inç)
+	Photo (8 × 10 in)	Fotoğraf (8 × 10 inç)
+	Lut	Lut
+	Cooling L B B	Soğutma L B B
+	Cooling80	Soğutma80
+	Cooling82	Soğutma82
+	Hsb	HSB
+	Hsl	HSL
+	Movie Prime	Film Başbakanı
+	Prime105	Prime105
+	Prime35	Prime35
+	Rgb	RGB
+	Sponge	Sünger
+	Warming L B A	Isınma L B A
+	Warming81	Isınma81
+	Warming85	Isınma85
+@id	filter.sharpen.sharpen	Keskinleştir
+	Good	iyi
+	Best	En iyi
+	Out of gamut for printing: click for the nearest printable colour	Yazdırma için gamın dışında: yazdırılabilir en yakın renk için tıklayın
+	Not a web colour: click for the nearest web colour	Web rengi değil: en yakın web rengi için tıklayın
+	Adjustment Properties	Ayarlama Özellikleri
+	Brush Stroke	Fırça Darbesi
+	Default Foreground and Background Colors	Varsayılan Ön Plan ve Arka Plan Renkleri
+	Move Layer	Katmanı Taşı
+	Rectangular Selection	Dikdörtgen Seçimi
+	Reorder Layer	Katmanı Yeniden Sırala
+	Select Layer	Katman Seç
+	Set Colors	Renkleri Ayarla
+	Switch Foreground and Background Colors	Ön Plan ve Arka Plan Renklerini Değiştir
+	Target	Hedef
+	3 by 3 Average	3'e 3 Ortalama
+	5 by 5 Average	5'e 5 Ortalama
+	11 by 11 Average	11'e 11 Ortalama
+	31 by 31 Average	31'e 31 Ortalama
+	51 by 51 Average	51'e 51 Ortalama
+	101 by 101 Average	101'e 101 Ortalama
+	All Layers No Adjustments	Tüm Katmanlar Ayarlama Yok
+	Color to Alpha…	Alfa'ya Renk…
+	Current & Below No Adjustments	Mevcut ve Altında Ayarlama Yok
+	Now drag the selection onto another area	Şimdi seçimi başka bir alana sürükleyin
+	Point Sample	Nokta Örneği
+	Sample Size:	Örnek Boyutu:
+	Show Sampling Ring	Örnekleme Halkasını Göster
+	Dual Axis	Çift Eksen
+	Diagonal	diyagonal
+	Transform Symmetry	Simetriyi Dönüştür
+	Rasterize svg groups deeper than	Svg gruplarını şundan daha derin bir şekilde rasterleştirin:
+	0 turns this threshold off; SVG groups nested deeper than 100 levels are always rasterized.	0 bu eşiği kapatır; 100 düzeyden daha derine yerleştirilmiş SVG grupları her zaman rasterleştirilir.
+	Rule of Thirds	Üçte Bir Kuralı
+	Golden Ratio	Altın Oran
+	Golden Spiral	Altın Spiral
+	Auto Show Overlay	Otomatik Göster Yer Paylaşımı
+	Always Show Overlay	Kaplamayı Her Zaman Göster
+	Never Show Overlay	Kaplamayı Hiçbir Zaman Gösterme
+	Cycle Overlay	Döngü Yerleşimi
+	Cycle Orientation	Döngü Yönü
+	Set the overlay options for the Crop tool	Kırpma aracının kaplama seçeneklerini ayarlama
+	Alt-click went to the desktop, which moves windows with Alt-drag. Set its window-move key to Super, or latch Alt in Window › Modifier Keys.	Alt tuşuna basıp masaüstüne giderek pencereleri Alt tuşuyla sürükleyerek hareket ettirin. Pencere taşıma tuşunu Süper olarak ayarlayın veya Pencere › Değiştirici Tuşlar'da Alt'ı mandallayın.
+	Color Picker (Layer Style Color)	Renk Seçici (Katman Stili Rengi)
+	Auto Hide Notifications	Bildirimleri Otomatik Gizle
+	Notification Duration (seconds)	Bildirim Süresi (saniye)
+	Appearance Mode	Görünüm Modu
+	Presentation	Sunum
+	Next Appearance Mode	Sonraki Görünüm Modu
+	Sync with system	Sistemle senkronizasyon
+	Active	Aktif
+	Color Picker (Solid Color)	Renk Seçici (Düz Renk)
+	Straighten the image by drawing a line on it	Üzerine bir çizgi çizerek görüntüyü düzeltin
+	Set additional Crop options	Ek Kırpma seçeneklerini ayarlayın
+	Show Cropped Area	Kırpılmış Alanı Göster
+	Enable Crop Shield	Kırpma Kalkanını Etkinleştir
+	Match Canvas	Maç Kanvası
+	Auto Adjust Opacity	Opaklığı Otomatik Ayarla
+	Crop Shield color	Kırpma Kalkanı rengi
+	Color Picker (Crop Shield Color)	Renk Seçici (Kırpma Kalkanı Rengi)
+	From Center	Merkezden
+	Link radii	Bağlantı yarıçapları
+	Star Ratio:	Yıldız Oranı:
+	Create Rectangle	Dikdörtgen Oluştur
+	Create Ellipse	Elips Oluştur
+	Create Triangle	Üçgen Oluştur
+	Create Polygon	Çokgen Oluştur
+	Pressure curve	Basınç eğrisi
+	Click to add a point, right-click to remove	Nokta eklemek için tıklayın, kaldırmak için sağ tıklayın
+	Some brush presets could not be loaded	Bazı fırça ön ayarları yüklenemedi
+	Retry saving presets	Ön ayarları kaydetmeyi yeniden deneyin
+	Brush preset changes are not saved: {error}	Fırça hazır ayarı değişiklikleri kaydedilmiyor: {error}
+	Keep this tab open to retain your brushes.	Fırçalarınızı korumak için bu sekmeyi açık tutun.
+	Browser storage is unavailable; brushes are session-only. Keep this tab open to retain them.	Tarayıcı depolama alanı kullanılamıyor; fırçalar yalnızca oturum içindir. Bunları korumak için bu sekmeyi açık tutun.
+	Saving brush presets… Keep this tab open until saving finishes.	Fırça ön ayarları kaydediliyor… Kaydetme bitene kadar bu sekmeyi açık tutun.
+	Reflect	Yansıt
+	Glow	Parıltı
+	Negation	Olumsuzluk
+	XOR	XOR
+	Color Burn (Paint.NET)	Renk Yanması (Paint.NET)
+	Color Dodge (Paint.NET)	Renk Soldurma (Paint.NET)
+	Pro Medium	Profesyonel Orta
+	Studio Light	Stüdyo Işığı
+	Stroke Options	Kontur Seçenekleri
+	Solid	Katı
+	Dashed	Kesikli
+	Dotted	Noktalı
+	Caps	Kapaklar
+	Butt / Flat	Popo / Düz
+	Miter	Gönye
+	Round	Yuvarlak
+	Bevel	Eğim
+	Miter limit	Gönye sınırı
+	Dashed line	Kesikli çizgi
+	Dash	Çizgi
+	Gap	Boşluk
+	Dash / gap lengths × stroke width	Çizgi / boşluk uzunlukları × kontur genişliği
+	Add pair	Çift ekle
+	Remove pair	Çifti kaldır
+	Dash offset	Çizgi ofseti
+	Open paths use centered strokes	Açık yollar ortalanmış konturlar kullanır
+	Use finite lengths and a positive pattern total	Sonlu uzunluklar ve pozitif bir model toplamı kullanın
+	No subject found — try Object Selection or the Lasso	Konu bulunamadı — Nesne Seçimi'ni veya Kement'i deneyin
+	Quick Selection found nothing there	Hızlı Seçim orada hiçbir şey bulamadı
+	Object Selection found nothing there — try a tighter rectangle	Nesne Seçimi burada hiçbir şey bulamadı; daha dar bir dikdörtgen deneyin
+	No subject found — try a rectangle around the object	Konu bulunamadı — nesnenin etrafında bir dikdörtgen oluşturmayı deneyin
+	Appearance Settings…	Görünüm Ayarları…
+	Add to favorites	Favorilere ekle
+	Remove from favorites	Favorilerden kaldır
+cameraData	Make	Üretici
+cameraData	Model	Model
+cameraData	Date Taken	Çekim Tarihi
+cameraData	Exposure	Pozlama
+cameraData	F-Stop	Diyafram
+cameraData	ISO Speed	ISO Hızı
+cameraData	Focal Length	Odak Uzaklığı
+cameraData	Focal Length (35 mm)	Odak Uzaklığı (35 mm)
+cameraData	Lens	Lens
+	Activate Panel	Paneli Etkinleştir
+	Change Panel Group	Panel Grubunu Değiştir
+	Change Panel Layout	Panel Düzenini Değiştir
+	Close Panel	Paneli Kapat
+	Dock Panel	Bağlantı İstasyonu Paneli
+	Float Panel	Şamandıra Paneli
+	Move Panel	Paneli Taşı
+	Group with	Şununla grupla:
+	Panel menu	Panel menüsü
+	Resize panel window	Panel penceresini yeniden boyutlandır
+	Resize panels	Panelleri yeniden boyutlandır
+	Use Classic Mode	Klasik Modu Kullan
+	Auto Center Preview	Otomatik Merkezleme Önizlemesi
+	Next Document	Sonraki Belge
+	Previous Document	Önceki Belge
+	W x H x Resolution	G x Y x Çözünürlük
+	Front Image	Ön Resim
+	Perspective Crop Tool	Perspektif Kırpma Aracı
+	Drag a box or click four corners · drag the corners onto the edges of a skewed shape · {commit} commits · Esc cancels	Bir kutuyu sürükleyin veya dört köşeyi tıklayın · köşeleri çarpık bir şeklin kenarlarına sürükleyin · {commit} taahhütleri · Esc iptalleri
+	Artboard Tool	Çalışma Yüzeyi Aracı
+	Make Portrait	Portre Yap
+	Make Landscape	Manzara Yap
+	Add New Artboard	Yeni Çalışma Yüzeyi Ekle
+	Freeform Pen Tool	Serbest Kalem Aracı
+	Curvature Pen Tool	Eğrilik Kalemi Aracı
+	Curve Fit:	Eğri Fitili:
+	Drag: draw freehand · Release on the start point: close	Sürükleyin: serbest çizim yapın · Başlangıç noktasında bırakın: kapat
+	Click: smooth point · Double-click: corner · Drag a point: move · Click first point: close · {key} finish	Tıklama: düzgün nokta · Çift tıklama: köşe · Bir noktayı sürükleyin: taşıma · İlk noktayı tıklayın: kapat · {key} bitiş
+	New Crop Preset…	Yeni Kırpma Ön Ayarı…
+	Delete Crop Preset…	Kırpma Ön Ayarını Sil…
+	Select the crop presets to delete:	Silinecek kırpma ön ayarlarını seçin:
+	Select the crop presets to delete	Silinecek kırpma ön ayarlarını seçin
+	Enter a name for the crop preset	Kırpma ön ayarı için bir ad girin
+	There is no crop size or ratio to save	Kaydedilecek kırpma boyutu veya oranı yok
+	Search settings…	Arama ayarları…
+	No matching settings	Eşleşen ayar yok
+	PhotoCraft — Screen Color Picker	PhotoCraft — Ekran Rengi Seçici
+	Loading fonts…	Yazı tipleri yükleniyor…
+	Onion Skin	Soğan Kabuğu
+	Marching Ants	Yürüyen Karıncalar
+	On Black	Siyah
+	On White	Beyaz
+	On Layers	Katmanlarda
+	Show Edge	Kenarı Göster
+	Show Original	Orijinali Göster
+	F cycles the views; hold X to see the image	F görünümleri döndürür; resmi görmek için X'i basılı tutun
+	Refine Edge Brush (R)	Kenar Fırçasını İncelt (R)
+	Expand Detection Area	Algılama Alanını Genişlet
+	Restore Original Edge	Orijinal Kenarı Geri Yükle
+	Paint over hair or fur on the image; Alt paints the other mode	Görüntünün üzerine saç veya kürkün üzerini boyayın; Alt diğer modu boyar
+	Clear Brush Strokes	Fırça Darbelerini Temizle
+	Show rulers	Cetvelleri göster
+	Frame Tool	Çerçeve Aracı
+	Create a new rectangular frame	Yeni bir dikdörtgen çerçeve oluşturun
+	Create a new elliptical frame	Yeni bir eliptik çerçeve oluşturun
+	Include in playback	Oynatmaya dahil et
+	Scale:	Ölçek:
+	Snap to Origin	Orijine Yapış
+	Click to place · Alt-click or drag off-canvas to remove	Yerleştirmek için tıklayın · Kaldırmak için Alt tuşuna basarak tıklayın veya tuvalin dışına sürükleyin
+	{n} of {max} sample points	{n} / {max} örnek nokta
+	Emulsion Down	Emülsiyon Aşağı
+	Functions	Fonksiyonlar
+	Print Resolution:	Baskı Çözünürlüğü:
+	Transparency Threshold	Saydamlık Eşiği
+	Opacity Threshold	Opaklık Eşiği
+	(No neutral color exists for {mode} mode.)	({mode} modu için nötr renk bulunmuyor.)
+	Drag: draw freehand · {alt}-click: straight segment · Release on the start point: close	Sürükle: serbest çiz · {alt}-tıkla: düz segment · Başlangıç noktasında bırak: kapat
+	Fill with {mode}-neutral color (50% gray)	{mode} nötr rengiyle doldur (%50 gri)
+	Fill with {mode}-neutral color (black)	{mode} nötr rengiyle doldur (siyah)
+	Fill with {mode}-neutral color (white)	{mode} nötr rengiyle doldur (beyaz)
+	Use Previous Layer to Create Clipping Mask	Kırpma Maskesi Oluşturmak İçin Önceki Katmanı Kullan
+	Amount:	Miktar:
+	Apply Vanishing Point ({key})	Ufuk Noktasını Uygula ({key})
+	Apply the removal ({key})	Kaldırmayı uygula ({key})
+	Drag to draw the curve · {key}-click draws a straight line	Eğriyi çizmek için sürükle · {key}-tıklama düz çizgi çizer
+	Draw to modify the curve	Eğriyi değiştirmek için çiz
+	Edit points to modify the curve	Eğriyi değiştirmek için noktaları düzenle
+	Fix the red plane first: its corners must form a convex quad	Önce kırmızı düzlemi düzeltin: köşeleri dışbükey bir dörtgen oluşturmalı
+	Grid Size:	Izgara Boyutu:
+	Light Blue	Açık Mavi
+	Light Gray	Açık Gri
+	Light Red	Açık Kırmızı
+	Medium Blue	Orta Mavi
+	Merge Group	Grubu Birleştir
+	Protect skin tones	Ten tonlarını koru
+	Protect:	Koru:
+	Remove after each stroke	Her vuruştan sonra kaldır
+	Saving {percent}	Kaydediliyor {percent}
+	Scale or rotate the moved area, then press {key}	Taşınan alanı ölçeklendirin veya döndürün, ardından {key} tuşuna basın
+	Smooth the curve values	Eğri değerlerini yumuşat
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Kaldırılacak vuruşlar: {n} (Enter uygular, Esc iptal eder)
+	The layer or its mask changed. Drag the mask onto the Trash again.	Katman veya maskesi değişti. Maskeyi yeniden Çöp Kutusu'na sürükleyin.
+	Transform On Drop	Bırakınca Dönüştür
+	Vanishing Point is not active	Ufuk Noktası etkin değil
+	Vanishing Point: click four corners to create a plane	Ufuk Noktası: düzlem oluşturmak için dört köşeye tıklayın
+@plural	Exported {n} swatch to {file}|Exported {n} swatches to {file}	{n} renk örneği {file} dosyasına dışa aktarıldı
+@plural	Imported {n} brush from {group}|Imported {n} brushes from {group}	{group} grubundan {n} fırça içe aktarıldı
+@plural	Imported {n} swatch from {file}|Imported {n} swatches from {file}	{file} dosyasından {n} renk örneği içe aktarıldı
+@plural	Played {n} step|Played {n} steps	{n} adım oynatıldı
+@plural	Saved for Web: {n} file|Saved for Web: {n} files	Web İçin Kaydedildi: {n} dosya
+@plural	Updated {n} linked smart object changed on disk|Updated {n} linked smart objects changed on disk	Diskte değişen {n} bağlantılı akıllı nesne güncellendi
+@plural	{n} layer recorded by this comp was deleted. Update the comp, or clear the warning.|{n} layers recorded by this comp were deleted. Update the comp, or clear the warning.	Bu kompozisyonun kaydettiği {n} katman silindi. Kompozisyonu güncelleyin veya uyarıyı temizleyin.
+@plural	{n} plane|{n} planes	{n} düzlem
+@plural	{n} preset|{n} presets	{n} ön ayar
+@plural	{n} sample point removed|{n} sample points removed	{n} örnek nokta kaldırıldı
+@plural	{n} slice|{n} slices	{n} dilim
+@plural	{n} step|{n} steps	{n} adım
+@plural	{warning} (+{n} more brush preset warning)|{warning} (+{n} more brush preset warnings)	{warning} (+{n} fırça ön ayarı uyarısı daha)
+@plural	{what} with {n} warning|{what} with {n} warnings	{what}, {n} uyarı ile
+	Clear Brush Controls	Fırça Denetimlerini Temizle
+	Reset All Locked Settings	Tüm Kilitli Ayarları Sıfırla
+	Copy Texture to Other Tools	Dokuyu Diğer Araçlara Kopyala
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Eylemleri Yükle…
+	Save Actions…	Eylemleri Kaydet…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	{file} dosyasından {n} eylem yüklendi
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} adımın PhotoCraft’ta henüz karşılığı yok
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	{n} eylem {file} dosyasına kaydedildi
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Photoshop karşılığı olmayan {n} adım atlandı
+
+	Starting serial	Başlangıç sıra numarası
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Durdurma Ekle…
+	Save Set…	Seti Kaydet…
+	Message:	İleti:
+	Allow Continue	Devam Etmeye İzin Ver
+	Show dialog during playback	Oynatma sırasında iletişim kutusunu göster
+	Select an action first	Önce bir eylem seçin
+	Action playback stopped	Eylem oynatma durduruldu
+	Step {step} is waiting for its dialog	{step}. adım iletişim kutusunu bekliyor
+@plural	{n} action|{n} actions	{n} eylem
+	Object Finder	Nesne Bulucu
+	No object found there — drag a rectangle around it	Orada nesne bulunamadı — çevresine bir dikdörtgen sürükleyin
+	Drag to pan · Scroll to zoom · Double-click to fit	Kaydırmak için sürükleyin · Yakınlaştırmak için kaydırın · Sığdırmak için çift tıklayın
+	Gradient Preset Options	Gradyan Ön Ayarı Seçenekleri
+	Import .GRD	.GRD İçe Aktar
+	Choose a gradient file (.grd).	Bir gradyan dosyası (.grd) seçin.
+	Save Settings…	Ayarları Kaydet…
+	Load Settings…	Ayarları Yükle…
+	Save these settings as a Camera Raw .xmp file	Bu ayarları Camera Raw .xmp dosyası olarak kaydet
+	Load settings from a Camera Raw .xmp file	Ayarları bir Camera Raw .xmp dosyasından yükle
+	Loaded Camera Raw settings from {file}	Camera Raw ayarları {file} dosyasından yüklendi
+	Loaded Camera Raw settings from {file} ({n} not supported)	Camera Raw ayarları {file} dosyasından yüklendi ({n} desteklenmiyor)
+	Auto Add/Delete	Otomatik Ekle/Sil
+	ICO is limited to 256 × 256 pixels	ICO 256 × 256 piksel ile sınırlıdır
+
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Kanal Rengi
+	Color Indicates:	Rengin Gösterdiği:
+	Ink Characteristics	Mürekkep Özellikleri
+	Solidity:	Doluluk:
+	Redrawing	Yeniden çiziliyor
diff --git a/crates/ui-egui/src/i18n/uk.tsv b/crates/ui-egui/src/i18n/uk.tsv
index ffaaca59c6..2a72fdaf19 100644
--- a/crates/ui-egui/src/i18n/uk.tsv
+++ b/crates/ui-egui/src/i18n/uk.tsv
@@ -8,9 +8,19 @@
 # No proprietary translation resources were used.
 # Licensed MIT OR Apache-2.0. See LICENSE-translations.txt and ATTRIBUTION.md.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Колір каналу
+	Color Indicates:	Кольором позначено:
+	Solidity:	Щільність:
+	Ink Characteristics	Характеристики фарби
+
 # Menus
 
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	Ширина паперу
+	Paper Height	Висота паперу
 	Rows	Рядки
 	Number	Кількість
 	Top:	Зверху:
@@ -69,6 +79,8 @@
 	Save	Зберегти
 	Save As…	Зберегти як…
 	Save a Copy…	Зберегти копію…
+	{name} can't keep everything in this document	{name} не може зберегти весь вміст цього документа
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Виберіть формат, який збереже все, наприклад Photoshop (PSD), або збережіть копію.
 	Save…	Зберегти…
 	Revert	Повернути до збереженого
 	Import	Імпорт
@@ -189,6 +201,9 @@
 	Enable Layer Mask	Увімкнути маску шару
 	Disable Layer Mask	Вимкнути маску шару
 	Apply Layer Mask	Застосувати маску шару
+	Add Mask to Selection	Додати маску до виділення
+	Subtract Mask from Selection	Відняти маску від виділення
+	Intersect Mask with Selection	Перетнути маску з виділенням
 	Link Layer Mask	Зв'язати маску шару
 	Unlink Layer Mask	Відв'язати маску шару
 	Vector Mask	Векторна маска
@@ -248,6 +263,8 @@
 	Check Spelling	Перевірити правопис
 	Language Options	Мовні параметри
 	Find and Replace Text…	Знайти та замінити текст…
+	Add to Dictionary	Додати до словника
+	No Spelling Suggestions	Немає варіантів написання
 	Paste Lorem Ipsum	Вставити Lorem Ipsum
 	Glyphs Panel	Панель гліфів
 	Type Styles	Текстові стилі
@@ -304,6 +321,9 @@
 	Oil Paint…	Олійний живопис…
 	Blur Gallery	Галерея розмиття
 	Field Blur…	Розмиття поля…
+# Field Blur pins (#3373)
+	No pin selected	Шпильку не вибрано
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Клацніть зображення, щоб додати шпильку; перетягніть шпильку, щоб перемістити її, або її кільце, щоб змінити розмиття. Delete видаляє вибрану шпильку.
 	Iris Blur…	Розмиття діафрагми…
 	Tilt-Shift…	Нахил і зсув…
 	Path Blur…	Розмиття вздовж контуру…
@@ -557,6 +577,7 @@
 	OK	Гаразд
 	Cancel	Скасувати
 	Cancel (Esc)	Скасувати (Esc)
+	Manage submitted jobs in the system print queue	Керуйте надісланими завданнями в системній черзі друку
 	Done	Готово
 	Apply	Застосувати
 	Reset	Скинути
@@ -995,9 +1016,17 @@
 	Rename Brush…	Перейменувати пензель…
 	Delete Brush	Видалити пензель
 	Import Brushes…	Імпортувати пензлі…
+	Gradient Preset Options	Параметри наборів градієнтів
+	Import .GRD	Імпортувати .GRD
+	Choose a gradient file (.grd).	Виберіть файл градієнтів (.grd).
 	Brush Name	Назва пензля
 	Brush Stroke	Мазок пензля
 	New Brush Preset…	Новий набір пензля…
+	Capture Brush Size in Preset	Зберегти розмір пензля в наборі
+	Include Tool Settings	Включити налаштування інструмента
+	Include Color	Включити колір
+	Enter a name for the brush preset	Введіть назву набору пензля
+	A brush preset with this name already exists	Набір пензля з такою назвою вже існує
 	Brush Preset Options	Параметри набору пензля
 	New Brush	Новий пензель
 	Create new brush from these settings	Створити новий пензель із цими параметрами
@@ -1159,6 +1188,8 @@
 	Offset	Зсув
 	Reset Transform	Скинути трансформацію
 	Rotate	Повернути
+	Set horizontal skew	Задати горизонтальний скіс
+	Set vertical skew	Задати вертикальний скіс
 	Flip Horizontal	Віддзеркалити горизонтально
 	Flip Vertical	Віддзеркалити вертикально
 	Frame Sync	Синхронізація кадрів
@@ -1354,7 +1385,6 @@
 	Choose…	Вибрати…
 	Select Folder…	Вибрати теку…
 	Override Action "Save" Commands	Перевизначити команди «Зберегти» в дії
-	File Naming	Іменування файлів
 	Compatibility	Сумісність
 	Windows	Windows
 	Mac OS	Mac OS
@@ -1406,6 +1436,10 @@
 	Breeze Dark Theme	Темна тема Breeze
 	Breeze light	Breeze світла
 	Breeze Light Theme	Світла тема Breeze
+	Soft dark	М'яка темна
+	Soft light	М'яка світла
+	Soft Dark Theme	М'яка темна тема
+	Soft Light Theme	М'яка світла тема
 	Adwaita Light Theme	Світла тема Adwaita
 	Adwaita Dark Theme	Темна тема Adwaita
 	Adwaita	Adwaita
@@ -1476,6 +1510,7 @@
 	Preset Name:	Назва набору:
 	Width and Height	Ширина та висота
 	Background Contents	Вміст фону
+	Custom background color	Довільний колір фону
 	White	Білий
 	Background Color	Колір фону
 	Transparent	Прозорий
@@ -1658,6 +1693,12 @@
 	Show in Explorer	Показати у Провіднику
 	Show in Folder	Показати в теці
 	Before (Y)	До (Y)
+	Save Settings…	Зберегти налаштування…
+	Load Settings…	Завантажити налаштування…
+	Save these settings as a Camera Raw .xmp file	Зберегти ці налаштування у файл Camera Raw .xmp
+	Load settings from a Camera Raw .xmp file	Завантажити налаштування з файлу Camera Raw .xmp
+	Loaded Camera Raw settings from {file}	Налаштування Camera Raw завантажено з {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Налаштування Camera Raw завантажено з {file} (не підтримується: {n})
 	After (X)	Після (X)
 	Original	Оригінал
 	Current	Поточний
@@ -1809,6 +1850,14 @@
 	Border…	Межа…
 	Bottom Edges	Нижні краї
 	Browse…	Огляд…
+	Source Files	Вихідні файли
+	Use:	Використовувати:
+	Files	Файли
+	Folder	Папка
+	Add Open Files	Додати відкриті файли
+	Sort By Name	Сортувати за назвою
+	Attempt to Automatically Align Source Images	Спробувати автоматично вирівняти вихідні зображення
+	Create Smart Object after Loading Layers	Створити смартоб'єкт після завантаження шарів
 	Canvas Guides	Напрямні полотна
 	Character Styles Panel	Панель стилів символів
 	Clear Canvas Guides	Очистити напрямні полотна
@@ -1876,6 +1925,7 @@
 	Lock Layers…	Заблокувати шари…
 	Mean	Середнє значення
 	Merge Down	Об'єднати з нижнім
+	Merge Group	Об'єднати групу
 	Merge Layers	Об'єднати шари
 	Merge Shape Components	Об'єднати компоненти фігури
 	Merge Visible	Об'єднати видимі
@@ -1927,6 +1977,7 @@
 	Solid Color…	Суцільний колір…
 	Square	Квадрат
 	Stack Mode	Режим стосу
+	Choose Stack Mode:	Виберіть режим стосу:
 	Standard Deviation	Стандартне відхилення
 	Statistics…	Статистика…
 	Stylistic Alternates	Стилістичні альтернативи
@@ -2396,6 +2447,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	Немає контуру для створення виділення: намалюйте його пером або виберіть на панелі контурів.
 	Cancel opening	Скасувати відкриття
 	Cancelled opening {name}	Відкриття {name} скасовано
+	The document “{name}” does not have an embedded {mode} profile.	Документ «{name}» не має вбудованого профілю {mode}.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Вбудований колірний профіль документа «{name}» не відповідає поточному робочому простору {mode}.
+	Embedded: {embedded}	Вбудований: {embedded}
+	Working: {working}	Робочий простір: {working}
 	Developing {name}	Обробка {name}
 	Cancelled {label}	Скасовано: {label}
 	Esc to cancel	Esc для скасування
@@ -2562,6 +2617,7 @@ cameraRaw	Roughness	Шорсткість
 	Click to pick · Esc to cancel	Клацніть для вибору · Esc для скасування
 	Pick a screen pixel or press Esc to cancel	Виберіть піксель екрана або натисніть Esc для скасування
 	Scroll to zoom	Прокрутіть для масштабування
+	Drag to pan · Scroll to zoom · Double-click to fit	Перетягніть для панорамування · Прокрутіть для масштабування · Двічі клацніть, щоб умістити
 	Show/Hide All Panels	Показати/приховати всі панелі
 	Show/Hide Panels	Показати/приховати панелі
 	Could not open	Не вдалося відкрити
@@ -2617,6 +2673,7 @@ cameraRaw	Roughness	Шорсткість
 	Fuchsia	Фуксія
 	Violet	Фіалковий
 	Large document: redrawing on the CPU	Великий документ: перемальовування на CPU
+	Redrawing	Перемальовування
 	This redraw took {seconds} s on the CPU.	Це перемальовування на CPU тривало {seconds} с.
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	Зміни, що впливають на весь документ, як-от режим накладання, непрозорість чи видимість шару, перемальовують його повністю.
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Його шари не вміщуються в бюджет пам'яті GPU. Збільшення використання пам'яті в Налаштування › Продуктивність підвищує бюджет до чверті пам'яті цього комп'ютера.
@@ -3708,6 +3765,7 @@ curves	Smooth	Згладити
 	There is no crop size or ratio to save	Немає розміру чи співвідношення сторін кадрування для збереження
 	Scale:	Масштаб:
 	Snap to Origin	Прив'язати до початку координат
+	Presentation	Представлення
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	Клацніть, щоб розмістити · Alt-клацання або перетягування за межі полотна для видалення
@@ -3745,3 +3803,36 @@ curves	Smooth	Згладити
 	Light Red	Світло-червоний
 	Medium Blue	Середньо-синій
 	Light Gray	Світло-сірий
+	Object Finder	Пошук об’єктів
+	No object found there — drag a rectangle around it	Там не знайдено об’єкта — обведіть його прямокутником
+	Remove after each stroke	Видаляти після кожного штриха
+	Apply the removal ({key})	Застосувати видалення ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Штрихів для видалення: {n} (Enter застосовує, Esc скасовує)
+	Clear Brush Controls	Очистити параметри пензля
+	Reset All Locked Settings	Скинути всі заблоковані параметри
+	Copy Texture to Other Tools	Скопіювати текстуру в інші інструменти
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Завантажити операції…
+	Save Actions…	Зберегти операції…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Завантажено {n} операцію з {file}|Завантажено {n} операції з {file}|Завантажено {n} операцій з {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} крок ще не має відповідника в PhotoCraft|{n} кроки ще не мають відповідника в PhotoCraft|{n} кроків ще не мають відповідника в PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Збережено {n} операцію до {file}|Збережено {n} операції до {file}|Збережено {n} операцій до {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Пропущено {n} крок без відповідника в Photoshop|Пропущено {n} кроки без відповідника в Photoshop|Пропущено {n} кроків без відповідника в Photoshop
+
+	File Naming	Іменування файлів
+	Starting serial	Початковий порядковий номер
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Вставити зупинку…
+	Save Set…	Зберегти набір…
+	Message:	Повідомлення:
+	Allow Continue	Дозволити продовження
+	Show dialog during playback	Показувати діалог під час відтворення
+	Select an action first	Спочатку виберіть операцію
+	Action playback stopped	Відтворення операції зупинено
+	Step {step} is waiting for its dialog	Крок {step} очікує на свій діалог
+@plural	{n} action|{n} actions	{n} операція|{n} операції|{n} операцій
+	Auto Add/Delete	Автододавання/видалення
+	ICO is limited to 256 × 256 pixels	ICO обмежено розміром 256 × 256 пікселів
diff --git a/crates/ui-egui/src/i18n/vi.tsv b/crates/ui-egui/src/i18n/vi.tsv
index 6fb20b3d84..88b855a707 100644
--- a/crates/ui-egui/src/i18n/vi.tsv
+++ b/crates/ui-egui/src/i18n/vi.tsv
@@ -20,7 +20,17 @@
 # (`plural_none` in i18n/mod.rs).
 
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	Màu kênh
+	Color Indicates:	Màu biểu thị:
+	Solidity:	Độ đặc:
+	Ink Characteristics	Đặc tính mực
+
 # Phase 3.1 — top-level menus, File menu, Edit menu
+# Custom paper dimensions in Print Settings.
+	Paper Width	Chiều rộng giấy
+	Paper Height	Chiều cao giấy
+
 	Again	Lặp lại
 	AI Integrations…	Tích hợp AI…
 	All	Tất cả
@@ -32,6 +42,14 @@
 	Automate	Tự động hóa
 	Batch…	Hàng loạt…
 	Browse…	Duyệt…
+	Source Files	Tệp nguồn
+	Use:	Dùng:
+	Files	Tệp
+	Folder	Thư mục
+	Add Open Files	Thêm các tệp đang mở
+	Sort By Name	Sắp xếp theo tên
+	Attempt to Automatically Align Source Images	Thử tự căn các ảnh nguồn
+	Create Smart Object after Loading Layers	Tạo đối tượng thông minh sau khi tải lớp
 	Check Spelling…	Kiểm tra chính tả…
 	Clear	Xóa
 	Clear Recent Files	Xóa tệp gần đây
@@ -73,6 +91,8 @@
 	Fill…	Tô…
 	Filter	Bộ lọc
 	Find and Replace Text…	Tìm và thay chữ…
+	Add to Dictionary	Thêm vào từ điển
+	No Spelling Suggestions	Không có gợi ý chính tả
 	Fit Image…	Vừa khung ảnh…
 	Flatten All Layer Effects	Làm phẳng mọi hiệu ứng lớp
 	Flatten All Masks	Làm phẳng mọi mặt nạ
@@ -135,11 +155,15 @@
 	Restore	Khôi phục
 	Revert	Hoàn nguyên
 	Rotate	Xoay
+	Set horizontal skew	Đặt độ nghiêng ngang
+	Set vertical skew	Đặt độ nghiêng dọc
 	Rotate 180°	Xoay 180°
 	Rotate 90° Clockwise	Xoay 90° theo chiều kim đồng hồ
 	Rotate 90° Counter Clockwise	Xoay 90° ngược chiều kim đồng hồ
 	Save	Lưu
 	Save a Copy…	Lưu bản sao…
+	{name} can't keep everything in this document	{name} không thể giữ mọi thứ trong tài liệu này
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	Hãy chọn một định dạng giữ được mọi thứ, như Photoshop (PSD), hoặc lưu bản sao.
 	Save As…	Lưu thành…
 	Save for Web (Legacy)…	Lưu cho Web (cũ)…
 	Scale	Tỷ lệ
@@ -361,6 +385,7 @@
 	Smart Objects	Đối tượng thông minh
 	Solid Color…	Màu đặc…
 	Stack Mode	Chế độ chồng
+	Choose Stack Mode:	Chọn chế độ chồng:
 	Standard Deviation	Độ lệch chuẩn
 	Subtract Front Shape	Trừ hình phía trước
 	Summation	Tổng
@@ -483,6 +508,9 @@
 	Facet	Mặt cắt
 	Fibers…	Sợi…
 	Field Blur…	Làm mờ vùng…
+# Field Blur pins (#3373)
+	No pin selected	Chưa chọn ghim nào
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	Bấm vào ảnh để thêm ghim; kéo ghim để di chuyển, hoặc kéo vòng của ghim để đổi độ mờ. Delete xóa ghim đã chọn.
 	Filter Gallery…	Thư viện bộ lọc…
 	Find Edges	Tìm cạnh
 	Flame…	Ngọn lửa…
@@ -932,10 +960,14 @@
 	Duplicate Layers…	Nhân bản các lớp…
 	Add Layer Mask	Thêm mặt nạ lớp
 	Apply Layer Mask	Áp dụng mặt nạ lớp
+	Add Mask to Selection	Thêm mặt nạ vào vùng chọn
+	Subtract Mask from Selection	Trừ mặt nạ khỏi vùng chọn
+	Intersect Mask with Selection	Giao mặt nạ với vùng chọn
 	Delete Layer Mask	Xóa mặt nạ lớp
 	Disable Layer Mask	Tắt mặt nạ lớp
 	Release Clipping Mask	Nhả mặt nạ cắt
 	Merge Down	Gộp xuống
+	Merge Group	Gộp nhóm
 	Quick Export As PNG	Xuất nhanh dạng PNG
 	Rename Layer…	Đổi tên lớp…
 	Frame from Layers…	Frame từ các lớp…
@@ -1271,6 +1303,12 @@
 	Aqua	Xanh ngọc
 	Balance	Cân bằng
 	Before (Y)	Trước (Y)
+	Save Settings…	Lưu cài đặt…
+	Load Settings…	Tải cài đặt…
+	Save these settings as a Camera Raw .xmp file	Lưu các cài đặt này thành tệp .xmp Camera Raw
+	Load settings from a Camera Raw .xmp file	Tải cài đặt từ tệp .xmp Camera Raw
+	Loaded Camera Raw settings from {file}	Đã tải cài đặt Camera Raw từ {file}
+	Loaded Camera Raw settings from {file} ({n} not supported)	Đã tải cài đặt Camera Raw từ {file} ({n} không được hỗ trợ)
 	Blacks	Điểm đen
 	Blending	Pha trộn
 	Blue	Xanh dương
@@ -1523,9 +1561,14 @@ cameraRaw	Shadows	Vùng tối
 	Working…	Đang xử lý…
 	Reading…	Đang đọc…
 	Cancel (Esc)	Hủy (Esc)
+	Manage submitted jobs in the system print queue	Quản lý các lệnh in đã gửi trong hàng đợi in của hệ thống
 	Esc to cancel	Esc để hủy
 	Cancel opening	Hủy mở tệp
 	Cancelled opening {name}	Đã hủy mở {name}
+	The document “{name}” does not have an embedded {mode} profile.	Tài liệu “{name}” không có hồ sơ {mode} nhúng.
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	Tài liệu “{name}” có hồ sơ màu nhúng không khớp với không gian làm việc {mode} hiện tại.
+	Embedded: {embedded}	Nhúng: {embedded}
+	Working: {working}	Không gian làm việc: {working}
 	Cancelled {label}	Đã hủy {label}
 	Cancel transform (Esc)	Hủy biến đổi (Esc)
 	Cancel warp (Esc)	Hủy biến dạng (Esc)
@@ -1696,6 +1739,7 @@ cameraRaw	Size	Kích thước
 	Resolution:	Độ phân giải:
 	Color Mode	Chế độ màu
 	Background Contents	Nội dung nền
+	Custom background color	Màu nền tùy chỉnh
 	Pixels/Inch	Pixel/inch
 	Pixels/Centimeter	Pixel/centimet
 	White	Trắng
@@ -2006,6 +2050,11 @@ layers	Fill:	Độ tô:
 	Move effect layer down	Di chuyển lớp hiệu ứng xuống
 	Move effect layer up	Di chuyển lớp hiệu ứng lên
 	New Brush Preset…	Thiết lập sẵn cọ mới…
+	Capture Brush Size in Preset	Lưu kích thước cọ vào thiết lập sẵn
+	Include Tool Settings	Bao gồm thiết lập công cụ
+	Include Color	Bao gồm màu
+	Enter a name for the brush preset	Nhập tên cho thiết lập sẵn cọ
+	A brush preset with this name already exists	Đã có thiết lập sẵn cọ với tên này
 	New effect layer	Lớp hiệu ứng mới
 	New Swatch Group…	Nhóm mẫu màu mới…
 	New Swatch…	Mẫu màu mới…
@@ -2023,6 +2072,7 @@ layers	Fill:	Độ tô:
 	Option-click to define a source point to clone from	Option+nhấp để chỉ định điểm nguồn nhân bản
 	Out of gamut for printing: click for the nearest printable colour	Ngoài gamut in: nhấp để lấy màu in được gần nhất
 	Pick screen color	Lấy màu màn hình
+	Pick Color From Image	Lấy màu từ hình ảnh
 	Point Sample	Mẫu điểm
 	Pupil Size	Kích thước đồng tử
 	Quick Selection found nothing there	Chọn nhanh không tìm thấy gì
@@ -2036,6 +2086,7 @@ layers	Fill:	Độ tô:
 	Sample Size:	Kích thước mẫu:
 	Save As Preset	Lưu thành thiết lập sẵn
 	Scroll to zoom	Cuộn để thu phóng
+	Drag to pan · Scroll to zoom · Double-click to fit	Kéo để xem toàn cảnh · Cuộn để thu phóng · Bấm đúp để vừa khung
 	Selection Preview:	Xem trước vùng chọn:
 	Set additional Crop options	Đặt tùy chọn Cắt bổ sung
 	Set Black Point	Đặt điểm đen
@@ -2108,6 +2159,7 @@ layers	Fill:	Độ tô:
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	Các lớp không vừa ngân sách bộ nhớ GPU. Tăng mức sử dụng bộ nhớ trong Tùy chọn › Hiệu năng sẽ nâng ngân sách, tối đa một phần tư bộ nhớ máy này.
 	Labels	Nhãn
 	Large document: redrawing on the CPU	Tài liệu lớn: đang vẽ lại trên CPU
+	Redrawing	Đang vẽ lại
 	Layer deleted, but confirmation preference could not be saved: {error}	Đã xóa lớp, nhưng không lưu được tùy chọn xác nhận: {error}
 	Layer From Background…	Lớp từ nền…
 	Load a keyboard shortcut set saved as .kys	Tải bộ phím tắt đã lưu dạng .kys
@@ -2341,6 +2393,10 @@ shape	Appearance	Diện mạo
 	Bottom:	Dưới:
 	Breeze Dark Theme	Chủ đề Breeze tối
 	Breeze Light Theme	Chủ đề Breeze sáng
+	Soft dark	Dịu tối
+	Soft light	Dịu sáng
+	Soft Dark Theme	Giao diện dịu tối
+	Soft Light Theme	Giao diện dịu sáng
 	Caps	Đầu nét
 	Center Columns	Căn giữa các cột
 	Change Panel Group	Đổi nhóm bảng
@@ -3531,3 +3587,40 @@ curves	Smooth	Làm mượt
 	Stroke Path…	Đi nét đường dẫn…
 	Apply mask to layer before removing?	Áp dụng mặt nạ vào lớp trước khi xóa?
 	Delete the vector mask?	Xóa mặt nạ vectơ?
+	Object Finder	Trình tìm đối tượng
+	No object found there — drag a rectangle around it	Không tìm thấy đối tượng ở đó — hãy kéo một hình chữ nhật quanh nó
+	Remove after each stroke	Xóa sau mỗi nét vẽ
+	Apply the removal ({key})	Áp dụng việc xóa ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	Nét vẽ cần xóa: {n} (Enter áp dụng, Esc hủy)
+	Clear Brush Controls	Xóa điều khiển cọ
+	Reset All Locked Settings	Đặt lại tất cả cài đặt đã khóa
+	Copy Texture to Other Tools	Sao chép họa tiết sang các công cụ khác
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	Nạp hành động…
+	Save Actions…	Lưu hành động…
+	{name} (Photoshop)	{name} (Photoshop)
+	{message} ({note})	{message} ({note})
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	Đã nạp {n} hành động từ {file}
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} bước chưa có chức năng tương ứng trong PhotoCraft
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	Đã lưu {n} hành động vào {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	Đã bỏ qua {n} bước không có chức năng tương ứng trong Photoshop
+
+	File Naming	Đặt tên tệp
+	Starting serial	Số thứ tự bắt đầu
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	Chèn điểm dừng…
+	Save Set…	Lưu bộ…
+	Message:	Thông báo:
+	Allow Continue	Cho phép tiếp tục
+	Show dialog during playback	Hiện hộp thoại khi phát
+	Select an action first	Hãy chọn một hành động trước
+	Action playback stopped	Đã dừng phát hành động
+	Step {step} is waiting for its dialog	Bước {step} đang chờ hộp thoại của nó
+@plural	{n} action|{n} actions	{n} hành động
+	Presentation	Trình bày
+	Gradient Preset Options	Tùy chọn thiết lập sẵn chuyển sắc
+	Import .GRD	Nhập .GRD
+	Choose a gradient file (.grd).	Chọn tệp chuyển sắc (.grd).
+	Auto Add/Delete	Tự động thêm/xóa
+	ICO is limited to 256 × 256 pixels	ICO giới hạn ở 256 × 256 pixel
diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv
index 187f63e18d..2842771124 100644
--- a/crates/ui-egui/src/i18n/zh-hans.tsv
+++ b/crates/ui-egui/src/i18n/zh-hans.tsv
@@ -11,7 +11,20 @@
 # Licensed MIT OR Apache-2.0, as the code.
 # Product and technology names retain their spelling. See docs/localization-zh-hans.md.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	通道颜色
+	Color Indicates:	色彩指示：
+	Solidity:	密度：
+	Masked Areas	被蒙版区域
+	Selected Areas	所选区域
+	Spot Color	专色
+	Ink Characteristics	油墨特性
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	纸张宽度
+	Paper Height	纸张高度
 	Columns	列
 	Rows	行
 	Number	数量
@@ -69,6 +82,8 @@
 	Save	保存
 	Save As…	另存为…
 	Save a Copy…	保存副本…
+	{name} can't keep everything in this document	{name} 无法保留此文档中的所有内容
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	请选择能保留全部内容的格式，例如 Photoshop (PSD)，或存储副本。
 	Revert	恢复
 	Export	导出
 	Quick Export as PNG	快速导出为 PNG
@@ -106,6 +121,14 @@
 	Script Events Manager…	脚本事件管理器…
 	Import	导入
 	Browse…	浏览…
+	Source Files	源文件
+	Use:	使用:
+	Files	文件
+	Folder	文件夹
+	Add Open Files	添加打开的文件
+	Sort By Name	按名称排序
+	Attempt to Automatically Align Source Images	尝试自动对齐源图像
+	Create Smart Object after Loading Layers	载入图层后创建智能对象
 	Reveal in Finder	在 Finder 中显示
 	Show in Explorer	在文件资源管理器中显示
 	Show in Folder	在文件夹中显示
@@ -130,6 +153,8 @@
 	Search…	搜索…
 	Check Spelling…	检查拼写…
 	Find and Replace Text…	查找和替换文本…
+	Add to Dictionary	添加到词典
+	No Spelling Suggestions	没有拼写建议
 	Fill…	填充…
 	Stroke…	描边…
 	Content-Aware Fill…	内容识别填充…
@@ -144,6 +169,8 @@
 	Transform Again on a Copy	复制并再次变换
 	Scale	缩放
 	Rotate	旋转
+	Set horizontal skew	设置水平斜切
+	Set vertical skew	设置垂直斜切
 	Skew	斜切
 	Distort	扭曲
 	Perspective	透视
@@ -359,6 +386,7 @@
 	Update Modified Content	更新已修改的内容
 	Update All Modified Content	更新所有已修改的内容
 	Stack Mode	堆栈模式
+	Choose Stack Mode:	选择堆栈模式：
 	Entropy	熵
 	Kurtosis	峰度
 	Maximum	最大值
@@ -393,6 +421,7 @@
 	Select Linked Layers	选择链接的图层
 	Merge Layers	合并图层
 	Merge Down	向下合并
+	Merge Group	合并组
 	Merge Visible	合并可见图层
 	Stamp Visible	盖印可见图层
 	Select Layer Above	选择上方图层
@@ -529,6 +558,9 @@
 	Blur	模糊
 	Blur Gallery	模糊库
 	Field Blur…	场景模糊…
+# Field Blur pins (#3373)
+	No pin selected	未选择图钉
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	单击图像以添加图钉；拖动图钉可移动它，拖动其圆环可更改模糊程度。按 Delete 键删除所选图钉。
 	Iris Blur…	光圈模糊…
 	Tilt-Shift…	移轴模糊…
 	Path Blur…	路径模糊…
@@ -727,6 +759,10 @@
 	Breeze Dark Theme	Breeze 深色主题
 	Breeze light	Breeze 浅色
 	Breeze Light Theme	Breeze 浅色主题
+	Soft dark	柔和深色
+	Soft light	柔和浅色
+	Soft Dark Theme	柔和深色主题
+	Soft Light Theme	柔和浅色主题
 	Next Theme	下一代主题
 	Actions	动作
 	Brush Settings	画笔设置
@@ -827,6 +863,9 @@
 	Appearance	外观
 	Appearance (Layer Style)	外观（图层样式）
 	Apply Layer Mask	应用图层蒙版
+	Add Mask to Selection	添加蒙版到选区
+	Subtract Mask from Selection	从选区中减去蒙版
+	Intersect Mask with Selection	蒙版与选区交叉
 	Apply Per Tip	应用于每个笔尖
 	Apply next selected layer comp	应用下一个选中的图层复合
 	Apply previous selected layer comp	应用上一个选中的图层复合
@@ -842,11 +881,18 @@
 	Background	背景
 	Background Color	背景颜色
 	Background Contents	背景内容
+	Custom background color	自定背景颜色
 	Balance	平衡
 	Baseline	基线
 	Baseline shift	基线偏移
 	Basic	基本
 	Before (Y)	调整前（Y）
+	Save Settings…	存储设置…
+	Load Settings…	载入设置…
+	Save these settings as a Camera Raw .xmp file	将这些设置存储为 Camera Raw .xmp 文件
+	Load settings from a Camera Raw .xmp file	从 Camera Raw .xmp 文件载入设置
+	Loaded Camera Raw settings from {file}	已从 {file} 载入 Camera Raw 设置
+	Loaded Camera Raw settings from {file} ({n} not supported)	已从 {file} 载入 Camera Raw 设置（{n} 项不支持）
 	Begin recording	开始录制
 	Bend:	弯曲：
 	Bicubic	双三次
@@ -877,6 +923,7 @@
 	Camera Raw isn't open	尚未打开 Camera Raw
 	Cancel	取消
 	Cancel (Esc)	取消（Esc）
+	Manage submitted jobs in the system print queue	在系统打印队列中管理已提交的作业
 	Cancel any current edits (Esc)	取消当前所有编辑（Esc）
 	Cancel current crop operation  (Esc)	取消当前裁剪操作  （Esc）
 	Cancel transform (Esc)	取消变换（Esc）
@@ -1150,6 +1197,9 @@
 	Ignore All	全部忽略
 	Image Size	图像大小
 	Import Brushes…	导入画笔…
+	Gradient Preset Options	渐变预设选项
+	Import .GRD	导入 .GRD
+	Choose a gradient file (.grd).	请选择渐变文件 (.grd)。
 	Import brushes (.abr)	导入画笔（.abr）
 	Import Presets	导入预设
 	Imported	已导入
@@ -2146,6 +2196,11 @@ cameraRaw	Blending	混合
 	Rename Brush…	重命名画笔…
 	Delete Brush	删除画笔
 	New Brush Preset…	新建画笔预设…
+	Capture Brush Size in Preset	在预设中存储画笔大小
+	Include Tool Settings	包含工具设置
+	Include Color	包含颜色
+	Enter a name for the brush preset	请输入画笔预设的名称
+	A brush preset with this name already exists	已存在同名的画笔预设
 	Brush Preset Options	画笔预设选项
 	Group name	组名称
 	Brush name	画笔名称
@@ -2204,6 +2259,10 @@ cameraRaw	Blending	混合
 # Layer navigation, copy transforms and cancellable opening (labels added on main since this catalog).
 	Cancel opening	取消打开
 	Cancelled opening {name}	已取消打开 {name}
+	The document “{name}” does not have an embedded {mode} profile.	文档“{name}”没有嵌入的 {mode} 配置文件。
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	文档“{name}”嵌入的颜色配置文件与当前的 {mode} 工作空间不匹配。
+	Embedded: {embedded}	嵌入：{embedded}
+	Working: {working}	工作空间：{working}
 	Developing {name}	正在处理 {name}
 	Cancelled {label}	已取消 {label}
 	Esc to cancel	按 Esc 取消
@@ -2328,6 +2387,7 @@ cameraRaw	Blending	混合
 	Click to pick · Esc to cancel	单击选取 · Esc 取消
 	Pick a screen pixel or press Esc to cancel	选取屏幕像素或按 Esc 取消
 	Scroll to zoom	滚动以缩放
+	Drag to pan · Scroll to zoom · Double-click to fit	拖动以平移 · 滚动以缩放 · 双击以适应窗口
 	Show/Hide All Panels	显示/隐藏所有面板
 	Show/Hide Panels	显示/隐藏面板
 	Could not open	无法打开
@@ -2386,6 +2446,7 @@ cameraRaw	Blending	混合
 	Violet	紫罗兰色
 	Reset	复位
 	Large document: redrawing on the CPU	大型文档：正在用 CPU 重绘
+	Redrawing	正在重绘
 	This redraw took {seconds} s on the CPU.	此次 CPU 重绘耗时 {seconds} 秒。
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	更改整个文档的编辑（如图层的混合模式、不透明度或可见性）会重绘整个文档。
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	图层超出 GPU 内存预算。在 首选项 › 性能 中提高内存使用量可增加预算，最多为本机内存的四分之一。
@@ -2630,6 +2691,7 @@ curves	Smooth	平滑
 	Select the crop presets to delete	选择要删除的裁剪预设
 	Enter a name for the crop preset	输入裁剪预设的名称
 	There is no crop size or ratio to save	没有可保存的裁剪大小或比例
+	Presentation	演示
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	单击以放置 · Alt 单击或拖到画布外以移除
@@ -2652,3 +2714,36 @@ curves	Smooth	平滑
 	Light Red	浅红色
 	Medium Blue	中蓝色
 	Light Gray	浅灰色
+	Object Finder	对象查找程序
+	No object found there — drag a rectangle around it	那里未找到对象 — 请在其周围拖动矩形
+	Remove after each stroke	每次描边后移除
+	Apply the removal ({key})	应用移除 ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	待移除的描边：{n}（Enter 应用，Esc 取消）
+	Clear Brush Controls	清除画笔控件
+	Reset All Locked Settings	复位所有锁定的设置
+	Copy Texture to Other Tools	将纹理复制到其他工具
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	载入动作…
+	Save Actions…	存储动作…
+	{name} (Photoshop)	{name}（Photoshop）
+	{message} ({note})	{message}（{note}）
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	已从 {file} 载入 {n} 个动作
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} 个步骤在 PhotoCraft 中尚无对应功能
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	已将 {n} 个动作存储到 {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	已省略 {n} 个没有 Photoshop 对应功能的步骤
+
+	File Naming	文件命名
+	Starting serial	起始序号
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	插入停止…
+	Save Set…	存储组…
+	Message:	信息:
+	Allow Continue	允许继续
+	Show dialog during playback	播放时显示对话框
+	Select an action first	请先选择一个动作
+	Action playback stopped	动作播放已停止
+	Step {step} is waiting for its dialog	步骤 {step} 正在等待其对话框
+@plural	{n} action|{n} actions	{n} 个动作
+	Auto Add/Delete	自动添加/删除
+	ICO is limited to 256 × 256 pixels	ICO 最大为 256 × 256 像素
diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv
index 3e0f8902cd..d02e06646e 100644
--- a/crates/ui-egui/src/i18n/zh-hant.tsv
+++ b/crates/ui-egui/src/i18n/zh-hant.tsv
@@ -19,7 +19,20 @@
 # kept. Full-width punctuation (，。：) inside sentences; half-width parentheses and the " · "
 # separators as in the English.
 
+# Channel Options and New Spot Channel (#3761)
+	Channel Color	色版顏色
+	Color Indicates:	色彩指示：
+	Solidity:	硬度：
+	Masked Areas	遮色片區域
+	Selected Areas	選取區域
+	Spot Color	特別色
+	Ink Characteristics	油墨特性
+
 # Guide layout dialog
+
+# Custom print paper (#3820)
+	Paper Width	紙張寬度
+	Paper Height	紙張高度
 	Columns	欄
 	Rows	列
 	Number	數量
@@ -77,6 +90,8 @@
 	Save	儲存
 	Save As…	另存新檔…
 	Save a Copy…	儲存拷貝…
+	{name} can't keep everything in this document	{name} 無法保留此文件中的所有內容
+	Choose a format that keeps it, such as Photoshop (PSD), or save a copy.	請選擇能保留全部內容的格式，例如 Photoshop (PSD)，或儲存拷貝。
 	Revert	回復
 	Export	匯出
 	Quick Export as PNG	快速匯出為 PNG
@@ -114,6 +129,14 @@
 	Script Events Manager…	指令碼事件管理員…
 	Import	匯入
 	Browse…	瀏覽…
+	Source Files	來源檔案
+	Use:	使用:
+	Files	檔案
+	Folder	資料夾
+	Add Open Files	增加開啟的檔案
+	Sort By Name	依名稱排序
+	Attempt to Automatically Align Source Images	嘗試自動對齊來源影像
+	Create Smart Object after Loading Layers	載入圖層後建立智慧型物件
 	Reveal in Finder	在 Finder 中顯示
 	Show in Explorer	在檔案總管中顯示
 	Show in Folder	在資料夾中顯示
@@ -138,6 +161,8 @@
 	Search…	搜尋…
 	Check Spelling…	拼字檢查…
 	Find and Replace Text…	尋找並取代文字…
+	Add to Dictionary	加入字典
+	No Spelling Suggestions	沒有拼字建議
 	Fill…	填滿…
 	Stroke…	筆畫…
 	Content-Aware Fill…	內容感知填滿…
@@ -152,6 +177,8 @@
 	Transform Again on a Copy	複製並再次變形
 	Scale	縮放
 	Rotate	旋轉
+	Set horizontal skew	設定水平傾斜
+	Set vertical skew	設定垂直傾斜
 	Skew	傾斜
 	Distort	扭曲
 	Perspective	透視
@@ -364,6 +391,7 @@
 	Update Modified Content	更新修改過的內容
 	Update All Modified Content	更新所有修改過的內容
 	Stack Mode	堆疊模式
+	Choose Stack Mode:	選擇堆疊模式：
 	Entropy	熵
 	Kurtosis	峰度
 	Maximum	最大
@@ -398,6 +426,7 @@
 	Select Linked Layers	選取連結的圖層
 	Merge Layers	合併圖層
 	Merge Down	向下合併圖層
+	Merge Group	合併群組
 	Merge Visible	合併可見圖層
 	Stamp Visible	蓋印可見圖層
 	Select Layer Above	選取上方圖層
@@ -534,6 +563,9 @@
 	Blur	模糊
 	Blur Gallery	模糊收藏館
 	Field Blur…	區域模糊…
+# Field Blur pins (#3373)
+	No pin selected	未選取圖釘
+	Click the image to add a pin; drag a pin to move it, or its ring to change its blur. Delete removes the selected pin.	按一下影像即可新增圖釘；拖移圖釘可移動它，拖移其圓環可變更模糊程度。按 Delete 鍵刪除所選圖釘。
 	Iris Blur…	光圈模糊…
 	Tilt-Shift…	傾斜偏移…
 	Path Blur…	路徑模糊…
@@ -732,6 +764,10 @@
 	Breeze Dark Theme	Breeze 深色主題
 	Breeze light	Breeze 淺色
 	Breeze Light Theme	Breeze 淺色主題
+	Soft dark	柔和深色
+	Soft light	柔和淺色
+	Soft Dark Theme	柔和深色主題
+	Soft Light Theme	柔和淺色主題
 	Next Theme	下一個主題
 	Actions	動作
 	Brush Settings	筆刷設定
@@ -830,6 +866,9 @@
 	Appearance	外觀
 	Appearance (Layer Style)	外觀 (圖層樣式)
 	Apply Layer Mask	套用圖層遮色片
+	Add Mask to Selection	增加遮色片至選取範圍
+	Subtract Mask from Selection	從選取範圍中減去遮色片
+	Intersect Mask with Selection	遮色片與選取範圍相交
 	Apply Per Tip	依筆尖套用
 	Apply next selected layer comp	套用下一個選取的圖層構圖
 	Apply previous selected layer comp	套用上一個選取的圖層構圖
@@ -845,11 +884,18 @@
 	Background	背景
 	Background Color	背景色
 	Background Contents	背景內容
+	Custom background color	自訂背景色
 	Balance	平衡
 	Baseline	基線
 	Baseline shift	基線位移
 	Basic	基本
 	Before (Y)	之前 (Y)
+	Save Settings…	儲存設定…
+	Load Settings…	載入設定…
+	Save these settings as a Camera Raw .xmp file	將這些設定儲存為 Camera Raw .xmp 檔案
+	Load settings from a Camera Raw .xmp file	從 Camera Raw .xmp 檔案載入設定
+	Loaded Camera Raw settings from {file}	已從 {file} 載入 Camera Raw 設定
+	Loaded Camera Raw settings from {file} ({n} not supported)	已從 {file} 載入 Camera Raw 設定（{n} 項不支援）
 	Begin recording	開始記錄
 	Bend:	彎曲：
 	Bicubic	雙三次
@@ -880,6 +926,7 @@
 	Camera Raw isn't open	Camera Raw 未開啟
 	Cancel	取消
 	Cancel (Esc)	取消 (Esc)
+	Manage submitted jobs in the system print queue	在系統列印佇列中管理已提交的工作
 	Cancel any current edits (Esc)	取消目前所有編輯 (Esc)
 	Cancel current crop operation  (Esc)	取消目前的裁切作業 (Esc)
 	Cancel transform (Esc)	取消變形 (Esc)
@@ -1151,6 +1198,9 @@
 	Ignore All	全部略過
 	Image Size	影像尺寸
 	Import Brushes…	匯入筆刷…
+	Gradient Preset Options	漸層預設選項
+	Import .GRD	匯入 .GRD
+	Choose a gradient file (.grd).	請選擇漸層檔案 (.grd)。
 	Import brushes (.abr)	匯入筆刷 (.abr)
 	Import Presets	匯入預設集
 	Imported	已匯入
@@ -2082,6 +2132,11 @@
 	Rename Brush…	重新命名筆刷…
 	Delete Brush	刪除筆刷
 	New Brush Preset…	新增筆刷預設集…
+	Capture Brush Size in Preset	在預設集中擷取筆刷尺寸
+	Include Tool Settings	包含工具設定
+	Include Color	包含顏色
+	Enter a name for the brush preset	請輸入筆刷預設集的名稱
+	A brush preset with this name already exists	已有相同名稱的筆刷預設集
 	Brush Preset Options	筆刷預設集選項
 	Group name	群組名稱
 	Brush name	筆刷名稱
@@ -2143,6 +2198,10 @@
 	No path to make a selection from: draw one with the Pen tool or select one in the Paths panel.	沒有可用來建立選取範圍的路徑：請使用鋼筆工具繪製，或在路徑面板中選取一個路徑。
 	Cancel opening	取消開啟
 	Cancelled opening {name}	已取消開啟 {name}
+	The document “{name}” does not have an embedded {mode} profile.	文件「{name}」沒有嵌入的 {mode} 描述檔。
+	The document “{name}” has an embedded color profile that does not match the current {mode} working space.	文件「{name}」嵌入的色彩描述檔與目前的 {mode} 工作空間不符。
+	Embedded: {embedded}	嵌入：{embedded}
+	Working: {working}	工作空間：{working}
 	Developing {name}	正在處理 {name}
 	Cancelled {label}	已取消 {label}
 	Esc to cancel	按 Esc 取消
@@ -2298,6 +2357,7 @@ cameraRaw	Blending	混合
 	Click to pick · Esc to cancel	按一下選取 · Esc 取消
 	Pick a screen pixel or press Esc to cancel	選取螢幕像素或按 Esc 取消
 	Scroll to zoom	捲動以縮放
+	Drag to pan · Scroll to zoom · Double-click to fit	拖曳以平移 · 捲動以縮放 · 按兩下以符合視窗
 	Show/Hide All Panels	顯示/隱藏所有面板
 	Show/Hide Panels	顯示/隱藏面板
 	Could not open	無法開啟
@@ -2356,6 +2416,7 @@ cameraRaw	Blending	混合
 	Violet	紫羅蘭色
 	Reset	重設
 	Large document: redrawing on the CPU	大型文件：正在以 CPU 重繪
+	Redrawing	正在重繪
 	This redraw took {seconds} s on the CPU.	此次 CPU 重繪耗時 {seconds} 秒。
 	Edits that change the whole document, such as a layer's blend mode, opacity or visibility, redraw all of it.	變更整份文件的編輯（例如圖層的混合模式、不透明度或可見度）會重繪整份文件。
 	Its layers don't fit the GPU memory budget. Raising Memory usage in Preferences › Performance raises the budget, up to a quarter of this computer's memory.	圖層超出 GPU 記憶體預算。在 偏好設定 › 效能 中提高記憶體使用量可增加預算，最多為本機記憶體的四分之一。
@@ -2600,6 +2661,7 @@ curves	Smooth	平滑
 	Select the crop presets to delete	選取要刪除的裁切預設集
 	Enter a name for the crop preset	輸入裁切預設集的名稱
 	There is no crop size or ratio to save	沒有可儲存的裁切尺寸或比例
+	Presentation	呈現
 
 # Color Sampler (added with the i18n coverage repair)
 	Click to place · Alt-click or drag off-canvas to remove	按一下以放置 · Alt 按一下或拖曳至畫布外以移除
@@ -2637,3 +2699,36 @@ curves	Smooth	平滑
 	Light Red	淺紅色
 	Medium Blue	中藍色
 	Light Gray	淺灰色
+	Object Finder	物件尋找器
+	No object found there — drag a rectangle around it	那裡找不到物件 — 請在其周圍拖曳矩形
+	Remove after each stroke	每次描邊後移除
+	Apply the removal ({key})	套用移除 ({key})
+	Strokes to remove: {n} (Enter applies, Esc cancels)	待移除的描邊：{n}（Enter 套用，Esc 取消）
+	Clear Brush Controls	清除筆刷控制項
+	Reset All Locked Settings	重設所有鎖定的設定
+	Copy Texture to Other Tools	複製紋理至其他工具
+
+# Actions panel: Load/Save Actions (.atn) and kept Photoshop steps
+	Load Actions…	載入動作…
+	Save Actions…	儲存動作…
+	{name} (Photoshop)	{name}（Photoshop）
+	{message} ({note})	{message}（{note}）
+@plural	Loaded {n} action from {file}|Loaded {n} actions from {file}	已從 {file} 載入 {n} 個動作
+@plural	{n} step has no PhotoCraft equivalent yet|{n} steps have no PhotoCraft equivalent yet	{n} 個步驟在 PhotoCraft 中尚無對應功能
+@plural	Saved {n} action to {file}|Saved {n} actions to {file}	已將 {n} 個動作儲存到 {file}
+@plural	{n} step with no Photoshop equivalent left out|{n} steps with no Photoshop equivalent left out	已略過 {n} 個沒有 Photoshop 對應功能的步驟
+
+	File Naming	檔案命名
+	Starting serial	起始序號
+# Actions panel: set folders, dialog toggle, Insert Stop
+	Insert Stop…	插入停止…
+	Save Set…	儲存組合…
+	Message:	訊息:
+	Allow Continue	允許繼續
+	Show dialog during playback	播放時顯示對話框
+	Select an action first	請先選取一個動作
+	Action playback stopped	動作播放已停止
+	Step {step} is waiting for its dialog	步驟 {step} 正在等待其對話框
+@plural	{n} action|{n} actions	{n} 個動作
+	Auto Add/Delete	自動增加/刪除
+	ICO is limited to 256 × 256 pixels	ICO 最大為 256 × 256 像素
diff --git a/crates/ui-egui/src/icon_data.rs b/crates/ui-egui/src/icon_data.rs
index 1fea9bb655..f1e22d5efa 100644
--- a/crates/ui-egui/src/icon_data.rs
+++ b/crates/ui-egui/src/icon_data.rs
@@ -68,6 +68,8 @@ pub static ICONS: &[(&str, &[u8])] = &[
     ("folder-plus", include_bytes!("../../../assets/icons/folder-plus.svg")),
     ("frame-placeholder", include_bytes!("../../../assets/icons/frame-placeholder.svg")),
     ("gauge", include_bytes!("../../../assets/icons/gauge.svg")),
+    // PhotoCraft original: the Gradient tool glyph (a rectangle filled with a linear ramp).
+    ("gradient", include_bytes!("../../../assets/icons/gradient.svg")),
     ("grid-2x2", include_bytes!("../../../assets/icons/grid-2x2.svg")),
     ("grid-3x3", include_bytes!("../../../assets/icons/grid-3x3.svg")),
     ("hand", include_bytes!("../../../assets/icons/hand.svg")),
diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs
index 0b3b58dd04..215e5994e8 100644
--- a/crates/ui-egui/src/icons.rs
+++ b/crates/ui-egui/src/icons.rs
@@ -111,7 +111,7 @@ pub fn tool_icon(t: Tool) -> &'static str {
         Tool::Slice => "slice-knife",
         Tool::SliceSelect => "square-dashed-mouse-pointer",
         Tool::Frame => "frame-placeholder",
-        Tool::Gradient => "blend",
+        Tool::Gradient => "gradient",
         Tool::PaintBucket => "paint-bucket",
         Tool::Type | Tool::VerticalType => "type",
         Tool::HorizontalTypeMask => "type-mask",
@@ -177,6 +177,12 @@ pub fn button(ui: &mut egui::Ui, name: &str, box_size: f32, selected: bool, tool
 
 /// Square icon button with an explicit glyph size, independent of its hit area.
 pub fn button_with_icon_size(ui: &mut egui::Ui, name: &str, box_size: f32, icon_size: f32, selected: bool, tooltip: &str) -> Response {
+    button_with_icon_size_tip(ui, name, box_size, icon_size, selected, tooltip, true)
+}
+
+/// [`button_with_icon_size`] whose tooltip shows only when `show_tip`; the tooltip text still
+/// names the button (for screen readers and tests) when it is hidden.
+pub fn button_with_icon_size_tip(ui: &mut egui::Ui, name: &str, box_size: f32, icon_size: f32, selected: bool, tooltip: &str, show_tip: bool) -> Response {
     let t = Tokens::get(ui.ctx());
     let style = IconButtonStyle {
         normal: ButtonVisuals { fill: Color32::TRANSPARENT, stroke: egui::Stroke::NONE, icon: t.icon },
@@ -190,7 +196,7 @@ pub fn button_with_icon_size(ui: &mut egui::Ui, name: &str, box_size: f32, icon_
     let resp = IconButton::new(label, Vec2::splat(box_size), &style).selected(selected).show(ui, |ui, rect, tint| {
         paint(ui, rect, name, icon_size, tint);
     });
-    if tooltip.is_empty() { resp } else { resp.on_hover_text(label) }
+    if tooltip.is_empty() || !show_tip { resp } else { resp.on_hover_text(label) }
 }
 
 /// Rail toggle: "on" gets a quiet filled background and full-strength icon (no accent).
@@ -218,6 +224,28 @@ mod tests {
         for t in Tool::ALL {
             assert!(exists(tool_icon(t)), "{t:?}");
         }
+        assert_eq!(tool_icon(Tool::Gradient), "gradient");
+        assert_ne!(tool_icon(Tool::Gradient), tool_icon(Tool::PaintBucket));
+    }
+
+    #[test]
+    fn gradient_tool_icon_rasterizes_left_to_right_ramp() {
+        let egui::ImageSource::Bytes { bytes, .. } = white_icons().source(tool_icon(Tool::Gradient)) else {
+            panic!("icon source must be embedded bytes");
+        };
+        let image = egui_extras::image::load_svg_bytes_with_size(
+            bytes.as_ref(),
+            egui::load::SizeHint::Size { width: 24, height: 24, maintain_aspect_ratio: true },
+            &Default::default(),
+        )
+        .unwrap();
+        let left_alpha = image[(6, 12)].a();
+        let mid_alpha = image[(12, 12)].a();
+        let right_alpha = image[(18, 12)].a();
+        assert!(
+            left_alpha > mid_alpha && mid_alpha > right_alpha,
+            "interior ramp should fade from left ({left_alpha}) through middle ({mid_alpha}) to right ({right_alpha})"
+        );
     }
 
     #[test]
diff --git a/crates/ui-egui/src/input_tests.rs b/crates/ui-egui/src/input_tests.rs
index d78dbedbad..3754e821fc 100644
--- a/crates/ui-egui/src/input_tests.rs
+++ b/crates/ui-egui/src/input_tests.rs
@@ -504,10 +504,12 @@ fn type_tool_alt_arrows_kern_the_pair() {
     h.key_press_modifiers(Modifiers::ALT | Modifiers::SHIFT, Key::ArrowRight);
     h.run_steps(2);
     assert_eq!(h.state().ui.text_edit.as_ref().map(|e| (e.anchor, e.caret)), Some((3, 6)));
-    // With a selection Alt+→ moves by word instead of kerning; at the text end there's no pair.
+    // With a selection Alt+→ tracks it instead (see `type_tool_format_keys_*`); at the text end
+    // there's no pair to kern.
     let before = kern(&h);
-    h.key_press_modifiers(Modifiers::ALT, Key::ArrowRight);
+    h.key_press(Key::ArrowRight);
     h.run_steps(2);
+    assert_eq!(h.state().ui.text_edit.as_ref().map(|e| (e.anchor, e.caret)), Some((6, 6)));
     h.key_press_modifiers(Modifiers::ALT, Key::ArrowRight);
     h.run_steps(2);
     assert_eq!(kern(&h), before);
@@ -518,6 +520,245 @@ fn type_tool_alt_arrows_kern_the_pair() {
     assert_eq!(kern(&h).1, metric + 120.0);
 }
 
+/// Starts a type editing session on `layer` with `anchor..caret` selected.
+fn edit_type(h: &mut Harness<'static, PhotocraftApp>, layer: u64, anchor: usize, caret: usize) {
+    h.state_mut().ui.text_edit = Some(crate::state::TextEdit {
+        layer,
+        caret,
+        anchor,
+        session: "format-keys".into(),
+        created: false,
+        mask: false,
+        dragging: false,
+        resize: None,
+        preedit: None,
+    });
+    h.run_steps(2);
+}
+
+fn type_layer(h: &Harness<'static, PhotocraftApp>, id: u64) -> photocraft_doc::TextLayer {
+    match &h.state().session.active().unwrap().doc.layer(photocraft_doc::LayerId(id)).unwrap().content {
+        photocraft_doc::LayerContent::Text(t) => t.clone(),
+        _ => panic!("not text"),
+    }
+}
+
+/// The character style of character `c` of a type layer.
+fn char_style(h: &Harness<'static, PhotocraftApp>, id: u64, c: usize) -> photocraft_doc::text::CharStyle {
+    let t = type_layer(h, id);
+    let byte = t.text.char_indices().nth(c).map_or(t.text.len(), |(i, _)| i);
+    let mut end = 0;
+    t.char_runs()
+        .into_iter()
+        .find(|r| {
+            end += r.len;
+            end > byte || t.text.is_empty()
+        })
+        .unwrap()
+        .style
+}
+
+/// The paragraph style of the paragraph holding character `c`.
+fn para_style(h: &Harness<'static, PhotocraftApp>, id: u64, c: usize) -> photocraft_doc::text::ParagraphStyle {
+    let t = type_layer(h, id);
+    let byte = t.text.char_indices().nth(c).map_or(t.text.len(), |(i, _)| i);
+    let mut end = 0;
+    t.paragraph_runs()
+        .into_iter()
+        .find(|r| {
+            end += r.len;
+            end > byte
+        })
+        .unwrap()
+        .style
+}
+
+fn history(h: &Harness<'static, PhotocraftApp>) -> Vec<String> {
+    h.state().session.active().unwrap().history.entries()
+}
+
+/// Photoshop's ⇧⌘K/U/B/I/: toggle All Caps, Underline, Faux Bold, Faux Italic and Strikethrough
+/// on the selected characters while typing, one step per press, and never reach the global
+/// ⇧⌘K/U/B/I (Color Settings, Desaturate, Auto Color, Inverse).
+#[test]
+fn type_tool_format_keys_toggle_character_styles() {
+    use photocraft_doc::text::{Caps, CharStyle};
+    let mut h = harness();
+    // A selection, so Select ▸ Inverse would be enabled if the key reached it.
+    h.state_mut().run("select.all", json!({})).unwrap();
+    let id = h.state_mut().run("type.create", json!({"x": 20, "y": 80, "text": "Hello world", "size": 20})).unwrap()["layer"].as_u64().unwrap();
+    edit_type(&mut h, id, 0, 5);
+    let cmd_shift = Modifiers::COMMAND | Modifiers::SHIFT;
+    type Has = fn(&CharStyle) -> bool;
+    let keys: [(Key, Has); 6] = [
+        (Key::K, |s| s.caps == Caps::AllCaps),
+        (Key::U, |s| s.underline),
+        (Key::B, |s| s.faux_bold),
+        (Key::I, |s| s.faux_italic),
+        (Key::Slash, |s| s.strikethrough),
+        (Key::Questionmark, |s| s.strikethrough),
+    ];
+    for (key, has) in keys {
+        let before = history(&h).len();
+        let was = has(&char_style(&h, id, 0));
+        h.key_press_modifiers(cmd_shift, key);
+        h.run_steps(2);
+        assert_eq!(has(&char_style(&h, id, 0)), !was, "{key:?} toggles the selection");
+        assert_eq!(has(&char_style(&h, id, 4)), !was, "{key:?}");
+        assert!(!has(&char_style(&h, id, 6)), "{key:?} leaves the unselected characters");
+        let steps = history(&h);
+        assert_eq!(steps.len(), before + 1, "{key:?}: one history step");
+        assert_eq!(steps.last().map(String::as_str), Some("Set Type Style"), "{key:?}");
+        assert!(h.state().ui.dialogs.is_empty(), "{key:?} must not open Color Settings");
+        assert!(h.state().ui.text_edit.is_some());
+    }
+    // The second strikethrough key turned it off again; press the rest again: all off.
+    for key in [Key::K, Key::U, Key::B, Key::I] {
+        h.key_press_modifiers(cmd_shift, key);
+        h.run_steps(2);
+    }
+    let s = char_style(&h, id, 2);
+    assert!(s.caps == Caps::Normal && !s.underline && !s.faux_bold && !s.faux_italic && !s.strikethrough);
+    // Partly underlined: the key underlines the whole selection rather than flipping each part.
+    h.state_mut().run("type.setStyle", json!({"layer": id, "range": [0, 2], "underline": true})).unwrap();
+    h.key_press_modifiers(cmd_shift, Key::U);
+    h.run_steps(2);
+    assert!((0..5).all(|c| char_style(&h, id, c).underline));
+    // Undo takes back one press.
+    assert!(h.state_mut().session.undo());
+    h.run_steps(1);
+    assert!(char_style(&h, id, 0).underline && !char_style(&h, id, 3).underline);
+    // A collapsed caret in non-empty text: nothing changes, and nothing global runs.
+    edit_type(&mut h, id, 3, 3);
+    let before = history(&h);
+    for key in [Key::K, Key::U, Key::B, Key::I] {
+        h.key_press_modifiers(cmd_shift, key);
+        h.run_steps(2);
+    }
+    assert_eq!(history(&h), before);
+    assert!(h.state().ui.dialogs.is_empty());
+    // Empty text: the key sets the style the next characters typed get.
+    let empty = h.state_mut().run("type.create", json!({"x": 20, "y": 160, "text": "", "size": 20})).unwrap()["layer"].as_u64().unwrap();
+    edit_type(&mut h, empty, 0, 0);
+    h.key_press_modifiers(cmd_shift, Key::B);
+    h.run_steps(2);
+    h.event(egui::Event::Text("ab".into()));
+    h.run_steps(2);
+    assert_eq!(type_layer(&h, empty).text, "ab");
+    assert!(char_style(&h, empty, 0).faux_bold && char_style(&h, empty, 1).faux_bold);
+}
+
+/// Outside text editing ⇧⌘K and ⇧⌘I keep their global meanings.
+#[test]
+fn global_cmd_shift_keys_still_work_outside_type_editing() {
+    let mut h = harness();
+    h.state_mut().run("select.all", json!({})).unwrap();
+    let id = h.state_mut().run("type.create", json!({"x": 20, "y": 80, "text": "Hello", "size": 20})).unwrap()["layer"].as_u64().unwrap();
+    h.run_steps(2);
+    assert!(h.state().ui.text_edit.is_none());
+    let cmd_shift = Modifiers::COMMAND | Modifiers::SHIFT;
+    h.key_press_modifiers(cmd_shift, Key::I);
+    h.run_steps(2);
+    assert_eq!(history(&h).last().map(String::as_str), Some("Inverse"));
+    h.key_press_modifiers(cmd_shift, Key::K);
+    h.run_steps(3);
+    assert_eq!(h.state().ui.dialogs.len(), 1, "Color Settings opens");
+    assert!(!char_style(&h, id, 0).faux_italic && char_style(&h, id, 0).caps == photocraft_doc::text::Caps::Normal);
+}
+
+/// ⌥↑/↓ leading (2 pt, 10 with ⌘), ⇧⌥↑/↓ baseline shift and ⌥←/→ tracking over a selection
+/// (20, 100 with ⌘): one step per press, from each character's own value, the selection kept.
+#[test]
+fn type_tool_format_keys_step_leading_baseline_and_tracking() {
+    let mut h = harness();
+    let id = h.state_mut().run("type.create", json!({"x": 20, "y": 80, "text": "Hello world", "size": 10})).unwrap()["layer"].as_u64().unwrap();
+    edit_type(&mut h, id, 0, 5);
+    let before = history(&h).len();
+    let press = |h: &mut Harness<'static, PhotocraftApp>, m: Modifiers, k: Key| {
+        h.key_press_modifiers(m, k);
+        h.run_steps(2);
+    };
+    // Auto leading is 120% of 10 pt: ⌥↓ makes it 14.
+    press(&mut h, Modifiers::ALT, Key::ArrowDown);
+    assert_eq!(char_style(&h, id, 0).leading_pt, Some(14.0));
+    press(&mut h, Modifiers::ALT, Key::ArrowUp);
+    assert_eq!(char_style(&h, id, 4).leading_pt, Some(12.0));
+    press(&mut h, Modifiers::ALT | Modifiers::COMMAND, Key::ArrowDown);
+    assert_eq!(char_style(&h, id, 0).leading_pt, Some(22.0));
+    press(&mut h, Modifiers::ALT | Modifiers::SHIFT, Key::ArrowUp);
+    assert_eq!(char_style(&h, id, 0).baseline_shift_pt, 2.0);
+    press(&mut h, Modifiers::ALT | Modifiers::SHIFT | Modifiers::COMMAND, Key::ArrowDown);
+    assert_eq!(char_style(&h, id, 0).baseline_shift_pt, -8.0);
+    press(&mut h, Modifiers::ALT, Key::ArrowRight);
+    assert_eq!(char_style(&h, id, 0).tracking, 20.0);
+    press(&mut h, Modifiers::ALT | Modifiers::COMMAND, Key::ArrowLeft);
+    assert_eq!(char_style(&h, id, 4).tracking, -80.0);
+    assert_eq!(history(&h).len(), before + 7, "one history step per press");
+    assert_eq!(h.state().ui.text_edit.as_ref().map(|e| (e.anchor, e.caret)), Some((0, 5)), "the selection stays");
+    let rest = char_style(&h, id, 7);
+    assert_eq!((rest.leading_pt, rest.baseline_shift_pt, rest.tracking), (None, 0.0, 0.0));
+    // A collapsed caret: ⌥↑/↓ change nothing and don't move the caret.
+    edit_type(&mut h, id, 8, 8);
+    let steps = history(&h).len();
+    press(&mut h, Modifiers::ALT, Key::ArrowDown);
+    press(&mut h, Modifiers::ALT | Modifiers::SHIFT, Key::ArrowUp);
+    assert_eq!(history(&h).len(), steps);
+    assert_eq!(h.state().ui.text_edit.as_ref().map(|e| (e.anchor, e.caret)), Some((8, 8)));
+}
+
+/// ⌥⇧⌘H toggles Hyphenate for the paragraphs the selection or caret touches.
+#[test]
+fn type_tool_format_keys_toggle_hyphenate() {
+    let mut h = harness();
+    let id = h.state_mut().run("type.create", json!({"box": [10, 10, 300, 200], "text": "one\ntwo\nthree", "size": 12})).unwrap()["layer"].as_u64().unwrap();
+    let keys = Modifiers::COMMAND | Modifiers::ALT | Modifiers::SHIFT;
+    // The caret in the second paragraph.
+    edit_type(&mut h, id, 5, 5);
+    let before = history(&h).len();
+    h.key_press_modifiers(keys, Key::H);
+    h.run_steps(2);
+    assert_eq!([0, 5, 9].map(|c| para_style(&h, id, c).hyphenate), [false, true, false]);
+    // A selection over the first two: not all hyphenate, so both do; again, neither.
+    edit_type(&mut h, id, 1, 5);
+    h.key_press_modifiers(keys, Key::H);
+    h.run_steps(2);
+    assert_eq!([0, 5, 9].map(|c| para_style(&h, id, c).hyphenate), [true, true, false]);
+    h.key_press_modifiers(keys, Key::H);
+    h.run_steps(2);
+    assert_eq!([0, 5, 9].map(|c| para_style(&h, id, c).hyphenate), [false, false, false]);
+    assert_eq!(history(&h).len(), before + 3);
+}
+
+/// The formatting keys never panic: an edit of a layer that has gone, or with no document.
+#[test]
+fn type_tool_format_keys_survive_hostile_state() {
+    let mut h = harness();
+    edit_type(&mut h, 9999, 0, 3);
+    h.key_press_modifiers(Modifiers::COMMAND | Modifiers::SHIFT, Key::U);
+    h.key_press_modifiers(Modifiers::ALT, Key::ArrowDown);
+    h.run_steps(2);
+    assert!(h.state().ui.text_edit.is_none(), "an edit of a missing layer ends");
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    for ed in [None, Some(1)] {
+        app.ui.text_edit = ed.map(|layer| crate::state::TextEdit {
+            layer,
+            caret: 4,
+            anchor: 0,
+            session: "x".into(),
+            created: false,
+            mask: false,
+            dragging: false,
+            resize: None,
+            preedit: None,
+        });
+        crate::type_tool::toggle_char_style(&mut app, crate::type_tool::CharToggle::AllCaps);
+        crate::type_tool::step_char_metric(&mut app, "leadingBy", 2.0);
+        crate::type_tool::step_char_metric(&mut app, "trackingBy", f32::NAN);
+        crate::type_tool::toggle_hyphenate(&mut app);
+    }
+    assert!(app.session.active().is_none());
+}
+
 /// The Character panel's kerning field reads and parses Photoshop's values.
 #[test]
 fn kerning_field_values() {
@@ -564,6 +805,22 @@ fn eyedropper_and_alt_sampling_show_a_pipette() {
     assert_eq!(precise(&mut h), (egui::CursorIcon::Crosshair, desktop));
 }
 
+/// The Paint Bucket shows a bucket instead of the crosshair (#3968); Precise Other Cursors keeps
+/// the crosshair.
+#[test]
+fn paint_bucket_shows_a_bucket_cursor() {
+    let mut h = harness();
+    let p = h.state().last_canvas_rect.center();
+    h.state_mut().ui.tool = crate::state::Tool::PaintBucket;
+    h.hover_at(p);
+    h.run_steps(2);
+    assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::None, "the bucket replaces the pointer");
+    h.state_mut().run("prefs.set", json!({"values": {"cursors.other": "precise"}})).unwrap();
+    h.hover_at(p);
+    h.run_steps(2);
+    assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::Crosshair, "Precise keeps the crosshair");
+}
+
 /// The Hand tool, and Space held over another tool, show an open hand while hovering and a fist
 /// while they pan (#2196). The OS draws those everywhere but Windows, where winit maps `Grab` to
 /// the four-arrow move cursor, so the app hands it a bitmap there (`Crosshair` is the fallback).
@@ -653,6 +910,35 @@ fn esc_ends_a_pen_path_and_keeps_it() {
     assert_eq!(h.state().ui.selected_path.as_deref(), Some("work"));
 }
 
+/// Over the first anchor of a Pen path the canvas shows the close-path pointer (#4596), a bitmap
+/// of its own; anywhere else the Pen keeps its crosshair.
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn pen_shows_the_close_path_pointer_over_the_first_anchor() {
+    let mut h = harness();
+    h.state_mut().ui.tool = crate::state::Tool::Pen;
+    h.state_mut().ui.pen = Some(crate::vector_ui::PenPath { knots: vec![[[50.0, 50.0]; 3], [[150.0, 50.0]; 3]], ..Default::default() });
+    let screen = |h: &Harness<'static, PhotocraftApp>, x: f32, y: f32| {
+        let v = &h.state().ui.views[0];
+        let c = h.state().last_canvas_rect.center();
+        pos2(c.x + (x - v.center[0]) * v.zoom, c.y + (y - v.center[1]) * v.zoom)
+    };
+    let pointer = |h: &mut Harness<'static, PhotocraftApp>, x: f32, y: f32| {
+        let p = screen(h, x, y);
+        h.hover_at(p);
+        h.run_steps(2);
+        let out = &h.output().platform_output;
+        (out.cursor_icon, out.cursor_image.as_ref().map(|i| i.rgba.clone()))
+    };
+    let close = pointer(&mut h, 50.0, 50.0);
+    assert_eq!(close.0, egui::CursorIcon::Crosshair, "the fallback under the bitmap");
+    assert!(close.1.is_some(), "a bitmap");
+    let elsewhere = pointer(&mut h, 200.0, 200.0);
+    assert_ne!(elsewhere.1, close.1, "empty canvas: the plain Pen pointer");
+    assert_ne!(pointer(&mut h, 150.0, 50.0).1, close.1, "the last anchor doesn't close");
+    assert_eq!(pointer(&mut h, 50.0, 50.0), close, "back on the first anchor");
+}
+
 /// Esc with no active operation deselects (#2674), like ⌘D.
 #[test]
 fn escape_deselects_when_nothing_else_needs_cancelling() {
@@ -707,3 +993,97 @@ fn escape_with_targa_options_open_does_not_deselect() {
     h.run_steps(2);
     assert!(h.state().session.active().unwrap().doc.selection.is_some(), "Esc belongs to Targa Options");
 }
+
+/// How much of the 400 × 300 document is on screen: the visible document span on each axis,
+/// clipped to the image (0 when the image has left the view on that axis).
+fn visible_image(h: &Harness<'static, PhotocraftApp>) -> [f32; 2] {
+    let r = h.state().last_canvas_rect;
+    let (a, b) = (doc_at(h, r.min), doc_at(h, r.max));
+    [(b[0].min(400.0) - a[0].max(0.0)).max(0.0), (b[1].min(300.0) - a[1].max(0.0)).max(0.0)]
+}
+
+#[test]
+fn wheel_zoom_over_the_pasteboard_keeps_the_image_in_view() {
+    // #3720: zooming in with the pointer on the gray pasteboard anchored on the pointer, so a few
+    // notches pushed the image out of the window. The anchor is now the nearest point of the image.
+    for (zoom_with_wheel, m) in [(true, Modifiers::NONE), (false, Modifiers::ALT)] {
+        let mut h = harness();
+        h.state_mut().session.edit_prefs(|p| p.general.zoom_with_scroll_wheel = zoom_with_wheel);
+        let r = h.state().last_canvas_rect;
+        let p = pos2(r.left() + 20.0, r.top() + 20.0);
+        let d = doc_at(&h, p);
+        assert!(d[0] < 0.0 && d[1] < 0.0, "the pointer starts on the pasteboard: {d:?}");
+        h.hover_at(p);
+        h.run_steps(2);
+        let z0 = zoom(&h);
+        for _ in 0..20 {
+            wheel(&h, 1.0, m);
+            h.run_steps(3);
+        }
+        h.run_steps(20);
+        assert!(zoom(&h) > z0 * 5.0, "the notches zoomed in: {z0} -> {}", zoom(&h));
+        let v = visible_image(&h);
+        assert!(v[0] > 0.0 && v[1] > 0.0, "zoom_with_wheel {zoom_with_wheel}: the image left the view {v:?}");
+        // The image's corner nearest the pointer is the anchor: it stays where it was on screen.
+        let c = doc_at(&h, pos2(r.left() + 20.0, r.top() + 20.0));
+        assert!(c[0] < 0.0 && c[1] < 0.0, "still pasteboard under the pointer, the corner held: {c:?}");
+        // A pinch from there behaves the same.
+        h.event(egui::Event::Zoom(4.0));
+        h.run_steps(3);
+        let v = visible_image(&h);
+        assert!(v[0] > 0.0 && v[1] > 0.0, "pinch: the image left the view {v:?}");
+    }
+}
+
+#[test]
+fn wheel_zoom_over_the_image_still_anchors_on_the_pointer() {
+    let mut h = harness();
+    let r = h.state().last_canvas_rect;
+    let p = pos2(r.center().x - 150.0, r.center().y - 100.0);
+    h.hover_at(p);
+    h.run_steps(2);
+    let d0 = doc_at(&h, p);
+    assert!(d0[0] > 0.0 && d0[1] > 0.0);
+    for _ in 0..5 {
+        wheel(&h, 1.0, Modifiers::ALT);
+        h.run_steps(3);
+    }
+    h.run_steps(20);
+    let d1 = doc_at(&h, p);
+    assert!((d1[0] - d0[0]).abs() < 0.1 && (d1[1] - d0[1]).abs() < 0.1, "{d0:?} -> {d1:?}");
+}
+
+/// #4658: with the Move tool's Show Transform Controls, the band just outside the box shows the
+/// curved rotate arrow, not a plain pointer, and one drag from there rotates the layer.
+#[test]
+fn move_tool_controls_rotate_from_just_outside_the_box() {
+    let mut h = harness();
+    h.state_mut().run("shape.create", json!({"kind": "rect", "rect": [150, 100, 100, 100], "fill": "#ff0000"})).unwrap();
+    h.state_mut().ui.tool = crate::state::Tool::Move;
+    h.state_mut().ui.tool_options.move_show_transform = true;
+    h.run_steps(3);
+    let screen = |h: &Harness<'static, PhotocraftApp>, x: f32, y: f32| {
+        let v = &h.state().ui.views[0];
+        let c = h.state().last_canvas_rect.center();
+        pos2(c.x + (x - v.center[0]) * v.zoom, c.y + (y - v.center[1]) * v.zoom)
+    };
+    let zoom = h.state().ui.views[0].zoom;
+    // Just outside the top edge, a quarter of the way along: the rotation band.
+    let at = screen(&h, 175.0, 100.0) - vec2(0.0, 12.0);
+    h.hover_at(at);
+    h.run_steps(2);
+    assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::None, "the drawn rotate arrow replaces the pointer");
+    press(&mut h, at, true);
+    let centre = screen(&h, 200.0, 150.0);
+    // A quarter turn around the box's centre.
+    for k in 1..=10 {
+        let a = std::f32::consts::FRAC_PI_2 * k as f32 / 10.0;
+        let (dx, dy) = (at.x - centre.x, at.y - centre.y);
+        let q = centre + vec2(dx * a.cos() - dy * a.sin(), dx * a.sin() + dy * a.cos());
+        h.hover_at(q);
+        h.run_steps(1);
+    }
+    let end = h.state().ui.transform.as_ref().map(|t| t.quad).expect("the drag opened Free Transform");
+    let tilt = (end[1][1] - end[0][1]).atan2(end[1][0] - end[0][0]).to_degrees();
+    assert!((tilt - 90.0).abs() < 8.0 || (tilt + 270.0).abs() < 8.0, "rotated about a quarter turn, got {tilt}° (zoom {zoom})");
+}
diff --git a/crates/ui-egui/src/jobs_ui.rs b/crates/ui-egui/src/jobs_ui.rs
index 301460fc5c..29da41d481 100644
--- a/crates/ui-egui/src/jobs_ui.rs
+++ b/crates/ui-egui/src/jobs_ui.rs
@@ -348,7 +348,7 @@ fn finish_save(app: &mut PhotocraftApp, ctx: &egui::Context, save: SaveJob, labe
 /// no save worker is left.
 fn close_after_saves(app: &mut PhotocraftApp, ctx: &egui::Context) {
     app.jobs.saves.retain(|s| !(s.ended && s.state.finished()));
-    if !app.saving() && std::mem::take(&mut app.jobs.close_after_saves) {
+    if !app.saving() && !app.printing() && std::mem::take(&mut app.jobs.close_after_saves) {
         ctx.send_viewport_cmd(egui::ViewportCommand::Close);
     }
 }
@@ -363,16 +363,14 @@ pub fn tick(app: &mut PhotocraftApp, ctx: &egui::Context) {
     if app.jobs.focus.is_some_and(|j| !app.jobs.opens.iter().any(|o| o.job == j)) {
         app.jobs.focus = app.jobs.opens.last().map(|o| o.job);
     }
-    if app.saving() {
-        close_after_saves(app, ctx);
+    close_after_saves(app, ctx);
+    if app.saving() || app.printing() {
         // Keep checking on a cancelled save's worker until it returns.
         ctx.request_repaint_after(std::time::Duration::from_millis(50));
     }
-    if !app.session.has_jobs() {
+    if !keep_polling(app, ctx) {
         return;
     }
-    // Animate progress and poll for results at display rate; the UI thread only draws.
-    ctx.request_repaint_after(std::time::Duration::from_millis(16));
     if let Some(job) = job_in_view(app)
         && !ctx.text_edit_focused()
         && ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape))
@@ -381,6 +379,21 @@ pub fn tick(app: &mut PhotocraftApp, ctx: &egui::Context) {
     }
 }
 
+/// Keep the event loop awake while a background document job exists.
+///
+/// Jobs can be started by a menu or dialog while the current frame is being drawn, after
+/// [`tick`] has already run. Calling this from the shell after drawing avoids leaving such a job
+/// unapplied on an otherwise idle event loop (notably Wayland): its document would remain locked,
+/// making Undo and Redo appear unavailable.
+pub fn keep_polling(app: &PhotocraftApp, ctx: &egui::Context) -> bool {
+    if !app.session.has_jobs() {
+        return false;
+    }
+    // Animate progress and poll for results at display rate; the UI thread only draws.
+    ctx.request_repaint_after(std::time::Duration::from_millis(16));
+    true
+}
+
 /// The job the user is looking at: the open tab in view, the active document's job, or (for
 /// the status bar) the newest running job.
 pub fn job_in_view(app: &PhotocraftApp) -> Option<JobInfo> {
@@ -391,7 +404,7 @@ pub fn job_in_view(app: &PhotocraftApp) -> Option<JobInfo> {
 }
 
 /// Cancel job `id` (the status bar's ×, the dialog's Cancel, Esc, closing an opening tab).
-pub fn cancel(app: &mut PhotocraftApp, id: JobId) {
+pub fn cancel(app: &mut PhotocraftApp, id: JobId) -> bool {
     let label = app.session.job(id).map(|j| j.label);
     // A save that has started replacing the file runs to the end: cancelling it now would leave
     // the file written but the document marked unsaved.
@@ -400,15 +413,17 @@ pub fn cancel(app: &mut PhotocraftApp, id: JobId) {
     {
         app.ui.status = crate::i18n::fmt(tl!("{label} is writing the file and can no longer be cancelled"), &[("label", label.as_deref().unwrap_or_default())]);
         app.ui.status_error = false;
-        return;
+        return false;
     }
-    if app.session.cancel_job(id) {
+    let cancelled = app.session.cancel_job(id);
+    if cancelled {
         // The event (and its status text) arrives with the next poll; say so now as well.
         if let Some(l) = label {
             app.ui.status = crate::i18n::fmt(tl!("Cancelled {label}"), &[("label", &l)]);
             app.ui.status_error = false;
         }
     }
+    cancelled
 }
 
 fn on_event(app: &mut PhotocraftApp, ctx: &egui::Context, e: JobEvent) {
@@ -434,6 +449,8 @@ fn on_event(app: &mut PhotocraftApp, ctx: &egui::Context, e: JobEvent) {
             true
         }
     });
+    // A Free Transform commit's session ends with its job (then reported like any job).
+    crate::transform_tool::on_job_event(app, &e);
     if crate::prefs_ui::on_recovery_event(app, &e) {
         return;
     }
@@ -484,12 +501,19 @@ fn on_event(app: &mut PhotocraftApp, ctx: &egui::Context, e: JobEvent) {
             app.ui.panels.brush_settings = true;
             app.ui.brush_tab = 1;
         }
+        JobOutcome::Done(ref result) if matches!(e.command.as_str(), "file.print" | "file.printOneCopy") => {
+            app.sync_views();
+            crate::file_ui::print_status(app, result);
+        }
         JobOutcome::Done(_) => {
             app.sync_views();
             app.ui.status = e.label;
             app.ui.status_error = false;
         }
         JobOutcome::Failed(err) => {
+            if matches!(e.command.as_str(), "file.print" | "file.printOneCopy") {
+                app.jobs.close_after_saves = false;
+            }
             app.sync_views();
             notices::error(app, format!("{}: {err}", e.label));
         }
@@ -503,37 +527,69 @@ fn on_event(app: &mut PhotocraftApp, ctx: &egui::Context, e: JobEvent) {
 /// What [`crate::PhotocraftApp::open_bytes`] does after decoding, for a background open's result
 /// (`{document, warnings, color}`).
 fn finish_open(app: &mut PhotocraftApp, name: &str, path: Option<&str>, v: &Value, slot: Option<usize>) -> Result<(), String> {
+    let warnings: Vec<String> =
+        v.get("warnings").and_then(Value::as_array).map(|a| a.iter().filter_map(|w| w.as_str().map(str::to_string)).collect()).unwrap_or_default();
+    let held = |doc, read_only, question, policy_applied| crate::open_prompt::Held {
+        doc,
+        read_only,
+        name: name.to_string(),
+        path: path.map(str::to_string),
+        warnings: warnings.clone(),
+        bytes: None,
+        slot,
+        question,
+        policy_applied,
+    };
+    // Held back for the profile prompt (Ask When Opening).
+    if let Some(id) = v.get("held").and_then(Value::as_u64) {
+        let (doc, read_only) = app.session.take_held_open(id).ok_or("the open job's document is gone")?;
+        crate::open_prompt::arrive(app, held(doc, read_only, v.get("color").cloned(), false));
+        return Ok(());
+    }
     let mut index = v.get("document").and_then(Value::as_u64).ok_or("the open job returned no document")? as usize;
+    // An earlier file is waiting on its prompt: this one opens after it, in order.
+    if crate::open_prompt::waiting(app)
+        && let Some(st) = app.session.close(index)
+    {
+        let read_only = st.source_read_only;
+        let doc = Arc::try_unwrap(st.doc).unwrap_or_else(|d| (*d).clone());
+        crate::open_prompt::arrive(app, held(doc, read_only, None, true));
+        return Ok(());
+    }
     if let Some(slot) = slot
         && let Ok(moved) = app.run("document.move", json!({"document": index, "to": slot}))
     {
         index = moved.get("document").and_then(Value::as_u64).map_or(index, |i| i as usize);
     }
-    let warnings: Vec<String> =
-        v.get("warnings").and_then(Value::as_array).map(|a| a.iter().filter_map(|w| w.as_str().map(str::to_string)).collect()).unwrap_or_default();
     app.session.set_active(index);
+    after_open(app, name, path, &warnings, None);
+    Ok(())
+}
+
+/// What every open does once its document is the active one: remember where it came from, say
+/// so, show the import warnings (a raw opens in Camera Raw first, developed from `path` or
+/// `bytes`) and fire the "Open Document" script events.
+pub(crate) fn after_open(app: &mut PhotocraftApp, name: &str, path: Option<&str>, warnings: &[String], bytes: Option<&[u8]>) {
     if let Some(p) = path {
         app.opened_from(p);
     }
     app.sync_views();
-    app.ui.status = crate::i18n::fmt(tl!("Opened {name}"), &[("name", name)]);
+    // Fonts the document's type uses that aren't installed join the import warnings (#4559).
+    let warnings = crate::file_open::with_missing_fonts(app, warnings.to_vec());
+    let warnings = warnings.as_slice();
+    let opened = crate::i18n::fmt(tl!("Opened {name}"), &[("name", name)]);
+    app.ui.status = opened.clone();
     app.ui.status_error = false;
     // A raw opens in Camera Raw first; the dialog says how it was developed.
-    if crate::camera_raw_ui::wants_open_dialog(app, &warnings) {
-        crate::camera_raw_ui::queue_open_dialog(app, name, path, None);
-        notices::io_warnings(app, &crate::i18n::fmt(tl!("Opened {name}"), &[("name", name)]), &crate::camera_raw_ui::without_develop_note(&warnings));
+    if crate::camera_raw_ui::wants_open_dialog(app, warnings) {
+        crate::camera_raw_ui::queue_open_dialog(app, name, path, bytes);
+        notices::io_warnings(app, &opened, &crate::camera_raw_ui::without_develop_note(warnings));
     } else {
-        notices::io_warnings(app, &crate::i18n::fmt(tl!("Opened {name}"), &[("name", name)]), &warnings);
+        notices::io_warnings(app, &opened, warnings);
     }
     // Script events bound to "Open Document".
     photocraft_engine::automate_cmds::document_opened(&mut app.session);
     app.sync_views();
-    let color = v.get("color").cloned().unwrap_or(Value::Null);
-    let ask = color.get("ask").and_then(Value::as_bool) == Some(true);
-    if ask && (color.get("mismatch").and_then(Value::as_bool) == Some(true) || color.get("missing").is_some()) {
-        crate::prefs_ui::open_mismatch(app, &color);
-    }
-    Ok(())
 }
 
 // ------------------------------------------------------------------------------------- drawing
@@ -559,6 +615,24 @@ pub fn bar(ui: &egui::Ui, rect: Rect, frac: Option<f32>, t: &Tokens) {
     }
 }
 
+/// A print job has already reached the spool worker; cancellation belongs to the system queue.
+fn print_status_progress(app: &PhotocraftApp, ui: &mut egui::Ui, j: &JobInfo) {
+    let t = Tokens::get(ui.ctx());
+    let (bar_w, bar_h) = if t.pro { (120.0, 6.0) } else { (140.0, 6.0) };
+    let more = app.session.jobs().len().saturating_sub(1);
+    let (xr, xresp) = ui.allocate_exact_size(vec2(18.0, 18.0), Sense::hover());
+    if xresp.hovered() {
+        ui.painter().rect_filled(xr, t.radius_sm, t.hover);
+    }
+    crate::icons::paint(ui, xr, "x", 11.0, if xresp.hovered() { t.text } else { t.text_dim });
+    xresp.on_hover_text(tl!("Manage submitted jobs in the system print queue"));
+    ui.label(RichText::new(percent(j)).color(t.text_dim).size(11.5).monospace());
+    let (br, _) = ui.allocate_exact_size(vec2(bar_w, bar_h), Sense::hover());
+    bar(ui, br, shown_fraction(j), &t);
+    let label = if more > 0 { format!("{} (+{more})", tl!(&j.label)) } else { tl!(&j.label).to_owned() };
+    ui.label(RichText::new(label).color(t.text_dim).size(12.0));
+}
+
 /// Progress that has been reported, or `None` (indeterminate) while it's still 0.
 fn shown_fraction(j: &JobInfo) -> Option<f32> {
     (j.progress > 0.0).then_some(j.progress)
@@ -594,6 +668,10 @@ pub fn status_progress(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let t = Tokens::get(ui.ctx());
     let (bar_w, bar_h) = if t.pro { (120.0, 6.0) } else { (140.0, 6.0) };
     let more = app.session.jobs().len().saturating_sub(1);
+    if matches!(j.command.as_str(), "file.print" | "file.printOneCopy") {
+        print_status_progress(app, ui, &j);
+        return;
+    }
     // Right to left: ×, percentage, bar, label.
     let (xr, xresp) = ui.allocate_exact_size(vec2(18.0, 18.0), Sense::click());
     if xresp.hovered() {
diff --git a/crates/ui-egui/src/jobs_ui_tests.rs b/crates/ui-egui/src/jobs_ui_tests.rs
index 1893075ac2..f2b7d0fbc0 100644
--- a/crates/ui-egui/src/jobs_ui_tests.rs
+++ b/crates/ui-egui/src/jobs_ui_tests.rs
@@ -66,9 +66,16 @@ fn slow_job(app: &mut PhotocraftApp, gate: &Arc<AtomicBool>) -> JobId {
 
 /// Step frames for `ms` of wall time; returns (frames, slowest frame in ms).
 fn frames_for(h: &mut Harness<'_, PhotocraftApp>, ms: u64) -> (u64, f64) {
+    frames_for_at_least(h, ms, 0)
+}
+
+/// Prove the frame loop advances while a gated worker stays blocked, without assuming a
+/// minimum frame rate on software-rendered CI machines. Also wait for the progress modal.
+fn frames_for_at_least(h: &mut Harness<'_, PhotocraftApp>, ms: u64, min_frames: u64) -> (u64, f64) {
     let t = Instant::now();
     let (mut n, mut worst) = (0, 0.0f64);
-    while t.elapsed() < Duration::from_millis(ms) {
+    while t.elapsed() < Duration::from_millis(ms) || n < min_frames {
+        assert!(t.elapsed() < Duration::from_secs(30), "frame observation timed out after {n} frames");
         let f = Instant::now();
         h.step();
         worst = worst.max(f.elapsed().as_secs_f64() * 1000.0);
@@ -84,7 +91,7 @@ fn the_frame_loop_keeps_running_during_a_slow_job_and_esc_cancels_it() {
     let doc_before = h.state().session.active().unwrap().doc.clone();
     let job = slow_job(h.state_mut(), &gate);
     let frame0 = h.state().frame;
-    let (n, worst) = frames_for(&mut h, 400);
+    let (n, worst) = frames_for_at_least(&mut h, 400, 10);
     assert!(h.state().frame - frame0 >= 10, "the UI kept rendering ({n} frames)");
     eprintln!("{n} frames during the job, slowest {worst:.1} ms");
     // The status bar shows the job, and after the delay the modal progress dialog.
@@ -104,6 +111,27 @@ fn the_frame_loop_keeps_running_during_a_slow_job_and_esc_cancels_it() {
     assert!(h.query_by_label("Esc to cancel").is_none(), "the dialog closed");
 }
 
+#[test]
+fn a_job_started_while_drawing_requests_the_follow_up_poll() {
+    let mut h = app_harness();
+    let gate = Arc::new(AtomicBool::new(false));
+    let job = slow_job(h.state_mut(), &gate);
+    let repaints = Arc::new(AtomicUsize::new(0));
+    let seen = repaints.clone();
+    h.ctx.set_request_repaint_callback(move |_| {
+        seen.fetch_add(1, Ordering::Relaxed);
+    });
+
+    // A job may start from a menu or dialog after the frame's initial `jobs_ui::tick`.
+    // The UI must still schedule a poll, or an idle Wayland event loop leaves the document
+    // locked after the worker finishes and blocks Edit > Undo / Redo.
+    assert!(crate::jobs_ui::keep_polling(h.state(), &h.ctx));
+    assert_eq!(repaints.load(Ordering::Relaxed), 1);
+
+    crate::jobs_ui::cancel(h.state_mut(), job);
+    h.run_steps(2);
+}
+
 #[test]
 fn a_finished_job_lands_as_one_undo_step_and_the_dialog_cancel_button_works() {
     let mut h = app_harness();
@@ -397,7 +425,7 @@ fn saves_run_in_the_background_and_are_recorded_when_they_end() {
     assert!(h.state().saving());
 
     // The window keeps drawing; the document stays unsaved and can't be edited meanwhile.
-    let (frames, _) = frames_for(&mut h, 400);
+    let (frames, _) = frames_for_at_least(&mut h, 400, 4);
     assert!(frames >= 4, "only {frames} frames while saving");
     let st = h.state().session.active().unwrap();
     assert!(st.is_dirty() && st.path.is_none());
@@ -614,3 +642,143 @@ fn a_finished_job_beeps_when_the_preference_is_on() {
     frames_for(&mut h, 800);
     assert_eq!(BEEPS.load(Ordering::Relaxed), 1, "one beep for the finished job");
 }
+
+#[test]
+fn printing_keeps_drawing_and_reports_only_the_final_spooler_result() {
+    for success in [true, false] {
+        let mut h = app_harness();
+        let gate = Arc::new(AtomicBool::new(false));
+        let worker_gate = gate.clone();
+        let Started::Job(id) = h
+            .state_mut()
+            .session
+            .start_job(
+                "file.print",
+                json!({}),
+                "Print",
+                false,
+                move |_| {
+                    while !worker_gate.load(Ordering::Relaxed) {
+                        std::thread::sleep(Duration::from_millis(1));
+                    }
+                    if success {
+                        Ok(json!({"sent": true, "spooler": "request id is Office-42", "pdf": null}))
+                    } else {
+                        Err(photocraft_engine::EngineError::Other("queue refused".into()))
+                    }
+                },
+                |_, result| Ok(result),
+            )
+            .unwrap()
+        else {
+            panic!("must run on a worker")
+        };
+        let frame = h.state().frame;
+        h.run_steps(4);
+        assert!(h.state().frame > frame);
+        assert!(!h.state().ui.status.contains("Sent to the printer"));
+        h.key_press(egui::Key::Escape);
+        h.run_steps(2);
+        assert!(h.state().session.job(id).is_some(), "Esc cannot retract a submitted job");
+        let (request, _) = crate::control::ControlRequest::new("jobs.cancel", json!({"job": id.0}));
+        let ctx = h.ctx.clone();
+        let crate::control::Outcome::Done(reply) = crate::control::handle(h.state_mut(), &ctx, &request) else { panic!("cancel replies immediately") };
+        assert_eq!(reply["result"]["cancelled"], 0, "control must not falsely report cancellation: {reply}");
+        let st = h.state_mut().session.active_mut().unwrap();
+        st.saved_revision = st.revision;
+        assert!(press_window_close(h.state_mut()), "quit waits for print submission");
+        assert!(h.state().jobs.close_after_saves);
+        gate.store(true, Ordering::Relaxed);
+        let deadline = Instant::now() + Duration::from_secs(10);
+        while h.state().session.has_jobs() && Instant::now() < deadline {
+            h.step();
+        }
+        assert!(!h.state().session.has_jobs());
+        assert!(!h.state().jobs.close_after_saves, "close repeats on success or is cleared for a visible error");
+        if success {
+            assert!(h.state().ui.status.contains("Office-42"), "{}", h.state().ui.status);
+            assert!(!h.state().ui.status_error);
+        } else {
+            assert!(h.state().ui.status.contains("queue refused"), "{}", h.state().ui.status);
+            assert!(h.state().ui.status_error);
+        }
+    }
+}
+
+fn layer_count(app: &PhotocraftApp) -> usize {
+    app.session.active().unwrap().doc.layers.len()
+}
+
+/// Free Transform the active layer to the right half of the canvas, then ↩.
+fn transform_and_commit(h: &mut Harness<'static, PhotocraftApp>, copy: bool) {
+    let ctx = h.ctx.clone();
+    let app = h.state_mut();
+    if copy { crate::transform_tool::begin_copy(app, &ctx) } else { crate::transform_tool::begin(app, &ctx) }.unwrap();
+    app.ui.transform.as_mut().unwrap().quad = [[160.0, 0.0], [320.0, 0.0], [320.0, 120.0], [160.0, 120.0]];
+    crate::transform_tool::commit(app);
+}
+
+#[test]
+fn a_free_transform_commit_runs_in_the_background_and_keeps_its_preview() {
+    let mut h = app_harness();
+    let (layers, steps) = (layer_count(h.state()), h.state().session.active().unwrap().history.past_len());
+    transform_and_commit(&mut h, true);
+    let app = h.state();
+    // The warp runs as a job; the moving pixels stay on screen until it lands, and the box's
+    // history is closed meanwhile.
+    let job = crate::transform_tool::committing(app).expect("the commit runs as a job");
+    assert!(app.session.job(job).is_some_and(|j| j.label == "Free Transform"));
+    assert!(app.ui.transform.is_some() && app.transform_preview.is_some());
+    assert_eq!(crate::transform_tool::is_enabled(app, "edit.undo"), Some(false));
+    assert!(h.state_mut().run("edit.undo", json!({})).is_err());
+    crate::transform_tool::commit(h.state_mut());
+    let t = Instant::now();
+    while h.state().session.has_jobs() && t.elapsed() < Duration::from_secs(10) {
+        h.step();
+    }
+    h.run_steps(2);
+    let app = h.state();
+    assert!(app.ui.transform.is_none() && app.transform_preview.is_none(), "the session ends with the job");
+    // The copy and its transform are one step, as when the commit ran inline.
+    let st = app.session.active().unwrap();
+    assert_eq!((layer_count(app), st.history.past_len()), (layers + 1, steps + 1));
+    assert_eq!(st.history.undo_label(), Some("Free Transform"));
+    let moved = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().content_bounds();
+    assert_eq!((moved.x0, moved.y0, moved.x1, moved.y1), (160, 0, 320, 120));
+}
+
+#[test]
+fn esc_cancels_a_background_free_transform_commit() {
+    let mut h = app_harness();
+    let (layers, steps) = (layer_count(h.state()), h.state().session.active().unwrap().history.past_len());
+    let before = h.state().session.active().unwrap().doc.clone();
+    transform_and_commit(&mut h, true);
+    let job = crate::transform_tool::committing(h.state()).expect("the commit runs as a job");
+    // Esc reaches the transform tool first (shortcuts), which cancels the job.
+    crate::transform_tool::cancel(h.state_mut());
+    h.run_steps(3);
+    let app = h.state();
+    assert!(app.session.job(job).is_none());
+    assert!(app.ui.transform.is_none() && app.transform_preview.is_none());
+    // The copy is taken back with the transform, leaving nothing to redo.
+    let st = app.session.active().unwrap();
+    assert_eq!((layer_count(app), st.history.past_len()), (layers, steps));
+    assert!(!st.history.can_redo());
+    assert_eq!(st.doc.layers.len(), before.layers.len());
+}
+
+/// #4559: a background open (the desktop app's) also warns, when its document arrives, about
+/// type in a font that isn't installed.
+#[test]
+fn background_open_warns_about_missing_fonts() {
+    let mut s = photocraft_engine::Session::new();
+    s.execute("file.new", json!({"width": 40, "height": 20})).unwrap();
+    s.execute("type.create", json!({"text": "Hi", "x": 2, "y": 12, "size": 10, "font": "NoSuchFamily4559"})).unwrap();
+    let doc = (*s.active().unwrap().doc).clone();
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    // What the open job leaves behind: the decoded document in the session, then its result.
+    let (index, _) = app.session.open_document(doc, None);
+    super::finish_open(&mut app, "poster.psd", None, &json!({"document": index, "warnings": []}), None).unwrap();
+    let want = vec!["font 'NoSuchFamily4559' is not installed; text may render using a fallback face".to_string()];
+    assert!(app.ui.notices.last().is_some_and(|n| n.title.contains("poster.psd") && n.lines == want), "{:?}", app.ui.notices);
+}
diff --git a/crates/ui-egui/src/last_brush.rs b/crates/ui-egui/src/last_brush.rs
new file mode 100644
index 0000000000..45c101a7ae
--- /dev/null
+++ b/crates/ui-egui/src/last_brush.rs
@@ -0,0 +1,21 @@
+//! The brush the tool was last using, remembered across restarts (`Preferences::last_brush`) so
+//! the next launch starts with the same brush, options bar and painting cursor outline.
+//!
+//! Saved once the pointer is up (a slider drag saves once, like the Brush Preset picker's view),
+//! and change-driven: `remember_brush` watches `ToolState::brush_rev`, so an unchanged brush
+//! costs a counter compare per frame, not a clone and a JSON serialisation of the whole brush.
+
+use crate::PhotocraftApp;
+
+/// Remember the current brush once the pointer is up.
+pub fn persist(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    if !ctx.input(|i| i.pointer.any_down()) {
+        photocraft_engine::brush_cmds::remember_brush(&mut app.session);
+    }
+}
+
+/// Restore the remembered brush at launch; stored tips load when the preset store attaches
+/// (`Session::attach_preset_store`).
+pub fn restore(app: &mut PhotocraftApp) {
+    photocraft_engine::brush_cmds::restore_brush(&mut app.session);
+}
diff --git a/crates/ui-egui/src/layer_menu_ui.rs b/crates/ui-egui/src/layer_menu_ui.rs
index 10629f2542..beb3e9bc32 100644
--- a/crates/ui-egui/src/layer_menu_ui.rs
+++ b/crates/ui-egui/src/layer_menu_ui.rs
@@ -40,14 +40,13 @@ pub fn mask_button_command(layer: Option<&Layer>, has_selection: bool, alt: bool
 }
 
 /// Commands that act on the active layer only and have no sensible meaning for a selection: Blending
-/// Options (one dialog), Copy Layer Style (copy from which layer?), Export As, and the per-layer
-/// mask items. With several layers selected they would hit whichever layer is active, not the one
-/// that was right-clicked, so the menu greys them. Adding a mask, Paste/Clear Layer Style and
-/// Rasterize run on every selected layer instead.
+/// Options (one dialog), Copy Layer Style (copy from which layer?) and the per-layer mask items.
+/// With several layers selected they would hit whichever layer is active, not the one that was
+/// right-clicked, so the menu greys them. Adding a mask, Paste/Clear Layer Style, Rasterize and
+/// Export As (one file per layer, #3629) run on every selected layer instead.
 pub fn single_layer_only(id: &str) -> bool {
     let adds_mask = matches!(id, "layer.layerMask.revealAll" | "layer.layerMask.hideAll" | "layer.layerMask.revealSelection" | "layer.layerMask.hideSelection");
-    matches!(id, "layer.layerStyle.blendingOptions" | "layer.layerStyle.copyLayerStyle" | "layer.exportAs")
-        || (id.starts_with("layer.layerMask.") && !adds_mask)
+    matches!(id, "layer.layerStyle.blendingOptions" | "layer.layerStyle.copyLayerStyle") || (id.starts_with("layer.layerMask.") && !adds_mask)
 }
 
 /// The context menu entries for a layer (Photoshop 2026 order, trimmed to the layer kind).
@@ -112,6 +111,9 @@ pub fn entries(l: &Layer, multi: bool, has_selection: bool) -> Vec<Entry> {
     v.push(None);
     if multi {
         v.push(Some((tl!("Merge Layers"), "layer.mergeLayers")));
+    } else if matches!(l.content, LayerContent::Group(_)) {
+        // Photoshop's Merge Group: a group merges itself, not into the layer below (#3832).
+        v.push(Some((tl!("Merge Group"), "layer.mergeGroup")));
     } else {
         v.push(Some((tl!("Merge Down"), "layer.mergeDown")));
     }
@@ -155,6 +157,41 @@ pub fn show(app: &crate::PhotocraftApp, ui: &mut egui::Ui, l: &Layer, on_set: bo
     })
 }
 
+/// The menu of `l`'s layer-mask thumbnail (#4575), in Photoshop's order. It acts on `l`, which it
+/// selects first like the row menu. Photoshop's Mask Options… (the overlay colour) has no
+/// command yet, so it is left out.
+pub fn show_mask(app: &crate::PhotocraftApp, ui: &mut egui::Ui, l: &Layer, actions: &mut Vec<(String, Value)>) {
+    let Some(mask) = &l.mask else { return };
+    crate::widgets::menu_scroll(ui, |ui| {
+        ui.set_min_width(220.0);
+        let edits = vec![
+            Some((tl!(mask_toggle_label(mask.enabled)), "layer.layerMask.enabled")),
+            Some((tl!("Delete Layer Mask"), "layer.layerMask.delete")),
+            Some((tl!("Apply Layer Mask"), "layer.layerMask.apply")),
+        ];
+        items(app, ui, l, false, edits, actions);
+        ui.separator();
+        // ⌘⇧-, ⌘⌥- and ⌘⇧⌥-clicking the thumbnail, as menu items.
+        let loads =
+            [(tl!("Add Mask to Selection"), "add"), (tl!("Subtract Mask from Selection"), "subtract"), (tl!("Intersect Mask with Selection"), "intersect")];
+        for (label, operation) in loads {
+            if ui.button(label).clicked() {
+                actions.push(("layer.select".into(), json!({"layer": l.id.0})));
+                actions.push(("select.loadSelection".into(), json!({"channel": "mask", "layer": l.id.0, "operation": operation})));
+                ui.close();
+            }
+        }
+        ui.separator();
+        if ui.add_enabled(crate::menus::is_enabled(app, "select.selectAndMask"), egui::Button::new(tl!("Select and Mask…"))).clicked() {
+            // Like double-clicking the thumbnail with that preference on: it refines the mask.
+            actions.push(("layer.select".into(), json!({"layer": l.id.0})));
+            actions.push(("ui.maskTarget".into(), json!(true)));
+            actions.push(("select.selectAndMask".into(), Value::Null));
+            ui.close();
+        }
+    });
+}
+
 /// Render the layer style menu of `l`'s effect rows ([`effects_entries`]); the actions select `l`
 /// first when it isn't the active layer.
 pub fn show_effects(app: &crate::PhotocraftApp, ui: &mut egui::Ui, l: &Layer, actions: &mut Vec<(String, Value)>) {
@@ -213,26 +250,31 @@ fn common_color(app: &crate::PhotocraftApp, l: &Layer, on_set: bool) -> Option<L
 }
 
 fn color_menu(app: &crate::PhotocraftApp, ui: &mut egui::Ui, l: &Layer, on_set: bool, actions: &mut Vec<(String, Value)>) {
-    let current = common_color(app, l, on_set);
     ui.menu_button(tl!("Color"), |ui| {
-        crate::widgets::menu_scroll(ui, |ui| {
-            ui.set_min_width(170.0);
-            for color in LabelColor::ALL {
-                if color == LabelColor::Red {
-                    ui.separator();
-                }
-                if color_button(ui, color, current == Some(color)).clicked() {
-                    let params = if on_set {
-                        json!({"color": color.id()})
-                    } else {
-                        actions.push(("layer.select".into(), json!({"layer": l.id.0})));
-                        json!({"layer": l.id.0, "color": color.id()})
-                    };
-                    actions.push(("layer.setLabelColor".into(), params));
-                    ui.close();
-                }
+        color_choices(app, ui, l, on_set, actions);
+    });
+}
+
+/// The eye column opens the same color choices directly, without the row's full context menu.
+pub(crate) fn color_choices(app: &crate::PhotocraftApp, ui: &mut egui::Ui, l: &Layer, on_set: bool, actions: &mut Vec<(String, Value)>) {
+    let current = common_color(app, l, on_set);
+    crate::widgets::menu_scroll(ui, |ui| {
+        ui.set_min_width(170.0);
+        for color in LabelColor::ALL {
+            if color == LabelColor::Red {
+                ui.separator();
             }
-        });
+            if color_button(ui, color, current == Some(color)).clicked() {
+                let params = if on_set {
+                    json!({"color": color.id()})
+                } else {
+                    actions.push(("layer.select".into(), json!({"layer": l.id.0})));
+                    json!({"layer": l.id.0, "color": color.id()})
+                };
+                actions.push(("layer.setLabelColor".into(), params));
+                ui.close();
+            }
+        }
     });
 }
 
@@ -427,6 +469,60 @@ mod tests {
         }
     }
 
+    /// #4575: right-clicking a layer-mask thumbnail opens Photoshop's mask menu, not the layer
+    /// menu, and its selection items load the clicked layer's mask (not the active layer's).
+    #[test]
+    fn mask_thumbnail_context_menu_acts_on_the_clicked_mask() {
+        use crate::PhotocraftApp;
+        use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
+        use egui_kittest::{Harness, kittest::Queryable};
+
+        fn click(h: &mut Harness<'_, PhotocraftApp>, at: Pos2, button: PointerButton) {
+            h.hover_at(at);
+            h.step();
+            for pressed in [true, false] {
+                h.event(Event::PointerButton { pos: at, button, pressed, modifiers: Modifiers::NONE });
+                h.step();
+            }
+            h.run_steps(3);
+        }
+
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 100, "height": 60})).unwrap();
+        s.execute("layer.new.layer", json!({"name": "Masked"})).unwrap();
+        s.execute("select.rect", json!({"x": 60, "y": 0, "width": 40, "height": 60})).unwrap();
+        s.execute("layer.layerMask.revealSelection", json!({})).unwrap();
+        let masked = s.active().unwrap().active_layer.unwrap();
+        // Another layer is active, and the selection doesn't overlap the mask.
+        s.execute("layer.new.layer", json!({"name": "Other active layer"})).unwrap();
+        s.execute("select.rect", json!({"x": 0, "y": 0, "width": 20, "height": 60})).unwrap();
+        let mut h = Harness::builder().with_size(vec2(1440.0, 900.0)).with_step_dt(1.0 / 60.0).with_max_steps(64).build_eframe(move |cc| {
+            PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+            PhotocraftApp::new(s, crate::Services::default())
+        });
+        let ctx = h.ctx.clone();
+        let (req, _rx) = crate::control::ControlRequest::new("ui.set", json!({"dock": {"collapsed": ["color", "properties", "history", "navigator"]}}));
+        crate::control::handle(h.state_mut(), &ctx, &req);
+        h.run_steps(8);
+        let (thumbs, _) = crate::mask_thumbs_ui::recorded(&h.ctx, masked.0).expect("mask thumbnail drawn");
+        let at = thumbs.iter().find(|(k, _)| *k == crate::mask_thumbs_ui::MaskKind::Pixel).unwrap().1.center();
+        click(&mut h, at, PointerButton::Secondary);
+        assert!(h.query_by_label("Blending Options…").is_none(), "the mask menu, not the layer menu");
+        for item in
+            ["Disable Layer Mask", "Delete Layer Mask", "Apply Layer Mask", "Subtract Mask from Selection", "Intersect Mask with Selection", "Select and Mask…"]
+        {
+            h.get_by_label(item);
+        }
+        let at = h.get_by_label("Add Mask to Selection").rect().center();
+        click(&mut h, at, PointerButton::Primary);
+        let st = h.state().session.active().unwrap();
+        assert_eq!(st.active_layer, Some(masked));
+        let sel = st.doc.selection.as_ref().expect("a selection");
+        assert!(sel.sample_channel(10, 30, 0) > 0.99, "the selection is kept");
+        assert!(sel.sample_channel(80, 30, 0) > 0.99, "the clicked layer's mask is added");
+        assert!(sel.sample_channel(40, 30, 0) < 0.01, "nothing else is selected");
+    }
+
     #[test]
     fn a_long_layer_menu_stays_inside_a_short_window_and_scrolls() {
         let mut s = photocraft_engine::Session::new();
@@ -567,11 +663,12 @@ mod tests {
     fn multi_selection_menu_greys_what_acts_on_one_layer() {
         use egui_kittest::kittest::{NodeT, Queryable};
         let (h, _) = open_multi_selection_menu();
-        for label in ["Blending Options…", "Copy Layer Style", "Export As…"] {
+        for label in ["Blending Options…", "Copy Layer Style"] {
             assert!(h.get_by_label(label).accesskit_node().is_disabled(), "{label} works on one layer only");
         }
         for label in [
             "Quick Export As PNG",
+            "Export As…",
             "Add Layer Mask",
             "Duplicate Layers…",
             "Delete Layers",
@@ -602,12 +699,12 @@ mod tests {
             "layer.layerMask.enabled",
             "layer.layerMask.apply",
             "layer.layerMask.delete",
-            "layer.exportAs",
         ] {
             assert!(single_layer_only(id), "{id}");
         }
         for id in [
             "layer.quickExportAsPng",
+            "layer.exportAs",
             "layer.duplicate",
             "layer.delete",
             "layer.rasterize.layer",
@@ -649,6 +746,31 @@ mod tests {
         assert!(ids.contains(&"layer.mergeLayers"));
     }
 
+    /// #3832: a group's right-click menu and the Layer menu offer Photoshop's Merge Group, which
+    /// merges the group itself (not into the layer below), and it is enabled.
+    #[test]
+    fn a_group_offers_merge_group() {
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 10, "height": 10})).unwrap();
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("layer.groupLayers", json!({"name": "G"})).unwrap();
+        let st = s.active().unwrap();
+        let g = st.doc.layer(st.active_layer.unwrap()).unwrap().clone();
+        let e: Vec<(&str, &str)> = entries(&g, false, false).into_iter().flatten().collect();
+        assert!(e.contains(&("Merge Group", "layer.mergeGroup")), "{e:?}");
+        assert!(!e.iter().any(|x| x.0 == "Merge Down"));
+        let mut app = crate::PhotocraftApp::new(s, Default::default());
+        app.sync_views();
+        let items = crate::menus::menu_items(&app);
+        let item = items.iter().find(|i| i.id == "layer.mergeLayers").unwrap();
+        assert_eq!(item.label, "Merge Group");
+        assert!(item.enabled, "Merge Group runs on a group");
+        // A plain layer keeps Merge Layers.
+        app.run("layer.new.layer", json!({})).unwrap();
+        let items = crate::menus::menu_items(&app);
+        assert_eq!(items.iter().find(|i| i.id == "layer.mergeLayers").unwrap().label, "Merge Layers");
+    }
+
     #[test]
     fn add_mask_uses_the_selection() {
         assert_eq!(add_mask_command(false, false), "layer.layerMask.revealAll");
diff --git a/crates/ui-egui/src/layer_menu_ui/color_tests.rs b/crates/ui-egui/src/layer_menu_ui/color_tests.rs
index a2a113a30a..88c11dfd2c 100644
--- a/crates/ui-egui/src/layer_menu_ui/color_tests.rs
+++ b/crates/ui-egui/src/layer_menu_ui/color_tests.rs
@@ -113,6 +113,21 @@ fn layer_color_background_is_confined_to_the_eye_column_in_every_theme() {
     }
 }
 
+#[test]
+fn right_clicking_eye_opens_color_choices_without_toggling_visibility() {
+    let (mut h, red, other) = harness(crate::theme::ThemeKind::Pro, 1.0);
+    let r = row(&h, red);
+    let eye = pos2(r.left() + 17.0, r.center().y);
+    click(&mut h, eye, PointerButton::Secondary, Modifiers::NONE);
+    let blue = h.get_by_label("Blue").rect().center();
+    click(&mut h, blue, PointerButton::Primary, Modifiers::NONE);
+
+    let st = h.state().session.active().unwrap();
+    assert!(st.doc.layer(red).unwrap().visible);
+    assert_eq!(st.doc.layer(red).unwrap().label, LabelColor::Blue);
+    assert_eq!(st.doc.layer(other).unwrap().label, LabelColor::None);
+}
+
 #[test]
 fn layer_color_menu_marks_only_the_common_color() {
     let mut h = Harness::new_ui(|ui| {
diff --git a/crates/ui-egui/src/layer_pick_ui.rs b/crates/ui-egui/src/layer_pick_ui.rs
index 654751b953..b75fe2b47b 100644
--- a/crates/ui-egui/src/layer_pick_ui.rs
+++ b/crates/ui-egui/src/layer_pick_ui.rs
@@ -2,8 +2,8 @@
 //! with any tool, lists the layers with visible pixels under the pointer, topmost first, as
 //! Photoshop does. Choosing one selects it.
 //!
-//! The hit test is `layer.pickAt` with `"list": true` (non-transparent pixels, layer masks, hidden
-//! layers and hidden groups skipped), and choosing runs `layer.select`, so the menu is the same
+//! The hit test is `layer.pickAt` with `"list": true` (non-transparent pixels, text bounds,
+//! layer masks, hidden layers and hidden groups), and choosing runs `layer.select`, so the menu is the same
 //! two commands an agent would run. Painting tools keep their plain right-click (the Brush
 //! Preset picker, #268); the ⌘/Ctrl variant reaches the layer list from them too.
 
@@ -27,7 +27,7 @@ pub fn is_gesture(tool: Tool, mods: Modifiers) -> bool {
     tool == Tool::Move || mods.command
 }
 
-/// The layers with pixels at document point (x, y), topmost first.
+/// The layers at document point (x, y), topmost first, including text between glyphs.
 pub fn layers_at(app: &mut PhotocraftApp, x: f64, y: f64) -> Vec<(u64, String)> {
     if !(x.is_finite() && y.is_finite()) {
         return Vec::new();
diff --git a/crates/ui-egui/src/layer_props_ui.rs b/crates/ui-egui/src/layer_props_ui.rs
index a0d2d7f058..c2ea848c5e 100644
--- a/crates/ui-egui/src/layer_props_ui.rs
+++ b/crates/ui-egui/src/layer_props_ui.rs
@@ -124,7 +124,6 @@ const LINK_W: f32 = 20.0;
 /// sections (Character/Paragraph/Type Options for type, Appearance/Shape for shapes), then Quick
 /// Actions, all with the same collapsible headers (#155).
 pub fn properties(app: &mut PhotocraftApp, ui: &mut egui::Ui, layer: &Layer) {
-    let t = Tokens::get(ui.ctx());
     let mut run: Vec<(String, Value)> = Vec::new();
     if let Some(s) = layer.surface() {
         let b = app.cached_bounds(layer.id.0, s);
@@ -167,38 +166,8 @@ pub fn properties(app: &mut PhotocraftApp, ui: &mut egui::Ui, layer: &Layer) {
     if gradient {
         crate::gradient_ui::properties(app, ui, layer);
     }
-    if !gradient && section(ui, "align", tl!("Align and Distribute")) {
-        ui.horizontal(|ui| {
-            ui.spacing_mut().item_spacing.x = 2.0;
-            for (i, kind) in ["leftEdges", "horizontalCenters", "rightEdges", "topEdges", "verticalCenters", "bottomEdges"].into_iter().enumerate() {
-                if i == 3 {
-                    ui.add_space(8.0);
-                }
-                let id = format!("layer.align.{kind}");
-                let on = app.session.is_enabled(&id);
-                let label = photocraft_engine::commands::find(&id).map_or(kind, |c| c.label);
-                let (r, resp) = ui.allocate_exact_size(vec2(24.0, 24.0), if on { Sense::click() } else { Sense::hover() });
-                if resp.hovered() && on {
-                    ui.painter().rect_filled(r, t.radius_sm, t.hover);
-                }
-                align_glyph(ui, r, kind, if on { t.icon } else { t.text_faint });
-                if resp.on_hover_text(crate::i18n::fmt(tl!("Align {what}"), &[("what", tl!(&label))])).clicked() {
-                    run.push((id, json!({})));
-                }
-            }
-        });
-        // The engine already supports equal-gap distribution in both axes. Make those
-        // existing commands discoverable here as well as through Layer > Distribute (#2349).
-        // Three or more selected layers are required; the engine remains authoritative.
-        ui.horizontal_wrapped(|ui| {
-            for (kind, text) in [("horizontally", tl!("Horizontally")), ("vertically", tl!("Vertically"))] {
-                let id = format!("layer.distribute.{kind}");
-                if ui.add_enabled(app.session.is_enabled(&id), egui::Button::new(text)).clicked() {
-                    run.push((id, json!({})));
-                }
-            }
-        });
-        ui.add_space(ROW_GAP);
+    if !gradient {
+        align_and_distribute(app, ui, &mut run);
     }
     for (id, p) in run.drain(..) {
         if let Err(e) = app.run(&id, p) {
@@ -222,6 +191,61 @@ pub fn properties(app: &mut PhotocraftApp, ui: &mut egui::Ui, layer: &Layer) {
     }
 }
 
+/// The Align and Distribute section: its buttons run `layer.align.*` and `layer.distribute.*` on
+/// the selected layers (pushed onto `run`), greyed where the engine says they can't.
+fn align_and_distribute(app: &PhotocraftApp, ui: &mut egui::Ui, run: &mut Vec<(String, Value)>) {
+    let t = Tokens::get(ui.ctx());
+    if !section(ui, "align", tl!("Align and Distribute")) {
+        return;
+    }
+    ui.horizontal(|ui| {
+        ui.spacing_mut().item_spacing.x = 2.0;
+        for (i, kind) in ["leftEdges", "horizontalCenters", "rightEdges", "topEdges", "verticalCenters", "bottomEdges"].into_iter().enumerate() {
+            if i == 3 {
+                ui.add_space(8.0);
+            }
+            let id = format!("layer.align.{kind}");
+            let on = app.session.is_enabled(&id);
+            let label = photocraft_engine::commands::find(&id).map_or(kind, |c| c.label);
+            let (r, resp) = ui.allocate_exact_size(vec2(24.0, 24.0), if on { Sense::click() } else { Sense::hover() });
+            if resp.hovered() && on {
+                ui.painter().rect_filled(r, t.radius_sm, t.hover);
+            }
+            align_glyph(ui, r, kind, if on { t.icon } else { t.text_faint });
+            let tip = crate::i18n::fmt(tl!("Align {what}"), &[("what", tl!(&label))]);
+            resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, on, &tip));
+            if resp.on_hover_text(tip).clicked() {
+                run.push((id, json!({})));
+            }
+        }
+    });
+    // The engine already supports equal-gap distribution in both axes. Make those
+    // existing commands discoverable here as well as through Layer > Distribute (#2349).
+    // Three or more selected layers are required; the engine remains authoritative.
+    ui.horizontal_wrapped(|ui| {
+        for (kind, text) in [("horizontally", tl!("Horizontally")), ("vertically", tl!("Vertically"))] {
+            let id = format!("layer.distribute.{kind}");
+            if ui.add_enabled(app.session.is_enabled(&id), egui::Button::new(text)).clicked() {
+                run.push((id, json!({})));
+            }
+        }
+    });
+    ui.add_space(ROW_GAP);
+}
+
+/// Several layers selected with the Background active: Photoshop's Properties keeps Align and
+/// Distribute for the selection there, above the Document properties (#4608).
+pub fn selection_align(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
+    let mut run = Vec::new();
+    align_and_distribute(app, ui, &mut run);
+    for (id, p) in run {
+        if let Err(e) = app.run(&id, p) {
+            app.ui.status = e;
+            app.ui.status_error = true;
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/ui-egui/src/layer_row_ui.rs b/crates/ui-egui/src/layer_row_ui.rs
index d265690597..7ac725a7cb 100644
--- a/crates/ui-egui/src/layer_row_ui.rs
+++ b/crates/ui-egui/src/layer_row_ui.rs
@@ -71,7 +71,7 @@ pub fn layout(row: Rect, name_left: f32, items: &[(Indicator, f32)]) -> (Vec<(In
 /// Width the always-shown indicators of `l` take at the row's right (blend label excluded).
 pub fn reserved_width(l: &Layer) -> f32 {
     let mut w = RIGHT_PAD;
-    if l.locks.transparency || l.locks.position || l.locks.all {
+    if l.locks.any() {
         w += ICON_W + GAP;
     }
     if !l.effects.items.is_empty() {
@@ -113,7 +113,7 @@ pub fn indicators(
     actions: &mut Vec<(String, Value)>,
 ) -> (f32, Vec<(Indicator, Rect)>, bool) {
     let t = Tokens::get(ui.ctx());
-    let locked = l.locks.transparency || l.locks.position || l.locks.all;
+    let locked = l.locks.any();
     let fx_font = theme::semibold(11.0);
     let blend_font = FontId::proportional(10.5);
     let has_fx = !l.effects.items.is_empty();
@@ -295,8 +295,20 @@ pub fn end_rename(ctx: &egui::Context, commit: bool) -> Option<(String, Value)>
     if commit { r.commit_action() } else { None }
 }
 
+/// Where Tab or ⇧Tab sends a rename: the layer it left and whether the next one is above.
+fn next_rename_id() -> egui::Id {
+    egui::Id::new("layer-rename-next")
+}
+
+/// The rename that Tab (`up` false) or ⇧Tab (`up` true) just left on `layer`, for the Layers panel
+/// to continue on the layer below or above, as Photoshop does. Taken once.
+pub fn take_next_rename(ctx: &egui::Context) -> Option<(u64, bool)> {
+    ctx.data_mut(|d| d.remove_temp::<(u64, bool)>(next_rename_id()))
+}
+
 /// Draw the rename field of `layer` in `rect` when it is the one being renamed, and handle its
-/// keys and focus. Returns the rename command when it was committed this frame.
+/// keys and focus. Returns the rename command when it was committed this frame. Tab and ⇧Tab
+/// commit too and ask for the next rename ([`take_next_rename`]).
 pub fn rename_field(ui: &mut egui::Ui, layer: u64, rect: Rect) -> Option<(String, Value)> {
     let ctx = ui.ctx().clone();
     let mut r = rename(&ctx).filter(|r| r.layer == layer)?;
@@ -316,6 +328,10 @@ pub fn rename_field(ui: &mut egui::Ui, layer: u64, rect: Rect) -> Option<(String
         return None;
     }
     let (enter, tab, esc) = ctx.input(|i| (i.key_pressed(egui::Key::Enter), i.key_pressed(egui::Key::Tab), i.key_pressed(egui::Key::Escape)));
+    if tab {
+        let up = ctx.input(|i| i.modifiers.shift);
+        ctx.data_mut(|d| d.insert_temp(next_rename_id(), (layer, up)));
+    }
     if esc {
         store(&ctx, None);
         None
diff --git a/crates/ui-egui/src/layer_row_ui/rename_tests.rs b/crates/ui-egui/src/layer_row_ui/rename_tests.rs
index a4e985a293..4a7ea135ff 100644
--- a/crates/ui-egui/src/layer_row_ui/rename_tests.rs
+++ b/crates/ui-egui/src/layer_row_ui/rename_tests.rs
@@ -1,6 +1,7 @@
 //! #314: renaming a layer in place works like Photoshop. A click anywhere else, Enter or Tab
 //! commits; Esc cancels; only one rename is open at a time, and starting another (double-click,
-//! the context menu or Layer › Rename Layer) commits the first.
+//! the context menu or Layer › Rename Layer) commits the first. Tab then renames the layer below,
+//! ⇧Tab the layer above.
 
 use egui::{Event, Key, Modifiers, PointerButton, Pos2, pos2, vec2};
 use egui_kittest::Harness;
@@ -127,7 +128,8 @@ fn enter_and_tab_commit_and_escape_cancels() {
     start(&mut h, b);
     type_text(&mut h, "By Tab");
     key(&mut h, Key::Tab);
-    assert_eq!((name(&h, b), renaming(&h.ctx)), ("By Tab".into(), None));
+    assert_eq!((name(&h, b), renaming(&h.ctx)), ("By Tab".into(), Some(a)), "Tab commits and renames the layer below");
+    key(&mut h, Key::Escape);
 
     start(&mut h, c);
     type_text(&mut h, "Never");
@@ -143,6 +145,28 @@ fn enter_and_tab_commit_and_escape_cancels() {
     assert_eq!(name(&h, c), "Gamma");
 }
 
+#[test]
+fn shift_tab_renames_the_layer_above_and_tab_at_the_bottom_ends() {
+    let (mut h, [a, b, c]) = harness(1.0);
+    start(&mut h, b);
+    type_text(&mut h, "Middle");
+    h.event(Event::ModifiersChanged(Modifiers::SHIFT));
+    h.event(Event::Key { key: Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::SHIFT });
+    h.event(Event::Key { key: Key::Tab, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::SHIFT });
+    h.run_steps(1);
+    h.event(Event::ModifiersChanged(Modifiers::NONE));
+    h.run_steps(2);
+    assert_eq!((name(&h, b), renaming(&h.ctx)), ("Middle".into(), Some(c)), "⇧Tab renames the layer above");
+    // Typing replaces the next layer's name too, as the whole name starts selected.
+    type_text(&mut h, "Top");
+    key(&mut h, Key::Enter);
+    assert_eq!((name(&h, c), renaming(&h.ctx)), ("Top".into(), None));
+    // Tab from the lowest layer ends the rename: the Background below isn't renamed in place.
+    start(&mut h, a);
+    key(&mut h, Key::Tab);
+    assert_eq!(renaming(&h.ctx), None);
+}
+
 #[test]
 fn starting_another_rename_commits_the_first_and_only_one_is_open() {
     for ppp in [1.0, 2.0] {
diff --git a/crates/ui-egui/src/layer_row_ui/tests.rs b/crates/ui-egui/src/layer_row_ui/tests.rs
index f2ac633ba2..6ec1241b46 100644
--- a/crates/ui-egui/src/layer_row_ui/tests.rs
+++ b/crates/ui-egui/src/layer_row_ui/tests.rs
@@ -3,7 +3,7 @@
 
 use egui::{Modifiers, PointerButton, Pos2, Rect, pos2, vec2};
 use egui_kittest::Harness;
-use egui_kittest::kittest::Queryable;
+use egui_kittest::kittest::{NodeT, Queryable};
 use photocraft_doc::{Effect, LayerContent};
 use serde_json::json;
 
@@ -171,7 +171,7 @@ fn the_eyes_on_the_effects_rows_hide_and_show_effects() {
     let steps = |h: &Harness<'_, PhotocraftApp>| h.state().session.active().unwrap().history.past_len();
     let eye = |h: &Harness<'_, PhotocraftApp>, row: &str| {
         let r = h.get_by_label(row).rect();
-        pos2(r.left() + 15.0, r.center().y)
+        pos2(r.left() + 45.0, r.center().y)
     };
     let (settings, n) = (h.state().session.active().unwrap().doc.layer(photocraft_doc::LayerId(id)).unwrap().effects.items.clone(), steps(&h));
     assert_eq!(fx(&h), (true, vec![true, true]));
@@ -536,3 +536,74 @@ fn press_drag_release_on_the_fx_button_opens_that_style() {
     let effects = open[0].fields["effects"].as_array().unwrap();
     assert!(effects.iter().any(|e| e["kind"] == json!("dropShadow")), "on Drop Shadow: {effects:?}");
 }
+
+/// One layer per lock, each with only that lock set (#4158).
+fn one_lock_each() -> (photocraft_engine::Session, Vec<(&'static str, u64)>) {
+    let mut s = photocraft_engine::Session::new();
+    s.execute("file.new", json!({"width": 64, "height": 48})).unwrap();
+    let mut ids = Vec::new();
+    for key in ["transparency", "pixels", "position", "artboard", "all"] {
+        let id = s.execute("layer.new.layer", json!({"name": key})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("layer.setProps", json!({"layer": id, "locks": {key: true}})).unwrap();
+        ids.push((key, id));
+    }
+    (s, ids)
+}
+
+#[test]
+fn every_lock_shows_the_lock_icon_on_the_row() {
+    // #4158: "Lock image pixels" and the artboard lock left the row without its lock icon.
+    // Photoshop shows it whenever any lock is set.
+    let (s, ids) = one_lock_each();
+    let doc = &s.active().unwrap().doc;
+    for &(key, id) in &ids {
+        let l = doc.layers.iter().find(|l| l.id.0 == id).unwrap();
+        assert_eq!(super::reserved_width(l), super::RIGHT_PAD + super::ICON_W + super::GAP, "{key}: room for the lock icon");
+    }
+    let h = harness(s, 1.0, "promedium", 290.0);
+    let rows = recorded(&h.ctx);
+    for &(key, id) in &ids {
+        let r = rows.iter().find(|r| r.layer == id).unwrap_or_else(|| panic!("{key}: row drawn"));
+        assert!(r.indicators.iter().any(|(k, _)| *k == Indicator::Lock), "{key}: lock icon drawn ({:?})", r.indicators);
+    }
+}
+
+#[test]
+fn the_studio_lock_button_shows_every_lock() {
+    // #4158: the simple themes' lock button drew "unlocked" for a pixels or artboard lock, though
+    // clicking it then unlocked the layer.
+    for key in ["transparency", "pixels", "position", "artboard", "all"] {
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 64, "height": 48})).unwrap();
+        s.execute("layer.new.layer", json!({"name": key})).unwrap();
+        s.execute("layer.setProps", json!({"locks": {key: true}})).unwrap();
+        let h = harness(s, 1.0, "studio", 290.0);
+        assert_eq!(h.get_by_label("Lock layer").accesskit_node().toggled(), Some(egui::accesskit::Toggled::True), "{key}");
+    }
+}
+
+#[test]
+fn clicking_the_lock_icon_on_a_row_unlocks_the_layer() {
+    // #4723: the row's lock icon was only painted. In Photoshop a click on it clears every lock,
+    // and on the Background makes it a normal layer.
+    let (s, ids) = one_lock_each();
+    let bg = s.active().unwrap().doc.background().unwrap().id;
+    let mut h = harness(s, 1.0, "promedium", 290.0);
+    let active = h.state().session.active().unwrap().active_layer;
+    let lock_icon = |h: &Harness<'_, PhotocraftApp>, id: u64| {
+        let row = recorded(&h.ctx).into_iter().find(|r| r.layer == id).unwrap();
+        row.indicators.into_iter().find(|(k, _)| *k == Indicator::Lock).unwrap_or_else(|| panic!("lock icon on {id}")).1.center()
+    };
+    for &(key, id) in &ids {
+        let p = lock_icon(&h, id);
+        click(&mut h, p);
+        let d = h.state().session.active().unwrap();
+        assert!(!d.doc.layer(photocraft_doc::LayerId(id)).unwrap().locks.any(), "{key}: unlocked");
+        assert_eq!(d.active_layer, active, "{key}: the lock icon doesn't select");
+    }
+    let p = lock_icon(&h, bg.0);
+    click(&mut h, p);
+    let doc = &h.state().session.active().unwrap().doc;
+    assert!(doc.background().is_none(), "the Background became a normal layer");
+    assert!(!doc.layer(bg).unwrap().locks.any());
+}
diff --git a/crates/ui-egui/src/layer_shortcut_tests.rs b/crates/ui-egui/src/layer_shortcut_tests.rs
new file mode 100644
index 0000000000..a363c340bf
--- /dev/null
+++ b/crates/ui-egui/src/layer_shortcut_tests.rs
@@ -0,0 +1,124 @@
+//! Photoshop's layer and selection keys reach their commands: ⌘, toggles visibility, ⌘\ targets
+//! the mask, / toggles Lock Transparent Pixels, ⌘⌥2 loads luminosity, ⌘⌥⌫ fills from history.
+
+use egui::{Key, Modifiers};
+use serde_json::json;
+
+use crate::PhotocraftApp;
+
+fn app() -> PhotocraftApp {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({"width": 20, "height": 10})).unwrap();
+    app.run("layer.new.layer", json!({})).unwrap();
+    app
+}
+
+fn press(app: &mut PhotocraftApp, key: Key, modifiers: Modifiers) {
+    let ctx = egui::Context::default();
+    let raw = egui::RawInput {
+        events: vec![egui::Event::ModifiersChanged(modifiers), egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }],
+        ..Default::default()
+    };
+    ctx.begin_pass(raw);
+    crate::shortcuts::handle(app, &ctx);
+    ctx.end_pass().textures_delta.clear();
+}
+
+fn active(app: &PhotocraftApp) -> &photocraft_doc::Layer {
+    let st = app.session.active().unwrap();
+    st.doc.layer(st.active_layer.unwrap()).unwrap()
+}
+
+#[test]
+fn command_comma_toggles_the_layers_visibility() {
+    let mut app = app();
+    press(&mut app, Key::Comma, Modifiers::COMMAND);
+    assert!(!active(&app).visible);
+    press(&mut app, Key::Comma, Modifiers::COMMAND);
+    assert!(active(&app).visible);
+}
+
+#[test]
+fn slash_toggles_lock_transparent_pixels() {
+    let mut app = app();
+    press(&mut app, Key::Slash, Modifiers::NONE);
+    assert!(active(&app).locks.transparency);
+    press(&mut app, Key::Slash, Modifiers::NONE);
+    assert!(!active(&app).locks.transparency);
+}
+
+#[test]
+fn command_backslash_targets_the_layer_mask() {
+    let mut app = app();
+    app.run("layer.layerMask.revealAll", json!({})).unwrap();
+    app.run("channel.target.composite", json!({})).unwrap();
+    press(&mut app, Key::Backslash, Modifiers::COMMAND);
+    assert_eq!(app.session.active().unwrap().channel_view.target, photocraft_engine::channel_cmds::ChannelTarget::LayerMask);
+    assert!(app.ui.mask_target && app.layer_mask_targeted(), "the Layers panel targets the mask too");
+    // Ctrl+2 goes back to the layer's pixels, in the Layers panel and for the tools.
+    press(&mut app, Key::Num2, Modifiers::COMMAND);
+    assert_eq!(app.session.active().unwrap().channel_view.target, photocraft_engine::channel_cmds::ChannelTarget::Composite);
+    assert!(!app.ui.mask_target && !app.layer_mask_targeted());
+    // The same after targeting the mask by its thumbnail (the panel's own flag).
+    app.ui.mask_target = true;
+    app.sync_mask_targets();
+    press(&mut app, Key::Num2, Modifiers::COMMAND);
+    assert!(!app.ui.mask_target && !app.layer_mask_targeted());
+}
+
+#[test]
+fn command_alt_2_loads_luminosity() {
+    let mut app = app();
+    press(&mut app, Key::Num2, Modifiers::COMMAND | Modifiers::ALT);
+    assert!(app.session.active().unwrap().doc.selection.is_some(), "the white image's luminosity selects it all");
+}
+
+#[test]
+fn command_alt_backspace_fills_from_history() {
+    // The Background exists in the oldest state, so its pixels come back from there.
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({"width": 20, "height": 10})).unwrap();
+    app.run("tools.setColors", json!({"foreground": "#ff0000"})).unwrap();
+    app.run("edit.fillForeground", json!({})).unwrap();
+    assert_eq!(active(&app).surface().unwrap().pixel(3, 3)[1], 0.0, "red");
+    press(&mut app, Key::Backspace, Modifiers::COMMAND | Modifiers::ALT);
+    assert_eq!(active(&app).surface().unwrap().pixel(3, 3)[1], 1.0, "white again");
+}
+
+/// ⌥-click a layer's thumbnail: select it and fit its content on screen.
+#[test]
+fn alt_click_on_a_layer_thumbnail_fits_the_layer() {
+    use egui::{Event, PointerButton, pos2, vec2};
+    let mut s = photocraft_engine::Session::new();
+    s.execute("file.new", json!({"width": 400, "height": 300})).unwrap();
+    let small = s.execute("layer.new.layer", json!({"name": "Small"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("select.rect", json!({"x": 300, "y": 200, "width": 20, "height": 10})).unwrap();
+    s.execute("edit.fill", json!({"contents": "black"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    s.execute("layer.new.layer", json!({"name": "Top"})).unwrap();
+    let mut h = egui_kittest::Harness::builder().with_size(vec2(1440.0, 900.0)).with_step_dt(1.0 / 60.0).with_max_steps(64).build_eframe(move |cc| {
+        PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+        PhotocraftApp::new(s, crate::Services::default())
+    });
+    let ctx = h.ctx.clone();
+    let (r, _) = crate::control::ControlRequest::new("ui.set", json!({"dock": {"collapsed": ["color", "properties", "history", "navigator"]}}));
+    crate::control::handle(h.state_mut(), &ctx, &r);
+    h.run_steps(8);
+    let before = h.state().ui.views[0].clone();
+    let row = crate::layer_row_ui::recorded(&h.ctx).into_iter().find(|r| r.layer == small).unwrap().row;
+    let at = pos2(row.left() + 46.0, row.center().y);
+    h.hover_at(at);
+    h.event(Event::ModifiersChanged(Modifiers::ALT));
+    h.run_steps(1);
+    h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::ALT });
+    h.run_steps(1);
+    h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::ALT });
+    h.run_steps(1);
+    h.event(Event::ModifiersChanged(Modifiers::NONE));
+    h.run_steps(3);
+    let app = h.state();
+    assert_eq!(app.session.active().unwrap().active_layer, Some(photocraft_doc::LayerId(small)));
+    let v = &app.ui.views[0];
+    assert_eq!(v.center, [310.0, 205.0], "centred on the layer's content");
+    assert!(v.zoom > before.zoom * 4.0, "zoomed in on 20 × 10 px: {} -> {}", before.zoom, v.zoom);
+}
diff --git a/crates/ui-egui/src/layer_style.rs b/crates/ui-egui/src/layer_style.rs
index 93f22c479b..af3e36c904 100644
--- a/crates/ui-egui/src/layer_style.rs
+++ b/crates/ui-egui/src/layer_style.rs
@@ -14,7 +14,7 @@
 //!   the page-only `blendIfChannel`; `channelNames`: the document's colour channels.
 
 use egui::{Color32, RichText, Sense, Stroke, StrokeKind, vec2};
-use photocraft_doc::effects::{FxPaint, StrokePosition};
+use photocraft_doc::effects::{FxPaint, GlowSource, StrokePosition};
 use photocraft_doc::{Effect, Layer};
 use serde_json::{Map, Value, json};
 
@@ -247,6 +247,9 @@ fn values_of(e: &Effect, light: f32) -> Value {
             set(&mut v, "contour", photocraft_engine::layer_style::contour_param(&g.contour));
             set(&mut v, "antiAlias", json!(g.anti_alias));
             set(&mut v, "noise", json!((g.noise * 100.0).round()));
+            if matches!(e, Effect::InnerGlow(_)) {
+                set(&mut v, "source", json!(if g.source == GlowSource::Center { "center" } else { "edge" }));
+            }
         }
         Effect::Stroke(s) => {
             set(&mut v, "blend", json!(s.common.blend.label()));
@@ -500,6 +503,14 @@ pub fn initial_fields(layer: &Layer, select: Option<&str>, light: f32) -> Map<St
 }
 
 pub fn open(app: &mut PhotocraftApp, select: Option<&str>) -> Option<u64> {
+    // An open Free Transform box is applied first, as in Photoshop (#4821): the canvas shows the
+    // box's preview while it is open, so the dialog's preview would not show until Enter.
+    if app.ui.transform.is_some() {
+        crate::transform_tool::commit(app);
+        if app.ui.transform.is_some() && crate::transform_tool::committing(app).is_none() {
+            return None; // refused: the box stays open, with the reason in the status bar
+        }
+    }
     let st = app.session.active()?;
     let layer = st.doc.layer(st.active_layer?)?.clone();
     let light = st.doc.global_light.angle;
@@ -512,6 +523,16 @@ pub fn open(app: &mut PhotocraftApp, select: Option<&str>) -> Option<u64> {
     Some(app.ui.open_dialog(crate::state::DialogKind::LayerStyle, f))
 }
 
+/// Double-click on an effect row of the Layers panel: open Layer Style for that row's layer. A
+/// row of another layer selects it first, as its right-click menu does (Photoshop does the same).
+pub fn open_for_layer(app: &mut PhotocraftApp, layer: photocraft_doc::LayerId, select: Option<&str>) -> Option<u64> {
+    let active = app.session.active().is_some_and(|s| s.active_layer == Some(layer));
+    if !active {
+        app.run("layer.select", json!({"layer": layer.0})).ok()?;
+    }
+    open(app, select)
+}
+
 /// `[[id, name], …]` of the patterns a style can use (document's, then the library's).
 pub fn pattern_list(app: &PhotocraftApp) -> Value {
     let mut out: Vec<Value> = Vec::new();
@@ -1380,6 +1401,30 @@ mod tests {
         assert_eq!(rows, KINDS.len(), "one empty checkbox per effect row");
     }
 
+    /// Double-clicking an effect row of a layer that isn't active selects that layer first, so
+    /// the dialog holds its effects (and OK edits it), not the active layer's.
+    #[test]
+    fn effect_row_of_another_layer_opens_that_layers_style() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 32, "height": 32})).unwrap();
+        app.run("layer.new.layer", json!({})).unwrap();
+        let with_fx = app.session.active().unwrap().active_layer.unwrap();
+        app.run("layer.layerStyle.replace", json!({"layer": with_fx.0, "effects": [{"kind": "dropShadow", "params": defaults("dropShadow")}]})).unwrap();
+        app.run("layer.new.layer", json!({})).unwrap();
+        let plain = app.session.active().unwrap().active_layer.unwrap();
+        assert_ne!(plain, with_fx);
+        assert!(app.session.active().unwrap().doc.layer(plain).unwrap().effects.items.is_empty());
+
+        let id = open_for_layer(&mut app, with_fx, Some("dropShadow")).unwrap();
+        assert_eq!(app.session.active().unwrap().active_layer, Some(with_fx), "the row's layer becomes active");
+        let d = app.ui.dialogs.iter().find(|d| d.id == id).unwrap();
+        assert_eq!(d.fields["layer"], json!(with_fx.0));
+        let fx = effects_of(&d.fields);
+        assert_eq!(fx.len(), 1);
+        assert_eq!(fx[0]["kind"], json!("dropShadow"));
+        assert!(fx[0]["fx"].is_object(), "the existing drop shadow, not a new instance");
+    }
+
     #[test]
     fn every_kind_has_spec_and_defaults() {
         for &(kind, _) in KINDS {
@@ -1693,17 +1738,19 @@ mod tests {
         apply(&f, |cmd, p| s.execute(cmd, p).map_err(|e| e.to_string())).unwrap();
         assert_eq!(shadow(&s), photocraft_engine::layer_style::builtin_contour("Cone").unwrap());
 
-        // The Contour Editor: drag the peak to 40 % / 80 %, make the first point a corner.
+        // The Contour Editor: drag the second point to 10 % / 30 % (between its neighbours on
+        // the measured Cone), make the first point a corner.
         contour::open_editor(&mut f, "fx1", "contour");
-        assert!(contour::set_point(&mut f, 1, 40.0, 80.0));
+        assert!(contour::set_point(&mut f, 1, 10.0, 30.0));
         assert!(contour::set_corner(&mut f, 0, true));
-        assert!(!contour::set_point(&mut f, 9, 10.0, 10.0), "no such point");
+        assert!(!contour::set_point(&mut f, 99, 10.0, 10.0), "no such point");
         contour::close_editor(&mut f, true);
         apply(&f, |cmd, p| s.execute(cmd, p).map_err(|e| e.to_string())).unwrap();
         let photocraft_doc::Contour::Custom { name, points, corners } = shadow(&s) else { panic!() };
         assert_eq!(name, "Custom", "an edited preset is no longer called Cone");
-        assert!((points[1].input - 102.0 / 255.0).abs() < 1e-6 && (points[1].output - 204.0 / 255.0).abs() < 1e-6, "{points:?}");
-        assert_eq!(corners, vec![true, true, false]);
+        assert!((points[1].input - 0.1).abs() < 3e-3 && (points[1].output - 0.3).abs() < 3e-3, "{points:?}");
+        assert_eq!(corners.len(), points.len());
+        assert!(corners[0] && corners[1] && !corners[corners.len() - 1], "{corners:?}");
 
         // Cancel restores the curve the editor opened with.
         let before = f.clone();
@@ -1728,6 +1775,30 @@ mod tests {
         assert_eq!(fx[1]["params"]["spread"], json!(12.0));
     }
 
+    /// OK with no edits used to turn a Center-source Inner Glow into an Edge one: the dialog never
+    /// loaded the source, so it showed the default and applied it.
+    #[test]
+    fn inner_glow_center_source_survives_ok() {
+        let mut s = session();
+        s.execute("layer.layerStyle.innerGlow", json!({"source": "center"})).unwrap();
+        let source = |s: &photocraft_engine::Session| {
+            let d = s.active().unwrap();
+            let id = d.active_layer.unwrap();
+            d.doc.layer(id).unwrap().effects.items.iter().find_map(|e| match e {
+                Effect::InnerGlow(g) => Some(g.source),
+                _ => None,
+            })
+        };
+        assert_eq!(source(&s), Some(GlowSource::Center));
+        let st = s.active().unwrap();
+        let id = st.active_layer.unwrap();
+        let f = initial_fields(st.doc.layer(id).unwrap(), None, st.doc.global_light.angle);
+        let glow = effects_of(&f).iter().find(|e| e["kind"] == json!("innerGlow")).unwrap();
+        assert_eq!(glow["params"]["source"], json!("center"), "the dialog shows the effect's source");
+        apply(&f, |cmd, p| s.execute(cmd, p).map_err(|e| e.to_string())).unwrap();
+        assert_eq!(source(&s), Some(GlowSource::Center), "OK keeps the source");
+    }
+
     #[test]
     fn drop_shadow_angle_reaches_the_effect() {
         // #350: the Angle slider was dead — the dialog never sent `useGlobalLight`, so the engine
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 006723102e..af45a4caec 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -25,25 +25,31 @@ pub mod analysis_ui;
 pub mod anchor_tools;
 pub mod artboard_tool;
 pub mod artboard_ui;
+pub(crate) mod background_redraw;
 mod blend_keys;
 pub(crate) mod blend_preview;
+pub mod blur_pins;
 mod brand;
 pub(crate) mod brush_cursor;
 pub mod brush_panel;
 pub mod brush_picker;
+pub mod brush_preset_dialog;
 pub mod brush_preview;
 pub mod brush_resize;
 pub mod brush_sections;
 pub mod brushes_tab;
+pub(crate) mod cam_preview;
 mod cam_transform;
 mod camera_raw_detail_ui;
 mod camera_raw_preview_ui;
 mod camera_raw_scope_ui;
 pub mod camera_raw_ui;
 pub mod canvas;
+pub mod canvas_autoscroll;
 mod canvas_popup;
 pub mod canvas_tool_menu;
 pub mod cas_transform;
+pub mod channel_options_ui;
 pub mod channel_view;
 pub mod channels_panel;
 pub mod chrome_ui;
@@ -62,6 +68,7 @@ pub mod crop_size;
 pub mod crop_straighten;
 pub mod crop_ui;
 pub mod delete_layer_prompt;
+pub mod dialog_alt_reset;
 pub mod dialog_blend_ui;
 pub mod dialogs;
 pub mod direct_select;
@@ -71,6 +78,8 @@ pub mod distort_ui;
 pub mod doc_props_ui;
 pub mod dock;
 pub mod duplicate_layer_ui;
+pub mod edit_history;
+pub mod egui_fonts;
 pub mod enable_rules;
 pub mod eraser_ui;
 pub mod export_dialog;
@@ -81,6 +90,7 @@ pub mod file_open;
 pub mod file_ui;
 pub mod fill_ui;
 pub mod filter_dialog;
+mod filter_preview_ui;
 #[cfg(not(target_arch = "wasm32"))]
 mod filter_preview_worker;
 pub mod flick_pan;
@@ -98,6 +108,7 @@ pub mod icons;
 pub mod jobs_ui;
 pub mod kys_import;
 pub mod lasso_ui;
+pub(crate) mod last_brush;
 pub mod layer_menu_ui;
 pub mod layer_pick_ui;
 pub mod layer_picker;
@@ -129,7 +140,9 @@ pub mod new_guide_ui;
 pub mod new_layer_ui;
 pub mod notices;
 mod numeric_expression;
+pub mod object_finder;
 mod opacity_keys;
+pub mod open_prompt;
 pub mod outline;
 pub mod paint_mouse;
 pub mod palette;
@@ -160,6 +173,7 @@ pub mod rotate_view;
 pub mod rulers;
 pub mod screen_picker;
 pub mod scrollbars;
+mod scrub_wrap;
 pub mod select_mask_view;
 pub mod served_fonts;
 pub mod shape_dialog;
@@ -173,6 +187,8 @@ pub mod slice_ui;
 pub mod smart_ui;
 pub mod snap_ui;
 pub(crate) mod solid_fill_ui;
+pub mod spring_tools;
+pub mod stack_dialog;
 pub mod state;
 pub mod stroke_constraint;
 pub mod stroke_trail;
@@ -186,13 +202,17 @@ pub mod targa_options_ui;
 pub mod text_field_menu;
 pub mod theme;
 pub mod tiff_options_ui;
+mod tile_overlay;
 mod timeline_ui;
 mod titlebar;
+pub use titlebar::{Caption, CaptionFamily, CaptionIcon, CaptionIcons, CaptionStyle, RenderIconFn};
 pub mod tone;
 mod tool_cursor;
 pub mod tool_feedback;
 pub(crate) mod tool_memory;
 mod tool_reset;
+mod tool_shortcuts;
+pub mod transform_fx;
 pub mod transform_tex;
 pub mod transform_tool;
 mod type_font_preview;
@@ -247,11 +267,23 @@ pub struct ExportSettings {
     /// PSD/PSB: embed a thumbnail (Preferences › File Handling › Image Previews; see
     /// [`PhotocraftApp::save_settings`]).
     pub image_previews: bool,
+    /// PSD/PSB: write the real merged image (Preferences › File Handling › Maximize PSD and PSB
+    /// File Compatibility; see [`PhotocraftApp::save_settings`]).
+    pub psd_maximize_compatibility: bool,
 }
 
 impl Default for ExportSettings {
     fn default() -> Self {
-        ExportSettings { jpeg_quality: None, webp_lossless: true, webp_quality: None, tiff_layers: true, xmp_all: true, tga_bits: None, image_previews: true }
+        ExportSettings {
+            jpeg_quality: None,
+            webp_lossless: true,
+            webp_quality: None,
+            tiff_layers: true,
+            xmp_all: true,
+            tga_bits: None,
+            image_previews: true,
+            psd_maximize_compatibility: true,
+        }
     }
 }
 
@@ -358,6 +390,8 @@ pub type CapsLockFn = Box<dyn FnMut() -> bool>;
 /// Keeps an undecorated window's OS frame from offsetting its content and pointer (#2246).
 /// Called once per frame; `None` when the window is decorated or the platform needs no fixing.
 pub type WindowFrameFn = Box<dyn FnMut()>;
+/// The caption buttons' current style ([`Services::caption_style`]).
+pub type CaptionStyleFn = Box<dyn Fn(&egui::Context) -> CaptionStyle>;
 
 /// Platform services injected by the app binary (file dialogs, codecs), keeping this crate free of
 /// I/O dependencies.
@@ -434,6 +468,10 @@ pub struct Services {
     /// (Windows custom title bar, #2246). Called once per frame; `None` when the window is
     /// decorated or the platform needs no fixing.
     pub window_frame: Option<WindowFrameFn>,
+    /// How the custom title bar's caption buttons look and where they sit (Linux: the desktop's
+    /// style and button layout). Read every frame, with the context to wake when it changes;
+    /// `None` keeps Windows' buttons at the right end.
+    pub caption_style: Option<CaptionStyleFn>,
     /// The persistent brush preset store, loading in the background (desktop; see
     /// `photocraft_engine::preset_store`). Attached to the session once it arrives; without
     /// one, brush presets are session-only unless the shell attached a store before startup.
@@ -466,6 +504,14 @@ pub struct PhotocraftApp {
     canvases: HashMap<(DocId, u32), canvas::CanvasCache>,
     /// Navigator textures belong to open documents, not the lifetime of the egui context.
     navigator_textures: HashMap<DocId, canvas::NavigatorCache>,
+    /// `canvas::display_doc`'s live-adjust and Duotone documents per document: (snapshot,
+    /// preview key, the document shown).
+    display_memo: HashMap<DocId, (std::sync::Weak<Document>, u64, std::sync::Arc<Document>)>,
+    /// The main canvas's last GPU view of each document while it shows the plain document on
+    /// the GPU canvas: the Navigator draws the same texture at its own size (#4518).
+    navigator_gpu: HashMap<DocId, crate::gpu_canvas::ViewParams>,
+    /// Documents whose GPU canvas texture holds the plain document (`canvas::ensure_gpu`).
+    navigator_plain: std::collections::HashSet<DocId>,
     /// Display profile readings (#569).
     monitors: monitor_status::State,
     checker: Option<egui::TextureHandle>,
@@ -483,16 +529,25 @@ pub struct PhotocraftApp {
     committed_stroke: Option<canvas::CommittedStroke>,
     /// Footprint trail of a retouching drag (see `stroke_trail`).
     trail: Option<stroke_trail::Trail>,
+    /// Remove tool strokes waiting to be applied together (Remove after each stroke off), the
+    /// document they belong to, and their tint on the canvas (`retouch_ui`).
+    pub(crate) remove_pending: Vec<Vec<[f64; 3]>>,
+    pub(crate) remove_pending_doc: Option<photocraft_doc::DocId>,
+    pub(crate) remove_trail: Option<stroke_trail::Trail>,
     /// The open menus' items, reused between frames (`menus::ItemCache`).
     pub(crate) menu_cache: Option<menus::ItemCache>,
     /// Move tool drag shown live (`move_ui`).
     pub(crate) move_preview: Option<move_ui::MovePreview>,
     /// Move tool › Show Highlight on Rollover: the last hover answer (`move_hover`).
     pub(crate) move_hover: Option<move_hover::Hover>,
+    /// Object Selection › Object Finder: the hover preview (`object_finder`).
+    pub(crate) object_finder: Option<object_finder::Finder>,
     /// A blend mode hovered in the Layers panel, shown live (`blend_preview`).
     pub(crate) blend_preview: Option<blend_preview::BlendPreview>,
     /// Patch Tool drag: the healed document at the pointer (`patch_preview`).
     pub(crate) patch_preview: Option<patch_preview::PatchPreview>,
+    /// Content-Aware Move drag or box shown with its result (`cam_preview`).
+    pub(crate) cam_preview: Option<cam_preview::CamPreview>,
     /// The pixels a Magnetic Lasso border follows (`magnetic_lasso_ui`).
     pub(crate) magnetic: magnetic_lasso_ui::Runtime,
     /// The next tool `Down` is a right-button drag that erases (see `paint_mouse`).
@@ -582,6 +637,8 @@ pub struct PhotocraftApp {
     pub(crate) filter_preview: Option<filter_dialog::FilterPreview>,
     #[cfg(not(target_arch = "wasm32"))]
     filter_preview_worker: filter_preview_worker::Worker,
+    /// Full CPU canvas redraws running in the background, by document (#4024).
+    pub(crate) redraws: std::collections::HashMap<photocraft_doc::DocId, background_redraw::Redraw>,
     /// Select › Color Range dialog preview (proxy document + mask / image textures).
     pub(crate) color_range: Option<color_range_ui::Preview>,
     /// Image › Adjustments dialog preview through a temporary clipped adjustment layer.
@@ -624,6 +681,11 @@ pub struct PhotocraftApp {
     pub(crate) raw_redevelop: Option<camera_raw_ui::Redevelop>,
     /// Filter › Adaptive Wide Angle dialog (wide_angle_ui).
     pub(crate) wide_angle: Option<wide_angle_ui::WideAngleDialog>,
+    /// ⌘Z history of each open parameter dialog (edit_history).
+    pub(crate) dialog_edits: edit_history::DialogEdits,
+    /// The filter a "Rasterize?" prompt answered for, run after the dialog closes, where the
+    /// egui context is available again (rasterize_prompt).
+    pub(crate) pending_after_prompt: Option<(String, serde_json::Value)>,
     /// Signature of the image we last put on the OS clipboard (to tell ours from other apps').
     os_clip_sig: Option<u64>,
     /// The session clipboard currently holds an image imported from the OS clipboard: it has no
@@ -634,6 +696,10 @@ pub struct PhotocraftApp {
     pub(crate) clip_read_for_paste: bool,
     /// Pointer position over the canvas (document px), for the Info panel and status bar.
     pub(crate) hover_doc: Option<[f64; 2]>,
+    /// Layer hovered in the Layers panel, outlined on the canvas.
+    pub(crate) hover_layer: Option<photocraft_doc::LayerId>,
+    /// Layer hovered on the canvas, highlighted in the Layers panel.
+    pub(crate) canvas_hover_layer: Option<photocraft_doc::LayerId>,
     pub(crate) clone_preview: Option<crate::canvas::ClonePreviewCache>,
     /// Info panel sample cache: ((x, y, revision, Sample Size), composite RGBA).
     info_sample: Option<(InfoSampleKey, [f32; 4])>,
@@ -678,6 +744,9 @@ pub struct PhotocraftApp {
     pub(crate) save_dirs: HashMap<photocraft_doc::DocId, std::path::PathBuf>,
     /// A save to an RGB Targa parked behind the Targa Options prompt (see `targa_options_ui`).
     pub(crate) targa_options: Option<targa_options_ui::Prompt>,
+    /// Files read but not opened yet: the first waits on its profile prompt, the rest behind it
+    /// (see `open_prompt`).
+    pub(crate) held_opens: std::collections::VecDeque<open_prompt::Held>,
     /// Set once the user has agreed to quit, so the resulting close request goes through.
     pub(crate) allow_close: bool,
     /// Pen pressure/tilt from the platform (see `stylus`).
@@ -700,6 +769,9 @@ impl PhotocraftApp {
             services,
             canvases: HashMap::new(),
             navigator_textures: HashMap::new(),
+            display_memo: HashMap::new(),
+            navigator_gpu: HashMap::new(),
+            navigator_plain: std::collections::HashSet::new(),
             monitors: Default::default(),
             checker: None,
             drag: None,
@@ -708,11 +780,16 @@ impl PhotocraftApp {
             live_stroke: None,
             committed_stroke: None,
             trail: None,
+            remove_pending: Vec::new(),
+            remove_pending_doc: None,
+            remove_trail: None,
             menu_cache: None,
             move_preview: None,
             move_hover: None,
+            object_finder: None,
             blend_preview: None,
             patch_preview: None,
+            cam_preview: None,
             magnetic: Default::default(),
             secondary_erase: false,
             held_erase: false,
@@ -755,6 +832,7 @@ impl PhotocraftApp {
             filter_preview: None,
             #[cfg(not(target_arch = "wasm32"))]
             filter_preview_worker: Default::default(),
+            redraws: Default::default(),
             color_range: None,
             adjust_preview: None,
             synthetic: Vec::new(),
@@ -770,6 +848,8 @@ impl PhotocraftApp {
             crop: Default::default(),
             pcrop: Default::default(),
             hover_doc: None,
+            hover_layer: None,
+            canvas_hover_layer: None,
             clone_preview: None,
             info_sample: None,
             os_clip_sig: None,
@@ -788,6 +868,8 @@ impl PhotocraftApp {
             pending_raw_open: None,
             raw_redevelop: None,
             wide_angle: None,
+            dialog_edits: Default::default(),
+            pending_after_prompt: None,
             tone_hist: None,
             doc_hist: None,
             hist_job: None,
@@ -800,6 +882,7 @@ impl PhotocraftApp {
             tiff_options: None,
             save_dirs: HashMap::new(),
             targa_options: None,
+            held_opens: Default::default(),
             allow_close: false,
             stylus: Default::default(),
             background_jobs: false,
@@ -889,6 +972,16 @@ impl PhotocraftApp {
         if gate.is_some() {
             self.session.authorize = None;
         }
+        // An explicit channel target (⌘2, ⌘\, ⌘3…) decides what the Layers panel targets too:
+        // ⌘2 after the mask was targeted goes back to the layer's pixels.
+        if result.is_ok() && id.starts_with("channel.target") {
+            if let Some(t) = self.session.active().map(|st| st.channel_view.target) {
+                use photocraft_engine::channel_cmds::ChannelTarget;
+                self.ui.mask_target = t == ChannelTarget::LayerMask;
+                self.ui.vector_mask_target = t == ChannelTarget::VectorMask;
+            }
+            self.sync_mask_targets();
+        }
         result
     }
 
@@ -933,12 +1026,17 @@ impl PhotocraftApp {
         let params = self.with_mask_target(id, params);
         let params = vector_ui::with_active_path(self, id, params);
         let path_mask = vector_ui::takes_path_mask(id) && params.get("path").is_some_and(|v| !v.is_null());
+        let on_active_layer = self
+            .session
+            .active()
+            .is_some_and(|st| st.active_layer.is_some_and(|layer| params.get("layer").and_then(Value::as_u64).is_none_or(|target| target == layer.0)));
         let creates_active_mask =
             matches!(id, "layer.layerMask.revealAll" | "layer.layerMask.hideAll" | "layer.layerMask.revealSelection" | "layer.layerMask.hideSelection")
-                && self
-                    .session
-                    .active()
-                    .is_some_and(|st| st.active_layer.is_some_and(|layer| params.get("layer").and_then(Value::as_u64).is_none_or(|target| target == layer.0)));
+                && on_active_layer;
+        let creates_active_vector_mask = matches!(
+            id,
+            "layer.vectorMask.add" | "layer.vectorMask.fromPath" | "layer.vectorMask.revealAll" | "layer.vectorMask.hideAll" | "layer.vectorMask.currentPath"
+        ) && on_active_layer;
         let r = if id == "actions.play" {
             actions::play(self, &params)
         } else if photocraft_engine::actions_cmds::shell_view_command(id) {
@@ -955,6 +1053,16 @@ impl PhotocraftApp {
             // as in Photoshop (#3369): clicking the mask thumbnail switches it to the mask.
             self.ui.properties_layer = if creates_adjustment_or_fill { self.session.active().and_then(|st| st.active_layer).map(|l| l.0) } else { None };
         }
+        if r.is_ok() && creates_adjustment_or_fill {
+            // Properties comes to the front, shown and expanded, so the new layer's settings can
+            // be edited at once, as in Photoshop (#4028). The layer is made whatever happens here.
+            if self.ui.docking.is_some() {
+                let _ = panel_docking::command(self, "window.panel.activate", &json!({"panel": "properties"}));
+            } else {
+                self.ui.dock_tabs.properties = 0;
+                dock::reveal(self, dock::Group::Properties);
+            }
+        }
         if r.is_ok() && id == "select.toWorkPath" {
             // Make Work Path selects the new work path in the Paths panel, as in Photoshop.
             self.ui.selected_path = Some("work".into());
@@ -969,6 +1077,15 @@ impl PhotocraftApp {
             self.ui.mask_target = true;
             self.ui.vector_mask_target = false;
         }
+        if r.is_ok() && creates_active_vector_mask {
+            // Likewise a new vector mask (#4728): Properties shows its Density and Feather, and a
+            // mask made from a path becomes the active path.
+            self.ui.vector_mask_target = true;
+            self.ui.mask_target = false;
+            if matches!(id, "layer.vectorMask.currentPath" | "layer.vectorMask.fromPath") {
+                self.ui.selected_path = Some("layer".into());
+            }
+        }
         if r.is_ok() && matches!(id, "edit.copy" | "edit.cut" | "edit.copyMerged") {
             self.clip_external = false;
             self.export_os_clipboard();
@@ -1013,6 +1130,13 @@ impl PhotocraftApp {
         type_transform::cancel_stale(self);
         crate::cam_transform::cancel_stale(self);
         crate::lasso_ui::cancel_stale(self);
+        // A polygon under construction belongs to the Polygonal Lasso tool, not the next tool.
+        if self.ui.tool != Tool::PolygonLasso {
+            self.ui.polygon.clear();
+            self.ui.polygon_mode.clear();
+        }
+        // ... and to the document it was started on.
+        crate::canvas::polygon_cancel_stale(self);
         crate::crop_ui::cancel_stale(self);
         let ids: Vec<DocId> = self.session.documents().iter().map(|d| d.doc.id).collect();
         // Where the document of view `i` is now. Views not tracked yet keep their index.
@@ -1098,6 +1222,12 @@ impl PhotocraftApp {
     /// shown to the user). Files from disk go through [`open_file`](Self::open_file), which also
     /// remembers the path. Brush and gradient files go to the preset libraries instead.
     pub fn open_bytes(&mut self, name: &str, bytes: &[u8]) -> Result<Vec<String>, String> {
+        self.open_bytes_from(name, bytes, None)
+    }
+
+    /// [`Self::open_bytes`] for a file read from `path` (File › Save writes back there; it goes
+    /// to Open Recent), when known.
+    pub(crate) fn open_bytes_from(&mut self, name: &str, bytes: &[u8], path: Option<&str>) -> Result<Vec<String>, String> {
         if let Some(r) = preset_files_ui::open(self, name, bytes) {
             return r.map(|()| Vec::new());
         }
@@ -1105,34 +1235,34 @@ impl PhotocraftApp {
         // Decoded on a worker: a tab with progress appears now, the document when it's ready
         // (warnings are shown then).
         if self.background_jobs {
-            jobs_ui::start_open(self, name, None, jobs_ui::bytes(bytes))?;
+            jobs_ui::start_open(self, name, path.map(str::to_string), jobs_ui::bytes(bytes))?;
             return Ok(Vec::new());
         }
         let import = self.services.import.as_ref().ok_or("no importer configured")?;
         let max_svg_group_depth = self.session.prefs().file_handling.rasterize_svg_groups_deeper_than as usize;
         let (doc, warnings) = import(name, bytes, max_svg_group_depth)?;
-        // Edit › Color Settings policies apply on open; mismatches can ask what to do.
-        // No path yet: a bare name isn't a location to save back to (`open_file` sets the path).
-        let (_, color) = self.session.open_document(doc, None);
-        if let Some(st) = self.session.active_mut() {
-            st.source_read_only = photocraft_io::affinity::is_affinity(bytes);
-        }
-        self.sync_views();
-        self.ui.status = crate::i18n::fmt(tl!("Opened {name}"), &[("name", name)]);
-        self.ui.status_error = false;
-        if camera_raw_ui::wants_open_dialog(self, &warnings) {
-            camera_raw_ui::queue_open_dialog(self, name, None, Some(bytes));
-            notices::io_warnings(self, &crate::i18n::fmt(tl!("Opened {name}"), &[("name", name)]), &camera_raw_ui::without_develop_note(&warnings));
-        } else {
-            notices::io_warnings(self, &crate::i18n::fmt(tl!("Opened {name}"), &[("name", name)]), &warnings);
-        }
-        // Script events bound to "Open Document".
-        photocraft_engine::automate_cmds::document_opened(&mut self.session);
-        self.sync_views();
-        let ask = color.get("ask").and_then(Value::as_bool) == Some(true);
-        if ask && (color.get("mismatch").and_then(Value::as_bool) == Some(true) || color.get("missing").is_some()) {
-            prefs_ui::open_mismatch(self, &color);
-        }
+        // Edit › Color Settings policies apply on open; Ask When Opening holds the file back
+        // until its prompt is answered, and later files wait behind it (`open_prompt`).
+        // Missing fonts are read from the document itself: it may not be open yet (#4559).
+        let warnings = file_open::with_missing_fonts_of(&doc, warnings);
+        // A developed raw has no embedded profile to ask about.
+        let developed = warnings.iter().any(|w| w.contains(photocraft_io::raw::DEVELOPED_NOTE));
+        let question = self.session.color.open_question(&doc).filter(|_| !developed);
+        let wants_raw = camera_raw_ui::wants_open_dialog(self, &warnings);
+        open_prompt::arrive(
+            self,
+            open_prompt::Held {
+                doc,
+                read_only: photocraft_io::affinity::is_affinity(bytes),
+                name: name.to_string(),
+                path: path.map(str::to_string),
+                warnings: warnings.clone(),
+                bytes: (wants_raw && path.is_none()).then(|| std::sync::Arc::new(bytes.to_vec())),
+                slot: None,
+                question,
+                policy_applied: false,
+            },
+        );
         Ok(warnings)
     }
 
@@ -1195,21 +1325,29 @@ impl PhotocraftApp {
             return self.save_to(path, tga_bits);
         }
         let st = self.session.active().ok_or("no document")?;
-        // PDN imports default to our native format, which preserves Paint.NET's blend modes.
+        // PDN imports default to our native format, which preserves Paint.NET's blend modes;
+        // Krita imports to OpenRaster, which Krita opens with its layers.
         // Other files keep their format only when it can retain their layers. A plain raster
         // (including an unlocked transparent PNG) can keep its flat format; editable contents,
         // masks and layer appearance settings need a layered format even with just one layer.
         let flat = plain_raster(&st.doc).is_some();
         let ext = st.path.as_deref().and_then(|p| std::path::Path::new(p).extension()).map(|e| e.to_string_lossy().to_ascii_lowercase());
+        // An OpenRaster file only when it holds the whole document (#3806): else PSD is offered.
+        let holds_ora = st.path.as_deref().is_some_and(|p| photocraft_engine::file_cmds::holds_at(&st.doc, p));
         let writable = ext.is_some_and(|e| {
-            matches!(e.as_str(), photocraft_format::EXTENSION | "psd" | "psb" | "tif" | "tiff" | "ora")
+            matches!(e.as_str(), photocraft_format::EXTENSION | "psd" | "psb" | "tif" | "tiff")
+                || (e == "ora" && holds_ora)
                 || (flat && photocraft_codecs::from_extension(&e).is_some_and(|f| f.caps().write))
         });
         let suggested = match &st.path {
             Some(p) if writable => p.clone(),
             p => {
                 let source = p.as_deref().unwrap_or(&st.doc.name);
-                let ext = if photocraft_engine::file_cmds::extension(source).as_deref() == Some("pdn") { "pcraft" } else { "psd" };
+                let ext = match photocraft_engine::file_cmds::extension(source).as_deref() {
+                    Some("pdn") => "pcraft",
+                    Some("kra" | "krz") => "ora",
+                    _ => "psd",
+                };
                 std::path::Path::new(source).with_extension(ext).to_string_lossy().into_owned()
             }
         };
@@ -1224,7 +1362,7 @@ impl PhotocraftApp {
         // which records the step once answered.
         if tga_bits.is_none() && targa_options_ui::wants_prompt(self, &path) {
             let copy = self.saves_copy(&path, None)?;
-            targa_options_ui::park(self, path.clone(), copy, true)?;
+            targa_options_ui::park(self, path.clone(), copy, "file.saveAs")?;
             return Ok(serde_json::json!({"path": path, "warnings": []}));
         }
         // A layered TIFF asks about its layers first (Preferences › File Handling); the save
@@ -1261,34 +1399,48 @@ impl PhotocraftApp {
         Ok(r)
     }
 
-    /// Replays a recorded `file.save` / `file.saveAs` step: no dialog or prompt, and the
+    /// Replays a recorded `file.save` / `file.saveAs` / `file.saveACopy` step: no dialog or prompt, and the
     /// recorded TIFF or Targa answer (if any) stands in for the TIFF or Targa Options prompt.
     pub(crate) fn replay_save(&mut self, id: &str, params: &Value) -> Result<Value, String> {
         if self.save_options_open() {
             return Err("Answer TIFF or Targa Options before starting another save".into());
         }
         if id == "file.save" {
-            let path = self
-                .session
-                .active()
-                .ok_or("no document")?
-                .path
-                .clone()
-                .filter(|p| photocraft_engine::file_cmds::saves_in_place(p))
-                .ok_or("Save writes back only to the document's own PSD, PSB or .pcraft file")?;
+            let st = self.session.active().ok_or("no document")?;
+            let path =
+                st.path.clone().filter(|p| photocraft_engine::file_cmds::holds_at(&st.doc, p)).ok_or(
+                    "Save writes back only to the document's own PSD, PSB, .pcraft or OpenRaster file, and to OpenRaster only when it holds everything",
+                )?;
             return self.save_in_place(path);
         }
         let path = params.get("path").and_then(Value::as_str).filter(|p| !p.is_empty()).ok_or("Save As needs a `path`")?;
         let tga_bits = targa_options_ui::bits_param(params, id)?;
+        if id == "file.saveACopy" {
+            // A copy: the document keeps its own file and unsaved state, as when recorded (#4373).
+            let doc = self.session.active().ok_or("no document")?.doc.clone();
+            return crate::view_cmds::write_copy(self, &doc, path, tga_bits);
+        }
         self.save_as_step(path.to_string(), params.get("tiffLayers").and_then(Value::as_bool), tga_bits)
     }
 
     /// What a save writes by default under the preferences: File Handling › Image Previews
-    /// decides whether a PSD/PSB gets its thumbnail. Ask When Saving has no Save As checkbox
-    /// here yet, so it saves the preview, as Photoshop's checkbox starts on.
+    /// decides whether a PSD/PSB gets its thumbnail, and Maximize PSD and PSB File Compatibility
+    /// whether it gets its real merged image. Ask When Saving has no dialog here yet, so it saves
+    /// both, as Photoshop's checkboxes start on. A JPEG or WebP is written the way the active
+    /// document's file was (its JPEG quality, a WebP lossy at its quality or lossless), as
+    /// Photoshop's Save and Save As options start there.
     pub(crate) fn save_settings(&self) -> ExportSettings {
-        let previews = self.session.prefs().file_handling.image_previews != photocraft_engine::prefs::Ask::Never;
-        ExportSettings { image_previews: previews, ..ExportSettings::default() }
+        let file_handling = &self.session.prefs().file_handling;
+        let previews = file_handling.image_previews != photocraft_engine::prefs::Ask::Never;
+        let maximize = file_handling.maximize_psd_compatibility != photocraft_engine::prefs::Ask::Never;
+        let mut settings = ExportSettings { image_previews: previews, psd_maximize_compatibility: maximize, ..ExportSettings::default() };
+        if let Some(st) = self.session.active() {
+            let e = &st.doc.file_encoding;
+            settings.jpeg_quality = e.jpeg_quality.map(|q| q.clamp(1, 100));
+            settings.webp_lossless = e.webp_lossless.unwrap_or(settings.webp_lossless);
+            settings.webp_quality = e.webp_quality.map(|q| q.min(100));
+        }
+        settings
     }
 
     /// Whether saving the active document to `path` writes a copy. `tiff_layers` is the TIFF
@@ -1297,10 +1449,13 @@ impl PhotocraftApp {
         // A flat file that can't hold the document (its layers, or the layered file it lives in)
         // is written as a copy, as in Photoshop: the document keeps its file, so Save still
         // writes the layered original and the edits stay unsaved (#2550).
+        // An OpenRaster file that can't hold everything (adjustment layers, styles…) is a copy too,
+        // so the editable document isn't marked saved after losing them (#3806).
         let st = self.session.active().ok_or("no document")?;
-        let layered =
-            |p: &str| photocraft_engine::file_cmds::saves_in_place(p) || matches!(photocraft_engine::file_cmds::extension(p).as_deref(), Some("tif" | "tiff"));
-        Ok(tiff_layers == Some(false) || (!layered(path) && (plain_raster(&st.doc).is_none() || st.path.as_deref().is_some_and(layered))))
+        let tiff = |p: &str| matches!(photocraft_engine::file_cmds::extension(p).as_deref(), Some("tif" | "tiff"));
+        let holds = photocraft_engine::file_cmds::holds_at(&st.doc, path) || tiff(path);
+        let lives_layered = st.path.as_deref().is_some_and(|p| photocraft_engine::file_cmds::saves_in_place(p) || tiff(p));
+        Ok(tiff_layers == Some(false) || (!holds && (plain_raster(&st.doc).is_none() || lives_layered)))
     }
 
     /// Writes the active document to a known path. `tiff_layers` is the TIFF Options answer:
@@ -1352,7 +1507,10 @@ impl PhotocraftApp {
         // copy, as in the headless server (#2579).
         let (hooks, arm) = match kind {
             SaveKind::User => (true, true),
-            SaveKind::Automation => (false, photocraft_engine::file_cmds::extension(path).is_some_and(|e| photocraft_engine::file_cmds::layered_extension(&e))),
+            SaveKind::Automation => {
+                let holds = self.session.documents().iter().find(|st| st.doc.id == doc).is_some_and(|st| photocraft_engine::file_cmds::holds_at(&st.doc, path));
+                (false, holds)
+            }
         };
         self.ui.status = crate::i18n::fmt(tl!("Saved {name}"), &[("name", path)]);
         if !copy {
@@ -1379,6 +1537,11 @@ impl PhotocraftApp {
                 }
                 Ok(())
             });
+            // The file the document now lives in goes to the top of Open Recent and the Home
+            // screen, as opening it does (#4400). Automation saves don't touch the user's list.
+            if hooks {
+                self.push_recent(path);
+            }
         }
         self.ui.status_error = false;
         let what = crate::i18n::fmt(tl!("Saved {name}"), &[("name", file_open::display_name(path).as_str())]);
@@ -1391,6 +1554,11 @@ impl PhotocraftApp {
         self.tiff_options.is_some() || self.targa_options.is_some()
     }
 
+    /// A print worker may still be handing a job to the system queue.
+    pub(crate) fn printing(&self) -> bool {
+        self.session.jobs().iter().any(|j| matches!(j.command.as_str(), "file.print" | "file.printOneCopy"))
+    }
+
     /// A save is running in the background.
     pub(crate) fn saving(&self) -> bool {
         !self.jobs.saves.is_empty()
@@ -1409,8 +1577,9 @@ impl PhotocraftApp {
         let target = {
             let state = self.session.active().ok_or("no document")?;
             // As File › Save: without `path` only a layered file is written back (#416).
-            path.or_else(|| state.path.clone().filter(|p| photocraft_engine::file_cmds::saves_in_place(p)))
-                .ok_or("pass `path`: a save without one writes back only to the document's own PSD, PSB or .pcraft file")?
+            path.or_else(|| state.path.clone().filter(|p| photocraft_engine::file_cmds::holds_at(&state.doc, p))).ok_or(
+                "pass `path`: a save without one writes back only to the document's own PSD, PSB, .pcraft or OpenRaster file, and to OpenRaster only when it holds everything (adjustment layers, styles and masks don't fit)",
+            )?
         };
         let reply = |path: &str, warnings: &[String]| json!({"path": path, "warnings": warnings});
         // #2017: the File › Save worker path, so the encode doesn't block the frame loop.
@@ -1440,8 +1609,8 @@ impl PhotocraftApp {
         let Some(rx) = self.control_rx.take() else { return };
         while let Ok(req) = rx.try_recv() {
             let reply = req.reply.clone();
-            if req.deadline.is_some_and(|deadline| std::time::Instant::now() >= deadline) {
-                let _ = reply.send(serde_json::json!({"ok": false, "error": control::timeout_error()}));
+            if req.deadline.is_some_and(|deadline| std::time::Instant::now() >= deadline) || !req.dispatch.start() {
+                let _ = reply.send(serde_json::json!({"ok": false, "error": control::expired_error()}));
                 continue;
             }
             match control::handle(self, ctx, &req) {
@@ -1598,12 +1767,16 @@ impl eframe::App for PhotocraftApp {
             menu.raw_input(raw_input);
         }
         shortcuts::clipboard_keys(ctx, ctx.text_edit_focused() || self.ui.text_edit.is_some(), raw_input);
-        // Windows sends a touchpad pinch as Ctrl + wheel; make it a pinch again (wheel_nav.rs) —
-        // unless the pinch preference is off, leaving those fractions to scroll sideways.
-        if cfg!(target_os = "windows") && self.session.prefs().enhanced_controls.zoom_with_trackpad_pinch {
+        // Windows precision touchpads and some Linux Wayland compositors send pinches
+        // as fractional Ctrl + wheel rather than a native Zoom event (#4566).
+        // Leave Ctrl+whole-notch mouse scrolling alone, and honour the pinch preference.
+        if cfg!(any(target_os = "windows", target_os = "linux")) && self.session.prefs().enhanced_controls.zoom_with_trackpad_pinch {
             wheel_nav::fold_legacy_pinch(ctx, raw_input);
         }
         raw_input.events.extend(self.take_synthetic_step());
+        // A pen held still is no touch screen's press-and-hold right click (stylus.rs).
+        let pen_down = self.stylus.pen_contacts.observe(&raw_input.events);
+        stylus::pen_hold_is_no_right_click(ctx, pen_down);
         if self.custom_titlebar {
             titlebar::release_after_os_resize(ctx, raw_input);
         }
@@ -1611,6 +1784,7 @@ impl eframe::App for PhotocraftApp {
 
     fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
         let ctx = ui.ctx().clone();
+        self.hover_layer = None;
         i18n::set_current(i18n::Lang::from_pref(&self.session.prefs().interface.language));
         // Fonts registered via set_fonts only take effect next frame; named families would panic now.
         if !self.fonts_ready {
@@ -1650,9 +1824,6 @@ impl eframe::App for PhotocraftApp {
         // system title bar this is where the document name lives, as the in-app title is hidden.
         panels::sync_window_title(self, &ctx);
         let chrome = !self.ui.view.hides_chrome();
-        if !chrome && ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
-            let _ = menus::invoke(self, &ctx, "view.screenMode.standard", serde_json::json!({}));
-        }
         if chrome && self.ui.panels.menu_bar {
             panels::title_bar(self, ui);
         }
@@ -1683,6 +1854,7 @@ impl eframe::App for PhotocraftApp {
         workspace_ui::windows(self, &ctx);
         palette::show(self, &ctx);
         dialogs::show(self, &ctx);
+        rasterize_prompt::run_pending(self, &ctx);
         jobs_ui::dialog(self, &ctx);
         discard_ui::show(self, &ctx);
         tiff_options_ui::show(self, &ctx);
@@ -1694,6 +1866,9 @@ impl eframe::App for PhotocraftApp {
         notices::show(self, &ctx);
         gpu_status::show_fallback(self, &ctx);
         kys_import::show_offer(self, &ctx);
+        if chrome && self.ui.panels.menu_bar && self.custom_titlebar && !self.ui.dialogs.is_empty() {
+            titlebar::modal_drag_overlay(&ctx);
+        }
         if self.custom_titlebar {
             titlebar::resize_zones(ui);
         }
@@ -1703,8 +1878,14 @@ impl eframe::App for PhotocraftApp {
         // remembered once the pointer is up. Here, after every panel, rather than in the
         // picker's own code: the control channel can set it while the picker is closed.
         brush_picker::persist(self, &ctx);
+        // The tool's brush (settings and tip references) is remembered the same way. Like the
+        // picker's view, in the frame loop, so the control channel can set it with the panels
+        // closed; the engine's revision counter keeps an unchanged brush free.
+        last_brush::persist(self, &ctx);
         // Tool options are remembered between launches the same way (#2814).
         tool_memory::persist(self, &ctx);
+        // So are View › Extras, Show and Snap To (#3762).
+        view_cmds::persist(self, &ctx);
         self.automation_input = false;
         shape_stroke_ui::finish_frame(self, &ctx);
         native_menu::sync(self, &ctx);
@@ -1723,6 +1904,9 @@ impl eframe::App for PhotocraftApp {
                 let _ = w.send(serde_json::json!({"ok": true, "result": null}));
             }
         }
+        // A menu or dialog can start a filter after `jobs_ui::tick` ran in this frame. Keep
+        // polling it even when the platform would otherwise put the event loop to sleep.
+        jobs_ui::keep_polling(self, &ctx);
         // Menus and buttons in this frame may have asked for a file dialog.
         self.poll_file_dialog(&ctx, Some(frame));
     }
@@ -1733,6 +1917,13 @@ fn read_dropped(f: &(dyn egui::DroppedFile + Send + Sync)) -> Result<Vec<u8>, St
     f.bytes()
 }
 
+/// The active layer is an adjustment layer. It has no pixels, so painting and filling it edit its
+/// mask even when its icon thumbnail, not the mask, is the Layers panel's target, as in
+/// Photoshop (#4298).
+pub(crate) fn adjustment_layer_active(st: &photocraft_engine::DocState) -> bool {
+    st.active_layer.and_then(|id| st.doc.layer(id)).is_some_and(|l| matches!(l.content, photocraft_doc::LayerContent::Adjustment(_)))
+}
+
 /// On the web, dropped-file bytes arrive asynchronously; the web shell handles drops itself.
 #[cfg(target_arch = "wasm32")]
 fn read_dropped(_f: &dyn egui::DroppedFile) -> Result<Vec<u8>, String> {
@@ -1757,9 +1948,9 @@ impl PhotocraftApp {
         }
     }
 
-    /// The active layer's mask is what pixel commands edit: the Layers panel targets it, or every
-    /// colour channel is off and that mask is the picture. An alpha channel or Quick Mask wins,
-    /// as the engine routes those itself.
+    /// The active layer's mask is what pixel commands edit: the Layers panel targets it, the layer
+    /// is an adjustment layer (no pixels of its own), or every colour channel is off and that mask
+    /// is the picture. An alpha channel or Quick Mask wins, as the engine routes those itself.
     pub fn layer_mask_targeted(&self) -> bool {
         let Some(st) = self.session.active() else { return false };
         let layer_mask = st.channel_view.target == photocraft_engine::channel_cmds::ChannelTarget::LayerMask;
@@ -1768,7 +1959,7 @@ impl PhotocraftApp {
         if !composite || !has_mask {
             return false;
         }
-        if self.ui.mask_target || layer_mask {
+        if self.ui.mask_target || layer_mask || adjustment_layer_active(st) {
             return true;
         }
         let colors_off = st.channel_view.visible_colors(photocraft_engine::channel_cmds::color_count(&st.doc)) == 0;
@@ -2056,7 +2247,20 @@ impl PhotocraftApp {
         // identity against address reuse without retaining the document's pixel data.
         let snapshot = std::sync::Arc::downgrade(&doc);
         let show_color = self.session.prefs().interface.show_channels_in_color;
-        if !matches!(&self.channel_thumbs, Some((d, old, in_color, _)) if *d == id && old.ptr_eq(&snapshot) && *in_color == show_color) {
+        // A step that changes only the selection (a marquee, Deselect) makes a new snapshot with
+        // the same pixels: keep the thumbnails, a full composite at 56 px costs ~0.7 s on a
+        // layered 20 MP document (#4518).
+        let current = match &mut self.channel_thumbs {
+            Some((d, old, in_color, _)) if *d == id && *in_color == show_color => {
+                let same = old.ptr_eq(&snapshot) || old.upgrade().is_some_and(|prev| same_but_selection(&prev, &doc));
+                if same {
+                    *old = snapshot.clone();
+                }
+                same
+            }
+            _ => false,
+        };
+        if !current {
             let comp = photocraft_compose::thumbnail(&doc, 56);
             let (w, h) = (comp.width as usize, comp.height as usize);
             let side = w.max(h);
@@ -2069,7 +2273,7 @@ impl PhotocraftApp {
                         px[(y + oy) * side + x + ox] = f(&comp.pixels[o..o + 4]);
                     }
                 }
-                ctx.load_texture(format!("chan-{name}"), egui::ColorImage::new([side, side], px), egui::TextureOptions::LINEAR)
+                (format!("chan-{name}"), egui::ColorImage::new([side, side], px))
             };
             let fmt = doc.pixel_format();
             let colors = fmt.mode.color_channels();
@@ -2102,14 +2306,37 @@ impl PhotocraftApp {
                         px[(y + oy) * side + x + ox] = egui::Color32::from_gray((v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8);
                     }
                 }
-                texs.push(ctx.load_texture(format!("chan-a{i}"), egui::ColorImage::new([side, side], px), egui::TextureOptions::LINEAR));
+                texs.push((format!("chan-a{i}"), egui::ColorImage::new([side, side], px)));
             }
-            self.channel_thumbs = Some((id, snapshot, show_color, texs));
+            // Update the textures already uploaded rather than allocating new ones.
+            let mut handles = match self.channel_thumbs.take() {
+                Some((d, _, _, h)) if d == id => h,
+                _ => Vec::new(),
+            };
+            handles.truncate(texs.len());
+            for (i, (name, image)) in texs.into_iter().enumerate() {
+                match handles.get_mut(i) {
+                    Some(h) => h.set(image, egui::TextureOptions::LINEAR),
+                    None => handles.push(ctx.load_texture(name, image, egui::TextureOptions::LINEAR)),
+                }
+            }
+            self.channel_thumbs = Some((id, snapshot, show_color, handles));
         }
         self.channel_thumbs.as_ref().map(|(_, _, _, t)| t.iter().map(|t| t.id()).collect()).unwrap_or_default()
     }
 }
 
+/// Whether `new` differs from `old` at most in its selection, so every composite and channel
+/// thumbnail of it is unchanged. Tiles compare by pointer first, so this costs little.
+fn same_but_selection(old: &Document, new: &Document) -> bool {
+    if old.selection == new.selection {
+        return old == new;
+    }
+    let mut o = old.clone();
+    o.selection = new.selection.clone();
+    o == *new
+}
+
 /// Layer › Layer Mask commands that add a layer mask: Photoshop targets the new mask (#2166).
 const ADDS_LAYER_MASK: [&str; 5] = [
     "layer.layerMask.revealAll",
@@ -2231,16 +2458,22 @@ impl PhotocraftApp {
         let r = photocraft_geom::Rect::new(0, 0, w as i32, h as i32);
         let mut surface = photocraft_raster::Surface::from_interleaved(photocraft_color::PixelFormat::RGBA8, r, &bytes);
         surface.prune();
-        self.session.clipboard = Some(photocraft_engine::edit_cmds::Clip { surface, bounds: r, layers: None });
+        self.session.clipboard = Some(photocraft_engine::edit_cmds::Clip { surface, bounds: r, layers: None, resolution: None });
         self.os_clip_sig = Some(sig);
         self.clip_external = true;
         true
     }
 }
 
+#[cfg(test)]
+mod navigator_gpu_tests;
+
 #[cfg(test)]
 mod color_swatch_tests;
 
+#[cfg(test)]
+mod profile_open_tests;
+
 #[cfg(test)]
 mod profile_prompt_tests;
 
@@ -2253,11 +2486,18 @@ mod pen_variants_tests;
 #[cfg(test)]
 mod color_replacement_tests;
 #[cfg(test)]
+mod layer_shortcut_tests;
+#[cfg(test)]
 mod pencil_tests;
+#[cfg(test)]
+mod tool_shortcut_tests;
 
 #[cfg(test)]
 mod pixel_aspect_tests;
 
+#[cfg(test)]
+mod transform_fx_tests;
+
 #[cfg(test)]
 mod transform_undo_tests;
 
@@ -2273,9 +2513,18 @@ mod move_auto_select_tests;
 #[cfg(test)]
 mod new_group_button_tests;
 
+#[cfg(test)]
+mod color_tab_theme_tests;
+
 #[cfg(test)]
 mod new_layer_button_tests;
 
+#[cfg(test)]
+mod smart_filter_rows_tests;
+
+#[cfg(test)]
+mod blur_pins_tests;
+
 #[cfg(test)]
 mod move_outline_tests;
 
@@ -2297,6 +2546,9 @@ mod warp_text_dialog_tests;
 #[cfg(test)]
 mod blend_dropdown_wheel_tests;
 
+#[cfg(test)]
+mod options_bar_mode_wheel_tests;
+
 #[cfg(test)]
 mod dropdown_press_tests;
 
@@ -2452,9 +2704,12 @@ mod clipboard_tests {
         let d = &app.session.active().unwrap().doc;
         assert_eq!((d.size.width, d.size.height, d.layers.len()), (5, 3, 1));
         assert_eq!(app.ui.views.len(), 1, "the new document has a view");
+        assert!(app.has_unsaved_work(), "closing after Paste must ask to save");
         // New from Clipboard with a document open adds another.
         crate::menus::invoke(&mut app, &ctx, "file.newFromClipboard", serde_json::json!({})).unwrap();
         assert_eq!(app.session.documents().len(), 2);
+        assert!(app.session.documents().iter().all(|d| d.is_dirty()));
+        assert!(crate::discard_ui::intercept(&mut app, "file.close", &serde_json::json!({})), "Close must ask before discarding clipboard pixels");
     }
 
     #[test]
diff --git a/crates/ui-egui/src/liquify_ui.rs b/crates/ui-egui/src/liquify_ui.rs
index 3e3a33e8aa..07c1e5a7b6 100644
--- a/crates/ui-egui/src/liquify_ui.rs
+++ b/crates/ui-egui/src/liquify_ui.rs
@@ -151,6 +151,8 @@ pub struct LiquifyDialog {
     zoom: f32,
     center: [f64; 2],
     hover: Option<[f64; 2]>,
+    /// Alt+right-drag (or Control+Alt-drag) resizing the brush: screen anchor, starting size, starting density.
+    brush_resize: Option<(Pos2, f32, f32)>,
     last_dab: f64,
     /// Last dab + proxy update time (ms), shown in the footer.
     pub dab_ms: f64,
@@ -286,6 +288,9 @@ impl LiquifyDialog {
     fn rebuild(&mut self) {
         self.field = LiquifyField::from_strokes(self.canvas, self.cell, &self.strokes);
         self.dirty = Some([0, 0, self.proxy.w, self.proxy.h]);
+        // Undo rebuilds the whole field. The zoomed viewport is a separate buffer; leaving it
+        // clean kept the pre-undo pixels on screen until the next zoom (#4100).
+        self.view_dirty = self.view_bounds;
         self.mask_dirty = true;
         self.render_dirty();
     }
@@ -479,6 +484,7 @@ pub fn open(app: &mut PhotocraftApp, ctx: &egui::Context) -> Result<(), String>
         zoom: 0.0,
         center,
         hover: None,
+        brush_resize: None,
         last_dab: 0.0,
         dab_ms: 0.0,
         preview_ms: 0.0,
@@ -566,6 +572,21 @@ fn alt_tool(t: LiquifyTool) -> LiquifyTool {
     }
 }
 
+/// Alt+right-drag, and Control+Alt-drag, change the Liquify brush instead of painting (#4702).
+fn brush_resize_gesture(mods: egui::Modifiers, secondary: bool) -> bool {
+    mods.alt && (secondary || mods.ctrl)
+}
+
+/// Horizontal motion sets the diameter (the circle's edge follows the pointer). Vertical motion
+/// sets density, Liquify's edge falloff, over the same 200 px travel the canvas uses for hardness.
+fn resized_brush(start_size: f32, start_density: f32, dx: f32, dy: f32) -> (f32, f32) {
+    let dx = if dx.is_finite() { dx } else { 0.0 };
+    let dy = if dy.is_finite() { dy } else { 0.0 };
+    let size = (start_size + dx).round().clamp(1.0, 15000.0);
+    let density = (start_density + dy * 100.0 / crate::brush_resize::HARDNESS_TRAVEL).clamp(0.0, 100.0);
+    (size, (density * 10.0).round() / 10.0)
+}
+
 /// Pointer in document coordinates (from the preview or the control channel). Alt at
 /// pointer-down subtracts from the freeze mask (lasso), reverses a twirl and swaps Pucker/Bloat;
 /// Shift adds to the mask, same as no modifier.
@@ -605,7 +626,8 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers) {
     }
 }
 
-pub fn keys(app: &mut PhotocraftApp, ctx: &egui::Context) {
+/// Ctrl+Z / Ctrl+Shift+Z inside Liquify, including while a slider's text field is focused.
+pub fn history_keys(app: &mut PhotocraftApp, ctx: &egui::Context) {
     let Some(d) = app.distort.liquify.as_mut() else { return };
     let cmd_shift = egui::Modifiers::COMMAND | egui::Modifiers::SHIFT;
     if ctx.input_mut(|i| i.consume_key(cmd_shift, egui::Key::Z)) {
@@ -613,6 +635,11 @@ pub fn keys(app: &mut PhotocraftApp, ctx: &egui::Context) {
     } else if ctx.input_mut(|i| i.consume_key(egui::Modifiers::COMMAND, egui::Key::Z)) {
         d.undo();
     }
+}
+
+pub fn keys(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    history_keys(app, ctx);
+    let Some(d) = app.distort.liquify.as_mut() else { return };
     // Ctrl+H (Hide Extras) toggles the red freeze-mask overlay; the mask itself stays active.
     if ctx.input_mut(|i| i.consume_key(egui::Modifiers::COMMAND, egui::Key::H)) {
         d.opts.show_mask = !d.opts.show_mask;
@@ -625,10 +652,11 @@ pub fn keys(app: &mut PhotocraftApp, ctx: &egui::Context) {
         d.global(LiquifyTool::ThawAll, None);
     }
     if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::OpenBracket)) {
-        d.opts.size = (d.opts.size * 0.9).max(1.0);
+        // At least one pixel, or 2 px * 0.9 rounds back to 2 and `[` never reaches 1.
+        d.opts.size = (d.opts.size * 0.9).round().min(d.opts.size - 1.0).clamp(1.0, 15000.0);
     }
     if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::CloseBracket)) {
-        d.opts.size = (d.opts.size * 1.1).min(15000.0);
+        d.opts.size = (d.opts.size * 1.1).round().max(d.opts.size + 1.0).min(15000.0);
     }
     let tools = [
         (egui::Key::W, LiquifyTool::ForwardWarp),
@@ -902,9 +930,26 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
             d.hover = Some(to_doc(d, area, hp));
         }
         clip.rect_stroke(img, 0.0, Stroke::new(1.0, t.separator), egui::StrokeKind::Outside);
-        // Mouse → strokes (Space or middle button pans).
-        let pan = ui.input(|i| i.key_down(egui::Key::Space) || i.pointer.middle_down());
-        if pan && resp.dragged() {
+        // Mouse → strokes (Space or middle button pans). Alt+right-drag resizes the brush (#4702).
+        let (pan, secondary, mods_now) =
+            ui.input(|i| (i.key_down(egui::Key::Space) || i.pointer.middle_down(), i.pointer.button_down(egui::PointerButton::Secondary), i.modifiers));
+        let resize = d.brush_resize.is_some() || (resp.drag_started() && brush_resize_gesture(mods_now, secondary));
+        if resize {
+            if d.brush_resize.is_none()
+                && let Some(p) = resp.interact_pointer_pos()
+            {
+                d.brush_resize = Some((p, d.opts.size, d.opts.density));
+            }
+            if let (Some((anchor, size0, dens0)), Some(p)) = (d.brush_resize, resp.interact_pointer_pos()) {
+                let delta = p - anchor;
+                let (size, density) = resized_brush(size0, dens0, delta.x, delta.y);
+                d.opts.size = size;
+                d.opts.density = density;
+            }
+            if resp.drag_stopped() || !ui.input(|i| i.pointer.any_down()) {
+                d.brush_resize = None;
+            }
+        } else if pan && resp.dragged() {
             let dl = resp.drag_delta();
             d.center = [d.center[0] - f64::from(dl.x / d.zoom), d.center[1] - f64::from(dl.y / d.zoom)];
         } else if let Some(pp) = resp.interact_pointer_pos() {
@@ -1010,6 +1055,18 @@ fn draw_mesh(d: &LiquifyDialog, painter: &egui::Painter, area: ERect) {
 mod tests {
     use super::*;
 
+    #[test]
+    fn alt_right_drag_resizes_the_liquify_brush_and_does_not_paint() {
+        assert!(brush_resize_gesture(egui::Modifiers::ALT, true));
+        assert!(brush_resize_gesture(egui::Modifiers::CTRL | egui::Modifiers::ALT, false));
+        assert!(!brush_resize_gesture(egui::Modifiers::ALT, false), "Alt+left stays the tool's opposite");
+        assert!(!brush_resize_gesture(egui::Modifiers::NONE, true));
+        let (size, density) = resized_brush(40.0, 50.0, 25.0, crate::brush_resize::HARDNESS_TRAVEL);
+        assert_eq!((size, density), (65.0, 100.0));
+        let (size, density) = resized_brush(40.0, 50.0, -100.0, 0.0);
+        assert_eq!((size, density), (1.0, 50.0));
+    }
+
     fn app_with_layer() -> PhotocraftApp {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
         app.session.execute("file.new", json!({"width": 120, "height": 80, "depth": 8})).unwrap();
@@ -1203,6 +1260,27 @@ mod tests {
         assert_eq!(d.out, expected, "dirty upload source must match the rebuilt field");
     }
 
+    #[test]
+    fn undo_dirties_the_zoomed_preview() {
+        let ctx = egui::Context::default();
+        let mut app = app_with_layer();
+        open(&mut app, &ctx).unwrap();
+        control(&mut app, &json!({"tool": "forwardWarp", "size": 40})).unwrap();
+        for ev in [ToolEvent::Down { x: 35.0, y: 40.0, pressure: 1.0 }, ToolEvent::Move { x: 55.0, y: 40.0, pressure: 1.0 }, ToolEvent::Up { x: 55.0, y: 40.0 }]
+        {
+            pointer(&mut app, ev, egui::Modifiers::NONE);
+        }
+        {
+            let d = app.distort.liquify.as_mut().unwrap();
+            d.zoom = 2.0;
+            d.view_bounds = Some(Rect::new(0, 0, 20, 20));
+            d.view_dirty = None;
+        }
+        control(&mut app, &json!({"undo": true})).unwrap();
+        let d = app.distort.liquify.as_ref().unwrap();
+        assert_eq!(d.view_dirty, d.view_bounds);
+    }
+
     #[test]
     fn liquify_redo_restores_undone_stroke_and_a_new_stroke_clears_redo() {
         let ctx = egui::Context::default();
diff --git a/crates/ui-egui/src/marquee_tests.rs b/crates/ui-egui/src/marquee_tests.rs
index a660a92ddb..cf4832904a 100644
--- a/crates/ui-egui/src/marquee_tests.rs
+++ b/crates/ui-egui/src/marquee_tests.rs
@@ -383,6 +383,32 @@ fn modifiers_held_before_the_drag_pick_the_mode_not_the_shape() {
     assert!(sel.sample_channel(120, 110, 0) < 0.01 && sel.sample_channel(90, 110, 0) > 0.99, "subtracted, not centred");
 }
 
+/// #208: `⇧⌥` held at the press intersects, the third selection mode after add (`⇧`) and subtract
+/// (`⌥`). Like those, the modifier at the press picks the mode; here the keys are released once the
+/// press has fixed the mode, so the drag stays a plain rectangle and only the overlap of the
+/// existing selection and the dragged rectangle survives. The three sample points below are each in
+/// exactly one of {overlap, first-only, drag-only}, so they pass only for intersect, not for
+/// replace, add or subtract.
+#[test]
+fn shift_alt_before_the_drag_intersects_the_selection() {
+    let mut h = harness(Tool::RectMarquee);
+    // A: the existing selection, 50..200 on both axes.
+    h.state_mut().run("select.rect", json!({"x": 50, "y": 50, "width": 150, "height": 150})).unwrap();
+    let both = Modifiers::SHIFT | Modifiers::ALT;
+    mods(&mut h, both);
+    press_at(&mut h, 120.0, 120.0, both);
+    // Mode is fixed at the press; releasing the keys keeps intersect mode but leaves the drag a
+    // plain rectangle (no square/centre constraint), so B is roughly 120..300 on both axes.
+    mods(&mut h, Modifiers::NONE);
+    move_to(&mut h, 300.0, 300.0);
+    release_at(&mut h, 300.0, 300.0, Modifiers::NONE);
+    let st = h.state().session.active().unwrap();
+    let sel = st.doc.selection.as_ref().expect("a selection survives the intersect");
+    assert!(sel.sample_channel(160, 160, 0) > 0.99, "the overlap of the two rectangles stays selected");
+    assert!(sel.sample_channel(60, 60, 0) < 0.01, "a point only in the existing selection is dropped (not add)");
+    assert!(sel.sample_channel(260, 260, 0) < 0.01, "a point only in the dragged rectangle is dropped (not replace)");
+}
+
 /// `cargo test --release -p photocraft-ui-egui marquee_drag_bench -- --ignored --nocapture`
 #[test]
 #[ignore]
@@ -766,7 +792,10 @@ fn m_cycles_only_the_rectangular_and_elliptical_marquee() {
     let mut seen = Vec::new();
     for _ in 0..4 {
         let raw = egui::RawInput {
-            events: vec![egui::Event::Key { key: egui::Key::M, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::SHIFT }],
+            events: vec![
+                egui::Event::Key { key: egui::Key::M, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::SHIFT },
+                egui::Event::Key { key: egui::Key::M, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::SHIFT },
+            ],
             ..Default::default()
         };
         ctx.begin_pass(raw);
diff --git a/crates/ui-egui/src/mask_props_ui_tests.rs b/crates/ui-egui/src/mask_props_ui_tests.rs
index d02af4f257..1cde904682 100644
--- a/crates/ui-egui/src/mask_props_ui_tests.rs
+++ b/crates/ui-egui/src/mask_props_ui_tests.rs
@@ -213,3 +213,43 @@ fn refine_row_opens_the_select_and_mask_and_color_range_dialogs() {
         }
     }
 }
+
+/// A Studio-layout theme's floating Properties card, with no mask targeted.
+fn card_harness(new_layer: bool, theme: crate::theme::ThemeKind) -> Harness<'static, PhotocraftApp> {
+    let mut session = photocraft_engine::Session::new();
+    session.execute("file.new", json!({"width": 64, "height": 64, "background": "white"})).unwrap();
+    if new_layer {
+        session.execute("layer.new.layer", json!({})).unwrap();
+    }
+    let mut app = PhotocraftApp::new(session, crate::Services::default());
+    app.ui.panels.properties = true;
+    app.last_canvas_rect = Rect::from_min_size(egui::Pos2::ZERO, vec2(800.0, 600.0));
+    let mut h = Harness::builder().with_size(vec2(800.0, 600.0)).with_step_dt(1.0 / 60.0).build_ui_state(
+        |ui, app: &mut PhotocraftApp| {
+            if ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("semibold".into()))) {
+                properties_window(app, ui.ctx());
+            }
+        },
+        app,
+    );
+    PhotocraftApp::setup_context(&h.ctx, theme);
+    h.run_steps(4);
+    h
+}
+
+#[test]
+fn floating_properties_card_shows_document_properties_for_the_background() {
+    for theme in [crate::theme::ThemeKind::Studio, crate::theme::ThemeKind::BreezeDark] {
+        let h = card_harness(false, theme);
+        assert!(h.query_all_by_label("Document").next().is_some(), "{theme:?}: Document properties in the card");
+    }
+}
+
+#[test]
+fn floating_properties_card_shows_pixel_layer_properties() {
+    for theme in [crate::theme::ThemeKind::Studio, crate::theme::ThemeKind::BreezeDark] {
+        let h = card_harness(true, theme);
+        assert!(h.query_all_by_label("Opacity").next().is_some(), "{theme:?}: layer controls in the card");
+        assert!(h.query_all_by_label("Document").next().is_none());
+    }
+}
diff --git a/crates/ui-egui/src/mask_thumbs_ui/tests.rs b/crates/ui-egui/src/mask_thumbs_ui/tests.rs
index f5ec70efb5..50ff96f083 100644
--- a/crates/ui-egui/src/mask_thumbs_ui/tests.rs
+++ b/crates/ui-egui/src/mask_thumbs_ui/tests.rs
@@ -169,6 +169,29 @@ fn a_new_mask_is_targeted_so_the_next_footer_trash_keeps_its_layer() {
     assert!(h.state().session.active().unwrap().doc.layer(photocraft_doc::LayerId(shape)).is_some());
 }
 
+/// #4728: with a path selected in the Paths panel, the footer's "Add vector mask" makes the vector
+/// mask from that path (Layer › Vector Mask › Current Path) and targets it, so Properties shows
+/// its Density and Feather.
+#[test]
+fn add_vector_mask_uses_the_selected_path_and_targets_the_new_mask() {
+    let (s, _, _) = session();
+    let mut h = harness(s, 0, 1.0, 290.0);
+    h.state_mut().run("layer.new.layer", json!({"name": "Spock"})).unwrap();
+    h.state_mut().run("layer.layerMask.revealAll", json!({})).unwrap();
+    let id = h.state().session.active().unwrap().active_layer.unwrap();
+    let path = json!({"subpaths": [{"closed": true, "knots": [[30, 20], [90, 20], [90, 80], [30, 80]]}]});
+    h.state_mut().run("path.set", json!({"name": "work", "path": path})).unwrap();
+    h.state_mut().ui.selected_path = Some("work".into());
+    let work = h.state().session.active().unwrap().doc.work_path.clone().unwrap();
+    h.run_steps(3);
+    let at = h.get_by_label("Add vector mask").rect().center();
+    click_with(&mut h, at, Modifiers::NONE);
+    let l = h.state().session.active().unwrap().doc.layer(id).unwrap().clone();
+    assert_eq!(l.vector_mask.map(|v| v.path), Some(work), "the vector mask is the selected path, not Reveal All");
+    assert!(h.state().ui.vector_mask_target && !h.state().ui.mask_target, "the new vector mask is targeted");
+    assert_eq!(h.state().ui.selected_path.as_deref(), Some("layer"), "the mask's path becomes the active path");
+}
+
 #[test]
 fn dragging_a_layer_row_to_trash_still_deletes_the_layer_with_a_mask_targeted() {
     let (s, masked, _) = session();
@@ -629,12 +652,13 @@ fn command_i_inverts_the_targeted_mask() {
     let mask = &l.mask.as_ref().unwrap().surface;
     assert_eq!((mask.sample_channel(50, 50, 0), mask.sample_channel(150, 10, 0)), (1.0, 0.0), "the mask inverted");
     assert!(l.content == pixels, "the layer's pixels are untouched");
-    // An adjustment layer's mask: Invert is enabled only through the mask target.
+    // An adjustment layer's mask: with no pixels of its own, Invert edits the mask whether the
+    // panel targets the mask or the icon thumbnail (#4298).
     let app = h.state_mut();
     app.run("layer.newAdjustmentLayer.curves", json!({})).unwrap();
     app.run("layer.layerMask.revealAll", json!({})).unwrap();
     app.ui.mask_target = false;
-    assert!(!crate::menus::is_enabled(app, "image.adjustments.invert"));
+    assert!(crate::menus::is_enabled(app, "image.adjustments.invert"));
     app.ui.mask_target = true;
     assert!(crate::menus::is_enabled(app, "image.adjustments.invert"));
     app.run("image.adjustments.invert", json!({})).unwrap();
@@ -737,3 +761,22 @@ fn a_new_adjustment_or_fill_layer_shows_its_settings_until_the_mask_thumbnail_is
         }
     }
 }
+
+// #4028: with Adjustments showing in a collapsed Properties group, a new adjustment layer brings
+// Properties to the front and expands it, as in Photoshop, so its settings can be edited at once.
+#[test]
+fn a_new_adjustment_layer_brings_properties_to_the_front() {
+    let mut s = photocraft_engine::Session::new();
+    s.execute("file.new", json!({"width": 200, "height": 100})).unwrap();
+    let mut h = harness(s, 0, 1.0, 290.0);
+    let ctx = h.ctx.clone();
+    let (req, _rx) = crate::control::ControlRequest::new("ui.set", json!({"dockTabs": {"properties": 1}}));
+    crate::control::handle(h.state_mut(), &ctx, &req);
+    h.run_steps(2);
+    assert!(h.state().ui.dock.is_collapsed(crate::dock::Group::Properties));
+    h.state_mut().run("layer.newAdjustmentLayer.curves", json!({})).unwrap();
+    h.run_steps(6);
+    assert_eq!(h.state().ui.dock_tabs.properties, 0, "Properties is the group's tab");
+    assert!(!h.state().ui.dock.is_collapsed(crate::dock::Group::Properties), "the group is expanded");
+    assert!(h.query_all_by_label("Reset to defaults").next().is_some(), "the Curves settings show");
+}
diff --git a/crates/ui-egui/src/menu_nav_tests.rs b/crates/ui-egui/src/menu_nav_tests.rs
index fa610c3c53..1643e2765b 100644
--- a/crates/ui-egui/src/menu_nav_tests.rs
+++ b/crates/ui-egui/src/menu_nav_tests.rs
@@ -11,6 +11,52 @@ const DISPLAYS: [(f32, f32, f32); 4] = [(1280.0, 720.0, 1.0), (1024.0, 600.0, 1.
 /// The tallest menus.
 const LONGEST: [&str; 4] = ["Filter", "Layer", "Image", "Edit"];
 
+/// #3737: on Wayland egui knows the monitor's size but never where the window is (no
+/// `inner_rect`). A window taller than the monitor less its taskbar or panel runs under it, so
+/// Layer, View and Window (and every other long menu) must end above it and scroll to their last
+/// row, at 1× and 1.5×.
+#[test]
+fn reported_menus_stay_above_the_panel_when_the_window_position_is_unknown() {
+    for scale in [1.0, 1.5] {
+        for top in ["Layer", "View", "Window", "Filter", "Image", "Edit"] {
+            let mut h = harness((1366.0 * scale, 740.0 * scale, scale));
+            let v = h.input_mut().viewports.entry(egui::ViewportId::ROOT).or_default();
+            v.monitor_size = Some(egui::vec2(1366.0, 768.0));
+            v.inner_rect = None;
+            v.outer_rect = None;
+            v.maximized = Some(false);
+            h.run_steps(3);
+            let bottom = 768.0 - crate::work_area::TASKBAR;
+            let what = format!("{scale}x {top}");
+            open(&mut h, top);
+            for r in popups(&h) {
+                assert!(r.bottom() <= bottom + 0.5, "{what}: popup {r:?} runs under the panel (from {bottom})");
+            }
+            check_bar_clear(&h, &what);
+            let last = rows(&h, 0).len() - 1;
+            let in_view = |h: &Harness<'static, PhotocraftApp>| {
+                let nav = Nav::current(&h.ctx);
+                nav.views[0].expand(0.5).contains_rect(nav.rows[0][last].rect) && nav.views[0].bottom() <= bottom + 0.5
+            };
+            let view = Nav::current(&h.ctx).views[0];
+            h.hover_at(view.center());
+            for _ in 0..80 {
+                if in_view(&h) {
+                    break;
+                }
+                h.event(egui::Event::MouseWheel {
+                    unit: egui::MouseWheelUnit::Point,
+                    delta: egui::vec2(0.0, -60.0),
+                    modifiers: egui::Modifiers::NONE,
+                    phase: egui::TouchPhase::Move,
+                });
+                h.run_steps(2);
+            }
+            assert!(in_view(&h), "{what}: the wheel reaches the last row, above the panel");
+        }
+    }
+}
+
 fn app() -> PhotocraftApp {
     let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
     app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
@@ -517,9 +563,61 @@ fn submenus_stay_above_the_taskbar() {
     }
 }
 
+/// #3737 on X11 (Linux Mint, 1920 × 1080 px): the window manager maximized the window to the whole
+/// monitor without keeping it clear of the bottom panel, so the window's position is known but the
+/// panel covers its bottom. At 1× and at a 150% UI scale (1280 × 720 pt).
+fn maximized_under_a_panel(scale: f32) -> Harness<'static, PhotocraftApp> {
+    let size = egui::vec2(1920.0, 1080.0) / scale;
+    let mut h = harness((1920.0, 1080.0, scale));
+    let v = h.input_mut().viewports.entry(egui::ViewportId::ROOT).or_default();
+    v.monitor_size = Some(size);
+    v.inner_rect = Some(egui::Rect::from_min_size(egui::pos2(0.0, 0.0), size));
+    v.maximized = Some(true);
+    h.run_steps(3);
+    h
+}
+
+#[test]
+fn menus_of_a_maximized_window_stay_above_a_panel_it_runs_under() {
+    let mut scrolled = 0;
+    for scale in [1.0_f32, 1.5] {
+        for menu in LONGEST.iter().copied().chain(["View", "Window"]) {
+            let mut h = maximized_under_a_panel(scale);
+            let bottom = taskbar_bottom(&h);
+            let what = format!("{scale}x {menu}");
+            assert!((bottom - (1080.0 / scale - crate::work_area::TASKBAR)).abs() < 1.0, "{what}: visible bottom {bottom}");
+            open(&mut h, menu);
+            for r in popups(&h) {
+                assert!(r.bottom() <= bottom + 0.5, "{what}: popup {r:?} runs under the panel (from {bottom})");
+            }
+            let last = rows(&h, 0).len() - 1;
+            let in_view = |h: &Harness<'static, PhotocraftApp>| {
+                let nav = Nav::current(&h.ctx);
+                nav.views[0].expand(0.5).contains_rect(nav.rows[0][last].rect) && nav.views[0].bottom() <= bottom + 0.5
+            };
+            let Some(down) = h.query_by_label("Scroll menu down").map(|n| n.rect()) else {
+                assert!(in_view(&h), "{what}: fits, so its last row is in view");
+                continue;
+            };
+            scrolled += 1;
+            assert!(down.bottom() <= bottom, "{what}: ▼ at {down:?} is under the panel");
+            h.hover_at(down.center());
+            for _ in 0..400 {
+                h.run_steps(1);
+                if in_view(&h) {
+                    break;
+                }
+            }
+            assert!(in_view(&h), "{what}: ▼ scrolls to the last row, above the panel");
+        }
+    }
+    assert!(scrolled >= 3, "at 150% the long menus overflow above the panel: {scrolled}");
+}
+
 #[test]
 fn a_maximized_window_or_an_unknown_monitor_uses_the_whole_window() {
-    let mut h = taskbar_harness((1366.0, 728.0), 0.0, 1.0);
+    // Maximized inside the work area (the window manager kept it clear of the taskbar).
+    let mut h = taskbar_harness((1366.0, 720.0), 0.0, 1.0);
     h.input_mut().viewports.entry(egui::ViewportId::ROOT).or_default().maximized = Some(true);
     h.run_steps(2);
     assert_eq!(crate::work_area::visible_rect(&h.ctx), h.ctx.content_rect());
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index 1817cf1c42..403994ac10 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -89,6 +89,8 @@ pub const UI_COMMANDS: &[(&str, &str, &[&str], Option<&str>)] = &[
     ("window.theme.adwaitaDark", "Adwaita Dark Theme", &["Window", "Theme"], None),
     ("window.theme.breezeLight", "Breeze Light Theme", &["Window", "Theme"], None),
     ("window.theme.breezeDark", "Breeze Dark Theme", &["Window", "Theme"], None),
+    ("window.theme.softLight", "Soft Light Theme", &["Window", "Theme"], None),
+    ("window.theme.softDark", "Soft Dark Theme", &["Window", "Theme"], None),
     ("window.theme.system", "Sync with system", &["Window", "Theme"], None),
     ("edit.search", "Search…", &["Edit"], Some("Cmd+F")),
     ("help.discord", "Join the ArtCraft Discord…", &["Help"], None),
@@ -161,12 +163,20 @@ pub fn invoke(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, params: Va
 
 /// [`invoke`] without the unsaved-changes prompt, for once the user has already answered it.
 pub(crate) fn invoke_unguarded(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, params: Value) -> Result<Value, String> {
+    if let Some(tool) = crate::tool_shortcuts::tool(id) {
+        app.ui.tool = tool;
+        return Ok(json!({"tool": tool}));
+    }
     if id == "ui.symmetryTransform" {
         return crate::symmetry_ui::begin(app).map(|_| Value::Null);
     }
     if let Some(r) = crate::tool_reset::invoke(app, id, &params) {
         return r;
     }
+    // A filter on a type layer asks to rasterize it first (#4303).
+    if let Some(r) = crate::rasterize_prompt::intercept_filter(app, id, &params) {
+        return r;
+    }
     // A pending Pen anchor is gesture state; Edit › Undo must match the keyboard.
     if id == "edit.undo" && crate::vector_ui::pen_undo_last_point(app) {
         return Ok(Value::Null);
@@ -292,15 +302,32 @@ pub(crate) fn invoke_unguarded(app: &mut PhotocraftApp, ctx: &egui::Context, id:
                 app.open_dialog_file()
             }
         }
+        "file.import.videoFramesToLayers" if params.get("path").and_then(Value::as_str).is_none() => {
+            app.ask_folder(|app, path| app.run("file.import.videoFramesToLayers", json!({"path": path})).map_err(|e| e.to_string()))
+        }
         "file.save" => {
-            // Writes back only to a layered file; a flat one goes through Save As.
+            // Writes back only to a layered file that holds the whole document; anything else
+            // goes through Save As, so the original is never overwritten with less (#3806).
             let tga_bits = crate::targa_options_ui::bits_param(&params, id)?;
             match params.get("path").and_then(Value::as_str) {
                 Some(path) => app.save_as_with(Some(path.to_string()), tga_bits),
-                None => match app.session.active().and_then(|d| d.path.clone()).filter(|p| photocraft_engine::file_cmds::saves_in_place(p)) {
-                    Some(path) => app.save_in_place(path),
-                    None => app.save_as_with(None, tga_bits),
-                },
+                None => {
+                    let own = app.session.active().and_then(|d| d.path.clone().map(|p| (photocraft_engine::file_cmds::holds_at(&d.doc, &p), p, d)));
+                    match own {
+                        Some((true, path, _)) => app.save_in_place(path),
+                        Some((false, path, d)) if photocraft_engine::file_cmds::saves_in_place(&path) => {
+                            // Its own file is layered but can't hold what the document has now.
+                            let losses = photocraft_engine::file_cmds::losses_at(&d.doc, &path);
+                            let name = crate::file_open::display_name(&path);
+                            let title = crate::i18n::fmt(tl!("{name} can't keep everything in this document"), &[("name", name.as_str())]);
+                            let mut lines = losses;
+                            lines.push(tl!("Choose a format that keeps it, such as Photoshop (PSD), or save a copy.").to_string());
+                            crate::notices::post(app, title, lines, false, None);
+                            app.save_as_with(None, tga_bits)
+                        }
+                        _ => app.save_as_with(None, tga_bits),
+                    }
+                }
             }
         }
         "file.exit" => {
@@ -340,7 +367,7 @@ pub(crate) fn invoke_unguarded(app: &mut PhotocraftApp, ctx: &egui::Context, id:
             let doc = app.session.active_index().ok_or("no document")?;
             let wid = app.ui.alloc_id();
             let view = app.ui.views[doc].clone();
-            app.ui.windows.push(crate::state::DocWindow { id: wid, document: doc, view, open: true });
+            app.ui.windows.push(crate::state::DocWindow { id: wid, document: doc, view, open: true, position: None });
             Ok(json!({"window": wid}))
         }
         "window.theme.toggle" => {
@@ -363,7 +390,9 @@ pub(crate) fn invoke_unguarded(app: &mut PhotocraftApp, ctx: &egui::Context, id:
         | "window.theme.adwaita"
         | "window.theme.adwaitaDark"
         | "window.theme.breezeLight"
-        | "window.theme.breezeDark" => {
+        | "window.theme.breezeDark"
+        | "window.theme.softLight"
+        | "window.theme.softDark" => {
             let k = crate::theme::ThemeKind::from_name(&id["window.theme.".len()..]).unwrap_or_default();
             app.set_theme(ctx, k);
             Ok(Value::Null)
@@ -393,6 +422,11 @@ pub(crate) fn invoke_unguarded(app: &mut PhotocraftApp, ctx: &egui::Context, id:
         l if matches!(l, "layer.exportAs" | "layer.quickExportAsPng") && params.as_object().is_none_or(|o| o.is_empty()) => {
             let layer = app.session.active().and_then(|d| d.active_layer).ok_or("no active layer")?;
             if l == "layer.exportAs" {
+                // Several layers (artboards, say) selected: one file each (#3629).
+                let layers = app.session.active().map(|d| d.selected_layers()).unwrap_or_default();
+                if layers.len() > 1 {
+                    return Ok(json!({"dialog": crate::export_dialog::open_layers(app, &layers)?}));
+                }
                 Ok(json!({"dialog": crate::export_dialog::open_layer(app, layer)?}))
             } else {
                 crate::export_dialog::quick_export_selected_layers_png(app)
@@ -453,6 +487,23 @@ pub(crate) fn invoke_unguarded(app: &mut PhotocraftApp, ctx: &egui::Context, id:
             }
             Ok(json!({"dialog": crate::stroke_ui::open(app)}))
         }
+        // Channels › Channel Options… without params: the dialog on the targeted alpha/spot
+        // channel, or Quick Mask Options while in Quick Mask (with params: the engine directly).
+        crate::channel_options_ui::COMMAND if params.as_object().is_none_or(|o| o.is_empty()) => {
+            let st = app.session.active().ok_or("no document is open")?;
+            let channel = match st.channel_view.target {
+                _ if st.doc.quick_mask.is_some() => json!("quickMask"),
+                photocraft_engine::channel_cmds::ChannelTarget::Alpha(i) => json!(i),
+                _ => return Err("target an alpha or spot channel first".into()),
+            };
+            let dialog = crate::channel_options_ui::open(app, &channel).ok_or("no such channel")?;
+            Ok(json!({"dialog": dialog}))
+        }
+        // Channels › New Spot Channel… without params: its dialog (with params: the engine).
+        crate::channel_options_ui::NEW_SPOT if params.as_object().is_none_or(|o| o.is_empty()) => {
+            let dialog = crate::channel_options_ui::open_new_spot(app).ok_or("no document is open")?;
+            Ok(json!({"dialog": dialog}))
+        }
         // Photoshop's "Select and Mask…" is the engine's select.refineEdge.
         // Select › Color Range… from the menu: the dialog (with params: the engine directly).
         "select.colorRange" if params.as_object().is_none_or(|o| o.is_empty()) => Ok(json!({"dialog": crate::color_range_ui::open(app)})),
@@ -648,6 +699,9 @@ fn open_path(app: &mut PhotocraftApp, path: &str) -> Result<Value, String> {
 }
 
 pub fn is_enabled(app: &PhotocraftApp, id: &str) -> bool {
+    if crate::tool_shortcuts::tool(id).is_some() {
+        return true;
+    }
     if id == "ui.symmetryTransform" {
         return crate::symmetry_ui::can_transform(app);
     }
@@ -663,6 +717,10 @@ pub fn is_enabled(app: &PhotocraftApp, id: &str) -> bool {
     if crate::crop_ui::blocks(app, id) {
         return false;
     }
+    // Filters stay live on a type layer: choosing one asks to rasterize it (#4303).
+    if crate::rasterize_prompt::filter_needs(app, id).is_some() {
+        return true;
+    }
     if let Some(e) = crate::workspace_ui::is_enabled(app, id) {
         return e;
     }
@@ -874,6 +932,7 @@ pub struct MenuItem {
 pub fn is_live(id: &str) -> bool {
     static UI_IDS: std::sync::OnceLock<std::collections::HashSet<&'static str>> = std::sync::OnceLock::new();
     photocraft_engine::commands::find(id).is_some()
+        || crate::tool_shortcuts::tool(id).is_some()
         || UI_IDS.get_or_init(|| UI_COMMANDS.iter().map(|c| c.0).collect()).contains(id)
         || panel_alias(id).is_some()
         || workspace_name(id).is_some()
@@ -958,6 +1017,14 @@ pub fn menu_items(app: &PhotocraftApp) -> Vec<MenuItem> {
     {
         item.label = crate::layer_menu_ui::mask_toggle_label(mask.enabled).into();
     }
+    // Layer › Merge Layers reads Merge Group with just a group selected, as in Photoshop (#3832).
+    if let Some(st) = app.session.active()
+        && st.selected_layers().len() <= 1
+        && st.active_layer.and_then(|id| st.doc.layer(id)).is_some_and(|l| matches!(l.content, photocraft_doc::LayerContent::Group(_)))
+        && let Some(item) = items.iter_mut().find(|i| i.id == "layer.mergeLayers")
+    {
+        item.label = "Merge Group".into();
+    }
     // The File quick-export command uses the format selected in Export Preferences.
     // On the web it intentionally downloads PNG until the quick-export service supports
     // the other formats; the Layer quick-export command also always produces PNG.
@@ -1051,6 +1118,17 @@ pub fn menu_items(app: &PhotocraftApp) -> Vec<MenuItem> {
             it.color = prefs.menus.colors.get(&it.id).cloned();
         }
     }
+    // Layer › Create Clipping Mask is Photoshop's one Create / Release item: when its shortcut
+    // would release ([`crate::shortcut_dispatch::clip_key_releases`]) it reads Release Clipping
+    // Mask and runs it, keeping that shortcut. The engine's own Release item lives in that slot.
+    items.retain(|i| i.id != "layer.releaseClippingMask");
+    if crate::shortcut_dispatch::clip_key_releases(app)
+        && let Some(item) = items.iter_mut().find(|i| i.id == "layer.createClippingMask")
+    {
+        item.id = "layer.releaseClippingMask".into();
+        item.label = "Release Clipping Mask".into();
+        item.enabled = is_enabled(app, &item.id);
+    }
     items
 }
 
diff --git a/crates/ui-egui/src/move_auto_select_tests.rs b/crates/ui-egui/src/move_auto_select_tests.rs
index 10dc5532f9..0f01222a57 100644
--- a/crates/ui-egui/src/move_auto_select_tests.rs
+++ b/crates/ui-egui/src/move_auto_select_tests.rs
@@ -51,10 +51,10 @@ fn drag(app: &mut PhotocraftApp, from: [f64; 2], by: [f64; 2], mods: egui::Modif
 }
 
 #[test]
-fn auto_select_is_on_by_default_with_the_layer_target() {
+fn auto_select_is_on_by_default_with_the_group_target() {
     let o = ToolOptions::default();
     assert!(o.move_auto_select, "Photoshop ships with Auto-Select checked");
-    assert_eq!(o.move_target, "layer");
+    assert_eq!(o.move_target, "group", "Photoshop defaults Auto-Select to Group (#4056)");
     // A saved tool preset that predates the option gets the default too.
     let mut v = serde_json::to_value(&o).unwrap();
     v.as_object_mut().unwrap().remove("move_auto_select");
@@ -182,3 +182,31 @@ fn every_theme_shows_the_type_options() {
         assert!(combos.iter().any(|c| c.contains(&font)), "{theme:?}: the font picker shows {font:?}; combo boxes: {combos:?}");
     }
 }
+
+#[test]
+fn every_theme_shows_the_gradient_options() {
+    // #3601: the Studio themes' options bar was only the hint "Drag to draw a gradient", with no
+    // mode, style, blend mode or opacity control.
+    use egui_kittest::Harness;
+    use egui_kittest::kittest::{NodeT, Queryable};
+    for theme in crate::theme::ThemeKind::ALL {
+        let (mut app, _, _) = app();
+        app.ui.tool = Tool::Gradient;
+        let mut h = Harness::builder().with_size(egui::vec2(1600.0, 60.0)).build_ui_state(
+            |ui, app: &mut PhotocraftApp| {
+                if !ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                    return;
+                }
+                crate::panels::options_bar(app, ui);
+            },
+            app,
+        );
+        PhotocraftApp::setup_context(&h.ctx, theme);
+        h.run_steps(4);
+        let combos: Vec<String> = h
+            .query_all_by_role(egui::accesskit::Role::ComboBox)
+            .map(|n| format!("{:?} {:?}", n.accesskit_node().label(), n.accesskit_node().value()))
+            .collect();
+        assert!(combos.iter().any(|c| c.contains("Normal")), "{theme:?}: the blend mode picker shows; combo boxes: {combos:?}");
+    }
+}
diff --git a/crates/ui-egui/src/move_box.rs b/crates/ui-egui/src/move_box.rs
index f826992a33..ccbfd9cb4f 100644
--- a/crates/ui-egui/src/move_box.rs
+++ b/crates/ui-egui/src/move_box.rs
@@ -114,4 +114,24 @@ mod tests {
         sel.sort_unstable_by_key(|l| l.0);
         assert_eq!(sel, ids);
     }
+
+    /// #4058: a drag that starts on the locked Background draws the layer marquee. It does not
+    /// open the move-lock dialog, and releasing selects the unlocked layer the box touches.
+    #[test]
+    fn a_drag_on_the_locked_background_selects_instead_of_erroring() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 80, "height": 60})).unwrap();
+        app.sync_views();
+        app.run("layer.new.layer", json!({})).unwrap();
+        app.run("select.rect", json!({"x": 40, "y": 8, "width": 16, "height": 16})).unwrap();
+        app.run("edit.fill", json!({"color": "#ff0000"})).unwrap();
+        app.run("select.deselect", json!({})).unwrap();
+        let paint = app.session.active().unwrap().active_layer.unwrap();
+        app.ui.tool = Tool::Move;
+        app.ui.tool_options.move_auto_select = true;
+        drag(&mut app, [8.0, 8.0], [50.0, 20.0], egui::Modifiers::NONE);
+        assert!(app.ui.dialogs.iter().all(|d| d.kind != crate::state::DialogKind::Error), "no lock dialog");
+        assert!(app.layer_box.is_none());
+        assert_eq!(app.session.active().unwrap().selected_layers(), vec![paint]);
+    }
 }
diff --git a/crates/ui-egui/src/move_hover.rs b/crates/ui-egui/src/move_hover.rs
index 01e6a40f3a..0db1a5c80d 100644
--- a/crates/ui-egui/src/move_hover.rs
+++ b/crates/ui-egui/src/move_hover.rs
@@ -19,6 +19,7 @@ pub(crate) struct Hover {
     revision: u64,
     at: [i32; 2],
     group: bool,
+    target_layer: Option<LayerId>,
     bounds: Option<Rect>,
 }
 
@@ -36,18 +37,26 @@ pub(crate) fn target(app: &mut PhotocraftApp, at: Option<[f64; 2]>, command: boo
         || app.ui.tool_options.move_auto_select == command
         || crate::move_ui::moves_selected_pixels_with(app, Tool::Move)
     {
+        app.canvas_hover_layer = None;
         return None;
     }
-    let at = at.filter(|p| p[0].is_finite() && p[1].is_finite())?;
+    let Some(at) = at.filter(|p| p[0].is_finite() && p[1].is_finite()) else {
+        app.canvas_hover_layer = None;
+        return None;
+    };
     let at = [at[0].floor() as i32, at[1].floor() as i32];
     let group = app.ui.tool_options.move_target == "group";
     let st = app.session.active()?;
     let (doc, revision) = (st.doc.id, st.revision);
     if let Some(h) = app.move_hover.as_ref().filter(|h| h.doc == doc && h.revision == revision && h.at == at && h.group == group) {
+        app.canvas_hover_layer = h.target_layer;
         return h.bounds;
     }
-    let bounds = photocraft_engine::pick_cmds::auto_select_target(&st.doc, at[0], at[1], group).and_then(|id| outline(&st.doc, id));
-    app.move_hover = Some(Hover { doc, revision, at, group, bounds });
+    let target_layer = photocraft_engine::pick_cmds::auto_select_target(&st.doc, at[0], at[1], group);
+    let bounds = target_layer.and_then(|id| outline(&st.doc, id));
+    let target_layer = if bounds.is_some() { target_layer } else { None };
+    app.move_hover = Some(Hover { doc, revision, at, group, target_layer, bounds });
+    app.canvas_hover_layer = target_layer;
     bounds
 }
 
@@ -79,15 +88,39 @@ fn bounds(doc: &Document, l: &Layer) -> Rect {
     }
 }
 
+/// The document-space bounds to outline: either a layer hovered in the Layers panel, or what a
+/// click at `at` would pick with the Move tool.
+pub(crate) fn active_outline(app: &mut PhotocraftApp, at: Option<[f64; 2]>, command: bool, pressed: bool) -> Option<Rect> {
+    if !app.session.prefs().tools.show_highlight_on_rollover {
+        app.canvas_hover_layer = None;
+        return None;
+    }
+    // A layer hovered in the Layers panel takes precedence over canvas rollover.
+    if let Some(id) = app.hover_layer
+        && app.drag.is_none()
+        && app.guide_drag.is_none()
+        && app.ui.transform.is_none()
+        && let Some(st) = app.session.active()
+    {
+        return outline(&st.doc, id);
+    }
+    target(app, at, command, pressed)
+}
+
 /// Draws the highlight on the active document's canvas, in the theme's accent colour.
 pub(crate) fn draw(app: &mut PhotocraftApp, painter: &egui::Painter, xf: &ViewXform, idx: usize, hover: Option<Pos2>) {
     if app.session.active_index() != Some(idx) {
         return;
     }
+    let prev_canvas_hover = app.canvas_hover_layer;
     let (mods, pressed) = painter.ctx().input(|i| (i.modifiers, i.pointer.any_down()));
     let command = crate::workspace_ui::sticky_mods(app, mods).command;
     let at = hover.map(|p| xf.to_doc(p));
-    let Some(b) = target(app, at, command, pressed) else { return };
+    let outline_rect = active_outline(app, at, command, pressed);
+    if app.canvas_hover_layer != prev_canvas_hover {
+        painter.ctx().request_repaint();
+    }
+    let Some(b) = outline_rect else { return };
     let accent = crate::theme::Tokens::get(painter.ctx()).accent;
     painter.rect_stroke(xf.doc_rect(b), 0.0, Stroke::new(1.5, accent), egui::StrokeKind::Outside);
 }
@@ -125,4 +158,57 @@ mod tests {
         app.session.edit_prefs(|p| p.tools.show_highlight_on_rollover = false);
         assert_eq!(target(&mut app, Some([10.5, 12.0]), true, false), None);
     }
+
+    #[test]
+    fn layer_panel_hover_outlines_layer_on_canvas() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.session.execute("file.new", json!({"width": 64, "height": 64})).unwrap();
+        app.session.execute("layer.new.layer", json!({})).unwrap();
+        app.session
+            .edit("paint", |doc, a| {
+                doc.layer_mut(a.unwrap()).unwrap().surface_mut().unwrap().fill_rect(Rect::new(8, 8, 24, 24), &[1.0, 0.0, 0.0, 1.0]);
+                Ok(())
+            })
+            .unwrap();
+        let target_layer = app.session.active().unwrap().active_layer.unwrap();
+        let a = Rect::new(8, 8, 24, 24);
+
+        // Even with a different tool (e.g. Brush) and no canvas hover, hovering the layer in the panel outlines it:
+        app.ui.tool = Tool::Brush;
+        assert_eq!(active_outline(&mut app, None, false, false), None);
+        app.hover_layer = Some(target_layer);
+        assert_eq!(active_outline(&mut app, None, false, false), Some(a));
+
+        // When a drag or transform is in progress, no outline:
+        app.guide_drag = Some(crate::rulers::GuideDrag { vertical: false, index: None, pos: 10.0 });
+        assert_eq!(active_outline(&mut app, None, false, false), None);
+        app.guide_drag = None;
+
+        // When rollover preference is disabled, no outline:
+        app.session.edit_prefs(|p| p.tools.show_highlight_on_rollover = false);
+        assert_eq!(active_outline(&mut app, None, false, false), None);
+    }
+
+    #[test]
+    fn canvas_hover_sets_canvas_hover_layer() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.session.execute("file.new", json!({"width": 64, "height": 64})).unwrap();
+        app.session.execute("layer.new.layer", json!({})).unwrap();
+        app.session
+            .edit("paint", |doc, a| {
+                doc.layer_mut(a.unwrap()).unwrap().surface_mut().unwrap().fill_rect(Rect::new(8, 8, 24, 24), &[1.0, 0.0, 0.0, 1.0]);
+                Ok(())
+            })
+            .unwrap();
+        let target_layer = app.session.active().unwrap().active_layer.unwrap();
+        app.ui.tool = Tool::Move;
+
+        // Hovering over painted layer sets canvas_hover_layer:
+        assert!(target(&mut app, Some([10.5, 12.0]), false, false).is_some());
+        assert_eq!(app.canvas_hover_layer, Some(target_layer));
+
+        // Hovering empty area clears canvas_hover_layer:
+        assert!(target(&mut app, Some([40.0, 40.0]), false, false).is_none());
+        assert_eq!(app.canvas_hover_layer, None);
+    }
 }
diff --git a/crates/ui-egui/src/move_mods.rs b/crates/ui-egui/src/move_mods.rs
index 193a70bb50..a9e5eeb782 100644
--- a/crates/ui-egui/src/move_mods.rs
+++ b/crates/ui-egui/src/move_mods.rs
@@ -175,7 +175,7 @@ pub fn arrow_keys(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
     use egui::{Key, Modifiers};
     let cmd = ctx.input(|i| i.modifiers.command) && crate::hold_keys::cmd_nudges(app);
     if app.ui.tool != Tool::Move && app.ui.transform.is_none() && !cmd {
-        return selection_arrow_keys(app, ctx);
+        return selection_arrow_keys(app, ctx) || crate::direct_select::arrow_keys(app, ctx) || brush_arrow_keys(app, ctx);
     }
     // `consume_key` never ignores an extra ⌘, so it is part of every pattern while it moves.
     let base = if cmd { Modifiers::COMMAND } else { Modifiers::NONE };
@@ -193,6 +193,30 @@ pub fn arrow_keys(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
     false
 }
 
+/// ← / → with a painting tool: turn the brush tip 1° (⇧ 15°), as Photoshop does; → turns it
+/// clockwise. Returns true when a key was used.
+fn brush_arrow_keys(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
+    use egui::{Key, Modifiers};
+    // Only plain or ⇧ arrows (`consume_key` ignores an extra ⌥, which kerns type), and never
+    // while type is being edited.
+    let m = ctx.input(|i| i.modifiers);
+    if !app.ui.tool.is_brushlike() || app.ui.text_edit.is_some() || m.alt || m.command || m.ctrl {
+        return false;
+    }
+    for (key, sign) in [(Key::ArrowLeft, 1.0), (Key::ArrowRight, -1.0)] {
+        // ⇧ first: `consume_key` ignores an extra ⇧.
+        for (mods, step) in [(Modifiers::SHIFT, 15.0), (Modifiers::NONE, 1.0)] {
+            if ctx.input_mut(|i| i.consume_key(mods, key)) {
+                if let Err(e) = app.run("tools.rotateBrush", json!({"degrees": sign * step})) {
+                    app.ui.status = e;
+                }
+                return true;
+            }
+        }
+    }
+    false
+}
+
 /// Moves the selected layers (or the Free Transform box, or the selected pixels) by `(dx, dy)`
 /// pixels, as the Move tool (also when ⌘ makes it the temporary Move tool).
 pub fn nudge(app: &mut PhotocraftApp, dx: f64, dy: f64, duplicate_first: bool) {
@@ -404,6 +428,27 @@ mod tests {
         arrow_keys(app, &ctx)
     }
 
+    /// Photoshop's ← / → with a painting tool turn the brush tip 1°, ⇧ 15°; → is clockwise. Other
+    /// tools keep their arrows (the Hand has none, the marquee nudges the selection).
+    #[test]
+    fn arrows_turn_the_brush_tip_for_painting_tools_only() {
+        let mut app = app_with_layer();
+        for tool in [Tool::Brush, Tool::Eraser, Tool::CloneStamp] {
+            app.ui.tool = tool;
+            app.run("tools.setBrush", json!({"brush": {"angle": 0}})).unwrap();
+            assert!(press(&mut app, egui::Key::ArrowLeft, egui::Modifiers::NONE), "{tool:?}");
+            assert_eq!(app.session.tools.brush.angle, 1.0, "{tool:?}: ← anticlockwise");
+            assert!(press(&mut app, egui::Key::ArrowRight, egui::Modifiers::SHIFT));
+            assert_eq!(app.session.tools.brush.angle, -14.0, "{tool:?}: ⇧→ 15° clockwise");
+        }
+        app.run("tools.setBrush", json!({"brush": {"angle": 0}})).unwrap();
+        // ⌥-arrows are not the brush's (they kern type, and ⌘ moves).
+        assert!(!press(&mut app, egui::Key::ArrowLeft, egui::Modifiers::ALT));
+        app.ui.tool = Tool::Hand;
+        assert!(!press(&mut app, egui::Key::ArrowLeft, egui::Modifiers::NONE));
+        assert_eq!(app.session.tools.brush.angle, 0.0);
+    }
+
     /// Real key events: ⇧ nudges 10 px and ⌥ duplicates first (egui ignores extra ⇧ / ⌥ when
     /// matching, so the plain arrow must not be tried first).
     #[test]
@@ -433,8 +478,11 @@ mod tests {
         app.ui.tool = Tool::Brush;
         let id = app.session.active().unwrap().active_layer.unwrap();
         let n0 = app.session.active().unwrap().doc.layers.len();
-        assert!(!press(&mut app, egui::Key::ArrowRight, egui::Modifiers::NONE), "a plain arrow is not the Brush's");
+        // A plain arrow turns the Brush's tip (below), never the layer.
+        assert!(press(&mut app, egui::Key::ArrowRight, egui::Modifiers::NONE));
         assert_eq!(bounds(&app, id), photocraft_geom::Rect::new(8, 8, 24, 24));
+        assert_eq!(app.session.tools.brush.angle, -1.0);
+        app.run("tools.setBrush", json!({"brush": {"angle": 0}})).unwrap();
         for cmd in [CTRL, MAC_CMD] {
             assert!(press(&mut app, egui::Key::ArrowRight, cmd));
         }
diff --git a/crates/ui-egui/src/move_ui.rs b/crates/ui-egui/src/move_ui.rs
index c99c230384..fb49b02474 100644
--- a/crates/ui-egui/src/move_ui.rs
+++ b/crates/ui-egui/src/move_ui.rs
@@ -114,6 +114,7 @@ pub(crate) fn display_doc(app: &mut PhotocraftApp, idx: usize) -> Option<(Arc<Do
         app.move_preview = None;
         return None;
     };
+    let mask_target = app.layer_mask_targeted();
     let st = app.session.documents().get(idx)?;
     let (doc_id, revision, doc) = (st.doc.id, st.revision, st.doc.clone());
     let fresh = app.move_preview.as_ref().is_some_and(|p| p.doc == doc_id && p.revision == revision);
@@ -126,6 +127,7 @@ pub(crate) fn display_doc(app: &mut PhotocraftApp, idx: usize) -> Option<(Arc<Do
         let bounds = ids.iter().try_fold(Rect::EMPTY, |acc, id| Some(acc.union(&photocraft_compose::change_bounds(doc.layer(*id)?, all)?)));
         let canvas = doc.bounds();
         let moving = with_descendants(&doc, &ids);
+        let bounds = bounds.map(|b| moving.iter().filter_map(|id| shape_reach(doc.layer(*id)?, canvas)).fold(b, |acc, r| acc.union(&r)));
         app.move_preview = Some(MovePreview { doc: doc_id, revision, ids, moving, bounds, canvas, offsets: Vec::new(), shown: None, floating: false });
     }
     let p = app.move_preview.as_mut()?;
@@ -134,7 +136,7 @@ pub(crate) fn display_doc(app: &mut PhotocraftApp, idx: usize) -> Option<(Arc<Do
     }
     if p.offsets.last() != Some(&offset) {
         let t0 = crate::gpu_canvas::now_ms();
-        match photocraft_engine::layer_multi_cmds::moved(&doc, &p.ids, offset.0, offset.1) {
+        match photocraft_engine::layer_multi_cmds::moved_target(&doc, &p.ids, offset.0, offset.1, mask_target) {
             Ok(d) => {
                 // Duotone documents display through their inks.
                 let d = photocraft_engine::mode_cmds::display_document(&d).unwrap_or(d);
@@ -152,6 +154,15 @@ pub(crate) fn display_doc(app: &mut PhotocraftApp, idx: usize) -> Option<(Arc<Do
     Some((p.shown.clone()?, p.key()))
 }
 
+/// Where shape layer `l` paints, effects included, not cut at the canvas as its rendered pixels
+/// are: a drag brings the rest of it into view (#3946). `None` for other layers.
+fn shape_reach(l: &photocraft_doc::Layer, canvas: Rect) -> Option<Rect> {
+    let photocraft_doc::LayerContent::Shape(sh) = &l.content else { return None };
+    let b = photocraft_vector::CompiledShape::new(sh, photocraft_vector::DEFAULT_TOLERANCE, canvas).bounds()?;
+    let m = if photocraft_compose::effects::has_effects(l) { photocraft_compose::effects::margin(l) } else { 0 };
+    Some(b.inflate(m))
+}
+
 /// `ids` and every layer inside them (groups move their contents).
 fn with_descendants(doc: &Document, ids: &[LayerId]) -> Vec<LayerId> {
     let walk = doc.walk();
@@ -298,6 +309,69 @@ mod tests {
         assert_eq!(r, Rect::new(0, 0, 64, 64));
     }
 
+    /// A shape reaching past the canvas edge renders cut at the canvas, but its path goes on: a
+    /// drag frame must redraw where the rest of it was, or the cut edge stays behind (#3946).
+    #[test]
+    fn dragging_a_shape_past_the_canvas_edge_leaves_no_trail() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.session.execute("file.new", json!({"width": 64, "height": 64, "background": "transparent"})).unwrap();
+        app.sync_views();
+        let id = app.session.execute("shape.create", json!({"kind": "rect", "rect": [40, 16, 50, 32], "fill": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+        let id = photocraft_doc::LayerId(id);
+        app.ui.tool = Tool::Move;
+        app.ui.extras.snap = false;
+        app.ui.view.show.smart_guides = false;
+        let m = egui::Modifiers::NONE;
+        crate::canvas::tool_event(&mut app, ToolEvent::Down { x: 50.0, y: 32.0, pressure: 1.0 }, m);
+        let mut frames = Vec::new();
+        for x in [40.0, 10.0] {
+            crate::canvas::tool_event(&mut app, ToolEvent::Move { x, y: 32.0, pressure: 1.0 }, m);
+            frames.push(super::display_doc(&mut app, 0).unwrap());
+        }
+        let st = app.session.active().unwrap();
+        let r = super::damage(&app, st.doc.id, st.revision, frames[0].1, frames[1].1).unwrap();
+        let alpha = |d: &photocraft_doc::Document, x, y| d.layer(id).and_then(|l| l.surface()).map_or(0.0, |s| s.pixel(x, y)[3]);
+        for y in 0..64 {
+            for x in 0..64 {
+                if alpha(&frames[0].0, x, y) != alpha(&frames[1].0, x, y) {
+                    assert!(r.contains(x, y), "({x}, {y}) changed outside the redrawn {r:?}");
+                }
+            }
+        }
+    }
+
+    /// Dragging with an unlinked mask targeted moves the mask alone, shown live and committed;
+    /// with the mask linked (or the pixels targeted) the layer moves.
+    #[test]
+    fn dragging_with_an_unlinked_mask_targeted_moves_the_mask_alone() {
+        for (linked, mask_target) in [(false, true), (false, false), (true, true)] {
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            app.session.execute("file.new", json!({"width": 64, "height": 64, "background": "transparent"})).unwrap();
+            app.sync_views();
+            app.session.execute("layer.new.layer", json!({})).unwrap();
+            app.session.execute("select.rect", json!({"x": 8, "y": 8, "width": 16, "height": 16})).unwrap();
+            app.session.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+            app.session.execute("select.deselect", json!({})).unwrap();
+            app.session.execute("layer.layerMask.revealAll", json!({})).unwrap();
+            app.session.execute("layer.layerMask.linked", json!({"linked": linked})).unwrap();
+            app.ui.mask_target = mask_target;
+            app.ui.tool = Tool::Move;
+            app.ui.extras.snap = false;
+            app.ui.view.show.smart_guides = false;
+            let m = egui::Modifiers::NONE;
+            crate::canvas::tool_event(&mut app, ToolEvent::Down { x: 16.0, y: 16.0, pressure: 1.0 }, m);
+            crate::canvas::tool_event(&mut app, ToolEvent::Move { x: 36.0, y: 16.0, pressure: 1.0 }, m);
+            let shown = super::display_doc(&mut app, 0).unwrap().0;
+            let id = app.session.active().unwrap().active_layer.unwrap();
+            let layer_moved = |d: &photocraft_doc::Document| d.layer(id).and_then(|l| l.surface()).is_some_and(|s| s.pixel(28, 16)[3] > 0.5);
+            let alone = !linked && mask_target;
+            assert_eq!(layer_moved(&shown), !alone, "preview, linked {linked} mask target {mask_target}");
+            crate::canvas::tool_event(&mut app, ToolEvent::Up { x: 36.0, y: 16.0 }, m);
+            let d = &app.session.active().unwrap().doc;
+            assert_eq!(layer_moved(d), !alone, "commit, linked {linked} mask target {mask_target}");
+        }
+    }
+
     /// Mid-drag on a painted layer: is the layer shown at the pointer?
     fn live(outline: bool) -> bool {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
diff --git a/crates/ui-egui/src/navigator_gpu_tests.rs b/crates/ui-egui/src/navigator_gpu_tests.rs
new file mode 100644
index 0000000000..51326597f4
--- /dev/null
+++ b/crates/ui-egui/src/navigator_gpu_tests.rs
@@ -0,0 +1,75 @@
+//! The Navigator draws the GPU canvas's own texture while the canvas is on the GPU (#4518), so an
+//! edit costs it no CPU composite; elsewhere (a flipped view draws on the CPU) it keeps the CPU
+//! thumbnail. Renders the real app offscreen; skips without a GPU adapter.
+
+use crate::PhotocraftApp;
+use serde_json::json;
+
+type Harness = egui_kittest::Harness<'static, PhotocraftApp>;
+
+fn harness() -> Option<Harness> {
+    let built = std::panic::catch_unwind(|| {
+        egui_kittest::Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_pixels_per_point(1.0).with_max_steps(64).wgpu().build_eframe(|cc| {
+            PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            if let Some(rs) = cc.wgpu_render_state.as_ref() {
+                app.set_wgpu(rs.clone());
+            }
+            app.ui.panels.navigator = true;
+            app.run("file.new", json!({"width": 400, "height": 300, "background": "white"})).unwrap();
+            app.run("select.rect", json!({"x": 0, "y": 0, "width": 200, "height": 300})).unwrap();
+            app.run("edit.fill", json!({"color": "#ff0000"})).unwrap();
+            app.run("select.deselect", json!({})).unwrap();
+            app.sync_views();
+            app
+        })
+    });
+    match built {
+        Ok(h) => Some(h),
+        Err(_) => {
+            eprintln!("skipping: no GPU adapter");
+            None
+        }
+    }
+}
+
+/// The colour at fractions (`fx`, `fy`) of the Navigator preview.
+fn preview_px(h: &mut Harness, fx: f32, fy: f32) -> [u8; 4] {
+    let r = crate::panels::last_navigator_preview(&h.ctx).expect("navigator preview drawn");
+    let img = h.render().expect("render");
+    let (x, y) = ((r.left() + r.width() * fx) as u32, (r.top() + r.height() * fy) as u32);
+    img.get_pixel(x, y).0
+}
+
+fn near(a: [u8; 4], b: [u8; 3]) -> bool {
+    (0..3).all(|i| a[i].abs_diff(b[i]) <= 8)
+}
+
+#[test]
+fn navigator_draws_the_gpu_canvas_texture_and_follows_edits() {
+    let Some(mut h) = harness() else { return };
+    h.run_steps(8);
+    if !h.state().perf.gpu {
+        eprintln!("skipping: the canvas fell back to the CPU here");
+        return;
+    }
+    let id = h.state().session.active().expect("doc").doc.id;
+    assert!(h.state().navigator_gpu.contains_key(&id), "the Navigator uses the GPU canvas view");
+    assert!(!h.state().navigator_textures.contains_key(&id), "no CPU thumbnail was built");
+    assert!(near(preview_px(&mut h, 0.25, 0.5), [255, 0, 0]), "left half red");
+    assert!(near(preview_px(&mut h, 0.75, 0.5), [255, 255, 255]), "right half white");
+
+    // An edit shows in the Navigator, still without a CPU thumbnail.
+    h.state_mut().run("select.rect", json!({"x": 200, "y": 0, "width": 200, "height": 300})).unwrap();
+    h.state_mut().run("edit.fill", json!({"color": "#0000ff"})).unwrap();
+    h.run_steps(6);
+    assert!(near(preview_px(&mut h, 0.75, 0.5), [0, 0, 255]), "right half now blue");
+    assert!(!h.state().navigator_textures.contains_key(&id));
+
+    // A flipped view draws on the CPU: the Navigator goes back to its CPU thumbnail.
+    h.state_mut().ui.view.flip_horizontal = true;
+    h.run_steps(6);
+    assert!(!h.state().navigator_gpu.contains_key(&id), "no GPU view while the canvas draws on the CPU");
+    assert!(h.state().navigator_textures.contains_key(&id), "the CPU thumbnail again");
+    assert!(near(preview_px(&mut h, 0.25, 0.5), [255, 0, 0]) && near(preview_px(&mut h, 0.75, 0.5), [0, 0, 255]), "same picture, unflipped");
+}
diff --git a/crates/ui-egui/src/new_doc_ui.rs b/crates/ui-egui/src/new_doc_ui.rs
index e3f00c6c9c..c9bf902c67 100644
--- a/crates/ui-egui/src/new_doc_ui.rs
+++ b/crates/ui-egui/src/new_doc_ui.rs
@@ -38,6 +38,8 @@ pub const CATEGORIES: &[(&str, &[Preset])] = &[
             ("A4", 2480, 3508, 300.0),
             ("A3", 3508, 4961, 300.0),
             ("A5", 1748, 2480, 300.0),
+            ("B3", 4169, 5906, 300.0),
+            ("B4", 2953, 4169, 300.0),
         ],
     ),
     (
@@ -171,6 +173,33 @@ fn is_print(p: &Preset) -> bool {
     p.3 >= 300.0
 }
 
+/// A built-in preset turned to the orientation picked with the Orientation buttons (#4668), so the
+/// cards and what they apply follow it. Square presets and the Clipboard preset stay as they are.
+fn oriented(p: &Preset, f: &Map<String, Value>) -> Preset {
+    let portrait = match f.get("__orientation").and_then(Value::as_str) {
+        Some("portrait") => true,
+        Some("landscape") => false,
+        _ => return *p,
+    };
+    if p.0 == CLIPBOARD || p.1 == p.2 || (p.2 > p.1) == portrait {
+        return *p;
+    }
+    (p.0, p.2, p.1, p.3)
+}
+
+/// The unit a built-in preset shows and applies: a print preset in the physical unit picked for
+/// Width/Height (#4668), else in inches; a screen preset in pixels.
+fn preset_unit(p: &Preset, f: &Map<String, Value>) -> String {
+    let unit = get_s(f, "__unit", "px");
+    if !is_print(p) {
+        "px".into()
+    } else if unit != "px" && UNITS.iter().any(|u| u.0 == unit) {
+        unit
+    } else {
+        "in".into()
+    }
+}
+
 /// A built-in preset at Preferences › Units & Rulers › New Document Preset Resolutions, as in
 /// Photoshop: a print preset keeps its size in inches at the Print Resolution (Letter at 200 ppi is
 /// 1700 x 2200 px), a screen preset keeps its pixels at the Screen Resolution. The Clipboard preset
@@ -193,12 +222,13 @@ pub fn at_pref_resolutions(p: &Preset, units: &UnitsAndRulers) -> Preset {
 /// dialog fields.
 pub fn apply_preset(f: &mut Map<String, Value>, p: &Preset, units: &UnitsAndRulers) {
     let (name, w, h, ppi) = at_pref_resolutions(p, units);
+    let unit = preset_unit(p, f);
     f.remove("__savedPreset");
     f.insert("width".into(), json!(w));
     f.insert("height".into(), json!(h));
     f.insert("resolution".into(), json!(ppi));
     f.insert("__preset".into(), json!(name));
-    f.insert("__unit".into(), json!(if is_print(p) { "in" } else { "px" }));
+    f.insert("__unit".into(), json!(unit));
 }
 
 /// Fields `file.new` takes (drops the dialog's `__` UI keys).
@@ -255,6 +285,31 @@ fn page_icon(ui: &egui::Ui, r: Rect, w: u32, h: u32, t: &Tokens) {
     ui.painter().rect_stroke(page, 1.0, Stroke::new(1.2, t.text_dim), StrokeKind::Inside);
 }
 
+/// The Background Contents menu's entry for a colour of the user's own ([`body`]).
+const CUSTOM: &str = "custom";
+/// Side of the Background Contents colour swatch.
+const SWATCH: f32 = 22.0;
+
+/// The colour the new document's background starts with: white, black, the captured or current
+/// toolbox background colour, or a custom `"#rrggbb"`; `None` for Transparent.
+fn background_rgb(app: &crate::PhotocraftApp, f: &Map<String, Value>) -> Option<[f32; 3]> {
+    let bg = get_s(f, "background", "white");
+    match bg.as_str() {
+        "transparent" => None,
+        "black" => Some([0.0; 3]),
+        "backgroundColor" => Some(
+            f.get("backgroundColor")
+                .and_then(Value::as_array)
+                .and_then(|a| Some([a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32, a.get(2)?.as_f64()? as f32]))
+                .unwrap_or_else(|| {
+                    let b = app.session.tools.background;
+                    [b[0], b[1], b[2]]
+                }),
+        ),
+        hex => Some(crate::color_picker_ui::parse_hex(hex).unwrap_or([1.0; 3])),
+    }
+}
+
 /// Restore a snapshot without replacing the new document's name or its clipboard offer.
 pub fn apply_saved_preset(f: &mut Map<String, Value>, preset: &photocraft_engine::document_preset_cmds::DocumentPreset) {
     apply_settings(f, &preset.settings);
@@ -324,18 +379,17 @@ impl Card {
         }
     }
 
-    /// The size line, in the unit the preset is specified in (a recent one: the unit it was made in).
-    fn size_line(&self, units: &UnitsAndRulers) -> String {
+    /// The size line, in the unit the preset applies (a recent one: the unit it was made in).
+    fn size_line(&self, units: &UnitsAndRulers, f: &Map<String, Value>) -> String {
         let (w, h, ppi) = self.size(units);
         let unit = match self {
-            Card::Builtin(p) if is_print(p) => "in",
-            Card::Builtin(_) => "px",
-            Card::Recent(s) => s.unit.as_str(),
+            Card::Builtin(p) => preset_unit(p, f),
+            Card::Recent(s) => s.unit.clone(),
         };
         if unit == "px" {
             format!("{w} x {h} px @ {} ppi", widgets::fmt_num(f64::from(ppi)))
         } else {
-            let v = |n: u32| widgets::fmt_num(f64::from(to_unit(n as f32, unit, ppi)));
+            let v = |n: u32| widgets::fmt_num(f64::from(to_unit(n as f32, &unit, ppi)));
             format!("{} x {} {unit} @ {} ppi", v(w), v(h), widgets::fmt_num(f64::from(ppi)))
         }
     }
@@ -450,7 +504,9 @@ pub fn body(app: &mut crate::PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<Strin
         for name in CATEGORIES.iter().map(|c| c.0).chain(["Saved"]) {
             let on = cat == name;
             let label = if name == "Saved" { tl!("Saved") } else { tl!(name) };
-            let r = ui.add(egui::Label::new(RichText::new(label).size(13.0).color(if on { t.text } else { t.text_dim })).sense(Sense::click()));
+            let r = ui
+                .add(egui::Label::new(RichText::new(label).size(13.0).color(if on { t.text } else { t.text_dim })).selectable(false).sense(Sense::click()))
+                .on_hover_cursor(egui::CursorIcon::PointingHand);
             if on {
                 ui.painter().line_segment([r.rect.left_bottom() + vec2(0.0, 3.0), r.rect.right_bottom() + vec2(0.0, 3.0)], Stroke::new(2.0, t.text));
             }
@@ -467,6 +523,13 @@ pub fn body(app: &mut crate::PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<Strin
         Some(c) if c.0 != CATEGORIES[0].0 => c.1.iter().copied().map(Card::Builtin).collect(),
         _ => recent_cards(f, &app.session.presets.recent_documents, &units),
     };
+    let presets: Vec<Card> = presets
+        .into_iter()
+        .map(|c| match c {
+            Card::Builtin(p) => Card::Builtin(oriented(&p, f)),
+            recent => recent,
+        })
+        .collect();
     let chosen = get_s(f, "__preset", "");
     ui.horizontal_top(|ui| {
         // Left: preset grid.
@@ -509,7 +572,7 @@ pub fn body(app: &mut crate::PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<Strin
                             let title = card_title(ui.painter(), tl!(c.title()), card.x - 12.0, t.text);
                             let elided = title.elided;
                             ui.painter().galley(pos2(r.center().x, r.top() + 70.0 - title.size().y / 2.0), title, t.text);
-                            let size = c.size_line(&units);
+                            let size = c.size_line(&units, f);
                             ui.painter().text(pos2(r.center().x, r.top() + 97.0), Align2::CENTER_CENTER, &size, egui::FontId::proportional(10.5), t.text_faint);
                             let resp = match c {
                                 // A recent document's tooltip names everything it restores.
@@ -591,8 +654,12 @@ pub fn body(app: &mut crate::PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<Strin
                 let (w, h) = (get_f(f, "width", 1920.0), get_f(f, "height", 1080.0));
                 for (icon, portrait) in [("rectangle-vertical", true), ("rectangle-horizontal", false)] {
                     // Tooltip strings are looked up via `icons::button` → `tl!`; enum/state is aspect swap only.
-                    if icons::button(ui, icon, 24.0, (h > w) == portrait, if portrait { "Portrait" } else { "Landscape" }).clicked() && (h > w) != portrait {
-                        swap_size(f);
+                    if icons::button(ui, icon, 24.0, (h > w) == portrait, if portrait { "Portrait" } else { "Landscape" }).clicked() {
+                        // The pick also turns the presets (`oriented`), even when the size already has it.
+                        f.insert("__orientation".into(), json!(if portrait { "portrait" } else { "landscape" }));
+                        if (h > w) != portrait {
+                            swap_size(f);
+                        }
                     }
                 }
             });
@@ -639,19 +706,57 @@ pub fn body(app: &mut crate::PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<Strin
             });
             ui.add_space(4.0);
             small_label(ui, tl!("Background Contents"));
-            let mut bg = get_s(f, "background", "white");
+            // A custom colour is kept as its "#rrggbb", which `file.new` takes as is (#4789).
+            let current = get_s(f, "background", "white");
+            let mut bg = if crate::color_picker_ui::parse_hex(&current).is_some() { CUSTOM.to_string() } else { current.clone() };
             let opts = [
                 ("white".to_string(), tl!("White")),
                 ("black".to_string(), tl!("Black")),
                 ("backgroundColor".to_string(), tl!("Background Color")),
                 ("transparent".to_string(), tl!("Transparent")),
+                (CUSTOM.to_string(), tl!("Custom…")),
             ];
-            if widgets::dropdown(ui, "nd-bg", &mut bg, &opts, 240.0) {
-                f.insert("background".into(), json!(bg));
-                f.remove("__savedPreset");
-                // A fresh choice of Background Color uses today's toolbox colour. Selecting a
-                // saved preset instead restores the colour captured when it was saved.
+            let shown = background_rgb(app, f);
+            let mut pick = false;
+            ui.horizontal(|ui| {
+                if widgets::dropdown(ui, "nd-bg", &mut bg, &opts, 240.0 - SWATCH - 6.0) {
+                    if bg == CUSTOM {
+                        // Custom… opens the Color Picker on the colour shown so far.
+                        pick = true;
+                    } else {
+                        f.insert("background".into(), json!(bg));
+                    }
+                    f.remove("__savedPreset");
+                    // A fresh choice of Background Color uses today's toolbox colour. Selecting a
+                    // saved preset instead restores the colour captured when it was saved.
+                    f.remove("backgroundColor");
+                }
+                // Photoshop's swatch beside the menu: the colour the canvas starts with; a click
+                // opens the Color Picker, as Custom… does.
+                let (r, resp) = ui.allocate_exact_size(vec2(SWATCH, SWATCH), Sense::click());
+                match shown {
+                    Some(c) => {
+                        ui.painter().rect_filled(
+                            r,
+                            2.0,
+                            egui::Color32::from_rgb((c[0] * 255.0).round() as u8, (c[1] * 255.0).round() as u8, (c[2] * 255.0).round() as u8),
+                        );
+                    }
+                    None => widgets::checker(ui.painter(), r, 4.0),
+                }
+                ui.painter().rect_stroke(r, 2.0, Stroke::new(1.0, Tokens::get(ui.ctx()).field_border), StrokeKind::Inside);
+                let resp = resp.on_hover_text(tl!("Custom background color")).on_hover_cursor(egui::CursorIcon::PointingHand);
+                resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, tl!("Custom background color")));
+                if resp.clicked() {
+                    pick = true;
+                    f.remove("__savedPreset");
+                }
+            });
+            if pick {
+                let start = shown.unwrap_or([1.0; 3]);
+                f.insert("background".into(), json!(crate::color_picker_ui::hex(start)));
                 f.remove("backgroundColor");
+                crate::color_picker_ui::request_field(f, "background", &crate::color_picker_ui::title_for(tl!("Background Contents")));
             }
             save_preset(app, ui, f);
         });
@@ -724,6 +829,22 @@ mod tests {
 
     /// Units & Rulers › New Document Preset Resolutions: print presets keep their inches at the
     /// Print Resolution, screen presets keep their pixels at the Screen Resolution.
+    #[test]
+    fn iso_b_paper_presets_use_correct_dimensions_and_selected_units() {
+        let presets = CATEGORIES.iter().find(|c| c.0 == "Print").unwrap().1;
+        let mut f = crate::state::UiState::new_document_fields();
+        f.insert("__unit".into(), json!("mm"));
+        for (name, w, h) in [("B3", 4169, 5906), ("B4", 2953, 4169)] {
+            let preset = presets.iter().find(|p| p.0 == name).unwrap();
+            assert_eq!((preset.1, preset.2, preset.3), (w, h, 300.0));
+            assert_eq!(preset_unit(preset, &f), "mm");
+            apply_preset(&mut f, preset, &Default::default());
+            let params = command_params(&f);
+            assert_eq!((params["width"].as_u64(), params["height"].as_u64()), (Some(u64::from(w)), Some(u64::from(h))));
+            assert_eq!(params["resolution"], 300.0);
+        }
+    }
+
     #[test]
     fn presets_follow_the_preset_resolution_preferences() {
         let find = |cat: &str, name: &str| *CATEGORIES.iter().find(|c| c.0 == cat).unwrap().1.iter().find(|p| p.0 == name).unwrap();
@@ -774,9 +895,16 @@ mod tests {
 
     #[test]
     fn new_document_depth_labels_and_tooltips_are_translated() {
+        // Bit-depth labels are unit/number strings that some languages legitimately write exactly
+        // like the English source (Turkish and Italian "8 bit"); they only need a catalog entry there.
+        const SAME_AS_SOURCE: &[(&str, &str)] = &[("tr", "8 bit"), ("tr", "16 bit"), ("it", "8 bit"), ("it", "16 bit")];
         for lang in crate::i18n::Lang::all().filter(|lang| lang.code() != "en") {
             for (_, label, tooltip) in DEPTH_OPTIONS {
-                assert_ne!(crate::i18n::tr(lang, label), *label, "{}: {label}", lang.code());
+                if SAME_AS_SOURCE.contains(&(lang.code(), *label)) {
+                    assert!(crate::i18n::has(lang, label), "{}: {label}", lang.code());
+                } else {
+                    assert_ne!(crate::i18n::tr(lang, label), *label, "{}: {label}", lang.code());
+                }
                 assert_ne!(crate::i18n::tr(lang, tooltip), *tooltip, "{}: {tooltip}", lang.code());
             }
         }
@@ -798,7 +926,7 @@ mod tests {
         let mut f = Map::new();
         set_clipboard(&mut f, 20, 30);
         let cards = recent_cards(&f, &[settings(800, 600, 72.0), settings(1920, 1080, 72.0)], &UnitsAndRulers::default());
-        let titles: Vec<(&str, String)> = cards.iter().map(|c| (c.title(), c.size_line(&UnitsAndRulers::default()))).collect();
+        let titles: Vec<(&str, String)> = cards.iter().map(|c| (c.title(), c.size_line(&UnitsAndRulers::default(), &f))).collect();
         assert_eq!(
             titles,
             [
@@ -912,6 +1040,48 @@ mod tests {
             h
         }
 
+        /// #4789: the swatch beside Background Contents (and Custom…) opens the Color Picker; its
+        /// colour becomes the new document's background (kept as its "#rrggbb").
+        #[test]
+        fn a_custom_background_color_is_picked_and_used() {
+            let mut h = harness_with_store(&Arc::new(Mutex::new(None)));
+            let nd = h.state().ui.dialogs[0].id;
+            assert!(h.query_by_label("Custom background color").is_some());
+            h.get_by_label("Custom background color").click();
+            h.run_steps(3);
+            let picker = h
+                .state()
+                .ui
+                .dialogs
+                .iter()
+                .find(|d| d.fields.get("__dialog").and_then(serde_json::Value::as_u64) == Some(nd))
+                .map(|d| d.id)
+                .expect("the Color Picker opens over the dialog");
+            h.state_mut().ui.dialog_mut(picker).unwrap().fields.insert("color".into(), serde_json::json!("#336699"));
+            crate::dialogs::confirm(h.state_mut(), picker).unwrap();
+            h.run_steps(3);
+            let bg = h.state().ui.dialogs.iter().find(|d| d.id == nd).unwrap().fields["background"].clone();
+            assert_eq!(bg, "#336699");
+            crate::dialogs::confirm(h.state_mut(), nd).unwrap();
+            let doc = &h.state().session.active().unwrap().doc;
+            let px = photocraft_compose::flatten(doc).px[0];
+            assert!((px[0] * 255.0 - 51.0).abs() < 1.0 && (px[1] * 255.0 - 102.0).abs() < 1.0 && (px[2] * 255.0 - 153.0).abs() < 1.0, "{px:?}");
+        }
+
+        /// #4789: the swatch shows what each Background Contents choice paints, Background Color included.
+        #[test]
+        fn the_swatch_shows_each_background_choice() {
+            let mut h = harness_with_store(&Arc::new(Mutex::new(None)));
+            h.state_mut().run("tools.setColors", serde_json::json!({"foreground": "#000000", "background": "#336699"})).unwrap();
+            let rgb = |bg: &str| super::super::background_rgb(h.state(), serde_json::json!({ "background": bg }).as_object().unwrap());
+            assert_eq!(rgb("white"), Some([1.0; 3]));
+            assert_eq!(rgb("black"), Some([0.0; 3]));
+            assert_eq!(rgb("transparent"), None);
+            assert_eq!(rgb("#ff0000"), Some([1.0, 0.0, 0.0]));
+            let c = rgb("backgroundColor").expect("Background Color shows the toolbox colour");
+            assert!((c[0] * 255.0 - 51.0).abs() < 1.0 && (c[1] * 255.0 - 102.0).abs() < 1.0 && (c[2] * 255.0 - 153.0).abs() < 1.0, "{c:?}");
+        }
+
         fn name_preset(h: &mut Harness<'static, PhotocraftApp>, name: &str) {
             h.get_by_label("Save Preset…").click();
             h.run_steps(2);
@@ -1310,5 +1480,59 @@ mod tests {
             enter(&mut h);
             assert_eq!(created(&h), (256, 512, 72.0));
         }
+
+        /// #4668: once an orientation is picked, the presets turn to it, on the cards and when applied.
+        #[test]
+        fn picked_orientation_turns_the_presets() {
+            let mut h = harness();
+            h.get_by_label("Print").click();
+            h.run_steps(2);
+            // The default 1920 x 1080 is already landscape: Landscape swaps nothing, but is picked.
+            let label = h.get_by_label("Orientation").rect();
+            let gap = h.ctx.global_style().spacing.item_spacing.x;
+            click_at(&mut h, egui::pos2(label.right() + gap + 24.0 + gap + 12.0, label.center().y));
+            assert_eq!((fields(&h)["width"].as_u64(), fields(&h)["height"].as_u64()), (Some(1920), Some(1080)));
+            let _ = preset_title_at(&h, "11.7 x 8.3 in @ 300 ppi");
+            let at = preset_title_at(&h, "A4");
+            click_at(&mut h, at);
+            enter(&mut h);
+            assert_eq!(created(&h), (3508, 2480, 300.0));
+        }
+
+        /// #4668: a physical unit picked for Width/Height is the one print presets show and keep.
+        #[test]
+        fn picked_physical_unit_is_the_print_presets_unit() {
+            let mut h = harness();
+            let mut f = fields(&h);
+            f.insert("__unit".into(), serde_json::json!("mm"));
+            set_fields(&mut h, f);
+            h.get_by_label("Print").click();
+            h.run_steps(2);
+            let _ = preset_title_at(&h, "210 x 297 mm @ 300 ppi");
+            let at = preset_title_at(&h, "A4");
+            click_at(&mut h, at);
+            assert_eq!(fields(&h)["__unit"], "mm");
+            // Screen presets stay in pixels.
+            h.get_by_label("Web").click();
+            h.run_steps(2);
+            let _ = preset_title_at(&h, "1024 x 768 px @ 72 ppi");
+            enter(&mut h);
+            assert_eq!(created(&h), (2480, 3508, 300.0));
+        }
+
+        #[test]
+        fn hovering_preset_tabs_shows_pointing_hand_not_text_cursor() {
+            let mut h = harness();
+            for tab in ["Recent", "Saved", "Photo", "Print", "Art & Illustration", "Web", "Mobile", "Film & Video"] {
+                let rect = h.get_by_label(tab).rect();
+                h.hover_at(rect.center());
+                h.run_steps(2);
+                assert_eq!(
+                    h.output().platform_output.cursor_icon,
+                    egui::CursorIcon::PointingHand,
+                    "hovering preset tab {tab:?} must show PointingHand instead of text caret"
+                );
+            }
+        }
     }
 }
diff --git a/crates/ui-egui/src/new_layer_button_tests.rs b/crates/ui-egui/src/new_layer_button_tests.rs
index 350ab7ebae..a01196a335 100644
--- a/crates/ui-egui/src/new_layer_button_tests.rs
+++ b/crates/ui-egui/src/new_layer_button_tests.rs
@@ -1,5 +1,6 @@
 //! The Layers panel New Layer button: a click makes a layer at once, ⌥-click opens the New Layer
-//! dialog first, as in Photoshop.
+//! dialog first, as in Photoshop. Its shortcut is the same pair the other way round: ⇧⌘N asks
+//! first, ⌥⇧⌘N makes the layer at once (#4794).
 
 use egui::Modifiers;
 use egui_kittest::kittest::Queryable;
@@ -41,3 +42,46 @@ fn alt_click_opens_the_new_layer_dialog() {
     crate::dialogs::confirm(h.state_mut(), id).unwrap();
     assert_eq!(layers(&h), 2);
 }
+
+fn dialog_open(h: &egui_kittest::Harness<'static, PhotocraftApp>) -> bool {
+    h.state().ui.dialogs.iter().any(|d| crate::new_layer_ui::owns(&d.fields))
+}
+
+#[test]
+fn shortcut_asks_first_and_alt_shortcut_makes_a_layer_at_once() {
+    let mut h = panel();
+    h.key_press_modifiers(Modifiers::COMMAND | Modifiers::SHIFT, egui::Key::N);
+    h.run_steps(4);
+    assert_eq!(layers(&h), 1, "⇧⌘N asks first");
+    assert!(dialog_open(&h), "the New Layer dialog");
+
+    let mut h = panel();
+    h.key_press_modifiers(Modifiers::COMMAND | Modifiers::SHIFT | Modifiers::ALT, egui::Key::N);
+    h.run_steps(4);
+    assert_eq!(layers(&h), 2, "⌥⇧⌘N makes the layer");
+    assert!(!dialog_open(&h));
+    h.key_press_modifiers(Modifiers::COMMAND | Modifiers::SHIFT | Modifiers::ALT, egui::Key::N);
+    h.run_steps(4);
+    assert_eq!(layers(&h), 3, "once per press");
+}
+
+#[test]
+fn alt_shortcut_follows_a_custom_new_layer_shortcut_and_yields_to_a_bound_command() {
+    // Rebound to F2: ⌥F2 makes the layer at once.
+    let mut h = panel();
+    h.state_mut().session.prefs.edit(|p| p.shortcuts.insert("layer.new.layer".into(), "F2".into()));
+    h.key_press_modifiers(Modifiers::ALT, egui::Key::F2);
+    h.run_steps(4);
+    assert_eq!(layers(&h), 2);
+    assert!(!dialog_open(&h));
+    // A command bound to ⌥⇧⌘N itself keeps the key.
+    let mut h = panel();
+    h.state_mut().session.prefs.edit(|p| p.shortcuts.insert("layer.new.layerViaCopy".into(), "Cmd+Alt+Shift+N".into()));
+    h.key_press_modifiers(Modifiers::COMMAND | Modifiers::SHIFT | Modifiers::ALT, egui::Key::N);
+    h.run_steps(4);
+    assert_eq!(layers(&h), 2);
+    assert!(!dialog_open(&h));
+    let doc = &h.state().session.active().unwrap().doc;
+    let top = doc.layers.last().unwrap().surface().unwrap();
+    assert!(!top.content_bounds().is_empty(), "Layer via Copy ran (the white background copied), not New Layer");
+}
diff --git a/crates/ui-egui/src/object_finder.rs b/crates/ui-egui/src/object_finder.rs
new file mode 100644
index 0000000000..e219b0ddff
--- /dev/null
+++ b/crates/ui-egui/src/object_finder.rs
@@ -0,0 +1,331 @@
+//! Object Selection › Object Finder (#4087): with the Object Selection tool active, resting the
+//! pointer on the canvas highlights the object a click there would select, as Photoshop's Object
+//! Finder does. A click (without dragging) commits that object (`select.object` with `"point"`;
+//! ⇧ adds, ⌥ subtracts, ⇧⌥ intersects); dragging keeps the rectangle mode.
+//!
+//! The lookup is `photocraft_engine::smartselect_cmds::find_object`, run after the pointer has
+//! been still for [`DEBOUNCE`] seconds on a worker thread (inline on the web), so the UI never
+//! waits for it. Results go into the session's `object_finder` cache, which the click reuses and
+//! which serves every point of an object already found; it is keyed by the document's pixels,
+//! so an edit drops it. The preview itself is keyed by document revision, sampled layer and
+//! Sample All Layers, and clears when the pointer leaves the canvas, the tool changes, a button
+//! goes down or the option is off. Quality of the object found is out of scope here (#2788).
+
+use std::sync::Arc;
+
+use egui::{Color32, TextureOptions, pos2};
+use photocraft_algo::selection::Region;
+use photocraft_doc::{DocId, Document, LayerId};
+use photocraft_engine::smartselect_cmds::{find_object, sampled_target};
+
+use crate::PhotocraftApp;
+use crate::canvas::ViewXform;
+use crate::state::Tool;
+
+/// Seconds the pointer must rest before an object is looked up.
+pub const DEBOUNCE: f64 = 0.12;
+/// Longest side of the overlay texture (the overlay is a preview, not the selection).
+const TEX_MAX: usize = 768;
+
+/// A lookup running off the UI thread.
+struct Job {
+    at: [i32; 2],
+    doc: Arc<Document>,
+    rx: std::sync::mpsc::Receiver<Option<Region>>,
+}
+
+/// The hover state of the active document (`PhotocraftApp::object_finder`).
+pub(crate) struct Finder {
+    doc: DocId,
+    revision: u64,
+    target: Option<LayerId>,
+    all_layers: bool,
+    /// The pointer pixel and when it got there.
+    at: [i32; 2],
+    since: f64,
+    job: Option<Job>,
+    /// Points already looked up that found nothing (the background).
+    misses: Vec<[i32; 2]>,
+    shown: Option<Arc<Region>>,
+    texture: Option<(usize, egui::TextureHandle)>,
+}
+
+/// What [`update`] decided.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Update {
+    /// The object to highlight.
+    pub shown: Option<Arc<Region>>,
+    /// A lookup is pending or running: repaint soon to pick it up.
+    pub busy: bool,
+}
+
+/// Whether the preview applies now (`pressed`: a pointer button is down).
+fn active(app: &PhotocraftApp, pressed: bool) -> bool {
+    app.ui.tool == Tool::ObjectSelection
+        && app.ui.tool_options.object_finder
+        && !pressed
+        && app.drag.is_none()
+        && app.ui.transform.is_none()
+        && app.session.active().is_some()
+}
+
+/// Advances the hover preview with the pointer at `at` (document px; `None` = off the canvas)
+/// at time `now` (seconds).
+pub(crate) fn update(app: &mut PhotocraftApp, at: Option<[f64; 2]>, pressed: bool, now: f64) -> Update {
+    let at = at.filter(|p| p[0].is_finite() && p[1].is_finite());
+    let (Some(at), true) = (at, active(app, pressed)) else {
+        app.object_finder = None;
+        return Update::default();
+    };
+    let Some(st) = app.session.active() else { return Update::default() };
+    let all_layers = app.ui.tool_options.sample_all_layers;
+    let target = sampled_target(&st.doc, st.active_layer, all_layers);
+    let (doc, revision, layer) = (st.doc.id, st.revision, st.active_layer);
+    let px = [at[0].floor() as i32, at[1].floor() as i32];
+    let fresh = app.object_finder.as_ref().is_some_and(|f| f.doc == doc && f.revision == revision && f.target == target && f.all_layers == all_layers);
+    if !fresh {
+        app.object_finder = Some(Finder { doc, revision, target, all_layers, at: px, since: now, job: None, misses: Vec::new(), shown: None, texture: None });
+    }
+    let doc_arc = Arc::clone(&st.doc);
+    let Some(f) = app.object_finder.as_mut() else { return Update::default() };
+    if f.at != px {
+        f.at = px;
+        f.since = now;
+    }
+    // A finished lookup: remember it (only for the pixels it was computed from).
+    if let Some(job) = &f.job {
+        match job.rx.try_recv() {
+            Ok(found) => {
+                if let Some(r) = found {
+                    if photocraft_engine::layer_multi_cmds::same_pixels(&job.doc, &doc_arc) {
+                        app.session.object_finder.insert(&doc_arc, target, Arc::new(r));
+                    }
+                } else {
+                    f.misses.push(job.at);
+                    if f.misses.len() > 64 {
+                        f.misses.remove(0);
+                    }
+                }
+                f.job = None;
+            }
+            Err(std::sync::mpsc::TryRecvError::Empty) => {}
+            Err(std::sync::mpsc::TryRecvError::Disconnected) => f.job = None,
+        }
+    }
+    let inside = |r: &Region| r.at(px[0], px[1]) >= 0.5;
+    if !f.shown.as_deref().is_some_and(inside) {
+        f.shown = app.session.object_finder.lookup(&doc_arc, target, at[0] as f32, at[1] as f32);
+    }
+    let missed = f.misses.iter().any(|m| (m[0] - px[0]).abs() <= 2 && (m[1] - px[1]).abs() <= 2);
+    if f.shown.is_none() && f.job.is_none() && !missed && now - f.since >= DEBOUNCE && doc_arc.bounds().contains(px[0], px[1]) {
+        f.job = Some(spawn(Arc::clone(&doc_arc), layer, all_layers, px, at));
+    }
+    let busy = f.job.is_some() || (f.shown.is_none() && !missed && now - f.since < DEBOUNCE);
+    Update { shown: f.shown.clone(), busy }
+}
+
+fn spawn(doc: Arc<Document>, layer: Option<LayerId>, all_layers: bool, px: [i32; 2], at: [f64; 2]) -> Job {
+    let (tx, rx) = std::sync::mpsc::channel();
+    let work = {
+        let doc = Arc::clone(&doc);
+        move || {
+            let _ = tx.send(find_object(&doc, layer, all_layers, at[0] as f32, at[1] as f32));
+        }
+    };
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let spawned = std::thread::Builder::new().name("object-finder".into()).spawn(work);
+        if spawned.is_err() {
+            // No thread: the receiver reports Disconnected and the next rest retries.
+        }
+    }
+    #[cfg(target_arch = "wasm32")]
+    work();
+    Job { at: px, doc, rx }
+}
+
+/// Clears the preview (a tool switch or an edit made elsewhere is caught by [`update`] too).
+pub(crate) fn clear(app: &mut PhotocraftApp) {
+    app.object_finder = None;
+}
+
+/// The overlay colour: the theme accent, translucent (Photoshop tints the object it finds).
+fn overlay(accent: Color32, cov: f32, edge: bool) -> Color32 {
+    let a = if edge { 0.95 } else { 0.42 * cov.clamp(0.0, 1.0) };
+    Color32::from_rgba_unmultiplied(accent.r(), accent.g(), accent.b(), (a * 255.0).round() as u8)
+}
+
+/// The overlay image of `r`: translucent fill with an opaque one-texel outline, at most
+/// [`TEX_MAX`] texels on its longest side.
+pub(crate) fn overlay_image(r: &Region, accent: Color32) -> egui::ColorImage {
+    let (w, h) = (r.bbox.width().max(1) as usize, r.bbox.height().max(1) as usize);
+    let step = w.max(h).div_ceil(TEX_MAX).max(1);
+    let (tw, th) = (w.div_ceil(step), h.div_ceil(step));
+    let cov = |tx: usize, ty: usize| r.at(r.bbox.x0 + (tx * step) as i32, r.bbox.y0 + (ty * step) as i32);
+    let mut px = Vec::with_capacity(tw * th);
+    for ty in 0..th {
+        for tx in 0..tw {
+            let c = cov(tx, ty);
+            let on = c >= 0.5;
+            let edge = on
+                && (tx == 0
+                    || ty == 0
+                    || tx + 1 == tw
+                    || ty + 1 == th
+                    || cov(tx - 1, ty) < 0.5
+                    || cov(tx + 1, ty) < 0.5
+                    || cov(tx, ty - 1) < 0.5
+                    || cov(tx, ty + 1) < 0.5);
+            px.push(if c <= 0.0 { Color32::TRANSPARENT } else { overlay(accent, c, edge) });
+        }
+    }
+    egui::ColorImage::new([tw, th], px)
+}
+
+/// Updates the preview for this frame and draws the highlight on the active document's canvas.
+pub(crate) fn draw(app: &mut PhotocraftApp, painter: &egui::Painter, xf: &ViewXform, idx: usize, hover: Option<egui::Pos2>) {
+    if app.session.active_index() != Some(idx) {
+        return;
+    }
+    let ctx = painter.ctx().clone();
+    let (pressed, now) = ctx.input(|i| (i.pointer.any_down(), i.time));
+    let up = update(app, hover.map(|p| xf.to_doc(p)), pressed, now);
+    if up.busy {
+        ctx.request_repaint_after(std::time::Duration::from_millis(40));
+    }
+    let Some(r) = up.shown else { return };
+    let Some(f) = app.object_finder.as_mut() else { return };
+    let key = Arc::as_ptr(&r) as usize;
+    if f.texture.as_ref().is_none_or(|(k, _)| *k != key) {
+        let accent = crate::theme::Tokens::get(&ctx).accent;
+        let tex = ctx.load_texture("object-finder", overlay_image(&r, accent), TextureOptions::LINEAR);
+        f.texture = Some((key, tex));
+    }
+    let Some((_, tex)) = &f.texture else { return };
+    let b = r.bbox;
+    let mut mesh = egui::Mesh::with_texture(tex.id());
+    let corners = [(b.x0, b.y0, 0.0, 0.0), (b.x1, b.y0, 1.0, 0.0), (b.x1, b.y1, 1.0, 1.0), (b.x0, b.y1, 0.0, 1.0)];
+    for (x, y, u, v) in corners {
+        mesh.vertices.push(egui::epaint::Vertex { pos: xf.to_screen(x as f32, y as f32), uv: pos2(u, v), color: Color32::WHITE });
+    }
+    mesh.indices.extend_from_slice(&[0, 1, 2, 0, 2, 3]);
+    painter.add(egui::Shape::mesh(mesh));
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    /// A 200 × 160 document: a red disc (centre 100, 80, radius 45) on blue.
+    pub(crate) fn disc_app() -> PhotocraftApp {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.session.execute("file.new", json!({"width": 200, "height": 160})).unwrap();
+        app.session
+            .edit("paint", |doc, a| {
+                let s = doc.layer_mut(a.unwrap()).unwrap().surface_mut().unwrap();
+                s.fill_rect(photocraft_geom::Rect::new(0, 0, 200, 160), &[0.2, 0.4, 0.8, 1.0]);
+                for y in 0..160 {
+                    for x in 0..200 {
+                        let (dx, dy) = (x as f32 + 0.5 - 100.0, y as f32 + 0.5 - 80.0);
+                        if dx * dx + dy * dy <= 45.0 * 45.0 {
+                            s.fill_rect(photocraft_geom::Rect::new(x, y, x + 1, y + 1), &[0.9, 0.2, 0.1, 1.0]);
+                        }
+                    }
+                }
+                Ok(())
+            })
+            .unwrap();
+        app.ui.tool = Tool::ObjectSelection;
+        app
+    }
+
+    /// Hovers at `at` until the lookup settles (time advances past the debounce).
+    pub(crate) fn hover(app: &mut PhotocraftApp, at: [f64; 2]) -> Update {
+        let mut t = 100.0;
+        loop {
+            let u = update(app, Some(at), false, t);
+            if !u.busy || t > 130.0 {
+                return u;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(5));
+            t += 0.05;
+        }
+    }
+
+    #[test]
+    fn hovering_an_object_highlights_it_after_a_rest() {
+        let mut app = disc_app();
+        // Not before the pointer has rested.
+        let u = update(&mut app, Some([100.0, 80.0]), false, 50.0);
+        assert!(u.shown.is_none() && u.busy);
+        let u = hover(&mut app, [100.0, 80.0]);
+        let r = u.shown.expect("the disc is highlighted");
+        assert!(r.at(100, 80) >= 0.5 && r.at(60, 80) >= 0.5 && r.at(5, 5) < 0.5);
+        // Elsewhere on the same object: served from the cache, no new lookup.
+        let u = update(&mut app, Some([120.0, 90.0]), false, 200.0);
+        assert!(u.shown.is_some_and(|s| Arc::ptr_eq(&s, &r)) && !u.busy);
+        assert_eq!(app.session.object_finder.len(), 1);
+        // The background highlights nothing.
+        assert!(hover(&mut app, [4.0, 4.0]).shown.is_none());
+    }
+
+    #[test]
+    fn preview_clears_on_leave_tool_switch_button_option_and_edits() {
+        let mut app = disc_app();
+        assert!(hover(&mut app, [100.0, 80.0]).shown.is_some());
+        assert!(update(&mut app, None, false, 300.0).shown.is_none());
+        assert!(app.object_finder.is_none());
+        assert!(hover(&mut app, [100.0, 80.0]).shown.is_some());
+        assert!(update(&mut app, Some([100.0, 80.0]), true, 300.0).shown.is_none());
+        app.ui.tool = Tool::Lasso;
+        assert!(update(&mut app, Some([100.0, 80.0]), false, 300.0).shown.is_none());
+        app.ui.tool = Tool::ObjectSelection;
+        app.ui.tool_options.object_finder = false;
+        assert!(update(&mut app, Some([100.0, 80.0]), false, 300.0).shown.is_none());
+        app.ui.tool_options.object_finder = true;
+        assert!(hover(&mut app, [100.0, 80.0]).shown.is_some());
+        // A pixel edit: the cached object is dropped and the preview starts over.
+        app.session.execute("paint.pencil", json!({"points": [[5, 5], [30, 5]], "size": 4, "color": "#000000"})).unwrap();
+        let u = update(&mut app, Some([100.0, 80.0]), false, 400.0);
+        assert!(u.shown.is_none() && u.busy);
+    }
+
+    #[test]
+    fn click_commits_the_highlighted_object_with_the_modifiers() {
+        use crate::canvas::{ToolEvent, tool_event};
+        let mut app = disc_app();
+        assert!(hover(&mut app, [100.0, 80.0]).shown.is_some());
+        let click = |app: &mut PhotocraftApp, m: egui::Modifiers| {
+            tool_event(app, ToolEvent::Down { x: 100.0, y: 80.0, pressure: 1.0 }, m);
+            tool_event(app, ToolEvent::Up { x: 100.0, y: 80.0 }, m);
+        };
+        let cov = |app: &PhotocraftApp, x: i32, y: i32| app.session.active().unwrap().doc.selection.as_ref().map_or(0.0, |s| s.sample_channel(x, y, 0));
+        click(&mut app, egui::Modifiers::NONE);
+        assert_eq!(app.session.journal.last().map(|(id, _)| id.as_str()), Some("select.object"));
+        assert!(cov(&app, 100, 80) >= 0.5 && cov(&app, 60, 80) >= 0.5 && cov(&app, 5, 5) < 0.5);
+        app.run("select.all", json!({})).unwrap();
+        click(&mut app, egui::Modifiers::ALT);
+        assert!(cov(&app, 100, 80) < 0.5 && cov(&app, 5, 5) >= 0.5);
+        click(&mut app, egui::Modifiers::SHIFT);
+        assert!(cov(&app, 100, 80) >= 0.5 && cov(&app, 5, 5) >= 0.5);
+        click(&mut app, egui::Modifiers { alt: true, shift: true, ..Default::default() });
+        assert!(cov(&app, 100, 80) >= 0.5 && cov(&app, 5, 5) < 0.5);
+        // Off: a click keeps the Quick Selection fallback.
+        app.ui.tool_options.object_finder = false;
+        click(&mut app, egui::Modifiers::NONE);
+        assert_eq!(app.session.journal.last().map(|(id, _)| id.as_str()), Some("select.quick"));
+    }
+
+    #[test]
+    fn overlay_image_tints_the_object_and_outlines_it() {
+        let r = Region { bbox: photocraft_geom::Rect::new(0, 0, 4, 4), mask: vec![255; 16] };
+        let img = overlay_image(&r, Color32::from_rgb(0, 120, 255));
+        assert_eq!(img.size, [4, 4]);
+        assert!(img.pixels[0].a() > 200, "edge");
+        assert!(img.pixels[5].a() > 0 && img.pixels[5].a() < 200, "fill");
+        let big = Region { bbox: photocraft_geom::Rect::new(0, 0, 3000, 10), mask: vec![255; 30_000] };
+        assert!(overlay_image(&big, Color32::WHITE).size[0] <= TEX_MAX);
+    }
+}
diff --git a/crates/ui-egui/src/open_prompt.rs b/crates/ui-egui/src/open_prompt.rs
new file mode 100644
index 0000000000..cd04a4fc5f
--- /dev/null
+++ b/crates/ui-egui/src/open_prompt.rs
@@ -0,0 +1,147 @@
+//! Ask When Opening (Edit › Color Settings): a file whose embedded profile doesn't match the
+//! working space (or that has none) is held back while a prompt asks what to do, as Photoshop
+//! does: one prompt at a time, naming its file, before that file opens. OK applies the answer to
+//! that file and opens it, then asks about the next; Cancel opens neither it nor the files still
+//! to come. Files that finish reading while a prompt is up wait their turn, so they open in order.
+
+use std::sync::Arc;
+
+use photocraft_doc::{ColorMode, Document};
+use serde_json::{Value, json};
+
+use crate::PhotocraftApp;
+
+/// The field that marks a prompt as this module's.
+const FIELD: &str = "__heldOpen";
+
+/// A file read and decoded, waiting to open.
+pub struct Held {
+    pub doc: Document,
+    /// The source is read-only (an Affinity file): Save doesn't write back to it.
+    pub read_only: bool,
+    pub name: String,
+    pub path: Option<String>,
+    pub warnings: Vec<String>,
+    /// The file's bytes, for Camera Raw to develop from when there is no path.
+    pub bytes: Option<Arc<Vec<u8>>>,
+    /// The tab position a reopened file keeps.
+    pub slot: Option<usize>,
+    /// The profile question ([`photocraft_engine::color_cmds::ColorState::open_question`]), or
+    /// `None` to open without asking.
+    pub question: Option<Value>,
+    /// The Color Settings policy was already applied (a background open added it before it had
+    /// to wait); otherwise opening applies it.
+    pub policy_applied: bool,
+}
+
+/// Whether a file that just finished reading has to wait: one earlier in the queue does.
+pub fn waiting(app: &PhotocraftApp) -> bool {
+    !app.held_opens.is_empty()
+}
+
+/// Opens `held` now, or queues it behind the file whose prompt is up.
+pub fn arrive(app: &mut PhotocraftApp, held: Held) {
+    app.held_opens.push_back(held);
+    advance(app);
+}
+
+/// Opens queued files in order until one needs its prompt, which is shown if it isn't yet.
+fn advance(app: &mut PhotocraftApp) {
+    while let Some(front) = app.held_opens.front() {
+        if front.question.is_some() {
+            if !app.ui.dialogs.iter().any(|d| d.fields.contains_key(FIELD)) {
+                show(app);
+            }
+            return;
+        }
+        if let Some(held) = app.held_opens.pop_front() {
+            // A failure is shown to the user (`open_failed`); the next file still opens.
+            let _ = open(app, held, None);
+        }
+    }
+}
+
+/// Shows the Embedded Profile Mismatch (or missing profile) prompt for the first queued file.
+fn show(app: &mut PhotocraftApp) {
+    let Some(front) = app.held_opens.front() else { return };
+    let Some(q) = &front.question else { return };
+    // The mode reads as the catalogs name it (French "RVB"); the file name goes in last, so
+    // nothing in it is taken for a placeholder.
+    let mode = tl!(match front.doc.mode {
+        ColorMode::Cmyk => "CMYK",
+        ColorMode::Grayscale => "Gray",
+        _ => "RGB",
+    });
+    let name = front.name.as_str();
+    let working = crate::i18n::fmt(tl!("Working: {working}"), &[("working", q.get("working").and_then(Value::as_str).unwrap_or("?"))]);
+    let missing = q.get("missing").and_then(Value::as_bool) == Some(true);
+    let message = if missing {
+        let what = crate::i18n::fmt(tl!("The document “{name}” does not have an embedded {mode} profile."), &[("mode", mode), ("name", name)]);
+        format!("{what}\n{working}")
+    } else {
+        let what = crate::i18n::fmt(
+            tl!("The document “{name}” has an embedded color profile that does not match the current {mode} working space."),
+            &[("mode", mode), ("name", name)],
+        );
+        let embedded = crate::i18n::fmt(tl!("Embedded: {embedded}"), &[("embedded", q.get("embedded").and_then(Value::as_str).unwrap_or("?"))]);
+        format!("{what}\n{embedded}\n{working}")
+    };
+    let action = q.get("action").and_then(Value::as_str).unwrap_or("preserve").to_string();
+    crate::prefs_ui::open_mismatch(app, &message, &action, missing, FIELD);
+}
+
+/// Whether `fields` are one of this module's prompts.
+pub fn owns(fields: &serde_json::Map<String, Value>) -> bool {
+    fields.contains_key(FIELD)
+}
+
+/// The prompt's answer: `Some(action)` (OK) opens the first queued file with it and moves on to
+/// the next; `None` (Cancel) drops every queued file and stops the reads still running.
+pub fn answer(app: &mut PhotocraftApp, action: Option<&str>) -> Result<Value, String> {
+    let Some(action) = action else {
+        let dropped = app.held_opens.len();
+        let name = app.held_opens.front().map(|h| h.name.clone()).unwrap_or_default();
+        app.held_opens.clear();
+        for job in app.jobs.opens.iter().map(|o| o.job).collect::<Vec<_>>() {
+            app.session.cancel_job(job);
+        }
+        app.ui.status = crate::i18n::fmt(tl!("Cancelled opening {name}"), &[("name", &name)]);
+        app.ui.status_error = false;
+        return Ok(json!({"cancelled": dropped}));
+    };
+    let Some(held) = app.held_opens.pop_front() else { return Err("no file is waiting to open".into()) };
+    let r = open(app, held, Some(action));
+    advance(app);
+    r
+}
+
+/// Opens a queued file, applying `action` (the prompt's answer) or else the Color Settings
+/// policy, then does what any open does afterwards.
+fn open(app: &mut PhotocraftApp, held: Held, action: Option<&str>) -> Result<Value, String> {
+    let Held { mut doc, read_only, name, path, warnings, bytes, slot, question, policy_applied } = held;
+    let index = if question.is_some() || policy_applied {
+        if let Some(action) = action
+            && let Err(e) = app.session.color.resolve_open(&mut doc, action)
+        {
+            app.open_failed(&name, &e.to_string());
+            return Err(e.to_string());
+        }
+        app.session.add_document(doc, None)
+    } else {
+        app.session.open_document(doc, None).0
+    };
+    if let Some(st) = app.session.active_mut() {
+        st.source_read_only = read_only;
+    }
+    let index = match slot {
+        Some(slot) => app
+            .run("document.move", json!({"document": index, "to": slot}))
+            .ok()
+            .and_then(|m| m.get("document").and_then(Value::as_u64))
+            .map_or(index, |i| i as usize),
+        None => index,
+    };
+    app.session.set_active(index);
+    crate::jobs_ui::after_open(app, &name, path.as_deref(), &warnings, bytes.as_deref().map(Vec::as_slice));
+    Ok(json!({"document": index, "action": action}))
+}
diff --git a/crates/ui-egui/src/options_bar_mode_wheel_tests.rs b/crates/ui-egui/src/options_bar_mode_wheel_tests.rs
new file mode 100644
index 0000000000..068561b4a0
--- /dev/null
+++ b/crates/ui-egui/src/options_bar_mode_wheel_tests.rs
@@ -0,0 +1,83 @@
+//! #2061: the scroll wheel over the options bar's Mode dropdown (Brush, Pencil, Gradient) steps
+//! through the blend modes, as over the Layers panel's (#1747) and as in Photoshop.
+
+use egui::accesskit::Role;
+use egui::{Pos2, Rect, vec2};
+use egui_kittest::Harness;
+use egui_kittest::kittest::Queryable;
+use photocraft_doc::BlendMode;
+use serde_json::json;
+
+use crate::PhotocraftApp;
+use crate::state::Tool;
+
+/// The app with a new document and `tool` chosen.
+fn harness(tool: Tool) -> Harness<'static, PhotocraftApp> {
+    let mut h = Harness::builder().with_size(vec2(1440.0, 900.0)).with_max_steps(64).build_eframe(move |cc| {
+        PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 64, "height": 48})).unwrap();
+        app.ui.tool = tool;
+        app
+    });
+    h.run_steps(8);
+    h
+}
+
+/// The options bar's Mode dropdown: the highest one showing `Normal` (the Layers panel's is lower).
+fn mode_dropdown(h: &Harness<'_, PhotocraftApp>) -> Rect {
+    h.query_all_by_role(Role::ComboBox).filter(|n| n.value().as_deref() == Some("Normal")).map(|n| n.rect()).min_by(|a, b| a.top().total_cmp(&b.top())).unwrap()
+}
+
+/// `lines` wheel lines at `at` in one event: negative is down.
+fn wheel(h: &mut Harness<'_, PhotocraftApp>, at: Pos2, lines: f32) {
+    h.hover_at(at);
+    h.run_steps(1);
+    h.event(egui::Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Line,
+        delta: vec2(0.0, lines),
+        phase: egui::TouchPhase::Move,
+        modifiers: Default::default(),
+    });
+    h.run_steps(3);
+}
+
+fn brush_mode(h: &Harness<'_, PhotocraftApp>) -> BlendMode {
+    h.state().session.tools.brush.mode
+}
+
+#[test]
+fn the_wheel_over_the_brush_mode_dropdown_steps_the_painting_mode() {
+    let mut h = harness(Tool::Brush);
+    let at = mode_dropdown(&h).center();
+    assert_eq!(brush_mode(&h), BlendMode::Normal);
+    wheel(&mut h, at, -1.0);
+    assert_eq!(brush_mode(&h), BlendMode::Dissolve);
+    wheel(&mut h, at, -1.0);
+    assert!(h.state().ui.tool_options.brush_clear, "Clear follows Dissolve, as in Photoshop");
+    wheel(&mut h, at, -1.0);
+    assert!(!h.state().ui.tool_options.brush_clear);
+    assert_eq!(brush_mode(&h), BlendMode::Darken);
+    wheel(&mut h, at, 3.0);
+    assert_eq!(brush_mode(&h), BlendMode::Normal, "up steps back and stops at the first mode");
+}
+
+#[test]
+fn the_wheel_over_the_pencil_mode_dropdown_steps_the_painting_mode() {
+    let mut h = harness(Tool::Pencil);
+    let at = mode_dropdown(&h).center();
+    wheel(&mut h, at, -1.0);
+    assert_eq!(brush_mode(&h), BlendMode::Dissolve);
+    wheel(&mut h, at, 1.0);
+    assert_eq!(brush_mode(&h), BlendMode::Normal);
+}
+
+#[test]
+fn the_wheel_over_the_gradient_mode_dropdown_steps_its_blend_mode() {
+    let mut h = harness(Tool::Gradient);
+    let at = mode_dropdown(&h).center();
+    wheel(&mut h, at, -2.0);
+    assert_eq!(h.state().ui.tool_options.gradient_blend_mode, BlendMode::Darken);
+    wheel(&mut h, at, 1.0);
+    assert_eq!(h.state().ui.tool_options.gradient_blend_mode, BlendMode::Dissolve);
+}
diff --git a/crates/ui-egui/src/paint_mouse.rs b/crates/ui-egui/src/paint_mouse.rs
index bb2d6653d2..a45c016c59 100644
--- a/crates/ui-egui/src/paint_mouse.rs
+++ b/crates/ui-egui/src/paint_mouse.rs
@@ -37,6 +37,7 @@ pub fn sync_tool_brush(app: &mut PhotocraftApp) {
     // The picked preset was the outgoing tool's brush: forget it, so Update Brush can't overwrite
     // that preset with this tool's brush.
     app.session.tools.current_preset = None;
+    app.session.tools.brush_changed();
     app.ui.brush_tool = tool;
 }
 
@@ -433,8 +434,8 @@ mod tests {
         assert!(h.state().ui.brush_picker.is_some());
     }
 
-    /// The gear menu's New Brush Preset… saves the brush and asks for its name in the picker's
-    /// rename bar; Enter there renames it and leaves the picker open (Enter closes it otherwise).
+    /// The gear menu's New Brush Preset… opens the New Brush Preset dialog (#4490), which saves
+    /// the preset under the typed name on OK.
     #[test]
     fn picker_gear_menu_saves_and_names_a_new_preset() {
         use egui_kittest::kittest::Queryable;
@@ -444,19 +445,20 @@ mod tests {
         h.run_steps(2);
         h.get_by_label("Brush Preset Options").click();
         h.run_steps(2);
+        let before = h.state().session.tools.presets.len();
         h.get_by_label("New Brush Preset…").click();
         h.run_steps(3);
-        let saved = h.state().ui.brush_picker_list.renaming.clone().expect("the rename bar asks for a name");
-        assert!(h.state().session.tools.presets.iter().any(|p| p.name == saved.name));
-        assert!(h.state().ui.brush_picker.is_some(), "the menu's click didn't close the picker");
-        h.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::A);
-        h.event(egui::Event::Text("Inky".into()));
-        h.run_steps(1);
-        h.key_press(egui::Key::Enter);
-        h.run_steps(3);
-        assert!(h.state().session.tools.presets.iter().any(|p| p.name == "Inky"), "renamed");
-        assert!(h.state().ui.brush_picker_list.renaming.is_none());
-        assert!(h.state().ui.brush_picker.is_some(), "Enter ended the rename, not the picker");
+        let dialog = h.state().ui.dialogs.iter().find(|d| crate::brush_preset_dialog::owns(&d.fields)).map(|d| d.id).expect("the dialog asks for a name");
+        assert_eq!(h.state().session.tools.presets.len(), before, "nothing is saved before OK");
+        assert!(h.state().ui.brush_picker.is_none(), "the dialog takes the picker's place");
+        // This harness draws the canvas only: OK as automation does (the dialog's own tests type).
+        h.state_mut().ui.dialog_mut(dialog).unwrap().fields.insert("name".into(), json!("Inky"));
+        crate::dialogs::confirm(h.state_mut(), dialog).unwrap();
+        h.run_steps(2);
+        assert!(h.state().session.tools.presets.iter().any(|p| p.name == "Inky"), "saved under the typed name");
+        assert_eq!(h.state().session.tools.current_preset.as_deref(), Some("Inky"));
+        h.state_mut().ui.brush_picker = Some([c.x, c.y]);
+        h.run_steps(2);
         // The gear's boxes pick the card parts; the last one on can't be turned off.
         h.get_by_label("Brush Preset Options").click();
         h.run_steps(2);
diff --git a/crates/ui-egui/src/panel_docking.rs b/crates/ui-egui/src/panel_docking.rs
index bc6bfcf087..de56d6714c 100644
--- a/crates/ui-egui/src/panel_docking.rs
+++ b/crates/ui-egui/src/panel_docking.rs
@@ -404,7 +404,9 @@ pub(crate) fn show(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> bool {
         style.tab_height = if t.pro { 28.0 } else { 40.0 };
         style.min_pane = 0.0;
         style.background = t.card;
-        style.tab_background = t.tab_strip;
+        // Studio themes leave the strip transparent over the dock's card; a floating group has no
+        // card behind it, so the canvas showed through its titles (#4509).
+        style.tab_background = if t.tab_strip.a() == 0 { t.card } else { t.tab_strip };
         style.active_background = t.card;
         style.text = t.text;
         style.inactive_text = t.text_dim;
@@ -843,6 +845,14 @@ fn panel_menu(app: &mut PhotocraftApp, ui: &mut egui::Ui, panel: &str) {
             crate::swatches_ui::panel_menu(app, ui);
             ui.separator();
         }
+        "brushSettings" | "brush_settings" => {
+            crate::brush_panel::panel_menu(app, ui);
+            ui.separator();
+        }
+        "actions" => {
+            crate::actions::panel_menu(app, ui);
+            ui.separator();
+        }
         _ => {}
     }
 }
diff --git a/crates/ui-egui/src/panel_docking_tests.rs b/crates/ui-egui/src/panel_docking_tests.rs
index 6980a8a93f..735274eb85 100644
--- a/crates/ui-egui/src/panel_docking_tests.rs
+++ b/crates/ui-egui/src/panel_docking_tests.rs
@@ -162,6 +162,37 @@ fn capture_custom_panel_docking_visual_fixtures() {
     }
 }
 
+#[test]
+fn floating_group_titles_are_opaque_in_studio_themes() {
+    // Studio's tab strip is transparent over the dock's card; a floating group must not show the canvas (#4509).
+    let mut app = app();
+    app.run("window.panel.float", json!({"panel":"swatches","x":40,"y":60,"width":300,"height":300})).unwrap();
+    let mut ready = false;
+    let mut h = Harness::builder().with_size(vec2(1280.0, 800.0)).wgpu().build_ui_state(
+        move |ui, app: &mut PhotocraftApp| {
+            if !ready {
+                PhotocraftApp::setup_context(ui.ctx(), crate::theme::ThemeKind::Studio);
+                app.ui.theme = crate::theme::ThemeKind::Studio;
+                ready = true;
+                return;
+            }
+            crate::panels::right_dock(app, ui);
+            egui::CentralPanel::default().frame(egui::Frame::NONE.fill(egui::Color32::from_rgb(255, 0, 255))).show(ui, |_| {});
+        },
+        app,
+    );
+    h.run_steps(5);
+    let area = h.ctx.memory(|m| m.area_rect(egui::Id::new("photocraft-panel-docking").with(("floating", &"swatches".to_string())))).unwrap();
+    let image = h.render().unwrap();
+    let ppp = image.width() as f32 / 1280.0;
+    let strip = egui::Rect::from_min_size(area.min, vec2(area.width(), 40.0)).shrink(2.0);
+    let magenta = (strip.left() as u32..strip.right() as u32)
+        .flat_map(|x| (strip.top() as u32..strip.bottom() as u32).map(move |y| (x, y)))
+        .filter(|&(x, y)| image.get_pixel((x as f32 * ppp) as u32, (y as f32 * ppp) as u32).0[..3] == [255, 0, 255])
+        .count();
+    assert_eq!(magenta, 0, "canvas shows through the floating group's title strip {strip:?}");
+}
+
 #[test]
 fn escape_cancels_the_first_drag_without_replacing_the_legacy_workspace() {
     let mut h = harness(app(), vec2(1280.0, 800.0));
@@ -504,6 +535,17 @@ fn explicit_reveal_activates_existing_tab_and_expands_custom_group() {
     assert_eq!(app.ui.docking, before);
 }
 
+// #4028: in a custom workspace too, a new adjustment layer brings Properties to the front.
+#[test]
+fn a_new_adjustment_layer_activates_properties_in_a_custom_workspace() {
+    let mut app = app();
+    app.run("window.panel.activate", json!({"panel":"adjustments"})).unwrap();
+    assert!(panel_active(app.ui.docking.as_ref().unwrap(), "adjustments"));
+    app.run("file.new", json!({"width":64,"height":64})).unwrap();
+    app.run("layer.newAdjustmentLayer.curves", json!({})).unwrap();
+    assert!(panel_active(app.ui.docking.as_ref().unwrap(), "properties"));
+}
+
 #[test]
 fn custom_group_commands_preserve_members_and_workspace_timeline() {
     let mut app = app();
diff --git a/crates/ui-egui/src/panels.rs b/crates/ui-egui/src/panels.rs
index c67ccec68e..311a7d6df9 100644
--- a/crates/ui-egui/src/panels.rs
+++ b/crates/ui-egui/src/panels.rs
@@ -123,14 +123,20 @@ pub fn toolbar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             if ui.input(|i| i.pointer.any_pressed()) {
                 ui.data_mut(|d| d.remove::<egui::Id>(held_id));
             }
+            // No tool tooltips over an open flyout, or while a button is held to open one (#4450):
+            // Photoshop shows none there. (The flyout is our own Area, so egui's rule for popups
+            // doesn't hide them.)
+            let tool_tips = ui.data(|d| d.get_temp::<(egui::Id, Rect)>(flyout_id)).is_none() && !ui.input(|i| i.pointer.primary_down());
             let ctx = ui.ctx().clone();
             let footer = (if t.pro { 8.0 } else { 14.0 })
                 + chips_height(t.pro, t.round_chips, t.round_chips && double)
                 + if t.pro { 8.0 + if double { bx } else { bx * 2.0 + 3.0 } } else { 0.0 }
                 + 6.0;
+            // As tall as the tools, so the colour chips sit right under them (Photoshop); a column
+            // taller than the window scrolls and keeps the chips at the bottom.
             egui::ScrollArea::vertical()
                 .id_salt("toolbar-columns")
-                .auto_shrink([false, false])
+                .auto_shrink([false, true])
                 .max_height((ui.available_height() - footer).max(0.0))
                 .min_scrolled_height(0.0)
                 .show(ui, |ui| {
@@ -151,9 +157,12 @@ pub fn toolbar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                                     let key = egui::Id::new(("tool-slot", *slot_index));
                                     let tool = slot_tool(ui, app.ui.tool, slot, key);
                                     let sel = slot.contains(&app.ui.tool);
-                                    let tip =
-                                        if tool.key() == '\0' { tl!(tool.label()).to_string() } else { format!("{}  ({})", tl!(tool.label()), tool.key()) };
-                                    let resp = icons::button_with_icon_size(ui, icons::tool_icon(tool), bx, toolbar_icon_size(bx, t.pro), sel, &tip);
+                                    let tip = match crate::tool_shortcuts::shortcut(app, tool) {
+                                        Some(sc) => format!("{}  ({})", tl!(tool.label()), crate::shortcuts::pretty(&sc)),
+                                        None => tl!(tool.label()).to_string(),
+                                    };
+                                    let resp =
+                                        icons::button_with_icon_size_tip(ui, icons::tool_icon(tool), bx, toolbar_icon_size(bx, t.pro), sel, &tip, tool_tips);
                                     if slot.len() > 1 {
                                         paint_toolbar_flyout_indicator(ui, &t, &resp);
                                     }
@@ -180,7 +189,14 @@ pub fn toolbar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                                         ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(0.35 - seconds));
                                     }
                                     let long_press = held_for.is_some_and(|seconds| seconds >= 0.35);
-                                    if slot.len() > 1 && (resp.secondary_clicked() || long_press) {
+                                    // Clicking the button of its open flyout again, with either button, closes
+                                    // it (#4932); the release that ends the long press that opened it doesn't.
+                                    let open_here = ui.data(|d| d.get_temp::<(egui::Id, Rect)>(flyout_id)).is_some_and(|(k, _)| k == key);
+                                    let reclicked = open_here
+                                        && (resp.secondary_clicked() || (resp.clicked() && ui.data(|d| d.get_temp::<egui::Id>(held_id)) != Some(key)));
+                                    if reclicked {
+                                        ui.data_mut(|d| d.remove::<(egui::Id, Rect)>(flyout_id));
+                                    } else if slot.len() > 1 && (resp.secondary_clicked() || long_press) {
                                         ui.data_mut(|d| {
                                             d.insert_temp(flyout_id, (key, resp.rect));
                                             if long_press {
@@ -189,6 +205,8 @@ pub fn toolbar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                                         });
                                     }
                                     if slot.len() > 1 && long_press {
+                                        // Holding a tool button selects the tool it shows, as a click would (#4453).
+                                        app.ui.tool = tool;
                                         ui.ctx().request_repaint();
                                     }
                                     if let Some((open_key, anchor)) = ui.data(|d| d.get_temp::<(egui::Id, Rect)>(flyout_id))
@@ -240,11 +258,11 @@ pub fn toolbar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                                                             egui::FontId::proportional(12.5),
                                                             t.text,
                                                         );
-                                                        if item.key() != '\0' {
+                                                        if let Some(sc) = crate::tool_shortcuts::shortcut(app, item) {
                                                             ui.painter().text(
                                                                 pos2(r.right() - 8.0, r.center().y),
                                                                 Align2::RIGHT_CENTER,
-                                                                item.key().to_string(),
+                                                                crate::shortcuts::pretty(&sc),
                                                                 egui::FontId::proportional(12.0),
                                                                 t.text_dim,
                                                             );
@@ -257,10 +275,13 @@ pub fn toolbar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                                                 });
                                             },
                                         );
-                                        let held_release = resp.clicked() && ui.data(|d| d.get_temp::<egui::Id>(held_id)) == Some(key);
-                                        let clicked_outside =
-                                            ui.input(|i| i.pointer.any_click()) && !held_release && !area.response.hovered() && !resp.hovered();
-                                        if clicked_outside || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+                                        // Any press outside the flyout and its button closes it, as in Photoshop: a
+                                        // drag on the canvas (cropping, painting) isn't a click (#4460).
+                                        let pressed_outside = ui.input(|i| {
+                                            i.pointer.any_pressed()
+                                                && i.pointer.press_origin().is_some_and(|p| !area.response.rect.contains(p) && !resp.rect.contains(p))
+                                        });
+                                        if pressed_outside || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
                                             ui.data_mut(|d| d.remove::<(egui::Id, Rect)>(flyout_id));
                                         }
                                     }
@@ -282,25 +303,52 @@ pub fn toolbar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
 
                 ui.with_layout(layout, |ui| {
                     let quick_mask = app.session.active().is_some_and(|s| s.doc.quick_mask.is_some());
-                    if icons::button(
+                    if icons::button_with_icon_size_tip(
                         ui,
                         "square-dashed",
                         bx,
+                        (bx * 0.52).round(),
                         quick_mask,
                         if quick_mask { tl!("Edit in Standard Mode  (Q)") } else { tl!("Edit in Quick Mask Mode  (Q)") },
+                        tool_tips,
                     )
                     .clicked()
                     {
                         let _ = crate::menus::invoke(app, &ctx, "select.editInQuickMaskMode", json!({}));
                     }
-                    let sm = icons::button(ui, "app-window", bx, false, tl!("Change Screen Mode  (F)"));
+                    let sm = icons::button_with_icon_size_tip(ui, "app-window", bx, (bx * 0.52).round(), false, tl!("Change Screen Mode  (F)"), tool_tips);
                     paint_toolbar_flyout_indicator(ui, &t, &sm);
 
-                    if sm.clicked() {
+                    // Right-click, or click and hold like the tool flyouts (#4444), lists the modes,
+                    // like Photoshop's flyout. The release that ends a hold doesn't cycle the mode.
+                    let held_id = sm.id.with("held");
+                    let was_held = ui.data(|d| d.get_temp::<bool>(held_id)).unwrap_or(false);
+                    let held_for = sm.is_pointer_button_down_on().then(|| ui.input(|i| i.pointer.press_start_time().map(|t0| i.time - t0))).flatten();
+                    if let Some(seconds) = held_for
+                        && seconds < 0.35
+                    {
+                        ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(0.35 - seconds));
+                    }
+                    let long_press = !was_held && held_for.is_some_and(|seconds| seconds >= 0.35);
+                    if long_press {
+                        ui.data_mut(|d| d.insert_temp(held_id, true));
+                    } else if was_held && !sm.is_pointer_button_down_on() {
+                        ui.data_mut(|d| d.remove::<bool>(held_id));
+                    }
+                    let cycle = sm.clicked() && !was_held;
+                    if cycle {
                         let _ = crate::menus::invoke(app, &ctx, "view.screenMode.cycle", json!({}));
                     }
-                    // Right-click (or long-press) lists the modes, like Photoshop's flyout.
-                    egui::Popup::context_menu(&sm).show(|ui| {
+                    let open = if sm.secondary_clicked() || long_press {
+                        Some(egui::SetOpenCommand::Bool(true))
+                    } else if cycle {
+                        Some(egui::SetOpenCommand::Bool(false))
+                    } else {
+                        None
+                    };
+                    // The release ending the hold counts as a click; it mustn't close the list it opened.
+                    let close = if was_held || long_press { egui::PopupCloseBehavior::IgnoreClicks } else { egui::PopupCloseBehavior::CloseOnClick };
+                    egui::Popup::menu(&sm).open_memory(open).close_behavior(close).at_pointer_fixed().show(|ui| {
                         ui.set_min_width(220.0);
                         for (id, label) in [
                             ("view.screenMode.standard", tl!("Standard Screen Mode")),
@@ -511,17 +559,25 @@ fn color_chips(app: &mut PhotocraftApp, ui: &mut egui::Ui, two_columns: bool) {
 
 /// The app's top bar: brand mark, menus, the document title and the workspace controls. With
 /// [`PhotocraftApp::custom_titlebar`] (Windows and Linux) it is also the window's title bar, as in
-/// Photoshop on Windows: the caption buttons take its right end (`titlebar`). With the system
+/// Photoshop on Windows: the caption buttons take its ends (`titlebar`). With the system
 /// title bar (Windows and Linux, `system_title_bar`) the OS draws its own icon and title, so the
 /// in-app bar shows menus and workspace controls only: no brand mark, no centred title.
 pub fn title_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let t = Tokens::get(ui.ctx());
     let custom = app.custom_titlebar;
     let system = system_title_bar(app);
-    let left = if cfg!(target_os = "macos") && app.integrated_titlebar { 78 } else { 10 };
-    let right = if custom { 0 } else { 10 };
+    // The caption buttons' room at each end (`titlebar`); a side with buttons has no margin.
+    let (caption_left, caption_right) = crate::titlebar::reserved(app, ui.ctx());
+    let left = if cfg!(target_os = "macos") && app.integrated_titlebar {
+        78
+    } else if caption_left > 0.0 {
+        0
+    } else {
+        10
+    };
+    let right = if caption_right > 0.0 { 0 } else { 10 };
     let bar = egui::Panel::top("title_bar")
-        .exact_size(if t.pro { 32.0 } else { 38.0 })
+        .exact_size(crate::titlebar::bar_height(app, ui.ctx(), if t.pro { 32.0 } else { 38.0 }))
         .frame(egui::Frame::NONE.fill(t.chrome).inner_margin(egui::Margin { left, right, top: 0, bottom: 0 }))
         .show(ui, |ui| {
             let full = ui.max_rect();
@@ -531,6 +587,7 @@ pub fn title_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             let span_id = ui.id().with("titledrag-span");
             let (gap_l, gap_r) = ui.ctx().data(|d| d.get_temp::<(f32, f32)>(span_id)).unwrap_or((full.right(), full.right()));
             let gap = egui::Rect::from_x_y_ranges(gap_l.max(full.left())..=gap_r.min(full.right()).max(gap_l), full.y_range());
+            ui.ctx().data_mut(|d| d.insert_temp(crate::titlebar::modal_drag_area_id(), gap));
             let drag = ui.interact(gap, ui.id().with("titledrag"), Sense::click_and_drag());
             if drag.drag_started() {
                 ui.ctx().send_viewport_cmd(egui::ViewportCommand::StartDrag);
@@ -547,9 +604,10 @@ pub fn title_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             let rtl = crate::direction::is_rtl();
             let mut free = (full.left(), full.right());
             crate::direction::horizontal_centered(ui, |ui| {
-                if rtl && custom {
-                    // The caption buttons keep the right end; the menus start beside them.
-                    ui.add_space(crate::titlebar::WIDTH + 4.0);
+                // The menus start beside the caption buttons at their end, if it has any.
+                let lead = if rtl { caption_right } else { caption_left };
+                if lead > 0.0 {
+                    ui.add_space(lead + 4.0);
                 }
                 if !system {
                     let side = if t.pro { 18.0 } else { 20.0 };
@@ -567,9 +625,10 @@ pub fn title_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                 // The menu bar takes the whole row, so the far-end group gets its own rect: from
                 // the menus to the bar's end, or to the caption buttons.
                 let group = if rtl {
-                    egui::Rect::from_min_max(egui::pos2(full.left(), full.top()), egui::pos2((menus_end - TITLE_GAP).max(full.left()), full.bottom()))
+                    let left_edge = if caption_left > 0.0 { full.left() + caption_left + 4.0 } else { full.left() };
+                    egui::Rect::from_min_max(egui::pos2(left_edge, full.top()), egui::pos2((menus_end - TITLE_GAP).max(left_edge), full.bottom()))
                 } else {
-                    let right_edge = if custom { full.right() - crate::titlebar::WIDTH - 4.0 } else { full.right() };
+                    let right_edge = if caption_right > 0.0 { full.right() - caption_right - 4.0 } else { full.right() };
                     egui::Rect::from_min_max(egui::pos2((menus_end + TITLE_GAP).min(right_edge), full.top()), egui::pos2(right_edge, full.bottom()))
                 };
                 let mut group_ui = ui.new_child(egui::UiBuilder::new().max_rect(group).layout(crate::direction::trailing()));
@@ -850,10 +909,22 @@ fn reveal_focused_control(ui: &egui::Ui) {
 
 // ----------------------------------------------------------------------------- options bar
 
+/// Options bar height: Preferences ▸ Workspace ▸ Enable Narrow Options Bar trims it, as in
+/// Photoshop, leaving the document more room.
+fn options_bar_height(pro: bool, narrow: bool) -> f32 {
+    match (pro, narrow) {
+        (true, false) => 36.0,
+        (true, true) => 30.0,
+        (false, false) => 42.0,
+        (false, true) => 34.0,
+    }
+}
+
 pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let t = Tokens::get(ui.ctx());
+    let narrow = app.session.prefs().workspace.narrow_options_bar();
     egui::Panel::top("options_bar")
-        .exact_size(if t.pro { 36.0 } else { 42.0 })
+        .exact_size(options_bar_height(t.pro, narrow))
         .frame(egui::Frame::NONE.fill(t.chrome).inner_margin(egui::Margin::symmetric(10, 0)))
         .show(ui, |ui| {
             ui.style_mut().spacing.scroll = egui::style::ScrollStyle { bar_width: 4.0, ..egui::style::ScrollStyle::floating() };
@@ -893,7 +964,7 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                     crate::transform_tool::options_bar(app, ui);
                     return;
                 }
-                if crate::distort_ui::options_bar(app, ui) {
+                if crate::symmetry_ui::options_bar(app, ui) || crate::distort_ui::options_bar(app, ui) {
                     return;
                 }
                 let tool = app.ui.tool;
@@ -999,6 +1070,10 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                         widgets::vline(ui, 22.0);
                         if app.ui.tool == Tool::Eraser {
                             crate::eraser_ui::mode_dropdown(ui, &mut app.ui.tool_options.eraser_mode);
+                        } else {
+                            opt_label(ui, tl!("Mode"));
+                            let held = app.held_erase;
+                            paint_mode_dropdown(ui, "brush-mode", b, &mut app.ui.tool_options.brush_clear, held);
                         }
                         // A Pencil-mode Eraser is always hard and at full flow (Photoshop).
                         let fixed = block || crate::eraser_ui::pencil_mode(app, app.ui.tool);
@@ -1157,7 +1232,7 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                         widgets::checkbox(ui, &mut app.ui.tool_options.contiguous, tl!("Contiguous"));
                         widgets::checkbox(ui, &mut app.ui.tool_options.sample_all_layers, tl!("All Layers"));
                     }
-                    Tool::Gradient if t.pro => {
+                    Tool::Gradient => {
                         // Live "Gradient" (a Gradient Fill layer) or "Classic gradient" (pixels).
                         let mut classic = app.ui.tool_options.gradient_classic;
                         if widgets::dropdown(ui, "gradient-mode", &mut classic, &[(false, "Gradient"), (true, "Classic gradient")], 118.0) {
@@ -1173,7 +1248,7 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                         ui.spacing_mut().item_spacing.x = 2.0;
                         let before = app.ui.tool_options.clone();
                         for (style, icon, tip) in [
-                            ("linear", "blend", tl!("Linear Gradient")),
+                            ("linear", "gradient", tl!("Linear Gradient")),
                             ("radial", "circle", tl!("Radial Gradient")),
                             ("angle", "rotate-cw", tl!("Angle Gradient")),
                             ("reflected", "arrow-left-right", tl!("Reflected Gradient")),
@@ -1187,9 +1262,20 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                         widgets::vline(ui, 22.0);
                         opt_label(ui, tl!("Mode"));
                         let opts: Vec<(BlendMode, &str)> = BlendMode::LAYER_MODES.iter().map(|m| (*m, m.label())).collect();
-                        widgets::dropdown(ui, "gradient-blend-mode", &mut app.ui.tool_options.gradient_blend_mode, &opts, 96.0);
+                        // The wheel over it steps the mode, as over the Layers panel's (#2061).
+                        widgets::dropdown_wheel_hovered(ui, "gradient-blend-mode", &mut app.ui.tool_options.gradient_blend_mode, &opts, 96.0);
                         opt_label(ui, tl!("Opacity"));
-                        widgets::value_field(ui, &mut app.ui.tool_options.fill_opacity, 1.0..=100.0, "%", 62.0);
+                        let r = widgets::value_field(ui, &mut app.ui.tool_options.fill_opacity, 1.0..=100.0, "%", 62.0);
+                        // Live while scrubbed, one undo step per scrub (#5012).
+                        let drag_key = r.id.with("gradient-opacity-drag");
+                        if r.drag_started() {
+                            let n = ui.ctx().cumulative_pass_nr();
+                            ui.data_mut(|d| d.insert_temp(drag_key, n));
+                        }
+                        if r.changed() {
+                            let drag = if r.dragged() { ui.data(|d| d.get_temp::<u64>(drag_key)) } else { None };
+                            crate::gradient_ui::opacity_changed(app, drag);
+                        }
                         widgets::checkbox(ui, &mut app.ui.tool_options.gradient_reverse, tl!("Reverse"));
                         widgets::checkbox(ui, &mut app.ui.tool_options.gradient_dither, tl!("Dither"));
                         // Live mode: the options also change a selected gradient fill layer.
@@ -1385,7 +1471,6 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                             &[("commit", &crate::shortcuts::pretty("Enter"))],
                         ),
                     ),
-                    Tool::Gradient => hint(ui, tl!("Drag to draw a gradient")),
                     Tool::PaintBucket => hint(ui, tl!("Click to fill similar colours")),
                     // Retouching and smart-selection tools draw their bar in `retouch_ui::options_bar`.
                     _ => {}
@@ -1423,10 +1508,10 @@ fn label(ui: &mut egui::Ui, s: &str) {
 
 /// Photoshop's scrubby Opacity/Fill labels: drag horizontally to change the percentage without
 /// hitting the small number field. The unique drag ID coalesces every frame into one undo step.
-fn scrub_pct_label(ui: &mut egui::Ui, text: &str, percent: &mut f32) -> widgets::PopupFieldResponse {
-    let t = Tokens::get(ui.ctx());
-    let resp =
-        ui.add(egui::Label::new(RichText::new(text).color(t.text_dim)).sense(Sense::click_and_drag())).on_hover_cursor(egui::CursorIcon::ResizeHorizontal);
+fn scrub_pct_label(ui: &mut egui::Ui, text: &str, percent: &mut f32, max_w: f32) -> widgets::PopupFieldResponse {
+    // Elide to the room left in the row (full text on hover): a longer translation shrinks here
+    // instead of running over the fixed controls beside it (#3580).
+    let resp = widgets::elided_label_sensed(ui, text, max_w, Sense::click_and_drag()).on_hover_cursor(egui::CursorIcon::ResizeHorizontal);
     let key = resp.id.with("percent-label-drag");
     if resp.drag_started() {
         let stamp = ui.ctx().cumulative_pass_nr();
@@ -1499,14 +1584,19 @@ pub fn status_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                 if t.pro {
                     crate::chrome_ui::status_bar_pro(app, ui);
                     // Background job progress with Cancel, at the far end (#210).
-                    ui.with_layout(crate::direction::trailing(), |ui| crate::jobs_ui::status_progress(app, ui));
+                    ui.with_layout(crate::direction::trailing(), |ui| {
+                        crate::jobs_ui::status_progress(app, ui);
+                        crate::background_redraw::status(app, ui);
+                    });
                     return;
                 }
                 if let (Some(st), Some(i)) = (app.session.active(), app.session.active_index()) {
                     let (w, h, mode, bits, layers) =
                         (st.doc.size.width, st.doc.size.height, crate::canvas::mode_label(&st.doc), st.doc.depth.bits(), st.doc.layer_count());
                     let mut pct = app.ui.views[i].zoom * 100.0;
-                    if widgets::compact_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[i]), "%", 78.0, control_h).changed() {
+                    if widgets::compact_wrapping_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[i]), "%", vec2(78.0, control_h))
+                        .changed()
+                    {
                         app.ui.views[i].zoom = crate::zoom_levels::clamp(pct / 100.0, app.ui.views[i].doc_size);
                         app.ui.views[i].fit_pending = false;
                     }
@@ -1536,6 +1626,7 @@ pub fn status_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                         ui.add_space(6.0);
                         crate::jobs_ui::status_progress(app, ui);
                     }
+                    crate::background_redraw::status(app, ui);
                 });
             });
         });
@@ -1666,7 +1757,7 @@ fn info_panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         empty(ui, tl!("No document"));
         return;
     };
-    let (rev, size) = (st.revision, st.doc.size);
+    let (rev, size, origin) = (st.revision, st.doc.size, st.doc.ruler_origin);
     // Positions and sizes in the ruler unit (Preferences › Units & Rulers).
     let units = app.session.prefs().units_and_rulers.clone();
     let dpi = st.doc.resolution_dpi as f64;
@@ -1715,8 +1806,9 @@ fn info_panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     widgets::hairline(ui);
     ui.columns(2, |cols| {
         let dash = || "—".to_string();
-        row(&mut cols[0], "X:", pos.map_or_else(dash, |p| fx(p.0 as f64)));
-        row(&mut cols[0], "Y:", pos.map_or_else(dash, |p| fy(p.1 as f64)));
+        // Measured from the rulers' zero point (#2955).
+        row(&mut cols[0], "X:", pos.map_or_else(dash, |p| fx(p.0 as f64 - origin[0])));
+        row(&mut cols[0], "Y:", pos.map_or_else(dash, |p| fy(p.1 as f64 - origin[1])));
         row(&mut cols[1], "W:", sel.map_or_else(dash, |r| fx(r.width() as f64)));
         row(&mut cols[1], "H:", sel.map_or_else(dash, |r| fy(r.height() as f64)));
     });
@@ -1765,7 +1857,6 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         return;
     };
     let ctx = ui.ctx().clone();
-    let Some(tex) = crate::canvas::navigator_texture(app, &ctx, idx) else { return };
     let size = app.session.documents()[idx].doc.size;
     let avail = ui.available_width();
     // The preview fills the group's height above the zoom controls (their height as measured
@@ -1777,8 +1868,16 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     ui.painter().rect_filled(frame, t.radius_sm, t.canvas);
     let rect = navigator_fit(frame, size.width, size.height);
     ui.data_mut(|d| d.insert_temp(navigator_preview_id(), rect));
-    widgets::checker(ui.painter(), rect, 6.0);
-    ui.painter().image(tex, rect, Rect::from_min_max(egui::Pos2::ZERO, pos2(1.0, 1.0)), Color32::WHITE);
+    // On the GPU canvas, its own texture at this size (#4518); otherwise the CPU thumbnail.
+    if let Some(params) = crate::canvas::navigator_gpu_view(app, idx, rect, &ctx) {
+        crate::gpu_canvas::GpuCanvas::paint(ui.painter(), rect, params);
+    } else if crate::canvas::navigator_waits_for_gpu(app, idx, &ctx) {
+        widgets::checker(ui.painter(), rect, 6.0);
+    } else {
+        let Some(tex) = crate::canvas::navigator_texture(app, &ctx, idx) else { return };
+        widgets::checker(ui.painter(), rect, 6.0);
+        ui.painter().image(tex, rect, Rect::from_min_max(egui::Pos2::ZERO, pos2(1.0, 1.0)), Color32::WHITE);
+    }
     let s = rect.width() / size.width.max(1) as f32;
     if (resp.clicked() || resp.dragged())
         && let Some(pp) = resp.interact_pointer_pos()
@@ -1812,29 +1911,38 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let c = pos2(rect.min.x + v.center[0] * s, rect.min.y + v.center[1] * s);
     let vr = Rect::from_center_size(c, vec2(vw, vh)).intersect(frame.shrink(1.0));
     ui.painter().rect_stroke(vr, 2.0, Stroke::new(1.5, Color32::from_rgb(255, 84, 84)), StrokeKind::Middle);
+    // Photoshop's one row under the preview (#4840): the zoom, typed in percent, then Zoom Out,
+    // the slider and Zoom In.
     let controls = ui.vertical(|ui| {
         ui.add_space(4.0);
         ui.horizontal(|ui| {
-            label(ui, crate::i18n::tr_ctx(crate::i18n::current(), "navigator", "Zoom"));
-            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                for (lbl, z) in [("200%", 2.0), ("100%", 1.0)] {
-                    if widgets::pill_tab(ui, lbl, (v.zoom - z).abs() < 1e-3).clicked() {
-                        app.ui.views[idx].zoom = z;
-                        app.ui.views[idx].fit_pending = false;
-                    }
-                }
-                if widgets::pill_tab(ui, tl!("Fit"), false).clicked() {
-                    app.ui.views[idx].fit_pending = true;
-                }
-            });
+            ui.spacing_mut().item_spacing.x = 4.0;
+            let set = |app: &mut PhotocraftApp, zoom: f32| {
+                app.ui.views[idx].zoom = crate::zoom_levels::clamp(zoom, v.doc_size);
+                app.ui.views[idx].fit_pending = false;
+            };
+            let mut pct = v.zoom * 100.0;
+            let field = widgets::compact_wrapping_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[idx]), "%", vec2(64.0, NAV_ROW_H));
+            if field.changed() {
+                set(app, pct / 100.0);
+            }
+            let out = crate::brush_picker::named(icons::button(ui, "minus", NAV_ROW_H, false, tl!("Zoom Out")), "Zoom Out");
+            if out.clicked() {
+                set(app, crate::zoom_levels::step(v.zoom, -1, v.doc_size));
+            }
+            // The whole zoom range, and always the current zoom: a narrower slider would pull it back.
+            let (lo, hi) = (crate::zoom_levels::min(v.doc_size).min(v.zoom).log2(), crate::zoom_levels::MAX.max(v.zoom).log2());
+            let mut lz = v.zoom.log2();
+            let slider_w = (ui.available_width() - NAV_ROW_H - 4.0).max(60.0);
+            let slid = ui.allocate_ui(vec2(slider_w, NAV_ROW_H), |ui| lz.is_finite() && widgets::slider(ui, &mut lz, lo..=hi, None).changed()).inner;
+            if slid {
+                set(app, 2f32.powf(lz));
+            }
+            let zin = crate::brush_picker::named(icons::button(ui, "plus", NAV_ROW_H, false, tl!("Zoom In")), "Zoom In");
+            if zin.clicked() {
+                set(app, crate::zoom_levels::step(v.zoom, 1, v.doc_size));
+            }
         });
-        // The whole zoom range, and always the current zoom: a narrower slider would pull it back.
-        let (lo, hi) = (crate::zoom_levels::min(v.doc_size).min(v.zoom).log2(), crate::zoom_levels::MAX.max(v.zoom).log2());
-        let mut lz = v.zoom.log2();
-        if lz.is_finite() && widgets::slider(ui, &mut lz, lo..=hi, None).changed() {
-            app.ui.views[idx].zoom = crate::zoom_levels::clamp(2f32.powf(lz), v.doc_size);
-            app.ui.views[idx].fit_pending = false;
-        }
     });
     // From the preview's bottom, so the spacing above the controls counts too.
     let controls = Rect::from_min_max(pos2(frame.left(), frame.bottom()), pos2(frame.right(), controls.response.rect.bottom()));
@@ -1844,6 +1952,9 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     });
 }
 
+/// Height of the Navigator's zoom row: its field, buttons and slider.
+const NAV_ROW_H: f32 = 22.0;
+
 /// The document's `w` × `h` fitted inside the Navigator's `frame` with an 8 pt inset, centred and
 /// keeping its aspect.
 fn navigator_fit(frame: Rect, w: u32, h: u32) -> Rect {
@@ -1914,6 +2025,33 @@ mod navigator_wheel_tests {
         frame(&mut app, &ctx, below, 1.0);
         assert!((app.ui.views[0].zoom - 1.0).abs() < 1e-4, "wheel outside preview leaves zoom unchanged");
     }
+
+    /// #4840: under the preview, one row as in Photoshop: the zoom in percent, Zoom Out, the
+    /// slider and Zoom In. The buttons step the zoom like View › Zoom In / Out.
+    #[test]
+    fn navigator_zoom_row_is_one_line_and_its_buttons_step_the_zoom() {
+        use egui_kittest::kittest::Queryable;
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+        app.sync_views();
+        app.ui.views[0].zoom = 1.0;
+        app.ui.views[0].fit_pending = false;
+        let mut h = egui_kittest::Harness::builder().with_size(vec2(360.0, 300.0)).build_ui_state(|ui, app: &mut PhotocraftApp| navigator(app, ui), app);
+        PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+        h.run_steps(4);
+        let row = last_navigator_controls(&h.ctx).expect("the zoom row");
+        assert!(row.height() <= NAV_ROW_H + 14.0, "one row (with the gap above it): {row:?}");
+        let zoom = |h: &egui_kittest::Harness<'_, PhotocraftApp>| h.state().ui.views[0].zoom;
+        h.get_by_label("Zoom In").click();
+        h.run_steps(2);
+        assert!((zoom(&h) - crate::zoom_levels::step(1.0, 1, [200, 100])).abs() < 1e-4, "{}", zoom(&h));
+        h.get_by_label("Zoom Out").click();
+        h.run_steps(2);
+        h.get_by_label("Zoom Out").click();
+        h.run_steps(2);
+        assert!((zoom(&h) - crate::zoom_levels::step(1.0, -1, [200, 100])).abs() < 1e-4, "{}", zoom(&h));
+        assert!(!h.state().ui.views[0].fit_pending);
+    }
 }
 
 fn empty(ui: &mut egui::Ui, s: &str) {
@@ -1923,7 +2061,16 @@ fn empty(ui: &mut egui::Ui, s: &str) {
     ui.add_space(6.0);
 }
 
+/// The Color tab of the themes other than Photoshop's: the same spectrum field (chips, saturation
+/// and brightness field, hue strip and readout) with HSB sliders under it (#4367).
 fn color_picker(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
+    color_field(app, ui);
+    ui.add_space(8.0);
+    hsb_sliders(app, ui);
+}
+
+/// Hue, Saturation and Brightness sliders for the foreground colour.
+fn hsb_sliders(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let fg = app.session.tools.foreground;
     // Keep the last edited HSB while it still gives the foreground: black and greys have no hue or
     // saturation of their own, so recomputing them from RGB would reset what was just typed to 0.
@@ -1950,16 +2097,6 @@ fn color_picker(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         ui.data_mut(|d| d.insert_temp(key, hsva));
         crate::type_tool::foreground_changed(app);
     }
-    ui.horizontal(|ui| {
-        let (sw, _) = ui.allocate_exact_size(vec2(26.0, 26.0), Sense::hover());
-        ui.painter().rect_filled(sw, 6.0, hsva_color32(hsva));
-        let mut c = app.session.tools.foreground;
-        if color_readout(ui, ui.id().with("color-panel"), &mut c) {
-            app.session.tools.foreground = c;
-            ui.data_mut(|d| d.insert_temp(key, srgb_hsva(c)));
-            crate::type_tool::foreground_changed(app);
-        }
-    });
 }
 
 // ----------------------------------------------------------------------------- layers
@@ -1973,9 +2110,8 @@ fn simple_lock_toggle(background: bool, l: &Layer) -> (String, Value) {
     if background {
         return ("layer.new.layerFromBackground".into(), json!({}));
     }
-    let k = &l.locks;
-    let locked = k.transparency || k.pixels || k.position || k.artboard || k.all;
-    let locks = if locked { json!({"transparency": false, "pixels": false, "position": false, "artboard": false, "all": false}) } else { json!({"all": true}) };
+    let locks =
+        if l.locks.any() { json!({"transparency": false, "pixels": false, "position": false, "artboard": false, "all": false}) } else { json!({"all": true}) };
     ("layer.setProps".into(), json!({"layer": l.id.0, "locks": locks}))
 }
 
@@ -2088,7 +2224,11 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                     let mut o = l.opacity * 100.0;
                     let field = widgets::popup_value_field(ui, opacity_label, &mut o, 0.0..=100.0, "%", LAYER_PCT_W);
                     // On a narrow dock the (scrubby) label yields its room to the controls (#2309).
-                    let scrub = if show_opacity_label { scrub_pct_label(ui, opacity_label, &mut o) } else { widgets::PopupFieldResponse::default() };
+                    let scrub = if show_opacity_label {
+                        scrub_pct_label(ui, opacity_label, &mut o, ui.available_width())
+                    } else {
+                        widgets::PopupFieldResponse::default()
+                    };
                     if field.changed || scrub.changed {
                         actions.push(pct_action(l, "opacity", o, scrub.drag.or(field.drag)));
                     }
@@ -2123,14 +2263,16 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                         ("artboard", "scan", tl!("Prevent auto-nesting in and out of Artboards and Frames"), lk.artboard),
                         ("all", "lock", tl!("Lock all"), lk.all),
                     ] {
-                        if icons::button(ui, icon, 20.0, on, tip).clicked() {
+                        // Lock Image Pixels includes Lock Transparent Pixels, which waits for it (#4892).
+                        let enabled = key != "transparency" || !lk.pixels;
+                        if ui.add_enabled_ui(enabled, |ui| icons::button(ui, icon, 20.0, on, tip)).inner.clicked() {
                             actions.push(("layer.setProps".into(), json!({"layer": l.id.0, "locks": { key: !on }})));
                         }
                     }
                 });
             }
             if !t.pro {
-                let locked = l.locks.transparency || l.locks.position || l.locks.all;
+                let locked = l.locks.any();
                 if icons::button(ui, if locked { "lock" } else { "lock-open" }, 22.0, locked, tl!("Lock layer")).clicked() {
                     actions.push(simple_lock_toggle(bg, l));
                 }
@@ -2139,7 +2281,7 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                 ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                     let mut f = l.fill_opacity * 100.0;
                     let field = widgets::popup_value_field(ui, fill_label, &mut f, 0.0..=100.0, "%", LAYER_PCT_W);
-                    let scrub = scrub_pct_label(ui, fill_label, &mut f);
+                    let scrub = scrub_pct_label(ui, fill_label, &mut f, ui.available_width());
                     if field.changed || scrub.changed {
                         actions.push(pct_action(l, "fill", f, scrub.drag.or(field.drag)));
                     }
@@ -2167,8 +2309,13 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             if !ctx.input(|i| i.pointer.primary_down() || i.pointer.any_released()) {
                 ctx.data_mut(|d| d.remove::<FxDrag>(fx_drag_key()));
                 ctx.data_mut(|d| d.remove::<MaskDrag>(mask_drag_key()));
+                ctx.data_mut(|d| d.remove::<crate::smart_ui::FilterDrag>(crate::smart_ui::drag_key()));
             }
-            let held = ctx.data(|d| d.get_temp::<u64>(egui::Id::new("layer-drag")).is_some() || d.get_temp::<FxDrag>(fx_drag_key()).is_some());
+            let held = ctx.data(|d| {
+                d.get_temp::<u64>(egui::Id::new("layer-drag")).is_some()
+                    || d.get_temp::<FxDrag>(fx_drag_key()).is_some()
+                    || d.get_temp::<crate::smart_ui::FilterDrag>(crate::smart_ui::drag_key()).is_some()
+            });
             let dragging = held && ctx.input(|i| i.pointer.primary_down());
             let pointer = ctx.input(|i| i.pointer.interact_pos());
             let delta = layer_drag_edge_scroll(pointer, ui.clip_rect(), dragging, ctx.input(|i| i.stable_dt));
@@ -2222,6 +2369,16 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                 let below = Rect::from_min_max(pos2(last_rect.left(), last_rect.bottom()), pos2(last_rect.right(), ui.clip_rect().bottom()));
                 layer_drop_zone(app, &ctx, ui, below, (last, last_rect), "below", &mut actions);
             }
+            // Tab / ⇧Tab in a rename: rename the layer below / above next, as in Photoshop. The
+            // Background isn't renamed in place (double-clicking it converts it), so it ends there.
+            if let Some((from, up)) = crate::layer_row_ui::take_next_rename(ui.ctx())
+                && let Some(at) = drawn.iter().position(|(id, _)| id.0 == from)
+                && let Some(&(next, _)) = if up { at.checked_sub(1).and_then(|i| drawn.get(i)) } else { drawn.get(at + 1) }
+                && let Some(l) = doc.layer(next).filter(|l| !crate::doc_props_ui::is_background(&doc, l))
+                && let Some(done) = crate::layer_row_ui::start_rename(ui.ctx(), next.0, &l.name)
+            {
+                actions.push(done);
+            }
             // ⌥-click the line between two layers: clip / release the upper one (#967).
             crate::clip_line_ui::show(ui, &doc, &mut actions);
             // A rename whose row is gone (deleted, filtered out, inside a closed group) ends,
@@ -2242,6 +2399,9 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     // An effect row can be dropped on Delete too (#3102), and a mask's thumbnail (#3113, #3119).
     let fx_footer_drag = ctx.data(|d| d.get_temp::<FxDrag>(fx_drag_key()));
     fx_drag_feedback(&ctx, &doc);
+    // And a smart filter's row (#4271).
+    let filter_footer_drag = ctx.data(|d| d.get_temp::<crate::smart_ui::FilterDrag>(crate::smart_ui::drag_key()));
+    crate::smart_ui::drag_feedback(&ctx, &doc);
     let mask_footer_drag = ctx.data(|d| d.get_temp::<MaskDrag>(mask_drag_key()));
     if let Some((_, kind)) = mask_footer_drag
         && let Some(p) = ctx.input(|i| i.pointer.interact_pos())
@@ -2254,6 +2414,7 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         ctx.data_mut(|d| d.remove::<u64>(egui::Id::new("layer-drag")));
         ctx.data_mut(|d| d.remove::<FxDrag>(fx_drag_key()));
         ctx.data_mut(|d| d.remove::<MaskDrag>(mask_drag_key()));
+        ctx.data_mut(|d| d.remove::<crate::smart_ui::FilterDrag>(crate::smart_ui::drag_key()));
     }
     widgets::panel_footer(ui, |ui| {
         let active_layer = active.and_then(|id| doc.layer(id));
@@ -2265,7 +2426,14 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             ("layer.delete", "Delete layer")
         };
         let trash = icons::button(ui, "trash", 26.0, false, tl!(label));
-        if trash.clicked() {
+        // A selected smart filter row is what Delete removes, as in Photoshop (#4751).
+        let picked_filter = crate::smart_ui::selected(&ctx, &doc, active);
+        if trash.clicked()
+            && let Some(picked) = picked_filter
+        {
+            actions.push(crate::smart_ui::trash_action(picked));
+            crate::smart_ui::deselect(&ctx, doc.id);
+        } else if trash.clicked() {
             // Like Photoshop, ⌥/Alt-click deletes without asking.
             let confirm = delete == "layer.delete" && !ui.input(|i| i.modifiers.alt);
             let params = if confirm { json!({"__trash": true}) } else { json!({}) };
@@ -2273,6 +2441,11 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         }
         actions.extend(footer_drop(ui, &trash, footer_drag, "layer.delete"));
         actions.extend(fx_trash_drop(ui, &trash, fx_footer_drag));
+        if let Some(drag) = filter_footer_drag
+            && dropped_on(ui, &trash)
+        {
+            actions.push(crate::smart_ui::trash_action(drag));
+        }
         // Photoshop asks "Apply mask to layer before removing?" or "Delete the vector mask?"
         // (`mask_trash_prompt`).
         if let Some((layer, kind)) = mask_footer_drag
@@ -2285,9 +2458,17 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         trash.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, tl!(label)));
         let new_layer = icons::button(ui, "square-plus", 26.0, false, &crate::shortcuts::tip_label(app, "Create a new layer", "layer.new.layer"));
         if new_layer.clicked() {
-            // A click makes the layer; ⌥-click asks first (the New Layer dialog), as in Photoshop.
-            let alt = ui.input(|i| i.modifiers.alt);
-            actions.push(("layer.new.layer".into(), if alt { Value::Null } else { json!({}) }));
+            // A click makes the layer above the selection; ⌥-click asks first (the New Layer
+            // dialog) and ⌘/Ctrl-click adds it below, as in Photoshop.
+            let (alt, below) = ui.input(|i| (i.modifiers.alt, i.modifiers.command));
+            let params = if alt {
+                Value::Null
+            } else if below {
+                json!({"position": "below"})
+            } else {
+                json!({})
+            };
+            actions.push(("layer.new.layer".into(), params));
         }
         actions.extend(footer_drop(ui, &new_layer, footer_drag, "layer.duplicate"));
         let group = icons::button(ui, "folder", 26.0, false, tl!("Create a new group"));
@@ -2330,7 +2511,12 @@ fn layers(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         if mask_btn.clicked()
             && let Some(cmd) = mask_cmd
         {
-            actions.push((cmd.into(), json!({})));
+            // A path selected in the Paths panel becomes the vector mask, as in Photoshop (#4728);
+            // Alt still inverts it.
+            match crate::vector_ui::selected_document_path(app).filter(|_| cmd.starts_with("layer.vectorMask.")) {
+                Some(name) => actions.push(("layer.vectorMask.currentPath".into(), json!({"name": name, "hide": alt}))),
+                None => actions.push((cmd.into(), json!({}))),
+            }
         }
         let fx = fx_button(ui, 26.0, tl!("Add a layer style"));
         crate::press_menu::show(&fx, |ui, menu| {
@@ -2396,7 +2582,7 @@ fn footer_drop(ui: &egui::Ui, button: &egui::Response, drag: Option<(u64, bool)>
 }
 
 /// While something is dragged over a footer `button`: highlights it, and is true on the release.
-fn dropped_on(ui: &egui::Ui, button: &egui::Response) -> bool {
+pub(crate) fn dropped_on(ui: &egui::Ui, button: &egui::Response) -> bool {
     let Some(p) = ui.ctx().input(|i| i.pointer.interact_pos()) else { return false };
     if !button.rect.contains(p) {
         return false;
@@ -2552,6 +2738,7 @@ fn layer_row(
     let mask_drag = mask_drag.is_some();
     layer_drag_and_drop(app, ctx, ui, l, rect, &resp, actions);
     fx_drop(ctx, ui, l, rect, actions);
+    crate::smart_ui::drop_on_row(ctx, ui, l, rect, actions);
     if resp.drag_started() && !mask_drag {
         crate::layer_transfer::begin_from_panel(app, ctx, l.id);
     }
@@ -2564,17 +2751,23 @@ fn layer_row(
         return rect;
     }
     let painter = ui.painter_at(rect.expand(1.0));
+    let is_hovered = resp.hovered() || app.canvas_hover_layer == Some(l.id);
+    if resp.hovered() {
+        app.hover_layer = Some(l.id);
+    }
     if t.pro {
         if selected {
             painter.rect_filled(rect, 0.0, t.row_selected);
-        } else if resp.hovered() {
+        } else if is_hovered {
             painter.rect_filled(rect, 0.0, t.hover.gamma_multiply(0.5));
+            painter.rect_filled(rect, 0.0, t.accent.gamma_multiply(0.12));
         }
     } else if selected {
         painter.rect_filled(rect, t.radius, t.hover);
         painter.rect_stroke(rect, t.radius, Stroke::new(1.0, t.field_border), StrokeKind::Inside);
-    } else if resp.hovered() {
+    } else if is_hovered {
         painter.rect_filled(rect, t.radius, t.hover.gamma_multiply(0.5));
+        painter.rect_filled(rect, t.radius, t.accent.gamma_multiply(0.12));
     }
     let eye_cell = Rect::from_min_max(rect.left_top(), pos2((rect.left() + 30.0).min(rect.right()), rect.bottom()));
     if let Some((_, background)) = t.layer_label_colors(l.label) {
@@ -2604,6 +2797,10 @@ fn layer_row(
             actions.push(("layer.setProps".into(), json!({"layer": l.id.0, "visible": !l.visible})));
         }
     }
+    eye_resp.context_menu(|ui| {
+        crate::widgets::style_spectrum_popup_menu(ui);
+        crate::layer_menu_ui::color_choices(app, ui, l, row.multi && selected, actions);
+    });
     // Everything but the thumbnails, the indentation and the name, so a narrow panel squeezes
     // the indentation first, then the thumbnails (a layer with two masks has three).
     let others = 6.0
@@ -2650,10 +2847,17 @@ fn layer_row(
     {
         start_fx_drag(ctx, l.id, None);
     }
+    // Clicking the lock icon unlocks the layer, and makes the Background a normal one (Photoshop,
+    // #4723). It takes the click from the row, so the row isn't selected.
+    if let Some(&(_, lock)) = indicators.iter().find(|(k, _)| *k == crate::layer_row_ui::Indicator::Lock)
+        && ui.interact(lock, ui.id().with(("row-lock", l.id.0)), Sense::click()).clicked()
+    {
+        actions.push(simple_lock_toggle(doc.is_background(l.id), l));
+    }
     let name_color = if l.visible { t.text } else { t.text_faint };
     let font = if selected && !t.pro { theme::medium(13.0) } else { egui::FontId::proportional(if t.pro { 12.0 } else { 13.0 }) };
     // Photoshop before 2026 set the Background layer's name in italics; 2026 sets it upright.
-    let italic = !t.pro && l.name == "Background" && l.locks.transparency;
+    let italic = !t.pro && doc.is_background(l.id);
     // Photoshop rows show only the name; the kind sub-label is a Studio-theme addition.
     let is_pixel = t.pro || matches!(l.content, LayerContent::Raster(_));
     let name_rect = crate::layer_row_ui::truncated(&painter, &l.name, font, name_color, italic, name_right - x).map(|galley| {
@@ -2692,6 +2896,7 @@ fn layer_row(
     } else if resp.clicked() && !eye_resp.clicked() && !toggled && !fx_toggled && !masks.clicked {
         let mode = select_mode(ui.input(|i| i.modifiers));
         actions.push(("layer.select".into(), json!({"layer": l.id.0, "mode": mode})));
+        crate::smart_ui::deselect(ctx, doc.id);
         // A thumbnail explicitly selects content or a mask. Selecting an adjustment/fill row
         // defaults to its mask, but clicking its content thumbnail must leave the mask target.
         let pos = resp.interact_pointer_pos();
@@ -2718,6 +2923,11 @@ fn layer_row(
         } else if on_thumb || !row.primary {
             actions.push(("ui.maskTarget".into(), json!(false)));
         }
+        // ⌥-click the layer thumbnail: fit the layer on screen, as Photoshop does.
+        let m = ui.input(|i| i.modifiers);
+        if on_thumb && m.alt && !m.shift && !m.command {
+            actions.push(("view.fitLayersOnScreen".into(), Value::Null));
+        }
     }
     // Double-click: the name renames in place (over the row's full height, not just the glyphs:
     // #651); the Background, which can't be renamed while it's locked, becomes a normal layer; an
@@ -2764,17 +2974,29 @@ fn layer_row(
     if let Some(done) = crate::layer_row_ui::rename_field(ui, l.id.0, edit_rect) {
         actions.push(done);
     }
-    // Right-click context menu.
-    resp.context_menu(|ui| {
-        crate::widgets::style_spectrum_popup_menu(ui);
-        // Right-clicking inside a multi-selection keeps it and acts on every selected layer.
-        let on_set = row.multi && selected;
-        if crate::layer_menu_ui::show(app, ui, l, on_set, actions)
-            && let Some(done) = crate::layer_row_ui::start_rename(ui.ctx(), l.id.0, &l.name)
-        {
-            actions.push(done);
-        }
-    });
+    // The visibility icon has its own color menu, and the layer-mask thumbnail its mask menu
+    // (#4575); elsewhere use the full layer menu.
+    let on_mask_id = ui.id().with(("mask-menu", l.id.0));
+    if resp.secondary_clicked() {
+        let on_mask = resp.interact_pointer_pos().and_then(|p| masks.hit(p)) == Some(crate::mask_thumbs_ui::MaskKind::Pixel);
+        ctx.data_mut(|d| d.insert_temp(on_mask_id, on_mask));
+    }
+    if !eye_resp.secondary_clicked() && !eye_resp.context_menu_opened() {
+        resp.context_menu(|ui| {
+            crate::widgets::style_spectrum_popup_menu(ui);
+            if ui.ctx().data(|d| d.get_temp::<bool>(on_mask_id)).unwrap_or(false) {
+                crate::layer_menu_ui::show_mask(app, ui, l, actions);
+                return;
+            }
+            // Right-clicking inside a multi-selection keeps it and acts on every selected layer.
+            let on_set = row.multi && selected;
+            if crate::layer_menu_ui::show(app, ui, l, on_set, actions)
+                && let Some(done) = crate::layer_row_ui::start_rename(ui.ctx(), l.id.0, &l.name)
+            {
+                actions.push(done);
+            }
+        });
+    }
     rect
 }
 
@@ -2858,7 +3080,7 @@ fn history(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         ui.painter().line_segment([rect.left_bottom(), rect.right_bottom()], Stroke::new(1.0, t.separator));
     }
     let mut snap_cmd = None;
-    let mut target: Option<isize> = None;
+    let mut target: Option<usize> = None;
     let all = entries.iter().map(|e| (e.clone(), false)).chain(redo.iter().map(|e| (e.clone(), true)));
     // The dock gives History a fixed height: the rows scroll above the footer.
     let footer = if t.pro { widgets::footer_height(ui) + ui.spacing().item_spacing.y } else { 0.0 };
@@ -2869,6 +3091,7 @@ fn history(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         snap_cmd = snapshot_rows(app, ui);
         for (i, (e, is_redo)) in all.enumerate() {
             let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 24.0), Sense::click());
+            resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::SelectableLabel, true, i == current, &e));
             if i == current {
                 ui.painter().rect_filled(rect, if t.pro { 0.0 } else { t.radius_sm }, if t.pro { t.row_selected } else { t.accent_soft });
             } else if resp.hovered() {
@@ -2891,8 +3114,8 @@ fn history(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
                 if is_redo { t.text_faint } else { t.icon },
             );
             ui.painter().text(pos2(rect.left() + 58.0, rect.center().y), Align2::LEFT_CENTER, &e, egui::FontId::proportional(12.0), color);
-            if resp.clicked() {
-                target = Some(i as isize - current as isize);
+            if resp.clicked() && i != current {
+                target = Some(i);
             }
         }
     });
@@ -2923,13 +3146,13 @@ fn history(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         app.ui.status = e;
         app.ui.status_error = true;
     }
-    if let Some(delta) = target.filter(|_| app.ui.transform.is_none()) {
-        let (cmd, n) = if delta < 0 { ("edit.undo", -delta) } else { ("edit.redo", delta) };
-        for _ in 0..n {
-            if app.run(cmd, json!({})).is_err() {
-                break;
-            }
-        }
+    // One command per click (#2966): stepping with Undo/Redo once per state made the canvas
+    // recomposite the whole document.
+    if let Some(state) = target.filter(|_| app.ui.transform.is_none())
+        && let Err(e) = app.run("history.selectState", json!({ "state": state }))
+    {
+        app.ui.status = e;
+        app.ui.status_error = true;
     }
 }
 
@@ -3008,7 +3231,8 @@ fn snapshot_rows(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> Option<(&'static
 
 // ----------------------------------------------------------------------------- properties
 
-/// Floating Properties card anchored to the canvas' top-right corner.
+/// Floating Properties card anchored to the canvas' top-right corner. It shows the same content as
+/// the docked panel (`properties_body`): document, layer, adjustment and mask properties.
 pub fn properties_window(app: &mut PhotocraftApp, ctx: &egui::Context) {
     if app.ui.docking.is_some() {
         return;
@@ -3017,14 +3241,7 @@ pub fn properties_window(app: &mut PhotocraftApp, ctx: &egui::Context) {
     if !app.ui.panels.properties || Tokens::get(ctx).pro {
         return;
     }
-    let Some(st) = app.session.active() else { return };
-    let Some(id) = st.active_layer else { return };
-    let doc = st.doc.clone();
-    let Some(layer) = doc.layer(id) else { return };
-    // Mask controls (pixel or vector) also belong here when their thumbnail is targeted.
-    let mask_target = crate::mask_props_ui::targeted(app, layer);
-    let vector_target = crate::mask_props_ui::vector_targeted(app, layer);
-    if !mask_target && !vector_target && !matches!(layer.content, LayerContent::Adjustment(_) | LayerContent::Fill(_)) {
+    if app.session.active().is_none() {
         return;
     }
     let t = Tokens::get(ctx);
@@ -3060,41 +3277,9 @@ pub fn properties_window(app: &mut PhotocraftApp, ctx: &egui::Context) {
             }
             drag = grip.drag_delta();
             ui.add_space(6.0);
-            let icon = match &layer.content {
-                LayerContent::Adjustment(_) => "sliders-horizontal",
-                LayerContent::Group(_) => "folder",
-                LayerContent::Fill(_) => "paint-bucket",
-                _ => "image",
-            };
-            ui.horizontal(|ui| {
-                let (r, _) = ui.allocate_exact_size(vec2(32.0, 32.0), Sense::hover());
-                ui.painter().rect_filled(r, t.radius_sm, t.field);
-                icons::paint(ui, r, icon, 17.0, t.icon);
-                ui.vertical(|ui| {
-                    ui.label(RichText::new(&layer.name).font(theme::medium(13.0)).color(t.text));
-                    let kind = match &layer.content {
-                        LayerContent::Adjustment(a) => crate::i18n::fmt(tl!("{name} Properties"), &[("name", tl!(a.label()))]),
-                        // Whole phrases ("Type Layer"), as the Properties header translates them.
-                        other => tl!(&format!("{} Layer", other.kind_name())).to_string(),
-                    };
-                    ui.label(RichText::new(kind).small().color(t.text_faint));
-                });
-            });
-            ui.add_space(8.0);
             widgets::hairline(ui);
             ui.add_space(8.0);
-            // Per-layer ids, so text still being typed for one layer can't commit to the next.
-            ui.push_id((doc.id, id, mask_target), |ui| {
-                if mask_target {
-                    crate::mask_props_ui::properties(app, ui, layer);
-                } else if vector_target {
-                    crate::mask_props_ui::vector_properties(app, ui, layer);
-                } else if let LayerContent::Adjustment(adj) = &layer.content {
-                    adjustment_controls(app, ui, id, adj);
-                } else {
-                    layer_controls(app, ui, layer);
-                }
-            });
+            properties_body(app, ui);
         });
     });
     if drag != egui::Vec2::ZERO && canvas.is_positive() {
@@ -3109,14 +3294,14 @@ pub fn properties_window(app: &mut PhotocraftApp, ctx: &egui::Context) {
 fn adjustment_controls(app: &mut PhotocraftApp, ui: &mut egui::Ui, id: LayerId, adj: &photocraft_doc::Adjustment) {
     crate::adjust_editors::layer_editor(app, ui, id, adj);
     ui.add_space(6.0);
-    let layer = app.session.active().and_then(|s| s.doc.layer(id).cloned());
-    if let Some(l) = layer {
+    let layer = app.session.active().and_then(|s| s.doc.layer(id).map(|l| (l.visible, l.clipped)));
+    if let Some((visible, clipped)) = layer {
         ui.horizontal(|ui| {
-            let mut vis = l.visible;
+            let mut vis = visible;
             if widgets::toggle(ui, &mut vis, tl!("Adjustment visible")).changed() {
                 let _ = app.run("layer.setProps", json!({"layer": id.0, "visible": vis}));
             }
-            let mut clip = l.clipped;
+            let mut clip = clipped;
             if widgets::toggle(ui, &mut clip, tl!("Clip to layer below")).changed() {
                 let _ = app.run("layer.setProps", json!({"layer": id.0, "clipped": clip}));
             }
@@ -3185,8 +3370,12 @@ fn properties_body_inner(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         crate::mask_props_ui::vector_properties(app, ui, layer);
         return;
     }
-    // Photoshop shows the Document properties when nothing or the Background layer is selected.
+    // Photoshop shows the Document properties when nothing or the Background layer is selected,
+    // with Align and Distribute above them when the Background is one of several (#4608).
     if crate::doc_props_ui::shows_document(&st.doc, st.active_layer) {
+        if t.pro && st.selected_layers().len() > 1 {
+            crate::layer_props_ui::selection_align(app, ui);
+        }
         crate::doc_props_ui::properties(app, ui);
         return;
     }
@@ -3332,7 +3521,9 @@ fn color_field(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let strip_w = 14.0;
     // Photoshop's Color panel field fills the panel: take the height the dock offers, less the
     // hex/RGB readout (which folds onto a second line in a narrow dock). Without a dock, 120 pt.
-    let h = color_field_height(ui.data(|d| d.get_temp::<f32>(color_field_fill_id())), w);
+    // Only Photoshop's themes stretch it over the group: the other themes put sliders under it.
+    let fill = if t.pro { ui.data(|d| d.get_temp::<f32>(color_field_fill_id())) } else { None };
+    let h = color_field_height(fill, w);
     ui.horizontal(|ui| {
         ui.spacing_mut().item_spacing.x = 8.0;
         let (chips, _) = ui.allocate_exact_size(vec2(38.0, h), Sense::hover());
@@ -3524,13 +3715,13 @@ fn brush_tip(p: &egui::Painter, c: egui::Pos2, rad: f32, hardness: f32, color: C
 
 /// The Brush's or Pencil's Mode dropdown: the blend modes, with Photoshop's painting-only Clear
 /// after Dissolve (#3439). Clear erases with the brush (`clear`); it shows while chosen, or while
-/// `~` is held (`held`).
+/// `~` is held (`held`). The wheel over it steps the mode, as over the Layers panel's (#2061).
 fn paint_mode_dropdown(ui: &mut egui::Ui, id: &str, b: &mut photocraft_engine::BrushSettings, clear: &mut bool, held: bool) {
     let mut opts: Vec<(Option<BlendMode>, &str)> = BlendMode::LAYER_MODES.iter().map(|m| (Some(*m), m.label())).collect();
     let at = opts.iter().position(|o| o.0 == Some(BlendMode::Dissolve)).map_or(opts.len(), |i| i + 1);
     opts.insert(at, (None, "Clear"));
     let mut mode = if *clear || held { None } else { Some(b.mode) };
-    if widgets::dropdown(ui, id, &mut mode, &opts, 96.0) {
+    if !widgets::dropdown_wheel_hovered(ui, id, &mut mode, &opts, 96.0).0.is_empty() {
         *clear = mode.is_none();
         if let Some(m) = mode {
             b.mode = m;
@@ -3542,6 +3733,7 @@ fn paint_mode_dropdown(ui: &mut egui::Ui, id: &str, b: &mut photocraft_engine::B
 fn smoothing_field(ui: &mut egui::Ui, b: &mut photocraft_engine::BrushSettings, width: f32) {
     let mut sm = (b.smoothing.amount * 100.0).round();
     if widgets::value_field(ui, &mut sm, 0.0..=100.0, "%", width).changed() {
+        b.smoothing.enabled = true;
         b.smoothing.amount = (sm / 100.0).clamp(0.0, 1.0);
     }
 }
@@ -3836,13 +4028,14 @@ fn effect_rows(app: &mut PhotocraftApp, ui: &mut egui::Ui, l: &Layer, depth: usi
         if t.pro {
             ui.painter().line_segment([pos2(rect.left() + 30.0, rect.top()), pos2(rect.left() + 30.0, rect.bottom())], Stroke::new(1.0, t.separator));
         }
-        let eye = Rect::from_min_size(pos2(rect.left() + 6.0, rect.center().y - 9.0), vec2(18.0, 18.0));
+        // Nested under the layer's eye column so an effect does not read as its own layer (#4572).
+        let eye = Rect::from_min_size(pos2(rect.left() + 36.0, rect.center().y - 9.0), vec2(18.0, 18.0));
         // A hidden effect's eye box is left empty (still clickable), like a hidden layer's.
         if on {
             icons::paint(ui, eye, "eye", 12.0, t.icon);
         }
         // The whole eye column of the row takes the click, so it never opens the Layer Style dialog.
-        let eye_cell = Rect::from_min_max(rect.left_top(), pos2((rect.left() + 30.0).min(rect.right()), rect.bottom()));
+        let eye_cell = Rect::from_min_max(pos2(rect.left() + 30.0, rect.top()), pos2((rect.left() + 58.0).min(rect.right()), rect.bottom()));
         if ui.interact(eye_cell, ui.id().with(("fx-eye", l.id.0, i)), Sense::click()).clicked() {
             let mut params = json!({"layer": l.id.0, "visible": !on});
             if let (Some(index), Some(o)) = (i.checked_sub(1), params.as_object_mut()) {
@@ -3850,7 +4043,7 @@ fn effect_rows(app: &mut PhotocraftApp, ui: &mut egui::Ui, l: &Layer, depth: usi
             }
             actions.push(("layer.setEffectsVisible".into(), params));
         }
-        let x = rect.left() + indent + if i == 0 { 0.0 } else { 16.0 };
+        let x = rect.left() + indent + if i == 0 { 8.0 } else { 24.0 };
         if i == 0 {
             icons::paint(ui, Rect::from_center_size(pos2(x - 12.0, rect.center().y), vec2(14.0, 14.0)), "sparkles", 11.0, t.text_dim);
         }
@@ -3866,7 +4059,7 @@ fn effect_rows(app: &mut PhotocraftApp, ui: &mut egui::Ui, l: &Layer, depth: usi
         );
         resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, name.clone()));
         if resp.double_clicked() {
-            crate::layer_style::open(app, kind);
+            crate::layer_style::open_for_layer(app, l.id, kind);
         }
         // #2846: right-click opens the layer style menu (Create Layer, Copy Layer Style…), as in Photoshop.
         resp.context_menu(|ui| {
@@ -4096,7 +4289,7 @@ mod color_tests {
         let mut h = egui_kittest::Harness::builder().with_size(vec2(300.0, 300.0)).build_ui_state(
             |ui, app: &mut PhotocraftApp| {
                 if ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
-                    color_picker(app, ui);
+                    hsb_sliders(app, ui);
                 }
             },
             app,
@@ -4418,8 +4611,9 @@ mod snapshot_row_tests {
         assert_eq!(st.history.entries().len(), steps + 1);
         assert_eq!(st.history.entries().last().map(String::as_str), Some("Snapshot 1"));
         assert_eq!(top_pixel(&h), [1.0, 0.0, 0.0, 1.0], "back to red");
-        // Right-click › Rename…: type a name, Enter.
-        h.get_by_label("Snapshot 1").click_secondary();
+        // Right-click › Rename…: type a name, Enter. The new "Snapshot 1" state is listed under the
+        // snapshot rows, so the first match is the snapshot's row.
+        h.get_all_by_label("Snapshot 1").next().unwrap().click_secondary();
         h.run_steps(2);
         h.get_by_label("Rename…").click();
         h.run_steps(2);
@@ -4445,8 +4639,8 @@ mod snapshot_row_tests {
         h.run_steps(2);
         assert_eq!(snapshot_names(&h), ["Lesson start"], "Escape cancels");
         assert_eq!(h.state().session.active().unwrap().history.entries().len(), steps_now + 1, "the click selected it once");
-        // Right-click › Delete.
-        h.get_by_label("Lesson start").click_secondary();
+        // Right-click › Delete (the snapshot's row, above the state the click made).
+        h.get_all_by_label("Lesson start").next().unwrap().click_secondary();
         h.run_steps(2);
         h.get_by_label("Delete").click();
         h.run_steps(2);
@@ -4538,7 +4732,7 @@ mod lock_tests {
         click_lock(&mut app);
         let l = &app.session.active().unwrap().doc.layers[0];
         assert_eq!(l.name, "Layer 0");
-        assert!(!(l.locks.transparency || l.locks.pixels || l.locks.position || l.locks.all));
+        assert!(!l.locks.any());
         erase_line(&mut app);
         assert!(!app.ui.status_error, "{}", app.ui.status);
         assert_eq!(app.session.active().unwrap().doc.layers[0].surface().unwrap().rgba(50, 40)[3], 0.0, "erased to transparency");
@@ -4546,8 +4740,7 @@ mod lock_tests {
         click_lock(&mut app);
         assert!(app.session.active().unwrap().doc.layers[0].locks.all);
         click_lock(&mut app);
-        let k = app.session.active().unwrap().doc.layers[0].locks;
-        assert!(!(k.transparency || k.pixels || k.position || k.artboard || k.all));
+        assert!(!app.session.active().unwrap().doc.layers[0].locks.any());
         // A layer with only transparency locked unlocks in one click.
         app.run("layer.setProps", json!({"locks": {"transparency": true}})).unwrap();
         click_lock(&mut app);
@@ -4604,9 +4797,9 @@ mod type_flyout_tests {
     }
 
     #[test]
-    fn long_press_type_button_selects_vertical_without_selecting_on_release() {
+    fn long_press_type_button_selects_type_then_vertical_from_the_flyout() {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
-        let initial = app.ui.tool;
+        assert_ne!(app.ui.tool, Tool::Type);
         let ctx = egui::Context::default();
         PhotocraftApp::setup_context(&ctx, crate::theme::ThemeKind::ALL[0]);
         frame(&mut app, &ctx, 0.0, vec![]);
@@ -4630,7 +4823,8 @@ mod type_flyout_tests {
         assert_eq!(ctx.data(|d| d.get_temp::<(egui::Id, Rect)>(egui::Id::new("tool-flyout"))).map(|(id, _)| id), Some(egui::Id::new(("tool-slot", index))));
         frame(&mut app, &ctx, 1.4, vec![pointer(at, false)]);
         frame(&mut app, &ctx, 1.45, vec![]);
-        assert_eq!(app.ui.tool, initial);
+        // The held button's tool is selected, as Photoshop does (#4453).
+        assert_eq!(app.ui.tool, Tool::Type);
         let key = egui::Id::new(("tool-slot", index));
         let menu = ctx.memory(|m| m.area_rect(key.with("flyout"))).unwrap();
         let row = egui::pos2(menu.left() + 65.0, menu.top() + 39.0 + 8.0);
@@ -4640,6 +4834,205 @@ mod type_flyout_tests {
         assert!(ctx.data(|d| d.get_temp::<(egui::Id, Rect)>(egui::Id::new("tool-flyout"))).is_none());
     }
 
+    /// #4444: click and hold on Change Screen Mode opens its list like the tool flyouts, without
+    /// cycling the mode on release; a plain click still cycles, and right-click still opens it.
+    #[test]
+    fn long_press_screen_mode_opens_the_modes_without_cycling() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let ctx = egui::Context::default();
+        PhotocraftApp::setup_context(&ctx, crate::theme::ThemeKind::ALL[0]);
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let bx = if Tokens::get(&ctx).pro { 30.0 } else { 36.0 };
+        // The toolbar's last button: Change Screen Mode, after Quick Mask.
+        let at = ctx
+            .viewport(|v| {
+                v.prev_pass
+                    .widgets
+                    .layers()
+                    .flat_map(|(_, w)| w.iter())
+                    .filter(|w| w.rect.size() == egui::Vec2::splat(bx) && w.sense.senses_click())
+                    .map(|w| w.rect)
+                    .max_by(|a, b| a.top().total_cmp(&b.top()).then(a.left().total_cmp(&b.left())))
+            })
+            .unwrap()
+            .center();
+        let standard = |app: &PhotocraftApp| crate::view_cmds::checked(app, "view.screenMode.standard") == Some(true);
+        let menu_open = |ctx: &egui::Context| egui::Popup::is_any_open(ctx);
+        let pointer = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        assert!(standard(&app));
+        // Hold, then release: the list opens and stays open, and the mode is unchanged.
+        frame(&mut app, &ctx, 1.0, vec![egui::Event::PointerMoved(at), pointer(at, true)]);
+        frame(&mut app, &ctx, 1.2, vec![]);
+        assert!(!menu_open(&ctx), "not before the hold time");
+        frame(&mut app, &ctx, 1.4, vec![]);
+        assert!(menu_open(&ctx), "open while still held");
+        frame(&mut app, &ctx, 1.5, vec![pointer(at, false)]);
+        frame(&mut app, &ctx, 1.55, vec![]);
+        assert!(menu_open(&ctx), "the release keeps it open");
+        assert!(standard(&app), "the release doesn't cycle the mode");
+        // Escape closes it; a plain click cycles the mode and opens nothing.
+        frame(
+            &mut app,
+            &ctx,
+            2.0,
+            vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }],
+        );
+        frame(&mut app, &ctx, 2.05, vec![]);
+        assert!(!menu_open(&ctx));
+        frame(&mut app, &ctx, 3.0, vec![egui::Event::PointerMoved(at), pointer(at, true)]);
+        frame(&mut app, &ctx, 3.1, vec![pointer(at, false)]);
+        frame(&mut app, &ctx, 3.15, vec![]);
+        assert!(!standard(&app), "a click cycles");
+        assert!(!menu_open(&ctx));
+        // Right-click opens it too.
+        let secondary = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Secondary, pressed, modifiers: Default::default() };
+        frame(&mut app, &ctx, 4.0, vec![secondary(true)]);
+        frame(&mut app, &ctx, 4.05, vec![secondary(false)]);
+        frame(&mut app, &ctx, 4.1, vec![]);
+        assert!(menu_open(&ctx));
+    }
+
+    /// Every text drawn in one toolbar frame.
+    fn frame_texts(app: &mut PhotocraftApp, ctx: &egui::Context, time: f64, events: Vec<egui::Event>) -> Vec<String> {
+        fn collect(shape: &egui::Shape, out: &mut Vec<String>) {
+            match shape {
+                egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+                egui::Shape::Vec(v) => v.iter().for_each(|s| collect(s, out)),
+                _ => {}
+            }
+        }
+        let mut out = ctx.run_ui(
+            egui::RawInput { time: Some(time), events, screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(1200.0, 1800.0))), ..Default::default() },
+            |ui| toolbar(app, ui),
+        );
+        out.textures_delta.clear();
+        let mut texts = Vec::new();
+        out.shapes.iter().for_each(|c| collect(&c.shape, &mut texts));
+        texts
+    }
+
+    /// #4450: no tool tooltip while a flyout is open or a tool button is held to open one, for the
+    /// held tool or any other; a plain hover still shows its tooltip.
+    #[test]
+    fn no_tooltips_over_an_open_tool_flyout() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let ctx = egui::Context::default();
+        PhotocraftApp::setup_context(&ctx, crate::theme::ThemeKind::ALL[0]);
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let bx = if Tokens::get(&ctx).pro { 30.0 } else { 36.0 };
+        let mut buttons: Vec<Rect> = ctx.viewport(|v| {
+            v.prev_pass
+                .widgets
+                .layers()
+                .flat_map(|(_, w)| w.iter())
+                .filter(|w| w.rect.size() == egui::Vec2::splat(bx) && w.sense.senses_click())
+                .map(|w| w.rect)
+                .collect()
+        });
+        buttons.sort_by(|a, b| a.top().total_cmp(&b.top()));
+        let slot_of = |tool: Tool| TOOL_SECTIONS.iter().flat_map(|section| section.iter()).position(|slot| slot.contains(&tool)).unwrap();
+        let (eyedropper, brush) = (buttons[slot_of(Tool::Eyedropper)].center(), buttons[slot_of(Tool::Brush)].center());
+        let tip = |tool: Tool| format!("{}  ({})", tl!(tool.label()), tool.key());
+        let pointer = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        // A plain hover shows the tooltip.
+        frame(&mut app, &ctx, 1.0, vec![egui::Event::PointerMoved(brush)]);
+        let mut texts = Vec::new();
+        for k in 1..=10 {
+            texts = frame_texts(&mut app, &ctx, 1.0 + 0.1 * f64::from(k), vec![]);
+        }
+        assert!(texts.contains(&tip(Tool::Brush)), "hovered long enough: {texts:?}");
+        // Held on the Eyedropper: no tooltip before or after its flyout opens.
+        frame(&mut app, &ctx, 3.0, vec![egui::Event::PointerMoved(eyedropper), pointer(eyedropper, true)]);
+        for k in 1..=10 {
+            let texts = frame_texts(&mut app, &ctx, 3.0 + 0.1 * f64::from(k), vec![]);
+            assert!(!texts.contains(&tip(Tool::Eyedropper)), "held {k}: {texts:?}");
+        }
+        assert!(ctx.data(|d| d.get_temp::<(egui::Id, Rect)>(egui::Id::new("tool-flyout"))).is_some(), "the flyout is open");
+        // Released, with the flyout still open: none for the held tool or another one.
+        frame(&mut app, &ctx, 4.1, vec![pointer(eyedropper, false)]);
+        for (start, at, tool) in [(4.5, eyedropper, Tool::Eyedropper), (6.0, brush, Tool::Brush)] {
+            frame(&mut app, &ctx, start, vec![egui::Event::PointerMoved(at)]);
+            for k in 1..=10 {
+                let texts = frame_texts(&mut app, &ctx, start + 0.1 * f64::from(k), vec![]);
+                assert!(!texts.contains(&tip(tool)), "{tool:?} under the flyout: {texts:?}");
+            }
+        }
+    }
+
+    /// #4460: a press outside an open flyout closes it, even when it becomes a drag (cropping or
+    /// painting on the canvas) rather than a click; a press on the flyout keeps it for its pick.
+    /// #4932: so does a click on its own tool button.
+    #[test]
+    fn a_drag_outside_closes_the_tool_flyout() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let ctx = egui::Context::default();
+        PhotocraftApp::setup_context(&ctx, crate::theme::ThemeKind::ALL[0]);
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let index = TOOL_SECTIONS.iter().flat_map(|section| section.iter()).position(|slot| slot.contains(&Tool::Brush)).unwrap();
+        let bx = if Tokens::get(&ctx).pro { 30.0 } else { 36.0 };
+        let mut buttons: Vec<Rect> = ctx.viewport(|v| {
+            v.prev_pass
+                .widgets
+                .layers()
+                .flat_map(|(_, w)| w.iter())
+                .filter(|w| w.rect.size() == egui::Vec2::splat(bx) && w.sense.senses_click())
+                .map(|w| w.rect)
+                .collect()
+        });
+        buttons.sort_by(|a, b| a.top().total_cmp(&b.top()));
+        let at = buttons[index].center();
+        let flyout = |ctx: &egui::Context| ctx.data(|d| d.get_temp::<(egui::Id, Rect)>(egui::Id::new("tool-flyout"))).is_some();
+        let secondary = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Secondary, pressed, modifiers: Default::default() };
+        let primary = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        // A right-click on the button of an open flyout closes it (#4932), so open only a closed one.
+        let open = |app: &mut PhotocraftApp, t: f64| {
+            if !flyout(&ctx) {
+                frame(app, &ctx, t, vec![egui::Event::PointerMoved(at), secondary(true)]);
+                frame(app, &ctx, t + 0.05, vec![secondary(false)]);
+                frame(app, &ctx, t + 0.1, vec![]);
+            }
+            assert!(flyout(&ctx), "right-click opens it");
+        };
+        // A press on the flyout itself keeps it open (the row picks on release).
+        open(&mut app, 1.0);
+        let menu = ctx.memory(|m| m.area_rect(egui::Id::new(("tool-slot", index)).with("flyout"))).unwrap();
+        frame(&mut app, &ctx, 1.5, vec![egui::Event::PointerMoved(menu.center()), primary(menu.center(), true)]);
+        assert!(flyout(&ctx), "a press on the flyout keeps it");
+        frame(&mut app, &ctx, 1.55, vec![primary(menu.center(), false)]);
+        // A drag far from the toolbar (the canvas) closes it as soon as it starts.
+        open(&mut app, 2.0);
+        let canvas = egui::pos2(900.0, 900.0);
+        frame(&mut app, &ctx, 2.5, vec![egui::Event::PointerMoved(canvas), primary(canvas, true)]);
+        frame(&mut app, &ctx, 2.55, vec![egui::Event::PointerMoved(canvas + vec2(80.0, 60.0))]);
+        assert!(!flyout(&ctx), "a press outside closes it, even one that becomes a drag");
+        frame(&mut app, &ctx, 2.6, vec![primary(canvas + vec2(80.0, 60.0), false)]);
+        assert!(!flyout(&ctx));
+        // #4932: clicking its own tool button again closes it, with either button.
+        open(&mut app, 3.0);
+        frame(&mut app, &ctx, 3.5, vec![egui::Event::PointerMoved(at), secondary(true)]);
+        frame(&mut app, &ctx, 3.55, vec![secondary(false)]);
+        frame(&mut app, &ctx, 3.6, vec![]);
+        assert!(!flyout(&ctx), "a second right-click on the button closes it");
+        open(&mut app, 4.0);
+        app.ui.tool = Tool::Move;
+        frame(&mut app, &ctx, 4.5, vec![egui::Event::PointerMoved(at), primary(at, true)]);
+        frame(&mut app, &ctx, 4.55, vec![primary(at, false)]);
+        frame(&mut app, &ctx, 4.6, vec![]);
+        assert!(!flyout(&ctx), "a click on the button closes it");
+        assert_eq!(app.ui.tool, Tool::Brush, "and picks the tool, as any click on it does");
+        // The release that ends a long press keeps the flyout it opened.
+        frame(&mut app, &ctx, 5.0, vec![egui::Event::PointerMoved(at), primary(at, true)]);
+        frame(&mut app, &ctx, 5.2, vec![]);
+        frame(&mut app, &ctx, 5.5, vec![]);
+        assert!(flyout(&ctx), "a long press opens it");
+        frame(&mut app, &ctx, 5.55, vec![primary(at, false)]);
+        frame(&mut app, &ctx, 5.6, vec![]);
+        assert!(flyout(&ctx), "releasing the long press keeps it open");
+    }
+
     #[test]
     fn red_eye_is_in_the_j_flyout() {
         let j = TOOL_SECTIONS.iter().flat_map(|section| section.iter()).find(|slot| slot.contains(&Tool::SpotHealing)).expect("J group");
@@ -5204,8 +5597,12 @@ mod compact_visual_regressions {
     }
 
     fn toolbar_harness(kind: theme::ThemeKind, scale: f32) -> egui_kittest::Harness<'static, PhotocraftApp> {
+        toolbar_harness_sized(kind, scale, 360.0)
+    }
+
+    fn toolbar_harness_sized(kind: theme::ThemeKind, scale: f32, height: f32) -> egui_kittest::Harness<'static, PhotocraftApp> {
         let mut ready = false;
-        let mut harness = egui_kittest::Harness::builder().with_size(vec2(400.0, 360.0)).with_pixels_per_point(scale).build_ui_state(
+        let mut harness = egui_kittest::Harness::builder().with_size(vec2(400.0, height)).with_pixels_per_point(scale).build_ui_state(
             move |ui, app: &mut PhotocraftApp| {
                 if !ready {
                     egui_extras::install_image_loaders(ui.ctx());
@@ -5274,6 +5671,18 @@ mod compact_visual_regressions {
         }
     }
 
+    /// A window taller than the tools keeps the colour chips right under the last tool, as
+    /// Photoshop does, instead of at the bottom of the toolbar.
+    #[test]
+    fn tall_toolbar_keeps_the_colour_chips_under_the_tools() {
+        for kind in theme::ThemeKind::ALL {
+            let harness = toolbar_harness_sized(kind, 1.0, 1600.0);
+            let last = harness.get_by_label("Zoom Tool  (Z)").rect();
+            let swap = harness.get_by_label("Swap colours (X)").rect();
+            assert!(swap.top() - last.bottom() < 80.0, "{kind:?}: the chips {swap:?} sit far below the last tool {last:?}");
+        }
+    }
+
     #[test]
     fn capture_compact_visual_fixtures() {
         let Some(directory) = std::env::var_os("CRAFT_UI_VISUAL_FIXTURES").map(std::path::PathBuf::from) else { return };
@@ -5487,6 +5896,34 @@ mod compact_visual_regressions {
         }
     }
 
+    #[test]
+    fn the_narrow_options_bar_preference_shortens_the_bar() {
+        assert_eq!(options_bar_height(true, false), 36.0);
+        assert_eq!(options_bar_height(true, true), 30.0);
+        assert_eq!(options_bar_height(false, false), 42.0);
+        assert_eq!(options_bar_height(false, true), 34.0);
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        crate::theme::apply(&ctx, crate::theme::ThemeKind::ALL[0]);
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        let screen = Rect::from_min_size(egui::Pos2::ZERO, vec2(1600.0, 900.0));
+        let run = |app: &mut PhotocraftApp| {
+            let mut top = 0.0;
+            let mut out = ctx.run_ui(input_at_scale(screen, 1.0), |ui| {
+                options_bar(app, ui);
+                top = ui.available_rect_before_wrap().top();
+            });
+            out.textures_delta.clear();
+            top
+        };
+        let normal = run(&mut app);
+        assert_eq!(normal, options_bar_height(Tokens::get(&ctx).pro, false));
+        app.session.execute("prefs.set", json!({"path": "workspace.enableNarrowOptionsBar", "value": true})).unwrap();
+        let narrow = run(&mut app);
+        assert_eq!(narrow, options_bar_height(Tokens::get(&ctx).pro, true));
+        assert!(narrow < normal, "narrow {narrow} must trim the bar under {normal}");
+    }
+
     #[test]
     fn narrow_tool_options_can_scroll_to_the_last_control() {
         for kind in crate::theme::ThemeKind::ALL {
@@ -5507,7 +5944,9 @@ mod compact_visual_regressions {
                             egui::RawInput {
                                 time: Some(f64::from(frame) * 0.1),
                                 events: vec![
-                                    egui::Event::PointerMoved(pos2(width * 0.5, 20.0)),
+                                    // Studio: above the controls, clear of the Brush's Mode dropdown, which takes the wheel
+                                    // to step through blend modes (#4512).
+                                    egui::Event::PointerMoved(if Tokens::get(&ctx).pro { pos2(width * 0.5, 20.0) } else { pos2(width * 0.5, 2.0) }),
                                     egui::Event::MouseWheel {
                                         unit: egui::MouseWheelUnit::Point,
                                         delta: vec2(-1500.0, 0.0),
@@ -5586,3 +6025,7 @@ mod properties_target_regressions {
         assert_eq!(after, before, "pending width belongs to the old document/layer");
     }
 }
+
+#[cfg(test)]
+#[path = "history_panel_select_tests.rs"]
+mod history_panel_select_tests;
diff --git a/crates/ui-egui/src/path_selection_tests.rs b/crates/ui-egui/src/path_selection_tests.rs
index 89dcd49c57..8f82e2ad68 100644
--- a/crates/ui-egui/src/path_selection_tests.rs
+++ b/crates/ui-egui/src/path_selection_tests.rs
@@ -227,3 +227,23 @@ fn thumbnail_selection_ctrl_click_layer_path_preserves_panel_target() {
         h.render().unwrap().save(path).unwrap();
     }
 }
+
+/// #3915: Clicking a shape with the Path Selection tool selects its layer.
+#[test]
+fn clicking_shape_with_path_selection_selects_its_layer() {
+    let mut h = harness();
+    let rect_layer =
+        h.state_mut().run("shape.create", json!({"kind": "rect", "rect": [20, 20, 80, 60], "fill": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+    // Add a new empty layer above so rect is not the active layer.
+    let empty_layer = h.state_mut().run("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+    assert_eq!(h.state().session.active().unwrap().active_layer.unwrap().0, empty_layer);
+
+    // Clicking inside the rectangle with Path Selection selects the rect layer.
+    h.state_mut().ui.tool = Tool::PathSelection;
+    crate::vector_ui::path_selection_finish(h.state_mut(), [50.0, 50.0], [50.0, 50.0]);
+    assert_eq!(h.state().session.active().unwrap().active_layer.unwrap().0, rect_layer);
+
+    // Clicking outside does not change active layer.
+    crate::vector_ui::path_selection_finish(h.state_mut(), [150.0, 90.0], [150.0, 90.0]);
+    assert_eq!(h.state().session.active().unwrap().active_layer.unwrap().0, rect_layer);
+}
diff --git a/crates/ui-egui/src/pen_draw_tests.rs b/crates/ui-egui/src/pen_draw_tests.rs
index 229d69995a..74689a1070 100644
--- a/crates/ui-egui/src/pen_draw_tests.rs
+++ b/crates/ui-egui/src/pen_draw_tests.rs
@@ -139,12 +139,17 @@ fn dragging_on_the_first_anchor_closes_with_its_handles_in_one_step() {
     assert!(near([k.in_ctrl.x, k.in_ctrl.y], [0.0, 40.0]) && near([k.out_ctrl.x, k.out_ctrl.y], [40.0, 0.0]), "{k:?}");
     assert!(k.smooth);
 
-    // A plain click on a smooth first anchor closes without touching its handles.
+    // A plain click on a smooth first anchor closes without touching its handles. This path is
+    // drawn over the anchors of the one just finished, which Auto Add/Delete would delete (#4144).
+    h.state_mut().ui.tool_options.pen_auto_add_delete = false;
     drag(&mut h, &[[20.0, 20.0], [40.0, 20.0]], None);
     click(&mut h, [120.0, 20.0]);
     click(&mut h, [120.0, 100.0]);
     click(&mut h, [20.0, 20.0]);
-    let sp = h.state().session.active().unwrap().doc.work_path.clone().unwrap().subpaths.remove(0);
+    // The second path joins the Work Path as its last subpath (#4721).
+    let subs = h.state().session.active().unwrap().doc.work_path.clone().unwrap().subpaths;
+    assert_eq!(subs.len(), 2, "the first path stays");
+    let sp = subs.last().unwrap();
     let k = &sp.knots[0];
     assert!(sp.closed && sp.knots.len() == 3);
     assert!(near([k.in_ctrl.x, k.in_ctrl.y], [0.0, 20.0]) && near([k.out_ctrl.x, k.out_ctrl.y], [40.0, 20.0]), "{k:?}");
diff --git a/crates/ui-egui/src/polygon_lasso_tests.rs b/crates/ui-egui/src/polygon_lasso_tests.rs
index ed46a7e50b..62975e2d73 100644
--- a/crates/ui-egui/src/polygon_lasso_tests.rs
+++ b/crates/ui-egui/src/polygon_lasso_tests.rs
@@ -82,6 +82,32 @@ fn near(r: Rect, x0: i32, y0: i32, x1: i32, y1: i32) -> bool {
     r.x0.abs_diff(x0) <= 1 && r.y0.abs_diff(y0) <= 1 && r.x1.abs_diff(x1) <= 1 && r.y1.abs_diff(y1) <= 1
 }
 
+#[test]
+fn switching_tools_discards_unfinished_polygon_without_changing_selection() {
+    let mut app = polygon_app();
+    app.run("select.rect", json!({"x": 200, "y": 150, "width": 50, "height": 50})).unwrap();
+    let before = app.session.active().unwrap().doc.selection.as_ref().unwrap().content_bounds();
+    let history = app.session.active().unwrap().history.past_len();
+
+    ev(&mut app, "down", 20.0, 20.0, Modifiers::NONE);
+    ev(&mut app, "up", 20.0, 20.0, Modifiers::NONE);
+    assert_eq!(app.ui.polygon.len(), 1);
+    assert_eq!(app.ui.polygon_mode, "replace");
+    assert!(crate::canvas::polygon_replaces_selection(&app));
+
+    app.ui.tool = Tool::QuickSelection;
+    app.sync_views();
+    assert!(app.ui.polygon.is_empty());
+    assert!(app.ui.polygon_mode.is_empty());
+    assert!(!crate::canvas::polygon_replaces_selection(&app));
+    assert_eq!(app.session.active().unwrap().doc.selection.as_ref().unwrap().content_bounds(), before);
+    assert_eq!(app.session.active().unwrap().history.past_len(), history);
+
+    app.ui.tool = Tool::PolygonLasso;
+    app.sync_views();
+    assert!(app.ui.polygon.is_empty(), "returning to the tool must start a fresh outline");
+}
+
 #[test]
 fn double_click_closes_the_polygon_at_the_last_point() {
     let mut h = harness();
@@ -379,3 +405,98 @@ fn shift_polygonal_lasso_snap_has_all_eight_directions_and_handles_zero_length()
     }
     assert_eq!(crate::canvas::constrained_polygon_point(origin, origin), origin);
 }
+
+/// Two vertices placed with the Polygonal Lasso, well apart in time so they aren't a double-click.
+fn two_vertices(h: &mut Harness<'static, PhotocraftApp>) {
+    click(h, 50.0, 50.0, Modifiers::NONE);
+    h.run_steps(30);
+    click(h, 150.0, 50.0, Modifiers::NONE);
+    h.run_steps(30);
+    assert_eq!(h.state().ui.polygon.len(), 2);
+}
+
+/// The polygon, its mode and its document are all gone, and the selection it would have replaced
+/// is shown again.
+fn assert_polygon_dropped(h: &Harness<'static, PhotocraftApp>, what: &str) {
+    let app = h.state();
+    assert!(app.ui.polygon.is_empty(), "{what}: the outline is gone: {:?}", app.ui.polygon);
+    assert!(app.ui.polygon_mode.is_empty(), "{what}: the mode is gone");
+    assert!(app.ui.polygon_doc.is_none(), "{what}: the document is forgotten");
+    assert!(!crate::canvas::polygon_replaces_selection(app), "{what}: the old outline is shown again");
+}
+
+/// Every other tool drops the polygon in progress, not just the Quick Selection tool, and coming
+/// back to the Polygonal Lasso starts a new one.
+#[test]
+fn every_other_tool_drops_the_polygon_in_progress() {
+    let tools = [
+        Tool::QuickSelection,
+        Tool::ObjectSelection,
+        Tool::MagicWand,
+        Tool::RectMarquee,
+        Tool::EllipseMarquee,
+        Tool::Lasso,
+        Tool::MagneticLasso,
+        Tool::Move,
+        Tool::Brush,
+    ];
+    for tool in tools {
+        let mut h = harness();
+        h.state_mut().run("select.rect", json!({"x": 200, "y": 150, "width": 100, "height": 100})).unwrap();
+        h.run_steps(1);
+        let before = steps(&h);
+        two_vertices(&mut h);
+        assert!(crate::canvas::polygon_replaces_selection(h.state()), "{tool:?}: the old outline is hidden while drawing");
+        h.state_mut().ui.tool = tool;
+        h.state_mut().sync_views();
+        assert_polygon_dropped(&h, &format!("{tool:?}"));
+        assert!(selection(&h).is_some_and(|r| near(r, 200, 150, 300, 250)), "{tool:?}: {:?}", selection(&h));
+        assert_eq!(steps(&h), before, "{tool:?}: nothing was recorded");
+        h.state_mut().ui.tool = Tool::PolygonLasso;
+        h.state_mut().sync_views();
+        assert!(h.state().ui.polygon.is_empty(), "{tool:?}: coming back starts a new polygon");
+    }
+}
+
+/// The polygon belongs to the document it was started on: another document becoming active drops
+/// it, while the tool stays the Polygonal Lasso (its outline would otherwise show on the other
+/// document).
+#[test]
+fn switching_documents_drops_the_polygon_in_progress() {
+    let mut h = harness();
+    two_vertices(&mut h);
+    let first = h.state().session.active().map(|st| st.doc.id);
+    assert!(first.is_some());
+    assert_eq!(h.state().ui.polygon_doc, first, "the polygon remembers its document");
+    h.state_mut().run("file.new", json!({"width": 200, "height": 100})).unwrap();
+    assert_ne!(h.state().session.active().map(|st| st.doc.id), first, "another document is active");
+    assert_polygon_dropped(&h, "new document");
+    assert_eq!(h.state().ui.tool, Tool::PolygonLasso, "the tool stays");
+    // Back on the first document, nothing is left of it.
+    h.state_mut().run("document.activate", json!({"document": 0})).unwrap();
+    h.state_mut().sync_views();
+    assert!(h.state().ui.polygon.is_empty());
+}
+
+/// A held temporary tool (Space is the Hand, ⌘ the Move tool) doesn't change the selected tool, so
+/// the polygon being drawn stays.
+#[test]
+fn a_held_temporary_tool_keeps_the_polygon() {
+    let mut h = harness();
+    two_vertices(&mut h);
+    h.event(egui::Event::Key { key: egui::Key::Space, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+    h.state_mut().sync_views();
+    assert_eq!(h.state().ui.tool, Tool::PolygonLasso);
+    assert_eq!(h.state().ui.polygon.len(), 2, "Space held");
+    h.event(egui::Event::Key { key: egui::Key::Space, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+    h.event(egui::Event::ModifiersChanged(Modifiers::COMMAND));
+    h.run_steps(3);
+    h.state_mut().sync_views();
+    assert_eq!(h.state().ui.tool, Tool::PolygonLasso);
+    assert_eq!(h.state().ui.polygon.len(), 2, "⌘ held");
+    h.event(egui::Event::ModifiersChanged(Modifiers::NONE));
+    h.run_steps(3);
+    assert_eq!(h.state().ui.polygon.len(), 2, "released");
+}
diff --git a/crates/ui-egui/src/prefs_ui.rs b/crates/ui-egui/src/prefs_ui.rs
index 5fc1065a4c..db908ae23f 100644
--- a/crates/ui-egui/src/prefs_ui.rs
+++ b/crates/ui-egui/src/prefs_ui.rs
@@ -97,6 +97,7 @@ fn selected_theme(interface: &prefs::Interface, system: Option<egui::Theme>) ->
             LightTheme::Classic => ThemeKind::Classic,
             LightTheme::Adwaita => ThemeKind::Adwaita,
             LightTheme::BreezeLight => ThemeKind::BreezeLight,
+            LightTheme::SoftLight => ThemeKind::SoftLight,
         }
     } else {
         match interface.dark_theme {
@@ -106,6 +107,7 @@ fn selected_theme(interface: &prefs::Interface, system: Option<egui::Theme>) ->
             DarkTheme::SolarizedDark => ThemeKind::SolarizedDark,
             DarkTheme::AdwaitaDark => ThemeKind::AdwaitaDark,
             DarkTheme::BreezeDark => ThemeKind::BreezeDark,
+            DarkTheme::SoftDark => ThemeKind::SoftDark,
         }
     }
 }
@@ -127,12 +129,13 @@ pub(crate) fn cycle_appearance(app: &mut PhotocraftApp, ctx: &egui::Context) {
 }
 
 const LIGHT_THEME_OPTIONS: &[(&str, ThemeKind)] = &[
-    ("studioLight", ThemeKind::StudioLight),
-    ("proLightGray", ThemeKind::ProLightGray),
     ("proLight", ThemeKind::ProLight),
+    ("proLightGray", ThemeKind::ProLightGray),
+    ("studioLight", ThemeKind::StudioLight),
     ("classic", ThemeKind::Classic),
     ("adwaita", ThemeKind::Adwaita),
     ("breezeLight", ThemeKind::BreezeLight),
+    ("softLight", ThemeKind::SoftLight),
 ];
 const DARK_THEME_OPTIONS: &[(&str, ThemeKind)] = &[
     ("proMedium", ThemeKind::ProMedium),
@@ -141,6 +144,7 @@ const DARK_THEME_OPTIONS: &[(&str, ThemeKind)] = &[
     ("solarizedDark", ThemeKind::SolarizedDark),
     ("adwaitaDark", ThemeKind::AdwaitaDark),
     ("breezeDark", ThemeKind::BreezeDark),
+    ("softDark", ThemeKind::SoftDark),
 ];
 
 fn favorite_theme_groups(favorites: &[SavedTheme]) -> (Vec<ThemeKind>, Vec<ThemeKind>) {
@@ -216,8 +220,10 @@ pub fn load(app: &mut PhotocraftApp) {
     }
     crate::dock::restore(app);
     crate::brush_picker::restore(app);
+    crate::last_brush::restore(app);
     sync_rulers(app);
     crate::tool_memory::restore(app);
+    crate::view_cmds::restore(app);
     app.sync_recent();
     app.prefs_rt.saved_rev = app.session.prefs.rev();
     app.prefs_rt.saved_value = Some(app.session.prefs_value());
@@ -764,6 +770,11 @@ pub fn shortcut_items(app: &PhotocraftApp) -> Vec<(String, String, Vec<String>,
     let at = out.iter().rposition(|i| i.2.first().map(String::as_str) == Some("Layer")).map_or(out.len(), |i| i + 1);
     out.splice(at..at, layer);
     out.extend(tools);
+    out.extend(
+        crate::state::Tool::ALL
+            .into_iter()
+            .map(|tool| (crate::tool_shortcuts::id(tool), tool.label().to_string(), vec!["Tools".into()], crate::tool_shortcuts::default(tool))),
+    );
     for (id, label, def) in prefs::TEMPORARY_TOOLS {
         if seen.insert(id.to_string()) {
             out.push((id.to_string(), label.to_string(), vec!["Tools".into(), "Temporary".into()], Some(def.to_string())));
@@ -983,26 +994,13 @@ pub fn open_shortcuts(app: &mut PhotocraftApp, tab: u64) -> u64 {
     open_kind(app, "shortcuts", tl!("Keyboard Shortcuts and Menus"), fields)
 }
 
-/// Open the Embedded Profile Mismatch prompt for the active document.
-pub fn open_mismatch(app: &mut PhotocraftApp, report: &Value) -> u64 {
-    let msg = if report.get("missing").and_then(Value::as_bool) == Some(true) {
-        let template = "The document does not have an embedded colour profile. Working space: {working}.";
-        crate::i18n::fmt(tl!(template), &[("working", report["working"].as_str().unwrap_or("?"))])
-    } else {
-        let template = "The document has an embedded colour profile that does not match the working space.\nEmbedded: {embedded}\nWorking: {working}";
-        crate::i18n::fmt(tl!(template), &[("embedded", report["embedded"].as_str().unwrap_or("?")), ("working", report["working"].as_str().unwrap_or("?"))])
-    };
-    let action = match report["action"].as_str() {
-        Some("converted") => "convert",
-        Some("discarded") => "discard",
-        _ => "preserve",
-    };
-    open_kind(
-        app,
-        "mismatch",
-        tl!("Embedded Profile Mismatch"),
-        json!({"message": msg, "action": action, "applied": action, "missing": report.get("missing").is_some()}),
-    )
+/// Open the Embedded Profile Mismatch prompt for a file waiting to open (`open_prompt`): its
+/// `message`, the answer selected first (`action`), and `marker`, the field that routes OK and
+/// Cancel back to `open_prompt`.
+pub fn open_mismatch(app: &mut PhotocraftApp, message: &str, action: &str, missing: bool, marker: &str) -> u64 {
+    let mut fields = json!({"message": message, "action": action, "missing": missing});
+    fields[marker] = json!(true);
+    open_kind(app, "mismatch", tl!("Embedded Profile Mismatch"), fields)
 }
 
 // ------------------------------------------------------------------ bodies
@@ -1082,7 +1080,7 @@ fn hex_field(ui: &mut egui::Ui, key: &str, rgb: &mut [u8; 3]) {
     let id = egui::Id::new(("pref-hex", key));
     let shown = format!("#{:02x}{:02x}{:02x}", rgb[0], rgb[1], rgb[2]);
     let mut text = ui.data(|d| d.get_temp::<String>(id)).unwrap_or_else(|| shown.clone());
-    let r = ui.add(egui::TextEdit::singleline(&mut text).font(crate::theme::mono(11.5)).desired_width(72.0).char_limit(7));
+    let r = crate::widgets::text_field_ex(ui, id, &mut text, "", 72.0, true, Some(7));
     if r.changed()
         && let Some(c) = prefs::parse_hex(&text)
     {
@@ -1130,7 +1128,7 @@ fn prefs_body(ui: &mut egui::Ui, f: &mut Map<String, Value>, system: Option<egui
     // The dialog follows the language being edited, so a change shows before OK.
     let lang = crate::i18n::Lang::from_pref(values.pointer("/interface/language").and_then(Value::as_str).unwrap_or("auto"));
     let mut search = f.get("__search").and_then(Value::as_str).unwrap_or("").to_string();
-    ui.add(egui::TextEdit::singleline(&mut search).hint_text(tl!("Search settings…")).desired_width(f32::INFINITY));
+    crate::widgets::text_field(ui, ui.id().with("prefs-search"), &mut search, tl!("Search settings…"), ui.available_width(), false);
     let found = preference_sections(&values, &search);
     if !found.iter().any(|(id, _)| *id == section)
         && let Some((first, _)) = found.first()
@@ -1291,133 +1289,170 @@ fn export_field_visible(obj: &Map<String, Value>, key: &str) -> bool {
     }
 }
 
-fn theme_preview(ui: &mut egui::Ui, kind: ThemeKind, width: f32) {
+/// One theme as a Color Theme swatch: its panel colour under a chrome strip with an accent dot,
+/// outlined when chosen. The name is the tooltip and the accessible label. A star badge on its
+/// corner adds the theme to (or removes it from) the favourites listed by the appearance
+/// button's menu; it shows while the swatch is hovered, and stays for a favourite.
+fn theme_swatch(ui: &mut egui::Ui, kind: ThemeKind, id: &str, selected: &mut String, favorites: &mut Vec<SavedTheme>) {
+    const BADGE: f32 = 7.0;
+    let t = Tokens::get(ui.ctx());
     let p = Tokens::for_kind(kind);
-    let (rect, _) = ui.allocate_exact_size(vec2(width, 108.0), Sense::hover());
+    let label = tl!(&choice_label(id)).to_string();
+    let on = selected.as_str() == id;
+    let (rect, resp) = ui.allocate_exact_size(vec2(30.0, 26.0), Sense::click());
     let painter = ui.painter();
-    painter.rect_filled(rect, 3.0, p.dock);
-    let bar = egui::Rect::from_min_size(rect.min, vec2(rect.width(), 16.0));
-    painter.rect_filled(bar, 0.0, p.chrome);
-    for (x, w) in [(8.0, 18.0), (31.0, 13.0), (49.0, 16.0), (70.0, 12.0)] {
-        painter.rect_filled(egui::Rect::from_min_size(bar.min + vec2(x, 6.0), vec2(w, 3.0)), 1.0, p.text_dim);
+    let inner = rect.shrink(3.0);
+    painter.rect_filled(inner, 2.0, p.dock);
+    painter.rect_filled(egui::Rect::from_min_size(inner.min, vec2(inner.width(), 5.0)), 0.0, p.chrome);
+    painter.circle_filled(inner.right_bottom() - vec2(6.0, 6.0), 2.5, p.accent);
+    let stroke = if on {
+        egui::Stroke::new(2.0, t.accent)
+    } else if resp.hovered() {
+        egui::Stroke::new(1.0, t.text_dim)
+    } else {
+        egui::Stroke::new(1.0, t.card_border)
+    };
+    painter.rect_stroke(rect.shrink(1.0), 3.0, stroke, egui::StrokeKind::Inside);
+    resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::RadioButton, true, on, &label));
+    if resp.on_hover_text(&label).clicked() {
+        *selected = id.to_string();
     }
-    let tools = egui::Rect::from_min_max(bar.left_bottom(), egui::pos2(rect.left() + 23.0, rect.bottom()));
-    painter.rect_filled(tools, 0.0, p.chrome);
-    for y in [24.0, 39.0, 54.0, 69.0, 84.0] {
-        // The first tool is the active one.
-        let color = if y == 24.0 { p.accent } else { p.icon };
-        painter.rect_filled(egui::Rect::from_min_size(rect.min + vec2(7.0, y), vec2(9.0, 9.0)), 2.0, color);
+    let Some(theme) = SavedTheme::parse(id) else { return };
+    let favorite = favorites.contains(&theme);
+    let center = rect.right_top() + vec2(-3.0, 3.0);
+    let badge = egui::Rect::from_center_size(center, vec2(BADGE * 2.0, BADGE * 2.0));
+    if !(favorite || ui.rect_contains_pointer(rect.union(badge))) {
+        return;
     }
-    let dock = egui::Rect::from_min_max(egui::pos2(rect.right() - 75.0, bar.bottom()), rect.max);
-    painter.rect_filled(dock, 0.0, p.dock);
-    painter.rect_filled(egui::Rect::from_min_size(dock.min, vec2(dock.width(), 12.0)), 0.0, p.tab_strip);
-    painter.rect_filled(egui::Rect::from_min_size(dock.min + vec2(6.0, 4.0), vec2(31.0, 3.0)), 1.0, p.text_dim);
-    for y in [36.0, 55.0, 74.0] {
-        let row = egui::Rect::from_min_size(rect.min + vec2(rect.width() - 71.0, y), vec2(67.0, 16.0));
-        // The middle row is the selected layer.
-        let selected = y == 55.0;
-        painter.rect_filled(row, 1.0, if selected { p.accent } else { p.card });
-        painter.rect_filled(egui::Rect::from_min_size(row.min + vec2(4.0, 3.0), vec2(13.0, 10.0)), 1.0, p.canvas);
-        let label = if selected { egui::Color32::from_white_alpha(210) } else { p.text_dim };
-        painter.rect_filled(egui::Rect::from_min_size(row.min + vec2(22.0, 6.0), vec2(35.0, 3.0)), 1.0, label);
+    ui.painter().circle(center, BADGE, t.card, egui::Stroke::new(1.0, t.card_border));
+    let (icon, tint) = if favorite { ("star-filled", t.accent) } else { ("star", t.text_dim) };
+    let action = if favorite { tl!("Remove from favorites") } else { tl!("Add to favorites") };
+    let star = egui::Button::image(crate::icons::image(icon, 10.0, tint)).frame(false);
+    let response = ui.put(badge, star).on_hover_text(action);
+    response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, format!("{action}: {label}")));
+    if response.clicked() {
+        if favorite {
+            favorites.retain(|saved| *saved != theme);
+        } else {
+            favorites.push(theme);
+        }
     }
-    let canvas = egui::Rect::from_min_max(egui::pos2(tools.right(), bar.bottom()), egui::pos2(dock.left(), rect.bottom()));
-    painter.rect_filled(canvas, 0.0, p.canvas);
-    let art = canvas.shrink2(vec2(15.0, 13.0));
-    painter.rect_filled(art, 0.0, p.card);
-    painter.rect_stroke(art, 0.0, egui::Stroke::new(1.0, p.card_border), egui::StrokeKind::Inside);
 }
 
-fn theme_card(ui: &mut egui::Ui, title: &str, active: bool, selected: &mut String, favorites: &mut Vec<SavedTheme>, options: &[(&str, ThemeKind)], width: f32) {
-    let Some((_, first_kind)) = options.first() else { return };
+/// A grid row of theme swatches, marked Active when the appearance mode shows this family.
+fn theme_row(ui: &mut egui::Ui, title: &str, active: bool, selected: &mut String, favorites: &mut Vec<SavedTheme>, options: &[(&str, ThemeKind)]) {
     let t = Tokens::get(ui.ctx());
-    egui::Frame::new()
-        .fill(t.card)
-        .stroke(egui::Stroke::new(1.0, if active { t.accent } else { t.card_border }))
-        .corner_radius(t.radius)
-        .inner_margin(10.0)
-        .show(ui, |ui| {
-            ui.set_width(width - 20.0);
-            // Room for the longer list (six dark themes), so both cards line up.
-            ui.set_min_height(298.0);
-            ui.horizontal(|ui| {
-                ui.label(RichText::new(tl!(title)).strong().color(t.text));
-                if active {
-                    ui.label(RichText::new(tl!("Active")).color(t.accent_text).small());
-                }
-            });
-            ui.add_space(5.0);
-            let preview = options.iter().find(|(id, _)| *id == selected.as_str()).map_or(*first_kind, |(_, kind)| *kind);
-            theme_preview(ui, preview, width - 20.0);
-            ui.add_space(6.0);
-            for (id, _) in options {
-                let label = choice_label(id);
-                let row = egui::Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), 24.0));
-                let hovered = ui.ctx().pointer_hover_pos().is_some_and(|p| row.contains(p));
-                ui.horizontal(|ui| {
-                    ui.radio_value(selected, (*id).to_string(), tl!(&label));
-                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                        if let Some(theme) = SavedTheme::parse(id) {
-                            let favorite = favorites.contains(&theme);
-                            let (icon, tint) = if favorite { ("star-filled", t.accent) } else { ("star", t.text_dim) };
-                            let star = egui::Button::image(crate::icons::image(icon, 15.0, tint)).frame(false);
-                            let response = ui.add_visible(favorite || hovered, star).on_hover_text(if favorite {
-                                tl!("Remove from favorites")
-                            } else {
-                                tl!("Add to favorites")
-                            });
-                            response.widget_info(|| {
-                                egui::WidgetInfo::labeled(
-                                    egui::WidgetType::Button,
-                                    true,
-                                    format!("{}: {}", if favorite { tl!("Remove from favorites") } else { tl!("Add to favorites") }, tl!(&label)),
-                                )
-                            });
-                            if response.clicked() {
-                                if favorite {
-                                    favorites.retain(|saved| *saved != theme);
-                                } else {
-                                    favorites.push(theme);
-                                }
-                            }
-                        }
-                    });
-                });
-            }
-        });
-}
-
-fn appearance_rows(ui: &mut egui::Ui, obj: &mut Map<String, Value>, system: Option<egui::Theme>) {
-    let t = Tokens::get(ui.ctx());
-    ui.label(RichText::new(tl!("Appearance")).strong().color(t.text));
-    let mut mode = obj.get("appearanceMode").and_then(Value::as_str).unwrap_or("auto").to_string();
+    ui.label(RichText::new(tl!(title)).color(t.text_dim));
     ui.horizontal(|ui| {
+        // Room for the favourite star badges on the swatch corners.
+        ui.spacing_mut().item_spacing.x = 6.0;
+        for (id, kind) in options {
+            theme_swatch(ui, *kind, id, selected, favorites);
+        }
+        if active {
+            ui.add_space(6.0);
+            ui.label(RichText::new(tl!("Active")).color(t.accent_text).small());
+        }
+    });
+    ui.end_row();
+}
+
+/// Which of the Appearance rows drawn by `appearance_rows` a search shows.
+#[derive(Clone, Copy)]
+struct AppearanceRows {
+    mode: bool,
+    light: bool,
+    dark: bool,
+}
+
+impl AppearanceRows {
+    /// `query` is lowercased; empty shows every row.
+    fn matching(query: &str) -> Self {
+        let shown = |key: &str| query.is_empty() || preference_matches("interface", key, query);
+        Self { mode: shown("appearanceMode"), light: shown("lightTheme"), dark: shown("darkTheme") }
+    }
+
+    fn any(self) -> bool {
+        self.mode || self.light || self.dark
+    }
+}
+
+/// Appearance Mode and the light and dark Color Theme swatches, as rows of the Appearance grid.
+fn appearance_rows(ui: &mut egui::Ui, obj: &mut Map<String, Value>, system: Option<egui::Theme>, rows: AppearanceRows) {
+    let t = Tokens::get(ui.ctx());
+    let mut mode = obj.get("appearanceMode").and_then(Value::as_str).unwrap_or("auto").to_string();
+    if rows.mode {
         ui.label(RichText::new(tl!("Appearance Mode")).color(t.text_dim));
         let choices: [(String, &str); 3] = [("auto".into(), tl!("Sync with system")), ("dark".into(), tl!("Dark")), ("light".into(), tl!("Light"))];
         let pairs: Vec<(String, &str)> = choices.iter().map(|(id, label)| (id.clone(), *label)).collect();
-        crate::widgets::dropdown(ui, "appearance-mode", &mut mode, &pairs, 190.0);
-    });
-    obj.insert("appearanceMode".into(), json!(mode));
-    ui.add_space(8.0);
+        crate::widgets::dropdown(ui, "appearance-mode", &mut mode, &pairs, 220.0);
+        ui.end_row();
+    }
     let light_active = mode == "light" || (mode == "auto" && system == Some(egui::Theme::Light));
-    let width = ((ui.available_width() - 10.0) / 2.0).max(190.0);
+    obj.insert("appearanceMode".into(), json!(mode));
     let mut light = obj.get("lightTheme").and_then(Value::as_str).unwrap_or("studioLight").to_string();
     let mut dark = obj.get("darkTheme").and_then(Value::as_str).unwrap_or("proMedium").to_string();
     let mut favorites: Vec<SavedTheme> = obj.get("favoriteThemes").cloned().and_then(|v| serde_json::from_value(v).ok()).unwrap_or_default();
-    ui.horizontal_top(|ui| {
-        ui.set_min_width(width * 2.0 + 10.0);
-        ui.allocate_ui_with_layout(vec2(width, 300.0), egui::Layout::top_down(egui::Align::Min), |ui| {
-            theme_card(ui, "Light Theme", light_active, &mut light, &mut favorites, LIGHT_THEME_OPTIONS, width);
-        });
-        ui.add_space(10.0);
-        ui.allocate_ui_with_layout(vec2(width, 300.0), egui::Layout::top_down(egui::Align::Min), |ui| {
-            theme_card(ui, "Dark Theme", !light_active, &mut dark, &mut favorites, DARK_THEME_OPTIONS, width);
-        });
-    });
+    if rows.light {
+        theme_row(ui, "Light Theme", light_active, &mut light, &mut favorites, LIGHT_THEME_OPTIONS);
+    }
+    if rows.dark {
+        theme_row(ui, "Dark Theme", !light_active, &mut dark, &mut favorites, DARK_THEME_OPTIONS);
+    }
     obj.insert("lightTheme".into(), json!(light));
     obj.insert("darkTheme".into(), json!(dark));
     obj.insert("favoriteThemes".into(), json!(favorites));
-    ui.add_space(12.0);
+}
+
+/// A titled, outlined group of settings (Photoshop's Interface page has Appearance,
+/// Presentation and Options).
+fn pref_group(ui: &mut egui::Ui, title: &str, add: impl FnOnce(&mut egui::Ui)) {
+    let t = Tokens::get(ui.ctx());
+    egui::Frame::new().stroke(egui::Stroke::new(1.0, t.card_border)).corner_radius(t.radius).inner_margin(10.0).show(ui, |ui| {
+        ui.set_width(ui.available_width());
+        ui.label(RichText::new(tl!(title)).strong().color(t.text));
+        ui.add_space(4.0);
+        add(ui);
+    });
+    ui.add_space(8.0);
+}
+
+/// Preferences › Interface laid out like Photoshop's: the theme and canvas settings, then UI
+/// language, font size and scaling, then everything else. Compact enough that the language
+/// shows without scrolling in a small window (#2532). A search (`query`, lowercased) hides the
+/// rows that don't match and skips a group left empty.
+fn interface_groups(ui: &mut egui::Ui, obj: &mut Map<String, Value>, keys: &[String], lang: crate::i18n::Lang, system: Option<egui::Theme>, query: &str) {
+    const APPEARANCE: [&str; 3] = ["canvasColor", "canvasCustomColor", "canvasBorder"];
+    const PRESENTATION: [&str; 3] = ["language", "uiFontSize", "uiScale"];
+    let shown = |k: &str| keys.iter().any(|key| key == k) && field_visible("interface", obj, k, query);
+    // In Photoshop's order, not the stored one.
+    let pick = |names: &[&str]| names.iter().filter(|n| shown(n)).map(|n| n.to_string()).collect::<Vec<_>>();
+    let appearance = pick(&APPEARANCE);
+    let presentation = pick(&PRESENTATION);
+    let rest = keys.iter().filter(|k| !APPEARANCE.contains(&k.as_str()) && !PRESENTATION.contains(&k.as_str()) && shown(k));
+    // Checkboxes line up at the left edge, as in Photoshop; the other options keep a label column.
+    let (checks, other): (Vec<String>, Vec<String>) = rest.cloned().partition(|k| obj.get(k).is_some_and(Value::is_boolean));
+    let rows = AppearanceRows::matching(query);
+    let grid = |id: &str| egui::Grid::new(("prefs-grid", id.to_string())).num_columns(2).spacing([14.0, 7.0]).min_col_width(150.0);
+    if rows.any() || !appearance.is_empty() {
+        pref_group(ui, "Appearance", |ui| {
+            grid("interface-appearance").show(ui, |ui| {
+                appearance_rows(ui, obj, system, rows);
+                field_rows(ui, "interface", obj, appearance, lang);
+            });
+        });
+    }
+    if !presentation.is_empty() {
+        pref_group(ui, "Presentation", |ui| {
+            grid("interface-presentation").show(ui, |ui| field_rows(ui, "interface", obj, presentation, lang));
+        });
+    }
+    if !checks.is_empty() || !other.is_empty() {
+        pref_group(ui, "Options", |ui| {
+            egui::Grid::new("prefs-grid-interface-checks").num_columns(2).spacing([0.0, 7.0]).show(ui, |ui| field_rows(ui, "interface", obj, checks, lang));
+            grid("interface-options").show(ui, |ui| field_rows(ui, "interface", obj, other, lang));
+        });
+    }
 }
 
 /// Where a clicked colour swatch leaves its preference path and label for the dialog body, which
@@ -1429,6 +1464,22 @@ fn ctx_take_pick(ui: &egui::Ui) -> Option<(String, String)> {
     ui.ctx().data_mut(|d| d.remove_temp::<(String, String)>(egui::Id::new(PICK_ID)))
 }
 
+/// Whether `section.key` gets a generic row for this search (`query`, lowercased; empty matches
+/// everything). Settings nothing reads yet stay out of the dialog (issue #204), as do those drawn
+/// by their own widgets; their stored values pass through untouched.
+fn field_visible(section: &str, obj: &Map<String, Value>, k: &str, query: &str) -> bool {
+    let path = format!("{section}.{k}");
+    let drawn_elsewhere = (section == "interface" && matches!(k, "theme" | "appearanceMode" | "darkTheme" | "lightTheme" | "favoriteThemes"))
+        // View › Rulers (⌘R) sets it, as in Photoshop.
+        || path == "unitsAndRulers.showRulers"
+        || (section == "performance" && matches!(k, "useGpu" | "gpuBackend" | "renderingMode"))
+        || (section == "export" && !export_field_visible(obj, k));
+    (query.is_empty() || preference_matches(section, k, query))
+        && !drawn_elsewhere
+        && !prefs::is_hidden(&path)
+        && obj.get(k).is_some_and(|v| !matches!(v, Value::Null | Value::Object(_)))
+}
+
 /// Generic editor for a section's fields: checkboxes, dropdowns for choices, colour swatches,
 /// number fields with the preference's range, text fields.
 fn section_fields(
@@ -1440,138 +1491,128 @@ fn section_fields(
     system: Option<egui::Theme>,
     search: &str,
 ) {
-    let t = Tokens::get(ui.ctx());
     let query = search.to_lowercase();
-    if section == "interface" && (query.is_empty() || ["appearanceMode", "darkTheme", "lightTheme"].iter().any(|key| preference_matches(section, key, &query)))
-    {
-        appearance_rows(ui, obj, system);
+    let mut keys: Vec<String> = order.iter().filter(|k| obj.contains_key(*k)).cloned().collect();
+    keys.extend(obj.keys().filter(|k| !order.contains(k)).cloned());
+    if section == "interface" {
+        interface_groups(ui, obj, &keys, lang, system, &query);
+        return;
     }
     if section == "performance" && (query.is_empty() || preference_matches(section, "renderingMode", &query)) {
         rendering_mode_row(ui, obj);
     }
-    let mut keys: Vec<String> = order.iter().filter(|k| obj.contains_key(*k)).cloned().collect();
-    keys.extend(obj.keys().filter(|k| !order.contains(k)).cloned());
-    egui::Grid::new(("prefs-grid", section)).num_columns(2).spacing([14.0, 7.0]).show(ui, |ui| {
-        for k in keys {
-            let path = format!("{section}.{k}");
-            if !query.is_empty() && !preference_matches(section, &k, &query) {
-                continue;
-            }
-            // Settings nothing reads yet stay out of the dialog (issue #204); their stored values
-            // pass through untouched.
-            if (section == "interface" && matches!(k.as_str(), "theme" | "appearanceMode" | "darkTheme" | "lightTheme" | "favoriteThemes"))
-                // View › Rulers (⌘R) sets it, as in Photoshop.
-                || path == "unitsAndRulers.showRulers"
-                || prefs::is_hidden(&path)
-                || (section == "performance" && matches!(k.as_str(), "useGpu" | "gpuBackend" | "renderingMode"))
-                || (section == "export" && !export_field_visible(obj, &k))
-            {
-                continue;
-            }
-            let v = obj.get(&k).cloned().unwrap_or(Value::Null);
-            let human = humanize(&k);
-            let label = tl!(&human).to_string();
-            match &v {
-                Value::Bool(b) => {
-                    ui.label("");
-                    let mut b = *b;
-                    if path == "interface.systemTitleBar" && cfg!(all(not(target_arch = "wasm32"), not(target_os = "macos"))) {
-                        ui.vertical(|ui| {
-                            crate::widgets::checkbox(ui, &mut b, &label);
-                            ui.label(RichText::new(tl!("Applies at next launch.")).color(t.text_dim));
-                        });
-                    } else {
-                        crate::widgets::checkbox(ui, &mut b, &label);
-                    }
-                    obj.insert(k, json!(b));
-                }
-                Value::String(s) if path == "interface.language" => {
-                    ui.label(RichText::new(tl!(&label)).color(t.text_dim));
-                    let mut pairs: Vec<(String, &str)> = vec![("auto".into(), tl!("Auto"))];
-                    pairs.extend(crate::i18n::Lang::all().map(|l| (l.code().to_string(), l.name())));
-                    let mut cur = s.clone();
-                    crate::widgets::dropdown(ui, &format!("pref-{path}"), &mut cur, &pairs, 220.0);
-                    obj.insert(k, json!(cur));
-                }
-                Value::String(s) if prefs::choices(&path).is_some() => {
-                    ui.label(RichText::new(tl!(&label)).color(t.text_dim));
-                    let opts = prefs::choices(&path).unwrap_or(&[]);
-                    let labels: Vec<String> = opts.iter().map(|o| choice_label(o)).collect();
-                    let pairs: Vec<(String, &str)> = opts.iter().map(|o| o.to_string()).zip(labels.iter().map(String::as_str)).collect();
-                    let mut cur = s.clone();
-                    crate::widgets::dropdown(ui, &format!("pref-{path}"), &mut cur, &pairs, 220.0);
-                    obj.insert(k, json!(cur));
-                }
-                Value::String(s) if prefs::is_color(&path) => {
-                    ui.label(RichText::new(tl!(&label)).color(t.text_dim));
-                    let c = prefs::parse_hex(s).unwrap_or([128, 128, 128]);
-                    let mut rgb = c;
-                    ui.horizontal(|ui| {
-                        // PhotoCraft's Color Picker, as everywhere else (#2144).
-                        if crate::widgets::color_swatch_button(ui, egui::Color32::from_rgb(rgb[0], rgb[1], rgb[2]), &label).clicked() {
-                            ui.ctx().data_mut(|d| d.insert_temp(egui::Id::new(PICK_ID), (path.clone(), label.clone())));
-                        }
-                        hex_field(ui, &path, &mut rgb);
-                    });
-                    obj.insert(k, json!(format!("#{:02x}{:02x}{:02x}", rgb[0], rgb[1], rgb[2])));
-                    let _ = color_of(s);
-                }
-                Value::String(s) => {
-                    ui.label(RichText::new(tl!(&label)).color(t.text_dim));
-                    let mut s = s.clone();
-                    ui.add(egui::TextEdit::singleline(&mut s).desired_width(260.0));
-                    obj.insert(k, json!(s));
-                }
-                Value::Number(n) => {
-                    ui.label(RichText::new(tl!(&label)).color(t.text_dim));
-                    let (lo, hi) = prefs::range(&path).unwrap_or((-1e9, 1e9));
-                    if n.is_u64() || n.is_i64() {
-                        let mut x = n.as_i64().unwrap_or(0);
-                        ui.add(egui::DragValue::new(&mut x).range(lo as i64..=hi as i64).custom_parser(crate::widgets::parse_num));
-                        obj.insert(k, json!(x));
-                    } else {
-                        let mut x = n.as_f64().unwrap_or(0.0);
-                        ui.add(egui::DragValue::new(&mut x).range(lo..=hi).speed(0.1).max_decimals(3).custom_parser(crate::widgets::parse_num));
-                        obj.insert(k, json!(x));
-                    }
-                }
-                Value::Array(_) if path == "tools.pressureCurve" => {
-                    ui.label(RichText::new(tl!(&label)).color(t.text_dim));
-                    if let Some(next) = crate::pressure_curve_ui::editor(ui, &v) {
-                        obj.insert(k, next);
-                    }
-                }
-                Value::Array(items) if k == "disks" => {
-                    ui.label(RichText::new(tl!("Scratch disks")).color(t.text_dim));
-                    let mut items = items.clone();
+    keys.retain(|k| field_visible(section, obj, k, &query));
+    egui::Grid::new(("prefs-grid", section)).num_columns(2).spacing([14.0, 7.0]).show(ui, |ui| field_rows(ui, section, obj, keys, lang));
+}
+
+/// One grid row per setting in `keys` (already filtered by `field_visible`).
+fn field_rows(ui: &mut egui::Ui, section: &str, obj: &mut Map<String, Value>, keys: Vec<String>, lang: crate::i18n::Lang) {
+    let t = Tokens::get(ui.ctx());
+    for k in keys {
+        let path = format!("{section}.{k}");
+        let v = obj.get(&k).cloned().unwrap_or(Value::Null);
+        let human = humanize(&k);
+        let label = tl!(&human).to_string();
+        match &v {
+            Value::Bool(b) => {
+                ui.label("");
+                let mut b = *b;
+                if path == "interface.systemTitleBar" && cfg!(all(not(target_arch = "wasm32"), not(target_os = "macos"))) {
                     ui.vertical(|ui| {
-                        for d in &mut items {
-                            ui.horizontal(|ui| {
-                                let mut on = d.get("enabled").and_then(Value::as_bool).unwrap_or(false);
-                                let mut path = d.get("path").and_then(Value::as_str).unwrap_or("").to_string();
-                                crate::widgets::checkbox(ui, &mut on, "");
-                                ui.add(egui::TextEdit::singleline(&mut path).desired_width(240.0));
-                                *d = json!({"enabled": on, "path": path});
-                            });
-                        }
-                        if ui.small_button(tl!("Add disk")).clicked() {
-                            items.push(json!({"enabled": true, "path": ""}));
-                        }
+                        crate::widgets::checkbox(ui, &mut b, &label);
+                        ui.label(RichText::new(tl!("Applies at next launch.")).color(t.text_dim));
                     });
-                    obj.insert(k, Value::Array(items));
+                } else {
+                    crate::widgets::checkbox(ui, &mut b, &label);
                 }
-                Value::Array(items) => {
-                    ui.label(RichText::new(tl!(&label)).color(t.text_dim));
-                    ui.label(RichText::new(crate::i18n::trn(lang, items.len() as u64, "{n} item", "{n} items")).color(t.text_faint));
-                    if !items.is_empty() && ui.small_button(tl!("Clear")).clicked() {
-                        obj.insert(k, json!([]));
-                    }
-                }
-                _ => continue,
+                obj.insert(k, json!(b));
             }
-            ui.end_row();
+            Value::String(s) if path == "interface.language" => {
+                ui.label(RichText::new(tl!(&label)).color(t.text_dim));
+                let mut pairs: Vec<(String, &str)> = vec![("auto".into(), tl!("Auto"))];
+                pairs.extend(crate::i18n::Lang::all().map(|l| (l.code().to_string(), l.name())));
+                let mut cur = s.clone();
+                crate::widgets::dropdown(ui, &format!("pref-{path}"), &mut cur, &pairs, 220.0);
+                obj.insert(k, json!(cur));
+            }
+            Value::String(s) if prefs::choices(&path).is_some() => {
+                ui.label(RichText::new(tl!(&label)).color(t.text_dim));
+                let opts = prefs::choices(&path).unwrap_or(&[]);
+                let labels: Vec<String> = opts.iter().map(|o| choice_label(o)).collect();
+                let pairs: Vec<(String, &str)> = opts.iter().map(|o| o.to_string()).zip(labels.iter().map(String::as_str)).collect();
+                let mut cur = s.clone();
+                crate::widgets::dropdown(ui, &format!("pref-{path}"), &mut cur, &pairs, 220.0);
+                obj.insert(k, json!(cur));
+            }
+            Value::String(s) if prefs::is_color(&path) => {
+                ui.label(RichText::new(tl!(&label)).color(t.text_dim));
+                let c = prefs::parse_hex(s).unwrap_or([128, 128, 128]);
+                let mut rgb = c;
+                ui.horizontal(|ui| {
+                    // PhotoCraft's Color Picker, as everywhere else (#2144).
+                    if crate::widgets::color_swatch_button(ui, egui::Color32::from_rgb(rgb[0], rgb[1], rgb[2]), &label).clicked() {
+                        ui.ctx().data_mut(|d| d.insert_temp(egui::Id::new(PICK_ID), (path.clone(), label.clone())));
+                    }
+                    hex_field(ui, &path, &mut rgb);
+                });
+                obj.insert(k, json!(format!("#{:02x}{:02x}{:02x}", rgb[0], rgb[1], rgb[2])));
+                let _ = color_of(s);
+            }
+            Value::String(s) => {
+                ui.label(RichText::new(tl!(&label)).color(t.text_dim));
+                let mut s = s.clone();
+                ui.add(egui::TextEdit::singleline(&mut s).desired_width(260.0));
+                obj.insert(k, json!(s));
+            }
+            Value::Number(n) => {
+                ui.label(RichText::new(tl!(&label)).color(t.text_dim));
+                let (lo, hi) = prefs::range(&path).unwrap_or((-1e9, 1e9));
+                if n.is_u64() || n.is_i64() {
+                    let mut x = n.as_i64().unwrap_or(0);
+                    ui.add(egui::DragValue::new(&mut x).range(lo as i64..=hi as i64).custom_parser(crate::widgets::parse_num));
+                    obj.insert(k, json!(x));
+                } else {
+                    let mut x = n.as_f64().unwrap_or(0.0);
+                    ui.add(egui::DragValue::new(&mut x).range(lo..=hi).speed(0.1).max_decimals(3).custom_parser(crate::widgets::parse_num));
+                    obj.insert(k, json!(x));
+                }
+            }
+            Value::Array(_) if path == "tools.pressureCurve" => {
+                ui.label(RichText::new(tl!(&label)).color(t.text_dim));
+                if let Some(next) = crate::pressure_curve_ui::editor(ui, &v) {
+                    obj.insert(k, next);
+                }
+            }
+            Value::Array(items) if k == "disks" => {
+                ui.label(RichText::new(tl!("Scratch disks")).color(t.text_dim));
+                let mut items = items.clone();
+                ui.vertical(|ui| {
+                    for d in &mut items {
+                        ui.horizontal(|ui| {
+                            let mut on = d.get("enabled").and_then(Value::as_bool).unwrap_or(false);
+                            let mut path = d.get("path").and_then(Value::as_str).unwrap_or("").to_string();
+                            crate::widgets::checkbox(ui, &mut on, "");
+                            ui.add(egui::TextEdit::singleline(&mut path).desired_width(240.0));
+                            *d = json!({"enabled": on, "path": path});
+                        });
+                    }
+                    if ui.small_button(tl!("Add disk")).clicked() {
+                        items.push(json!({"enabled": true, "path": ""}));
+                    }
+                });
+                obj.insert(k, Value::Array(items));
+            }
+            Value::Array(items) => {
+                ui.label(RichText::new(tl!(&label)).color(t.text_dim));
+                ui.label(RichText::new(crate::i18n::trn(lang, items.len() as u64, "{n} item", "{n} items")).color(t.text_faint));
+                if !items.is_empty() && ui.small_button(tl!("Clear")).clicked() {
+                    obj.insert(k, json!([]));
+                }
+            }
+            _ => continue,
         }
-    });
+        ui.end_row();
+    }
 }
 
 /// Keyboard Shortcuts and Menus: a searchable list of commands by menu with editable shortcuts
@@ -1669,6 +1710,9 @@ fn shortcuts_body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String
         let mut last_top = String::new();
         egui::Grid::new("shortcut-grid").num_columns(3).spacing([12.0, 3.0]).striped(true).show(ui, |ui| {
             for (id, label, path, def) in &items {
+                if tab == 1 && crate::tool_shortcuts::tool(id).is_some() {
+                    continue;
+                }
                 let cur = eff(&overrides, id, def);
                 let (shown_path, shown_label) = shown(id, label, path);
                 // Match what is shown and the English name (commands are documented in English).
@@ -1954,13 +1998,10 @@ pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value,
                 })
             }
         }
+        // The file it asks about opens with this answer (`open_prompt`).
         "mismatch" => {
             let action = f.get("action").and_then(Value::as_str).unwrap_or("preserve");
-            let applied = f.get("applied").and_then(Value::as_str).unwrap_or("preserve");
-            if action == applied {
-                return Ok(json!({"action": action}));
-            }
-            app.run("color.profileMismatch", json!({"action": action}))
+            crate::open_prompt::answer(app, Some(action))
         }
         _ => Err("unknown dialog".into()),
     }
@@ -2065,7 +2106,7 @@ mod tests {
     fn appearance_resolves_both_saved_themes_and_follows_system() {
         let mut interface = prefs::Interface { appearance_mode: AppearanceMode::Auto, ..prefs::Interface::default() };
         assert_eq!(selected_theme(&interface, Some(egui::Theme::Dark)), ThemeKind::ProMedium);
-        assert_eq!(selected_theme(&interface, Some(egui::Theme::Light)), ThemeKind::StudioLight);
+        assert_eq!(selected_theme(&interface, Some(egui::Theme::Light)), ThemeKind::ProLight);
         interface.dark_theme = DarkTheme::Studio;
         interface.light_theme = LightTheme::Classic;
         assert_eq!(selected_theme(&interface, Some(egui::Theme::Dark)), ThemeKind::Studio);
@@ -2080,7 +2121,12 @@ mod tests {
     fn breeze_themes_are_chosen_by_preference_and_fix_the_matching_mode() {
         let ctx = egui::Context::default();
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
-        for (id, kind, mode) in [("breezeLight", ThemeKind::BreezeLight, AppearanceMode::Light), ("breezeDark", ThemeKind::BreezeDark, AppearanceMode::Dark)] {
+        for (id, kind, mode) in [
+            ("breezeLight", ThemeKind::BreezeLight, AppearanceMode::Light),
+            ("breezeDark", ThemeKind::BreezeDark, AppearanceMode::Dark),
+            ("softLight", ThemeKind::SoftLight, AppearanceMode::Light),
+            ("softDark", ThemeKind::SoftDark, AppearanceMode::Dark),
+        ] {
             app.run("prefs.set", json!({"path": "interface.theme", "value": id})).unwrap();
             tick(&mut app, &ctx);
             let interface = app.session.prefs().interface.clone();
@@ -2089,8 +2135,8 @@ mod tests {
             assert_eq!(app.ui.theme, kind, "{id}");
         }
         // The two slots are independent: choosing the dark one left the light choice alone.
-        assert_eq!(app.session.prefs().interface.light_theme, LightTheme::BreezeLight);
-        assert_eq!(app.session.prefs().interface.dark_theme, DarkTheme::BreezeDark);
+        assert_eq!(app.session.prefs().interface.light_theme, LightTheme::SoftLight);
+        assert_eq!(app.session.prefs().interface.dark_theme, DarkTheme::SoftDark);
     }
 
     #[test]
@@ -2101,7 +2147,7 @@ mod tests {
         app.run("prefs.set", json!({"path": "interface.appearanceMode", "value": "auto"})).unwrap();
         let ctx = egui::Context::default();
         tick(&mut app, &ctx);
-        assert_eq!(app.ui.theme, ThemeKind::StudioLight);
+        assert_eq!(app.ui.theme, ThemeKind::ProLight);
     }
 
     #[test]
@@ -2214,13 +2260,13 @@ mod tests {
         ctx.set_theme(egui::ThemePreference::Dark);
         assert_eq!(ctx.options(|o| o.theme_preference), egui::ThemePreference::Dark);
         appearance_frame(&mut app, &ctx, Some(egui::Theme::Light));
-        assert_palette(&ctx, ThemeKind::StudioLight);
+        assert_palette(&ctx, ThemeKind::ProLight);
         assert_eq!(app.session.prefs().interface.appearance_mode, AppearanceMode::Auto);
         // A restored pin must also clear when the concrete PhotoCraft palette stays the same.
         ctx.set_theme(egui::ThemePreference::Dark);
         appearance_frame(&mut app, &ctx, Some(egui::Theme::Light));
         assert_eq!(ctx.options(|o| o.theme_preference), egui::ThemePreference::System);
-        assert_palette(&ctx, ThemeKind::StudioLight);
+        assert_palette(&ctx, ThemeKind::ProLight);
         appearance_frame(&mut app, &ctx, Some(egui::Theme::Dark));
         assert_palette(&ctx, ThemeKind::ProMedium);
         assert_eq!(app.session.prefs().interface.appearance_mode, AppearanceMode::Auto);
@@ -2331,6 +2377,67 @@ mod tests {
         assert_eq!(dark, vec![ThemeKind::Studio]);
     }
 
+    #[test]
+    fn preferences_interface_shows_language_without_scrolling() {
+        // #2532: in a small window the theme cards filled the page and Language sat out of view
+        // below them. Like Photoshop, Presentation follows Appearance and both fit.
+        use egui_kittest::{Harness, kittest::Queryable};
+        let (mut app, _) = app_with_store();
+        app.run("prefs.set", json!({"values": {"interface.language": "en"}})).unwrap();
+        open_preferences(&mut app, "interface");
+        let mut h = Harness::builder().with_size(vec2(1000.0, 750.0)).build_eframe(move |cc| {
+            PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+            app
+        });
+        h.run_steps(4);
+        let language = h.get_by_label("Language").rect();
+        let dark = h.get_by_label("Dark Theme").rect();
+        let ok = h.get_by_label("OK").rect();
+        assert!(dark.bottom() < language.top(), "Presentation {language:?} follows the theme swatches {dark:?}");
+        assert!(language.bottom() < ok.top() - 20.0, "Language {language:?} must show above the buttons {ok:?} without scrolling");
+        // Every theme in the option lists gets a swatch, Breeze included.
+        for (id, _) in LIGHT_THEME_OPTIONS.iter().chain(DARK_THEME_OPTIONS) {
+            let label = choice_label(id);
+            assert!(h.query_by_label(&label).is_some(), "missing theme swatch {label}");
+        }
+        assert!(h.query_by_label("Breeze light").is_some() && h.query_by_label("Breeze dark").is_some());
+    }
+
+    #[test]
+    fn preferences_interface_search_hides_rows_and_skips_empty_groups() {
+        use egui_kittest::{Harness, kittest::Queryable};
+        let render = |search: &str| {
+            let (mut app, _) = app_with_store();
+            app.run("prefs.set", json!({"values": {"interface.language": "en"}})).unwrap();
+            let id = open_preferences(&mut app, "interface");
+            app.ui.dialog_mut(id).unwrap().fields.insert("__search".into(), json!(search));
+            let mut h = Harness::builder().with_size(vec2(1000.0, 750.0)).build_eframe(move |cc| {
+                PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+                app
+            });
+            h.run_steps(4);
+            h
+        };
+        let shown = |h: &Harness<'_, PhotocraftApp>, label: &str| h.query_all_by_label(label).next().is_some();
+
+        let h = render("language");
+        assert!(shown(&h, "Language") && shown(&h, "Presentation"));
+        for gone in ["Appearance", "Appearance Mode", "Dark Theme", "Options", "UI scale"] {
+            assert!(!shown(&h, gone), "\"language\" must not show {gone}");
+        }
+
+        let h = render("theme");
+        assert!(shown(&h, "Appearance") && shown(&h, "Light Theme") && shown(&h, "Dark Theme") && shown(&h, "Breeze dark"));
+        for gone in ["Appearance Mode", "Presentation", "Language", "Options"] {
+            assert!(!shown(&h, gone), "\"theme\" must not show {gone}");
+        }
+
+        let h = render("");
+        for group in ["Appearance", "Appearance Mode", "Presentation", "Options", "UI scale"] {
+            assert!(shown(&h, group), "an empty search shows {group}");
+        }
+    }
+
     /// Every generated preference label, section title and choice label has an entry in each
     /// language that claims complete menus (Japanese, Traditional Chinese, ...).
     #[test]
@@ -2649,6 +2756,39 @@ mod tests {
         }
     }
 
+    #[test]
+    fn view_show_items_survive_a_restart() {
+        let (mut app, store) = app_with_store();
+        let ctx = egui::Context::default();
+        tick(&mut app, &ctx);
+        // Untouched: nothing is stored, so later default changes still reach the user.
+        crate::view_cmds::persist(&mut app, &ctx);
+        tick(&mut app, &ctx);
+        assert!(stored(&store).get("viewExtras").is_none_or(Value::is_null));
+        // The menu commands, as a user toggles them (#3762: Pixel Grid off).
+        for id in ["view.show.pixelGrid", "view.show.grid", "view.snapTo.layers", "view.extras"] {
+            crate::menus::invoke(&mut app, &ctx, id, json!({})).unwrap();
+        }
+        crate::view_cmds::persist(&mut app, &ctx);
+        tick(&mut app, &ctx);
+        assert_eq!(stored(&store)["viewExtras"], json!({"extras": false, "grid": true, "show": {"pixelGrid": false}, "snapTo": {"layers": false}}));
+        // A restart gets them back.
+        let saved = store.lock().unwrap().clone().unwrap();
+        let (mut app2, _) = app_with_saved(Some(saved));
+        tick(&mut app2, &ctx);
+        let v = &app2.ui.view;
+        assert!(!v.extras && !v.show.pixel_grid && !v.snap_to.layers && app2.ui.extras.grid);
+        assert!(v.show.selection_edges && v.snap_to.guides && app2.ui.extras.guides, "the rest keep their defaults");
+        // A hand-edited file: unknown keys and non-booleans keep the defaults, good ones still load.
+        for bad in [json!("junk"), json!({"extras": 0, "show": {"pixelGrid": "no", "mesh": true, "bogus": true}, "snapTo": [1]})] {
+            let (mut app3, _) = app_with_saved(Some(json!({"viewExtras": bad}).to_string()));
+            tick(&mut app3, &ctx);
+            let v = &app3.ui.view;
+            assert!(v.extras && v.show.pixel_grid && v.snap_to.layers, "{bad}");
+            assert_eq!(v.show.mesh, bad.is_object());
+        }
+    }
+
     #[test]
     fn show_tooltips_preferences_turn_tooltips_off() {
         let (mut app, _) = app_with_store();
diff --git a/crates/ui-egui/src/preset_files_ui.rs b/crates/ui-egui/src/preset_files_ui.rs
index e58961d9b5..6138c08844 100644
--- a/crates/ui-egui/src/preset_files_ui.rs
+++ b/crates/ui-egui/src/preset_files_ui.rs
@@ -2,7 +2,8 @@
 //! Import Brushes…, the Preset Manager's Load…): Photoshop brushes (`.abr`) go to the brush
 //! library through `brush.presets.importAbr`, gradients (`.grd`) to the Gradients panel through
 //! `gradient.presets.importGrd`, swatches (`.aco`, `.ase`) to the Swatches panel through
-//! `swatches.import`, keyboard shortcut sets (`.kys`) to Edit › Keyboard Shortcuts through
+//! `swatches.import`, patterns (`.pat`) to the Patterns panel through `pattern.import`, keyboard
+//! shortcut sets (`.kys`) to Edit › Keyboard Shortcuts through
 //! [`crate::kys_import`], instead of opening as documents.
 
 use serde_json::{Value, json};
@@ -13,7 +14,7 @@ use crate::PhotocraftApp;
 /// the Swatches panel through [`crate::swatches_ui::import_bytes`]).
 /// `.psp` is Photoshop's live `Keyboard Shortcuts.psp` (the same XML as a `.kys`); other `.psp`
 /// settings files are refused with a clear message.
-pub const PRESET_EXTS: &[&str] = &["abr", "grd", "aco", "ase", "kys", "psp"];
+pub const PRESET_EXTS: &[&str] = &["abr", "grd", "pat", "aco", "ase", "kys", "psp"];
 
 fn ext(name: &str) -> String {
     std::path::Path::new(name).extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default()
@@ -24,6 +25,23 @@ pub fn is_preset_file(name: &str) -> bool {
     PRESET_EXTS.contains(&ext(name).as_str())
 }
 
+/// Import from a gradient picker through the same preset command as File › Open.
+pub(crate) fn import_gradients_dialog(app: &mut PhotocraftApp) {
+    let result = app.pick_file_bytes_filtered(&["grd"], |app, name, bytes| {
+        if ext(&name) != "grd" {
+            return Err(tl!("Choose a gradient file (.grd).").into());
+        }
+        open(app, &name, &bytes).ok_or_else(|| tl!("Choose a gradient file (.grd).").to_string())??;
+        Ok(Value::Null)
+    });
+    if let Err(error) = result
+        && error != crate::file_dialog::CANCELLED
+    {
+        app.ui.status = error;
+        app.ui.status_error = true;
+    }
+}
+
 /// Command params for the file: a real path keeps the journal small; browser files arrive as bytes.
 fn source(name: &str, bytes: &[u8]) -> Value {
     #[cfg(not(target_arch = "wasm32"))]
@@ -39,6 +57,7 @@ pub fn open(app: &mut PhotocraftApp, name: &str, bytes: &[u8]) -> Option<Result<
     let (cmd, what) = match ext(name).as_str() {
         "abr" => ("brush.presets.importAbr", "brushes"),
         "grd" => ("gradient.presets.importGrd", "gradients"),
+        "pat" => ("pattern.import", "patterns"),
         "aco" | "ase" => return Some(crate::swatches_ui::import_bytes(app, name, bytes, false).map(|_| ())),
         "kys" | "psp" => return Some(crate::kys_import::open_bytes(app, name, bytes).map(|_| ())),
         _ => return None,
@@ -60,10 +79,10 @@ pub fn open(app: &mut PhotocraftApp, name: &str, bytes: &[u8]) -> Option<Result<
         let n = r.get("count").and_then(Value::as_u64).unwrap_or(0);
         let warnings: Vec<String> = r.get("warnings").and_then(|w| serde_json::from_value(w.clone()).ok()).unwrap_or_default();
         app.ui.status_error = false;
-        let (one, other) = if what == "brushes" {
-            ("Imported {n} brush from {file}", "Imported {n} brushes from {file}")
-        } else {
-            ("Imported {n} gradient from {file}", "Imported {n} gradients from {file}")
+        let (one, other) = match what {
+            "brushes" => ("Imported {n} brush from {file}", "Imported {n} brushes from {file}"),
+            "patterns" => ("Imported {n} pattern from {file}", "Imported {n} patterns from {file}"),
+            _ => ("Imported {n} gradient from {file}", "Imported {n} gradients from {file}"),
         };
         let imported = crate::i18n::fmt(&crate::i18n::trn(crate::i18n::current(), n, one, other), &[("file", &stem)]);
         app.ui.status = match warnings.first() {
@@ -91,6 +110,7 @@ mod tests {
         assert!(is_preset_file("sunsets.grd"));
         assert!(is_preset_file("Brand.ACO"));
         assert!(is_preset_file("exchange.ase"));
+        assert!(is_preset_file("Debaser-ColourLibrary-Part6.PAT"));
         assert!(!is_preset_file("photo.psd"));
         assert!(!is_preset_file("abr"));
     }
diff --git a/crates/ui-egui/src/preset_panels.rs b/crates/ui-egui/src/preset_panels.rs
index 2528ec697b..7e9e9b6727 100644
--- a/crates/ui-egui/src/preset_panels.rs
+++ b/crates/ui-egui/src/preset_panels.rs
@@ -37,15 +37,71 @@ pub struct PresetUi {
     pub current_tool_only: bool,
     /// Custom Shape tool: the shape it draws.
     pub custom_shape: String,
+    /// Folder/group order per panel, by name (#3658), like the dock's `tabOrder` (#2272). A panel
+    /// with no entry keeps the library's order; unknown names are ignored and groups missing from
+    /// a list follow it in library order. Saved with the UI state.
+    #[serde(rename = "groupOrder", alias = "group_order", deserialize_with = "lenient_group_order", skip_serializing_if = "BTreeMap::is_empty")]
+    pub group_order: BTreeMap<String, Vec<String>>,
     /// In-place rename: (panel, preset or "group:<name>", text).
     #[serde(skip)]
     pub renaming: Option<(String, String, String)>,
 }
 
+/// Read `groupOrder` keeping what makes sense: non-object values, non-list entries and non-string
+/// names are dropped instead of failing the whole saved UI state.
+const MAX_GROUP_ORDER: usize = 10_000;
+fn lenient_group_order<'de, D: serde::Deserializer<'de>>(d: D) -> Result<BTreeMap<String, Vec<String>>, D::Error> {
+    let v = Value::deserialize(d)?;
+    let mut out = BTreeMap::new();
+    for (panel, names) in v.as_object().into_iter().flatten() {
+        let Some(names) = names.as_array() else { continue };
+        out.insert(panel.clone(), names.iter().filter_map(Value::as_str).take(MAX_GROUP_ORDER).map(str::to_owned).collect());
+    }
+    Ok(out)
+}
+
 impl PresetUi {
     pub fn shape(&self) -> &str {
         if self.custom_shape.is_empty() { tl!("Heart") } else { &self.custom_shape }
     }
+
+    /// Display order of the folders for `panel`, as library indices: the stored order first
+    /// (names that no longer exist are dropped), then groups missing from it in library order.
+    /// Mirrors the dock's per-group tab order (#2272, #3658).
+    pub(crate) fn display_order(&self, panel: &str, names: &[String]) -> Vec<usize> {
+        let mut out: Vec<usize> = Vec::with_capacity(names.len());
+        for name in self.group_order.get(panel).into_iter().flatten() {
+            if let Some(i) = names.iter().position(|n| n == name)
+                && !out.contains(&i)
+            {
+                out.push(i);
+            }
+        }
+        for i in 0..names.len() {
+            if !out.contains(&i) {
+                out.push(i);
+            }
+        }
+        out
+    }
+
+    /// Move folder `from` so it is drawn before `before` (`None` = last) for `panel`. The
+    /// library's own order is stored as no entry, as the dock does for its tabs.
+    pub(crate) fn move_group(&mut self, panel: &str, names: &[String], from: &str, before: Option<&str>) {
+        if before == Some(from) {
+            return;
+        }
+        let mut order: Vec<String> = self.display_order(panel, names).into_iter().filter_map(|i| names.get(i).cloned()).collect();
+        let Some(at) = order.iter().position(|n| n == from) else { return };
+        let moved = order.remove(at);
+        let to = before.and_then(|b| order.iter().position(|n| n == b)).unwrap_or(order.len());
+        order.insert(to, moved);
+        if order.as_slice() == names {
+            self.group_order.remove(panel);
+        } else {
+            self.group_order.insert(panel.to_string(), order);
+        }
+    }
 }
 
 const PANELS: [&str; 6] =
@@ -273,6 +329,9 @@ fn group_open(st: &PresetUi, panel: &str, gi: usize, name: &str) -> bool {
     (gi == 0 || panel == crate::swatches_ui::PANEL) != st.toggled.contains(&format!("{panel}/{name}"))
 }
 
+/// The footer's height (gap, size slider and buttons) before it has been measured.
+const FOOTER_GUESS: f32 = 32.0;
+
 /// Draws the folders and footer; `thumb` paints item `(group, item)` into a rect.
 /// Where a browser sits: the canvas (drop target), its height cap and the New button's tooltip.
 pub(crate) struct Place<'a> {
@@ -319,130 +378,179 @@ pub(crate) fn browser(
             }
         }
     }
-    let mut headers: Vec<(Rect, String)> = Vec::new();
+    let mut headers: Vec<(usize, Rect, String)> = Vec::new();
     let mut dropped: Option<(String, Pos2)> = None;
+    // Folder drag (#3658): the order the folders are drawn in, and what the pointer is doing this
+    // frame (the insertion line and the drop are resolved once every header is known).
+    let mut drag: Option<(usize, Pos2)> = None;
+    let mut released: Option<(usize, Pos2)> = None;
     let group_names: Vec<String> = groups.iter().map(|g| g.name.clone()).collect();
-    egui::ScrollArea::vertical().id_salt(("preset-scroll", panel)).max_height(max_h).auto_shrink([false, true]).show(ui, |ui| {
-        ui.spacing_mut().item_spacing = vec2(0.0, 2.0);
-        for (gi, g) in groups.iter().enumerate() {
-            let open = group_open(st, panel, gi, &g.name);
-            let (hr, hresp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click());
-            if hresp.hovered() {
-                ui.painter().rect_filled(hr, 2.0, t.hover.gamma_multiply(0.5));
-            }
-            let tri = Rect::from_center_size(pos2(hr.left() + 9.0, hr.center().y), vec2(12.0, 12.0));
-            crate::icons::paint(ui, tri, if open { "chevron-down" } else { "chevron-right" }, 10.0, t.text_dim);
-            let fold = Rect::from_center_size(pos2(hr.left() + 25.0, hr.center().y), vec2(14.0, 14.0));
-            crate::icons::paint(ui, fold, if open { "folder-open" } else { "folder" }, 12.0, t.icon);
-            ui.painter().text(pos2(hr.left() + 37.0, hr.center().y), Align2::LEFT_CENTER, &g.name, FontId::proportional(11.5), t.text);
-            if hresp.clicked() {
-                let k = format!("{panel}/{}", g.name);
-                if !st.toggled.remove(&k) {
-                    st.toggled.insert(k);
+    let display = st.display_order(panel, &group_names);
+    // The footer stays in view: the list gets the height left after it (as measured last frame)
+    // and scrolls, rather than pushing the footer out of a short dock group (#4790).
+    let footer_id = egui::Id::new(("preset-footer", panel));
+    let footer_h = ui.data(|d| d.get_temp::<f32>(footer_id)).unwrap_or(FOOTER_GUESS);
+    let max_h = max_h.min((ui.available_height() - footer_h).max(0.0));
+    egui::ScrollArea::vertical().id_salt(("preset-scroll", panel)).max_height(max_h).min_scrolled_height(max_h.min(64.0)).auto_shrink([false, true]).show(
+        ui,
+        |ui| {
+            ui.spacing_mut().item_spacing = vec2(0.0, 2.0);
+            for &gi in &display {
+                let Some(g) = groups.get(gi) else { continue };
+                let open = group_open(st, panel, gi, &g.name);
+                let (hr, hresp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click_and_drag());
+                if hresp.hovered() || hresp.dragged() {
+                    ui.painter().rect_filled(hr, 2.0, t.hover.gamma_multiply(0.5));
                 }
-            }
-            hresp.context_menu(|ui| {
-                if ui.button(tl!("Rename Group…")).clicked() {
-                    st.renaming = Some((panel.to_string(), format!("group:{}", g.name), g.name.clone()));
-                    ui.close();
-                }
-                if ui.button(tl!("Delete Group")).clicked() {
-                    ev.push(Ev::DeleteGroup(g.name.clone()));
-                    ui.close();
-                }
-            });
-            headers.push((hr, g.name.clone()));
-            if !open {
-                continue;
-            }
-            let w = ui.available_width();
-            let (cell, cols) = if list {
-                (vec2(w, 24.0), 1)
-            } else {
-                let cols = ((w - 8.0 + 4.0) / (size + 4.0)).floor().max(1.0) as usize;
-                (vec2(size, size), cols)
-            };
-            let rows = g.items.len().div_ceil(cols);
-            let pad = if list { 0.0 } else { 8.0 };
-            let gap = if list { 0.0 } else { 4.0 };
-            let (area, _) = ui.allocate_exact_size(vec2(w, rows as f32 * (cell.y + gap) + 2.0), Sense::hover());
-            for (ii, it) in g.items.iter().enumerate() {
-                let (cx, cy) = ((ii % cols) as f32, (ii / cols) as f32);
-                let r = Rect::from_min_size(area.min + vec2(pad + cx * (cell.x + gap), cy * (cell.y + gap)), cell);
-                let resp = ui.interact(r, ui.id().with((panel, gi, ii)), Sense::click_and_drag());
-                resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, &it.name));
-                let is_sel = selected.as_deref() == Some(&it.key);
-                if list {
-                    if is_sel {
-                        ui.painter().rect_filled(r, 0.0, t.row_selected);
-                    } else if resp.hovered() {
-                        ui.painter().rect_filled(r, 0.0, t.hover.gamma_multiply(0.5));
+                let tri = Rect::from_center_size(pos2(hr.left() + 9.0, hr.center().y), vec2(12.0, 12.0));
+                crate::icons::paint(ui, tri, if open { "chevron-down" } else { "chevron-right" }, 10.0, t.text_dim);
+                let fold = Rect::from_center_size(pos2(hr.left() + 25.0, hr.center().y), vec2(14.0, 14.0));
+                crate::icons::paint(ui, fold, if open { "folder-open" } else { "folder" }, 12.0, t.icon);
+                ui.painter().text(pos2(hr.left() + 37.0, hr.center().y), Align2::LEFT_CENTER, &g.name, FontId::proportional(11.5), t.text);
+                if hresp.clicked() {
+                    let k = format!("{panel}/{}", g.name);
+                    if !st.toggled.remove(&k) {
+                        st.toggled.insert(k);
                     }
-                    let tr = Rect::from_min_size(r.min + vec2(24.0, 2.0), vec2(20.0, 20.0));
-                    thumb(ui, tr, gi, ii);
-                    ui.painter().text(pos2(tr.right() + 8.0, r.center().y), Align2::LEFT_CENTER, &it.name, FontId::proportional(11.5), t.text);
-                } else {
-                    thumb(ui, r, gi, ii);
-                    let (stroke, kind) = if is_sel {
-                        (Stroke::new(2.0, t.accent), egui::StrokeKind::Outside)
-                    } else if resp.hovered() {
-                        (Stroke::new(1.0, t.text_dim), egui::StrokeKind::Outside)
-                    } else {
-                        (Stroke::new(1.0, t.card_border), egui::StrokeKind::Inside)
-                    };
-                    ui.painter().rect_stroke(r, CornerRadius::same(2), stroke, kind);
                 }
-                let resp = if list { resp } else { resp.on_hover_text(&it.name) };
-                if resp.double_clicked() {
-                    ev.push(Ev::Activate(it.key.clone()));
-                } else if resp.clicked() {
-                    ev.push(Ev::Select(it.key.clone()));
-                }
-                if resp.dragged()
-                    && let Some(pp) = ui.ctx().pointer_interact_pos()
-                {
-                    // A ghost of the swatch follows the pointer.
-                    let lp = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::new("preset-drag")));
-                    let gr = Rect::from_center_size(pp, vec2(28.0, 28.0));
-                    lp.rect_filled(gr, 3.0, t.card.gamma_multiply(0.8));
-                    lp.rect_stroke(gr, 3.0, Stroke::new(1.0, t.accent), egui::StrokeKind::Outside);
-                    lp.text(gr.center(), Align2::CENTER_CENTER, "+", FontId::proportional(16.0), t.accent);
-                }
-                if resp.drag_stopped()
-                    && let Some(pp) = ui.ctx().pointer_interact_pos()
-                    && !r.contains(pp)
-                {
-                    dropped = Some((it.key.clone(), pp));
-                }
-                resp.context_menu(|ui| {
-                    if ui.button(tl!("Rename…")).clicked() {
-                        st.renaming = Some((panel.to_string(), it.key.clone(), it.name.clone()));
+                hresp.context_menu(|ui| {
+                    if ui.button(tl!("Rename Group…")).clicked() {
+                        st.renaming = Some((panel.to_string(), format!("group:{}", g.name), g.name.clone()));
                         ui.close();
                     }
-                    if ui.button(tl!("Delete")).clicked() {
-                        ev.push(Ev::Delete(it.key.clone()));
+                    if ui.button(tl!("Delete Group")).clicked() {
+                        ev.push(Ev::DeleteGroup(g.name.clone()));
                         ui.close();
                     }
-                    ui.menu_button(tl!("Move to"), |ui| {
-                        for gname in group_names.iter().filter(|n| **n != g.name) {
-                            if ui.button(gname).clicked() {
-                                ev.push(Ev::Move(it.key.clone(), gname.clone()));
-                                ui.close();
-                            }
-                        }
-                    });
                 });
+                if hresp.dragged()
+                    && let Some(p) = ui.ctx().pointer_interact_pos()
+                {
+                    drag = Some((gi, p));
+                    ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
+                }
+                if hresp.drag_stopped()
+                    && let Some(p) = ui.ctx().pointer_interact_pos()
+                {
+                    released = Some((gi, p));
+                }
+                headers.push((gi, hr, g.name.clone()));
+                if !open {
+                    continue;
+                }
+                let w = ui.available_width();
+                let (cell, cols) = if list {
+                    (vec2(w, 24.0), 1)
+                } else {
+                    let cols = ((w - 8.0 + 4.0) / (size + 4.0)).floor().max(1.0) as usize;
+                    (vec2(size, size), cols)
+                };
+                let rows = g.items.len().div_ceil(cols);
+                let pad = if list { 0.0 } else { 8.0 };
+                let gap = if list { 0.0 } else { 4.0 };
+                let (area, _) = ui.allocate_exact_size(vec2(w, rows as f32 * (cell.y + gap) + 2.0), Sense::hover());
+                for (ii, it) in g.items.iter().enumerate() {
+                    let (cx, cy) = ((ii % cols) as f32, (ii / cols) as f32);
+                    let r = Rect::from_min_size(area.min + vec2(pad + cx * (cell.x + gap), cy * (cell.y + gap)), cell);
+                    let resp = ui.interact(r, ui.id().with((panel, gi, ii)), Sense::click_and_drag());
+                    resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, &it.name));
+                    let is_sel = selected.as_deref() == Some(&it.key);
+                    if list {
+                        if is_sel {
+                            ui.painter().rect_filled(r, 0.0, t.row_selected);
+                        } else if resp.hovered() {
+                            ui.painter().rect_filled(r, 0.0, t.hover.gamma_multiply(0.5));
+                        }
+                        let tr = Rect::from_min_size(r.min + vec2(24.0, 2.0), vec2(20.0, 20.0));
+                        thumb(ui, tr, gi, ii);
+                        ui.painter().text(pos2(tr.right() + 8.0, r.center().y), Align2::LEFT_CENTER, &it.name, FontId::proportional(11.5), t.text);
+                    } else {
+                        thumb(ui, r, gi, ii);
+                        let (stroke, kind) = if is_sel {
+                            (Stroke::new(2.0, t.accent), egui::StrokeKind::Outside)
+                        } else if resp.hovered() {
+                            (Stroke::new(1.0, t.text_dim), egui::StrokeKind::Outside)
+                        } else {
+                            (Stroke::new(1.0, t.card_border), egui::StrokeKind::Inside)
+                        };
+                        ui.painter().rect_stroke(r, CornerRadius::same(2), stroke, kind);
+                    }
+                    let resp = if list { resp } else { resp.on_hover_text(&it.name) };
+                    if resp.double_clicked() {
+                        ev.push(Ev::Activate(it.key.clone()));
+                    } else if resp.clicked() {
+                        ev.push(Ev::Select(it.key.clone()));
+                    }
+                    if resp.dragged()
+                        && let Some(pp) = ui.ctx().pointer_interact_pos()
+                    {
+                        // A ghost of the swatch follows the pointer.
+                        let lp = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::new("preset-drag")));
+                        let gr = Rect::from_center_size(pp, vec2(28.0, 28.0));
+                        lp.rect_filled(gr, 3.0, t.card.gamma_multiply(0.8));
+                        lp.rect_stroke(gr, 3.0, Stroke::new(1.0, t.accent), egui::StrokeKind::Outside);
+                        lp.text(gr.center(), Align2::CENTER_CENTER, "+", FontId::proportional(16.0), t.accent);
+                    }
+                    if resp.drag_stopped()
+                        && let Some(pp) = ui.ctx().pointer_interact_pos()
+                        && !r.contains(pp)
+                    {
+                        dropped = Some((it.key.clone(), pp));
+                    }
+                    resp.context_menu(|ui| {
+                        if ui.button(tl!("Rename…")).clicked() {
+                            st.renaming = Some((panel.to_string(), it.key.clone(), it.name.clone()));
+                            ui.close();
+                        }
+                        if ui.button(tl!("Delete")).clicked() {
+                            ev.push(Ev::Delete(it.key.clone()));
+                            ui.close();
+                        }
+                        ui.menu_button(tl!("Move to"), |ui| {
+                            for gname in group_names.iter().filter(|n| **n != g.name) {
+                                if ui.button(gname).clicked() {
+                                    ev.push(Ev::Move(it.key.clone(), gname.clone()));
+                                    ui.close();
+                                }
+                            }
+                        });
+                    });
+                }
             }
+            // Insertion line while a folder is dragged by its header.
+            if let Some((from, p)) = drag {
+                let before = group_drop_before(&headers, from, p.y);
+                let anchor = match before {
+                    Some(i) => headers.iter().find(|(x, _, _)| *x == i).map(|(_, r, _)| *r),
+                    None => headers.last().map(|(_, r, _)| *r),
+                };
+                if let Some(r) = anchor {
+                    let y = if before.is_some() { r.top() - 1.0 } else { r.bottom() + 1.0 };
+                    ui.painter().line_segment([pos2(r.left(), y), pos2(r.right(), y)], Stroke::new(2.0, t.accent));
+                }
+            }
+        },
+    );
+    // Apply the drop now every header rect is known; the next frame draws the new order.
+    if let Some((from, p)) = released {
+        let before = group_drop_before(&headers, from, p.y);
+        let from_name = groups.get(from).map(|g| g.name.clone());
+        let before_name = before.and_then(|i| groups.get(i).map(|g| g.name.clone()));
+        if let Some(from_name) = from_name {
+            st.move_group(panel, &group_names, &from_name, before_name.as_deref());
         }
-    });
+    }
+    let recorded: Vec<(String, Rect)> = headers.iter().map(|(_, r, n)| (n.clone(), *r)).collect();
+    ui.ctx().data_mut(|d| d.insert_temp(egui::Id::new(("preset-group-headers", panel)), recorded));
     if let Some((key, pos)) = dropped {
-        if let Some((_, g)) = headers.iter().find(|(r, _)| r.contains(pos)) {
+        if let Some((_, _, g)) = headers.iter().find(|(_, r, _)| r.contains(pos)) {
             ev.push(Ev::Move(key, g.clone()));
         } else if canvas.contains(pos) {
             ev.push(Ev::Drop(key, pos));
         }
     }
     // Footer: thumbnail size | New Group, New, Delete.
+    let footer_top = ui.min_rect().bottom();
     ui.add_space(4.0);
     ui.horizontal(|ui| {
         ui.spacing_mut().item_spacing.x = 2.0;
@@ -465,9 +573,33 @@ pub(crate) fn browser(
             }
         });
     });
+    let measured = ui.min_rect().bottom() - footer_top;
+    if measured.is_finite() && (measured - footer_h).abs() > 0.5 {
+        ui.data_mut(|d| d.insert_temp(footer_id, measured));
+        ui.ctx().request_repaint();
+    }
     ev
 }
 
+/// The folder (by library index) a header dragged to `y` lands before (`None` = last). `headers`
+/// is in display order; mirrors `dock::drop_before`.
+fn group_drop_before(headers: &[(usize, Rect, String)], from: usize, y: f32) -> Option<usize> {
+    let hit = headers.iter().find(|(_, r, _)| y < r.center().y).map(|(i, _, _)| *i);
+    match hit {
+        Some(i) if i == from => Some(from),
+        Some(i) => {
+            let after_self = headers.iter().position(|(x, _, _)| *x == from).zip(headers.iter().position(|(x, _, _)| *x == i)).is_some_and(|(a, b)| b == a + 1);
+            if after_self { Some(from) } else { Some(i) }
+        }
+        None => None,
+    }
+}
+
+/// Folder header rects drawn last frame (name → rect), in display order; for tests and automation.
+pub fn last_group_headers(ctx: &egui::Context, panel: &str) -> Vec<(String, Rect)> {
+    ctx.data(|d| d.get_temp(egui::Id::new(("preset-group-headers", panel)))).unwrap_or_default()
+}
+
 /// Shared handling of the generic events through `<prefix>.edit` / `.new`.
 fn generic(app: &mut PhotocraftApp, panel: &str, prefix: &str, e: &Ev, new_params: Value) -> bool {
     let edit = format!("{prefix}.edit");
@@ -1169,6 +1301,50 @@ mod tests {
         assert!(matches!(l.content, photocraft_doc::LayerContent::Shape(_)));
     }
 
+    /// #3658: a group/folder drag reorders by name, stores only a real reorder, and falls back to
+    /// the library's order when the saved order matches it or names a group that's gone.
+    #[test]
+    fn moving_a_folder_reorders_like_the_dock_tabs() {
+        let names: Vec<String> = ["Grays", "Pastel", "Pure", "Dark"].iter().map(|s| s.to_string()).collect();
+        let mut st = PresetUi::default();
+        assert_eq!(st.display_order("swatches", &names), vec![0, 1, 2, 3]);
+        st.move_group("swatches", &names, "Pastel", None);
+        assert_eq!(st.group_order.get("swatches").unwrap(), &["Grays", "Pure", "Dark", "Pastel"]);
+        st.move_group("swatches", &names, "Pastel", Some("Grays"));
+        assert_eq!(st.group_order.get("swatches").unwrap(), &["Pastel", "Grays", "Pure", "Dark"]);
+        assert_eq!(st.display_order("swatches", &names), vec![1, 0, 2, 3]);
+        // Back to the library's own order: no entry, as the dock stores its default tab order.
+        st.move_group("swatches", &names, "Pastel", Some("Pure"));
+        assert!(!st.group_order.contains_key("swatches"), "a no-op order is not stored");
+        // Out-of-range names, moves onto themselves and unknown `before` names change nothing bad.
+        for (from, before) in [("Nope", None), ("Grays", Some("Grays"))] {
+            let mut m = PresetUi::default();
+            m.move_group("swatches", &names, from, before);
+            assert!(m.group_order.is_empty(), "{from} {before:?}");
+            assert_eq!(m.display_order("swatches", &names), vec![0, 1, 2, 3]);
+        }
+        // A missing group in a saved order follows the rest in library order.
+        let mut m = PresetUi::default();
+        m.group_order.insert("swatches".into(), vec!["Dark".into(), "Grays".into()]);
+        assert_eq!(m.display_order("swatches", &names), vec![3, 0, 1, 2]);
+    }
+
+    /// #3658: the folder order persists with the UI state and reads leniently (an old state has no
+    /// field, and garbage in one never fails the whole state).
+    #[test]
+    fn folder_order_persists_and_reads_leniently() {
+        let old: PresetUi = serde_json::from_value(json!({"sizes": {"swatches": 22.0}})).unwrap();
+        assert!(old.group_order.is_empty(), "an older state without the field still loads");
+        let mut st = PresetUi::default();
+        st.group_order.insert("swatches".into(), vec!["Dark".into(), "Grays".into()]);
+        let back: PresetUi = serde_json::from_value(serde_json::to_value(&st).unwrap()).unwrap();
+        assert_eq!(back.group_order.get("swatches").unwrap(), &["Dark", "Grays"]);
+        for bad in [json!("x"), json!(7), json!({"swatches": "paths"}), json!({"swatches": [1, null, {"a": 1}]})] {
+            let back: PresetUi = serde_json::from_value(json!({"groupOrder": bad})).unwrap();
+            assert!(back.group_order.get("swatches").is_none_or(Vec::is_empty), "{bad}");
+        }
+    }
+
     /// Regression: preset drops mapped the pointer through the raw widget rect, ignoring the
     /// rulers' 16 px inset — a dropped shape landed 8 screen px from the pointer, and a drop on
     /// the ruler strip counted as a canvas drop. Drops now map through, and target, the same
diff --git a/crates/ui-egui/src/press_menu.rs b/crates/ui-egui/src/press_menu.rs
index 9f124afe91..7110e833b4 100644
--- a/crates/ui-egui/src/press_menu.rs
+++ b/crates/ui-egui/src/press_menu.rs
@@ -57,8 +57,20 @@ impl PressMenu {
         self.item_response(ui, text).1
     }
 
+    /// Is the press-drag gesture that opened this menu over `item`, still held? egui doesn't
+    /// hover other widgets while one is dragged, so the item would show no highlight (#4601).
+    fn dragged_over(&self, ui: &Ui, item: &Response) -> bool {
+        item.enabled() && !item.hovered() && item.contains_pointer() && ui.input(|i| i.pointer.primary_down()) && self.owns_gesture(ui.ctx())
+    }
+
     fn item_response(&self, ui: &mut Ui, text: impl Into<egui::WidgetText>) -> (Response, bool) {
+        // Under the item: the highlight it would have if hovered, while the gesture drags over it.
+        let highlight = ui.painter().add(egui::Shape::Noop);
         let response = ui.button(text);
+        if self.dragged_over(ui, &response) {
+            let v = &ui.visuals().widgets.hovered;
+            ui.painter().set(highlight, egui::Shape::rect_filled(response.rect.expand(v.expansion), v.corner_radius, v.weak_bg_fill));
+        }
         let hit = self.chosen(ui, &response);
         if hit {
             ui.close();
@@ -158,6 +170,8 @@ mod tests {
     struct Frame {
         open: bool,
         chosen: Option<&'static str>,
+        /// The items drawn with a (hover) fill under them.
+        highlighted: Vec<&'static str>,
     }
 
     const LABELS: [[&str; 2]; 2] = [["Levels", "Curves"], ["Drop Shadow", "Stroke"]];
@@ -174,6 +188,7 @@ mod tests {
             let mut items = [Vec::new(), Vec::new()];
             let rect = Rect::from_min_size(Pos2::ZERO, vec2(400.0, 400.0));
             let mut buttons = [Rect::NOTHING; 2];
+            let mut labels = Vec::new();
             let mut output = self.ctx.run_ui(egui::RawInput { screen_rect: Some(rect), events, ..Default::default() }, |ui| {
                 ui.add_space(20.0);
                 ui.horizontal(|ui| {
@@ -188,12 +203,21 @@ mod tests {
                                     out.chosen = Some(label);
                                 }
                                 items[m].push(r.rect);
+                                labels.push((label, r.rect));
                             }
                         });
                     }
                 });
             });
             output.textures_delta.clear();
+            for (label, rect) in labels {
+                // An item's own frame is transparent unless hovered; the popup's fade-in can soften
+                // the fill's alpha a little.
+                let lit = output.shapes.iter().any(|c| matches!(&c.shape, egui::Shape::Rect(r) if r.fill.a() > 200 && r.rect.contains_rect(rect)));
+                if lit {
+                    out.highlighted.push(label);
+                }
+            }
             self.buttons = buttons;
             for (m, list) in items.into_iter().enumerate() {
                 if !list.is_empty() {
@@ -226,7 +250,10 @@ mod tests {
         assert!(rig.press(at, true).open, "the menu opens on the press");
         rig.frame(Vec::new());
         let curves = rig.item_center(1);
-        rig.drag_to(at, curves);
+        rig.drag_to(at, rig.item_center(0));
+        assert_eq!(rig.frame(Vec::new()).highlighted, ["Levels"], "the item under the drag is highlighted (#4601)");
+        rig.drag_to(rig.item_center(0), curves);
+        assert_eq!(rig.frame(Vec::new()).highlighted, ["Curves"], "and only that one");
         let f = rig.press(curves, false);
         assert_eq!(f.chosen, Some("Curves"), "releasing on Curves chose it");
         assert!(!rig.frame(Vec::new()).open, "and closed the menu");
diff --git a/crates/ui-egui/src/profile_open_tests.rs b/crates/ui-egui/src/profile_open_tests.rs
new file mode 100644
index 0000000000..6828da6f70
--- /dev/null
+++ b/crates/ui-egui/src/profile_open_tests.rs
@@ -0,0 +1,255 @@
+//! Files opened together whose embedded profile doesn't match the working space (File › Open with
+//! several selected, Ask When Opening on). Checked in Photoshop 27.11: one Embedded Profile
+//! Mismatch prompt at a time, naming its file, before that file opens; OK opens it and asks about
+//! the next; Cancel opens neither it nor the files still to come.
+
+use crate::{PhotocraftApp, Services};
+use egui::{Modifiers, PointerButton, Pos2, vec2};
+use egui_kittest::{
+    Harness,
+    kittest::{NodeT, Queryable},
+};
+use photocraft_doc::{Color, ColorMode, Document, SampleType, Size};
+use photocraft_engine::Session;
+use serde_json::Value;
+
+const USE: &str = "Use the embedded profile (instead of the working space)";
+const CONVERT: &str = "Convert document's colors to the working space";
+const DISCARD: &str = "Discard the embedded profile (don't color manage)";
+
+/// A PNG tagged with Adobe RGB, which doesn't match the sRGB working space.
+fn adobe_png() -> Vec<u8> {
+    let mut d = Document::with_background("t", Size::new(8, 8), ColorMode::Rgb, SampleType::U8, Color::rgba(0.2, 0.6, 0.9, 1.0));
+    d.icc_profile = Some(photocraft_cms::Builtin::from_id("adobe-rgb-compat").unwrap().profile().to_bytes());
+    photocraft_io::export(&d, "t.png", &Default::default()).unwrap().bytes
+}
+
+fn harness(background: bool) -> Harness<'static, PhotocraftApp> {
+    let mut h = Harness::builder().with_size(vec2(1400.0, 900.0)).with_max_steps(64).build_eframe(|cc| {
+        PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+        PhotocraftApp::new(
+            Session::new(),
+            Services {
+                import: Some(Box::new(|name, bytes, depth| {
+                    photocraft_io::import_with_svg_group_depth(name, bytes, depth).map(|r| (r.document, r.warnings)).map_err(|e| e.to_string())
+                })),
+                ..Default::default()
+            },
+        )
+    });
+    h.state_mut().background_jobs = background;
+    h.run_steps(3);
+    h.state_mut().run("edit.colorSettings", serde_json::json!({"askOnMismatch": true, "policyRgb": "preserve"})).unwrap();
+    h
+}
+
+/// Open a.png, b.png and c.png together and let every read finish.
+fn open_three(h: &mut Harness<'static, PhotocraftApp>) {
+    let png = adobe_png();
+    for name in ["a.png", "b.png", "c.png"] {
+        h.state_mut().open_file(&format!("/pics/{name}"), &png).unwrap();
+    }
+    settle(h);
+}
+
+/// Run frames until no open is still reading.
+fn settle(h: &mut Harness<'static, PhotocraftApp>) {
+    for _ in 0..200 {
+        h.run_steps(2);
+        if h.state().jobs.opens.is_empty() && h.state().session.jobs().is_empty() {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    h.run_steps(6);
+}
+
+fn docs(h: &Harness<'static, PhotocraftApp>) -> Vec<String> {
+    h.state().session.documents().iter().map(|d| d.doc.name.clone()).collect()
+}
+
+/// The one prompt up: its message.
+fn prompt(h: &Harness<'static, PhotocraftApp>) -> String {
+    let d = &h.state().ui.dialogs;
+    assert_eq!(d.len(), 1, "one prompt at a time");
+    d[0].fields.get("message").and_then(Value::as_str).unwrap_or_default().to_string()
+}
+
+/// A real click (pointer events, hit-tested like a mouse).
+fn click(h: &mut Harness<'static, PhotocraftApp>, label: &str) {
+    let at: Pos2 = h.query_all_by_label(label).find(|n| !n.accesskit_node().is_disabled()).map(|n| n.rect().center()).unwrap();
+    h.event(egui::Event::PointerMoved(at));
+    h.run_steps(1);
+    for pressed in [true, false] {
+        h.event(egui::Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+        h.run_steps(1);
+    }
+    settle(h);
+}
+
+fn answer(h: &mut Harness<'static, PhotocraftApp>, choice: &str) {
+    click(h, choice);
+    click(h, "OK");
+}
+
+fn profile(h: &Harness<'static, PhotocraftApp>, name: &str) -> Option<String> {
+    let st = h.state().session.documents().iter().find(|d| d.doc.name == name).unwrap();
+    st.doc.icc_profile.as_ref().map(|b| photocraft_engine::color_cmds::profile_from_bytes(b).unwrap().description.clone())
+}
+
+/// The file the prompt on screen asks about.
+fn asked(h: &Harness<'static, PhotocraftApp>) -> &'static str {
+    let msg = prompt(h);
+    ["a.png", "b.png", "c.png", "d.png"]
+        .into_iter()
+        .find(|n| msg.starts_with(&format!("The document “{n}” has an embedded color profile that does not match the current RGB working space.")))
+        .unwrap_or_else(|| panic!("the prompt names its file: {msg}"))
+}
+
+/// Files read on the spot ask in the order they were given. Read in the background, they ask in
+/// the order their reads finish, which is the same order unless a later read overtakes an earlier
+/// one: the tests hold either way.
+fn in_order(background: bool, order: &[&str]) {
+    if !background {
+        assert_eq!(order, &["a.png", "b.png", "c.png"][..order.len()]);
+    }
+}
+
+#[test]
+fn files_opened_together_ask_one_at_a_time_before_each_opens() {
+    for background in [false, true] {
+        let mut h = harness(background);
+        open_three(&mut h);
+        let mut answered: Vec<&str> = Vec::new();
+        for _ in 0..3 {
+            assert_eq!(docs(&h), answered, "background {background}: a file opens only after its prompt");
+            let name = asked(&h);
+            assert!(!answered.contains(&name), "background {background}: {name} asked twice");
+            answer(&mut h, USE);
+            answered.push(name);
+        }
+        in_order(background, &answered);
+        assert!(h.state().ui.dialogs.is_empty());
+        assert_eq!(docs(&h), answered, "background {background}: each opened when it was answered");
+        assert_eq!(h.state().session.active().map(|d| d.doc.name.as_str()), answered.last().copied());
+    }
+}
+
+/// The prompt reads in the interface language: its sentence, the Embedded and Working lines and
+/// the mode's name (French "RVB"). The file's name goes in as it is, braces and all.
+#[test]
+fn the_prompt_is_translated_and_still_names_its_file() {
+    let png = adobe_png();
+    for (code, sentence, embedded, working) in [
+        (
+            "en",
+            "The document “shot {mode}.png” has an embedded color profile that does not match the current RGB working space.",
+            "Embedded: Adobe RGB",
+            "Working: sRGB",
+        ),
+        (
+            "de",
+            "Das Dokument „shot {mode}.png“ hat ein eingebettetes Farbprofil, das nicht zum aktuellen RGB-Arbeitsfarbraum passt.",
+            "Eingebettet: Adobe RGB",
+            "Arbeitsfarbraum: sRGB",
+        ),
+        (
+            "fr",
+            "Le document «NBSPshot {mode}.pngNBSP» a un profil colorimétrique incorporé qui ne correspond pas à l'espace de travail RVB actuel.",
+            "IncorporéNBSP: Adobe RGB",
+            "Espace de travailNBSP: sRGB",
+        ),
+        (
+            "ja",
+            "ドキュメント「shot {mode}.png」の埋め込みカラープロファイルは、現在の RGB 作業用スペースと一致しません。",
+            "埋め込み: Adobe RGB",
+            "作業用スペース: sRGB",
+        ),
+    ] {
+        let services = Services {
+            import: Some(Box::new(|name, bytes, depth| {
+                photocraft_io::import_with_svg_group_depth(name, bytes, depth).map(|r| (r.document, r.warnings)).map_err(|e| e.to_string())
+            })),
+            ..Default::default()
+        };
+        let mut app = PhotocraftApp::new(Session::new(), services);
+        app.run("edit.colorSettings", serde_json::json!({"askOnMismatch": true, "policyRgb": "preserve"})).unwrap();
+        let lang = crate::i18n::Lang::from_code(code).unwrap();
+        crate::i18n::with_language(lang, || app.open_file("/pics/shot {mode}.png", &png)).unwrap();
+        assert!(app.session.documents().is_empty(), "{code}: held until answered");
+        let message = app.ui.dialogs[0].fields.get("message").and_then(Value::as_str).unwrap().to_string();
+        let lines: Vec<&str> = message.lines().collect();
+        assert_eq!(lines.len(), 3, "{code}: {message}");
+        assert_eq!(lines[0], sentence.replace("NBSP", "\u{a0}"), "{code}");
+        assert!(lines[1].starts_with(&embedded.replace("NBSP", "\u{a0}")), "{code}: {}", lines[1]);
+        assert!(lines[2].starts_with(&working.replace("NBSP", "\u{a0}")), "{code}: {}", lines[2]);
+    }
+}
+
+/// #4559 with a held file: type in a font that isn't installed is reported with the import
+/// warnings while the file still waits for its profile prompt, and shown once when it opens.
+#[test]
+fn a_held_file_still_reports_its_missing_fonts() {
+    const MISSING: &str = "NoSuchFamily3471";
+    let warning = format!("font '{MISSING}' is not installed; text may render using a fallback face");
+    let mut s = Session::new();
+    s.execute("file.new", serde_json::json!({"width": 40, "height": 20})).unwrap();
+    s.execute("type.create", serde_json::json!({"text": "Hi", "x": 2, "y": 12, "size": 10, "font": MISSING})).unwrap();
+    let mut doc = (*s.active().unwrap().doc).clone();
+    doc.icc_profile = Some(photocraft_cms::Builtin::from_id("adobe-rgb-compat").unwrap().profile().to_bytes());
+    let services = Services { import: Some(Box::new(move |_: &str, _: &[u8], _: usize| Ok((doc.clone(), Vec::new())))), ..Default::default() };
+    let mut app = PhotocraftApp::new(Session::new(), services);
+    app.run("edit.colorSettings", serde_json::json!({"askOnMismatch": true, "policyRgb": "preserve"})).unwrap();
+    assert_eq!(app.open_bytes("poster.psd", b"x").unwrap(), vec![warning.clone()]);
+    assert!(app.session.documents().is_empty() && app.ui.notices.is_empty(), "held: nothing shown yet");
+    crate::open_prompt::answer(&mut app, Some("preserve")).unwrap();
+    assert_eq!(app.session.documents().len(), 1);
+    assert_eq!(app.ui.notices.len(), 1);
+    assert_eq!(app.ui.notices[0].lines, vec![warning]);
+}
+
+#[test]
+fn each_answer_applies_to_its_own_file() {
+    for background in [false, true] {
+        let mut h = harness(background);
+        open_three(&mut h);
+        // Whichever file a prompt names gets that file's own answer.
+        let mut answered: Vec<&str> = Vec::new();
+        for _ in 0..3 {
+            let name = asked(&h);
+            answer(
+                &mut h,
+                match name {
+                    "a.png" => CONVERT,
+                    "b.png" => DISCARD,
+                    _ => USE,
+                },
+            );
+            answered.push(name);
+        }
+        in_order(background, &answered);
+        assert_eq!(docs(&h), answered);
+        assert_eq!(profile(&h, "a.png").as_deref(), Some("sRGB IEC61966-2.1"), "background {background}: a converted");
+        assert_eq!(profile(&h, "b.png"), None, "background {background}: b discarded");
+        assert!(profile(&h, "c.png").unwrap().starts_with("Adobe RGB"), "background {background}: c kept");
+    }
+}
+
+#[test]
+fn cancel_opens_neither_the_file_nor_the_ones_still_to_come() {
+    for background in [false, true] {
+        let mut h = harness(background);
+        open_three(&mut h);
+        let first = asked(&h);
+        in_order(background, &[first]);
+        answer(&mut h, USE);
+        click(&mut h, "Cancel");
+        settle(&mut h);
+        assert!(h.state().ui.dialogs.is_empty(), "background {background}: no prompt left");
+        assert_eq!(docs(&h), [first], "background {background}");
+        // A later open asks again.
+        h.state_mut().open_file("/pics/d.png", &adobe_png()).unwrap();
+        settle(&mut h);
+        assert_eq!(asked(&h), "d.png");
+    }
+}
diff --git a/crates/ui-egui/src/profile_prompt_tests.rs b/crates/ui-egui/src/profile_prompt_tests.rs
index ca206b6a52..cec2a8c289 100644
--- a/crates/ui-egui/src/profile_prompt_tests.rs
+++ b/crates/ui-egui/src/profile_prompt_tests.rs
@@ -1,6 +1,6 @@
-//! Embedded Profile Mismatch prompts when several files open at once (File › Open with several
-//! selected): every prompt can be answered with a real click, one after another, even when the
-//! user clicks while the next file's prompt is appearing.
+//! Stacked dialogs of the same size in the same place (Embedded Profile Mismatch prompts used to
+//! stack like this when several files opened at once): each can be answered with a real click,
+//! one after another, even when an older one has been raised above the live one.
 
 use crate::{PhotocraftApp, Services};
 use egui::{Modifiers, PointerButton, Pos2, vec2};
@@ -8,16 +8,8 @@ use egui_kittest::{
     Harness,
     kittest::{NodeT, Queryable},
 };
-use photocraft_doc::{Color, ColorMode, Document, SampleType, Size};
 use photocraft_engine::Session;
 
-/// A PNG tagged with Adobe RGB, which doesn't match the sRGB working space.
-fn adobe_png() -> Vec<u8> {
-    let mut d = Document::with_background("t", Size::new(8, 8), ColorMode::Rgb, SampleType::U8, Color::rgba(0.2, 0.6, 0.9, 1.0));
-    d.icc_profile = Some(photocraft_cms::Builtin::from_id("adobe-rgb-compat").unwrap().profile().to_bytes());
-    photocraft_io::export(&d, "t.png", &Default::default()).unwrap().bytes
-}
-
 fn harness(background: bool) -> Harness<'static, PhotocraftApp> {
     let mut h = Harness::builder().with_size(vec2(1400.0, 900.0)).with_max_steps(64).build_eframe(|cc| {
         PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
@@ -36,11 +28,13 @@ fn harness(background: bool) -> Harness<'static, PhotocraftApp> {
     h
 }
 
-/// Open `n` mismatched files in one go and wait until their prompts are up and laid out.
+/// Stack `n` identical Embedded Profile Mismatch dialogs (same size, same place; only the newest
+/// is live) and wait until they are up and laid out. Opening files no longer stacks them (they ask
+/// one at a time, `profile_open_tests`), so they are opened directly.
 fn open_together(h: &mut Harness<'static, PhotocraftApp>, n: usize) {
-    let png = adobe_png();
-    for i in 0..n {
-        h.state_mut().open_file(&format!("shot{i}.png"), &png).unwrap();
+    let message = "The document “shot.png” has an embedded color profile that does not match the current RGB working space.";
+    for _ in 0..n {
+        crate::prefs_ui::open_mismatch(h.state_mut(), message, "preserve", false, "__stacked");
     }
     for _ in 0..100 {
         h.run_steps(2);
diff --git a/crates/ui-egui/src/props_layout_tests.rs b/crates/ui-egui/src/props_layout_tests.rs
index 0b99569fe7..74fd29121a 100644
--- a/crates/ui-egui/src/props_layout_tests.rs
+++ b/crates/ui-egui/src/props_layout_tests.rs
@@ -175,8 +175,12 @@ fn type_controls_fill_the_panel_at_every_width_and_scale() {
                 .map(|r| r.right())
                 .fold(f32::MIN, f32::max);
             // (Both rows have a unit suffix: compare with the size/leading row.)
-            let top = fields.iter().map(|r| r.top()).fold(f32::MAX, f32::min);
-            let lead = fields.iter().filter(|r| (r.top() - top).abs() < 0.5).map(|r| r.right()).fold(f32::MIN, f32::max);
+            // Variable-font axes can precede the size/leading row and have no unit suffix.
+            // Compare the intended point-valued controls, retaining the same edge tolerance.
+            let lead = ["Font size", "Leading (set to the font size × auto-leading when Auto)"]
+                .into_iter()
+                .map(|label| h.get_by_role_and_label(egui::accesskit::Role::SpinButton, label).rect().right())
+                .fold(f32::MIN, f32::max);
             assert!((t_right - lead).abs() < 0.5, "{what}: Transform fields end at {t_right}, Character at {lead}");
             // Quick Actions buttons span the panel too.
             let qa = h.get_by_label("Rasterize Type").rect();
@@ -309,3 +313,36 @@ fn properties_distribute_buttons_move_selected_layers_and_undo_in_both_axes() {
         assert_eq!(restored, before, "{button}: undo restores its location");
     }
 }
+
+/// #4608: with the Background one of several selected layers (and the active one), Properties
+/// shows the Document properties as before, with Align and Distribute above them, and its buttons
+/// align the selection: the Background stays, the other layer lines up with it.
+#[test]
+fn background_in_a_multiple_selection_keeps_align_and_distribute() {
+    use photocraft_doc::LayerId;
+    let mut s = photocraft_engine::Session::new();
+    s.execute("file.new", json!({"width": 300, "height": 200})).unwrap();
+    let bg = s.active().unwrap().doc.layers[0].id.0;
+    let block = s.execute("layer.new.layer", json!({"name": "Block"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("select.rect", json!({"x": 20, "y": 30, "width": 40, "height": 20})).unwrap();
+    s.execute("edit.fill", json!({"contents": "color", "color": "#336699"})).unwrap();
+    s.execute("select.deselect", json!({})).unwrap();
+    // Background alone: the Document properties only.
+    s.execute("layer.select", json!({"layer": bg})).unwrap();
+    let mut h = harness(s, 1.0, 320.0);
+    assert!(h.query_by_label("Align Horizontal Centers").is_none(), "one layer: Document properties only");
+    // The Background is still the active layer once Block joins the selection.
+    h.state_mut().run("layer.select", json!({"layer": block, "mode": "add"})).unwrap();
+    h.state_mut().run("layer.select", json!({"layer": bg, "mode": "add"})).unwrap();
+    h.run_steps(8);
+    assert_eq!(h.state().session.active().unwrap().active_layer, Some(LayerId(bg)));
+    assert_eq!(h.state().session.active().unwrap().selected_layers().len(), 2);
+    let names: Vec<String> = headers(&h).into_iter().map(|(n, _)| n).collect();
+    assert!(names.iter().any(|n| n == "Align and Distribute"), "{names:?}");
+    h.get_by_label("Align Horizontal Centers").click();
+    h.run_steps(4);
+    let st = h.state().session.active().unwrap();
+    let b = st.doc.layer(LayerId(block)).unwrap().surface().unwrap().content_bounds();
+    assert_eq!((b.x0 + b.x1) / 2, 150, "centred on the Background, which spans the canvas: {b:?}");
+    assert_eq!(b.y0, 30, "only horizontally");
+}
diff --git a/crates/ui-egui/src/puppet_ui.rs b/crates/ui-egui/src/puppet_ui.rs
index 42791715d6..b08546a51d 100644
--- a/crates/ui-egui/src/puppet_ui.rs
+++ b/crates/ui-egui/src/puppet_ui.rs
@@ -1,6 +1,7 @@
 //! Edit › Puppet Warp on the canvas: click on the mesh to add pins, drag pins to move them,
 //! ⌥-click a pin to remove it; the options bar sets mode, density, expansion, mesh visibility,
-//! the selected pin's depth and rotation. ↩ / Commit runs `edit.puppetWarp` with the pins.
+//! the selected pin's depth and rotation. ⌘Z / ⌘⇧Z undo and redo pin edits inside the session
+//! (#4440). ↩ / Commit runs `edit.puppetWarp` with the pins.
 //!
 //! The preview is the layer texture on the deformed triangle mesh (an egui textured mesh, drawn
 //! by the GPU), re-solved with a few warm-started ARAP rounds per drag event (well under a
@@ -37,9 +38,47 @@ pub struct PuppetSession {
     texture: TextureHandle,
     opacity: f32,
     pub preview_doc: Arc<Document>,
+    /// Pins before each edit of this session, newest last (⌘Z), and the edits undone (⌘⇧Z).
+    undo: Vec<Vec<PuppetPin>>,
+    redo: Vec<Vec<PuppetPin>>,
+    /// The pins when the current drag started: one undo step per drag that moved something.
+    drag_from: Option<Vec<PuppetPin>>,
 }
 
 impl PuppetSession {
+    /// Records `before` as one undoable pin edit.
+    fn record(&mut self, before: Vec<PuppetPin>) {
+        if before != self.warp.pins {
+            self.undo.push(before);
+            self.redo.clear();
+        }
+    }
+
+    /// Puts `pins` back (undo or redo), keeping the selection when that pin still exists.
+    fn restore(&mut self, pins: Vec<PuppetPin>) {
+        self.warp.pins = pins;
+        self.selected = self.selected.filter(|i| *i < self.warp.pins.len());
+        self.drag = None;
+        self.drag_from = None;
+        self.rebind();
+    }
+
+    /// ⌘Z: the last pin edit undone. False when there is none.
+    pub fn undo(&mut self) -> bool {
+        let Some(pins) = self.undo.pop() else { return false };
+        self.redo.push(std::mem::replace(&mut self.warp.pins, pins.clone()));
+        self.restore(pins);
+        true
+    }
+
+    /// ⌘⇧Z: the last undone pin edit redone. False when there is none.
+    pub fn redo(&mut self) -> bool {
+        let Some(pins) = self.redo.pop() else { return false };
+        self.undo.push(std::mem::replace(&mut self.warp.pins, pins.clone()));
+        self.restore(pins);
+        true
+    }
+
     pub fn describe(&self) -> Value {
         json!({
             "layer": self.layer.0,
@@ -162,6 +201,9 @@ pub fn begin(app: &mut PhotocraftApp, ctx: &egui::Context, command: &str) -> Res
         texture,
         opacity,
         preview_doc,
+        undo: Vec::new(),
+        redo: Vec::new(),
+        drag_from: None,
     };
     s.rebuild_mesh();
     if s.mesh.tris.is_empty() {
@@ -192,6 +234,14 @@ pub fn control(app: &mut PhotocraftApp, ui: &Value) -> Result<Value, String> {
         return Ok(json!({"cancelled": true}));
     }
     let s = app.distort.puppet.as_mut().ok_or(tl!("Puppet Warp is not active"))?;
+    if ui.get("undo").and_then(Value::as_bool) == Some(true) {
+        s.undo();
+        return Ok(s.describe());
+    }
+    if ui.get("redo").and_then(Value::as_bool) == Some(true) {
+        s.redo();
+        return Ok(s.describe());
+    }
     let mut remesh = false;
     let (density, expansion) = (s.warp.density, s.warp.expansion);
     if let Some(m) = ui.get("mode").and_then(Value::as_str) {
@@ -222,14 +272,17 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers) {
     match ev {
         ToolEvent::Down { x, y, .. } => {
             let p = [x, y];
+            let before = s.warp.pins.clone();
             if let Some(i) = s.pin_at(p, tol) {
                 if mods.alt {
                     s.warp.pins.remove(i);
                     s.selected = None;
                     s.rebind();
+                    s.record(before);
                 } else {
                     s.selected = Some(i);
                     s.drag = Some(i);
+                    s.drag_from = Some(before);
                 }
             } else if !mods.alt
                 && let Some(src) = s.rest_of(p)
@@ -238,6 +291,8 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers) {
                 s.selected = Some(s.warp.pins.len() - 1);
                 s.drag = s.selected;
                 s.rebind();
+                // Placing a pin is one step; dragging it on from there is part of that step.
+                s.record(before);
             }
         }
         ToolEvent::Move { x, y, .. } => {
@@ -255,6 +310,9 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers) {
                     pin.dst = [x, y];
                 }
                 s.solve(true);
+                if let Some(before) = s.drag_from.take() {
+                    s.record(before);
+                }
             }
         }
     }
@@ -305,6 +363,8 @@ pub fn draw(s: &PuppetSession, painter: &egui::Painter, xf: &ViewXform) {
 
 pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
     let Some(s) = app.distort.puppet.as_mut() else { return };
+    // Pin depth, rotation and Remove All Pins are undoable pin edits too.
+    let pins_before = s.warp.pins.clone();
     let mut remesh = false;
     let mut resolve = false;
     let mut rebind = false;
@@ -369,6 +429,7 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
         s.selected = None;
         rebind = true;
     }
+    s.record(pins_before);
     if remesh {
         // A refused value snaps the fields back to the previous settings.
         let _ = s.remesh_or_restore(density, expansion);
@@ -393,6 +454,65 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
 mod tests {
     use super::*;
 
+    /// #4440: ⌘Z / ⌘⇧Z undo and redo pin edits while Puppet Warp is open: placing a pin,
+    /// dragging one and removing one are a step each; a click that moves nothing isn't one.
+    #[test]
+    fn pin_edits_undo_and_redo_inside_the_session() {
+        let ctx = egui::Context::default();
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.session.execute("file.new", json!({"width": 100, "height": 80, "depth": 8})).unwrap();
+        app.session.execute("layer.new.layer", json!({})).unwrap();
+        app.session
+            .edit("paint", |doc, active| {
+                doc.layer_mut(active.unwrap()).unwrap().surface_mut().unwrap().fill_rect(Rect::new(20, 30, 80, 50), &[1.0, 0.0, 0.0, 1.0]);
+                Ok(())
+            })
+            .unwrap();
+        app.sync_views();
+        crate::distort_ui::menu(&mut app, &ctx, "edit.puppetWarp", &json!({})).unwrap().unwrap();
+        let ev = |app: &mut PhotocraftApp, e| crate::distort_ui::pointer(app, e, egui::Modifiers::NONE);
+        let pins = |app: &PhotocraftApp| app.distort.puppet.as_ref().unwrap().warp.pins.iter().map(|p| p.dst).collect::<Vec<_>>();
+        ev(&mut app, ToolEvent::Down { x: 25.0, y: 40.0, pressure: 1.0 });
+        ev(&mut app, ToolEvent::Up { x: 25.0, y: 40.0 });
+        ev(&mut app, ToolEvent::Down { x: 75.0, y: 40.0, pressure: 1.0 });
+        ev(&mut app, ToolEvent::Up { x: 75.0, y: 40.0 });
+        // Drag the second pin up; then a click on it that moves nothing.
+        ev(&mut app, ToolEvent::Down { x: 75.0, y: 40.0, pressure: 1.0 });
+        ev(&mut app, ToolEvent::Move { x: 75.0, y: 30.0, pressure: 1.0 });
+        ev(&mut app, ToolEvent::Up { x: 75.0, y: 20.0 });
+        ev(&mut app, ToolEvent::Down { x: 75.0, y: 20.0, pressure: 1.0 });
+        ev(&mut app, ToolEvent::Up { x: 75.0, y: 20.0 });
+        crate::distort_ui::pointer(&mut app, ToolEvent::Down { x: 25.0, y: 40.0, pressure: 1.0 }, egui::Modifiers { alt: true, ..Default::default() });
+        assert_eq!(pins(&app), [[75.0, 20.0]]);
+        // ⌘Z, through the keyboard: the removed pin comes back, then the drag is undone.
+        let press = |app: &mut PhotocraftApp, modifiers: egui::Modifiers| {
+            let ev = egui::Event::Key { key: egui::Key::Z, physical_key: None, pressed: true, repeat: false, modifiers };
+            let input = egui::RawInput { events: vec![ev], ..Default::default() };
+            ctx.run_ui(input, |ui| assert!(crate::distort_ui::keys(app, ui.ctx()))).textures_delta.clear();
+        };
+        press(&mut app, egui::Modifiers::COMMAND);
+        assert_eq!(pins(&app), [[25.0, 40.0], [75.0, 20.0]]);
+        press(&mut app, egui::Modifiers::COMMAND);
+        assert_eq!(pins(&app), [[25.0, 40.0], [75.0, 40.0]], "the drag, not the click after it");
+        // ⌘⇧Z redoes it; a new edit after an undo drops what was undone.
+        press(&mut app, egui::Modifiers::COMMAND | egui::Modifiers::SHIFT);
+        assert_eq!(pins(&app), [[25.0, 40.0], [75.0, 20.0]]);
+        control(&mut app, &json!({"undo": true})).unwrap();
+        control(&mut app, &json!({"undo": true})).unwrap();
+        assert_eq!(pins(&app), [[25.0, 40.0]]);
+        ev(&mut app, ToolEvent::Down { x: 50.0, y: 40.0, pressure: 1.0 });
+        ev(&mut app, ToolEvent::Up { x: 50.0, y: 40.0 });
+        control(&mut app, &json!({"redo": true})).unwrap();
+        assert_eq!(pins(&app), [[25.0, 40.0], [50.0, 40.0]], "nothing left to redo");
+        // Undo past the first pin stops there, and the document's History is untouched.
+        let past = app.session.active().unwrap().history.past_len();
+        for _ in 0..5 {
+            control(&mut app, &json!({"undo": true})).unwrap();
+        }
+        assert!(pins(&app).is_empty());
+        assert_eq!(app.session.active().unwrap().history.past_len(), past);
+    }
+
     #[test]
     fn pins_drag_and_commit_through_the_engine() {
         let ctx = egui::Context::default();
diff --git a/crates/ui-egui/src/rasterize_prompt.rs b/crates/ui-egui/src/rasterize_prompt.rs
index bb1a7570b5..76de6a89a5 100644
--- a/crates/ui-egui/src/rasterize_prompt.rs
+++ b/crates/ui-egui/src/rasterize_prompt.rs
@@ -7,6 +7,11 @@
 //! and `ui.dialog.cancel` answer it). OK runs the matching `layer.rasterize.*` command, then paints
 //! where the click was, so rasterizing and painting are two history states, as in Photoshop.
 //! Cancel does nothing.
+//!
+//! A filter on a type layer asks the same question (#4303), with Photoshop's Convert to Smart
+//! Object / Rasterize / Cancel: the layer is converted or rasterized, then the filter is chosen
+//! again from the menu (its dialog, window or mode opens, or it runs), a smart filter on the Smart
+//! Object. `ui.dialog.set` with `"choice": "smartObject"` picks the conversion.
 
 use serde_json::{Map, Value, json};
 
@@ -120,6 +125,62 @@ pub fn open(app: &mut PhotocraftApp, kind: Kind, layer: photocraft_doc::LayerId,
     app.ui.open_dialog(DialogKind::Command, f)
 }
 
+/// The active type layer when `id` is a filter that only needs it rasterized: the engine greys it
+/// for not being a pixel layer, and the layer is not locked. The flag says whether the filter also
+/// runs on a Smart Object, as a smart filter (Vanishing Point doesn't).
+pub fn filter_needs(app: &PhotocraftApp, id: &str) -> Option<(photocraft_doc::LayerId, bool)> {
+    if !id.starts_with("filter.") {
+        return None;
+    }
+    let st = app.session.active()?;
+    let layer = st.active_layer?;
+    if !matches!(st.doc.layer(layer)?.content, photocraft_doc::LayerContent::Text(_)) {
+        return None;
+    }
+    let locks = st.doc.effective_locks(layer);
+    if locks.all || locks.pixels {
+        return None;
+    }
+    // Last Filter checks the layer before the journal: with no filter to repeat it stays grey.
+    if id == "filter.lastFilter" && photocraft_engine::filters::last_filter(&app.session).is_none() {
+        return None;
+    }
+    // The engine's reason for a type layer: "filters need a pixel layer (active layer is a Type
+    // layer)" from filters::has_filterable_layer, which also takes Smart Objects, or a filter's own
+    // wording ("Vanishing Point needs a pixel layer (…)", "active layer is a Type layer, not a pixel
+    // layer"). Any other reason (a job running) keeps the item grey.
+    let reason = app.session.disabled_reason(id)?;
+    (reason.contains("active layer is a Type layer") && reason.contains("pixel layer")).then(|| (layer, reason.starts_with("filters need a pixel layer")))
+}
+
+/// A filter chosen on a type layer: open the prompt instead and return its answer to the caller.
+pub fn intercept_filter(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<Value, String>> {
+    let (layer, smart) = filter_needs(app, id)?;
+    if let Some(d) = app.ui.dialogs.iter().find(|d| owns(&d.fields)) {
+        return Some(Ok(json!({"dialog": d.id})));
+    }
+    let mut f = Map::new();
+    f.insert(MARK.into(), json!(Kind::Type.key()));
+    f.insert("__label".into(), json!("PhotoCraft"));
+    f.insert("message".into(), json!(Kind::Type.message()));
+    f.insert("layer".into(), json!(layer.0));
+    f.insert("filter".into(), json!(id));
+    f.insert("params".into(), params.clone());
+    f.insert("choice".into(), json!("rasterize"));
+    f.insert("smartObject".into(), json!(smart));
+    Some(Ok(json!({"dialog": app.ui.open_dialog(DialogKind::Command, f)})))
+}
+
+/// Is this the filter prompt (Convert to Smart Object / Rasterize / Cancel)?
+pub fn is_filter(fields: &Map<String, Value>) -> bool {
+    owns(fields) && fields.contains_key("filter")
+}
+
+/// Does the filter prompt offer Convert to Smart Object?
+pub fn offers_smart_object(fields: &Map<String, Value>) -> bool {
+    fields.get("smartObject").and_then(Value::as_bool) == Some(true)
+}
+
 /// Is this dialog the prompt?
 pub fn owns(fields: &Map<String, Value>) -> bool {
     fields.contains_key(MARK)
@@ -141,6 +202,9 @@ pub fn body(ui: &mut egui::Ui, f: &Map<String, Value>) {
 pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value, String> {
     let kind = f.get(MARK).and_then(Value::as_str).and_then(Kind::from_key).ok_or("not a rasterize prompt")?;
     let layer = f.get("layer").and_then(Value::as_u64).ok_or("the prompt has no layer")?;
+    if let Some(filter) = f.get("filter").and_then(Value::as_str) {
+        return confirm_filter(app, f, filter, layer);
+    }
     let r = app.run(kind.command(), json!({ "layer": layer }))?;
     let tool = f.get("tool").and_then(Value::as_str).and_then(Tool::from_name);
     let at: Vec<f64> = f.get("at").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_f64).collect()).unwrap_or_default();
@@ -159,6 +223,30 @@ pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value,
     Ok(json!({ "rasterized": r, "painted": painted }))
 }
 
+/// The filter prompt's answer: convert or rasterize the layer, then queue the filter for
+/// [`run_pending`]. Liquify, Camera Raw and the other filters with their own window need the
+/// egui context to open, which a dialog's answer doesn't have.
+fn confirm_filter(app: &mut PhotocraftApp, f: &Map<String, Value>, filter: &str, layer: u64) -> Result<Value, String> {
+    let smart = f.get("choice").and_then(Value::as_str) == Some("smartObject");
+    if smart && !offers_smart_object(f) {
+        return Err(format!("{filter} can't run as a smart filter"));
+    }
+    let command = if smart { "layer.smartObjects.convertToSmartObject" } else { Kind::Type.command() };
+    let r = app.run(command, json!({ "layer": layer }))?;
+    let params = f.get("params").cloned().unwrap_or(Value::Null);
+    app.pending_after_prompt = Some((filter.to_string(), params));
+    Ok(json!({ "converted": r, "filter": filter }))
+}
+
+/// Runs the filter a prompt was answered for, as the menu would, now that the layer can take it.
+pub fn run_pending(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    let Some((filter, params)) = app.pending_after_prompt.take() else { return };
+    if let Err(e) = crate::menus::invoke(app, ctx, &filter, params) {
+        app.ui.status = e;
+        app.ui.status_error = true;
+    }
+}
+
 #[cfg(test)]
 #[path = "rasterize_prompt_tests.rs"]
 mod tests;
diff --git a/crates/ui-egui/src/rasterize_prompt_tests.rs b/crates/ui-egui/src/rasterize_prompt_tests.rs
index 8eb2dfa58b..510723beb6 100644
--- a/crates/ui-egui/src/rasterize_prompt_tests.rs
+++ b/crates/ui-egui/src/rasterize_prompt_tests.rs
@@ -169,3 +169,236 @@ fn the_control_channel_sees_and_confirms_the_prompt() {
     assert_eq!(r["ok"], json!(true), "{r}");
     assert_eq!(active_content(&app), "Pixel");
 }
+
+const BLUR: &str = "filter.blur.gaussianBlur";
+
+fn menu(app: &mut PhotocraftApp, id: &str) -> Result<serde_json::Value, String> {
+    crate::menus::invoke(app, &egui::Context::default(), id, json!({}))
+}
+
+/// Answers the filter prompt, then the frame runs the queued filter.
+fn answer(app: &mut PhotocraftApp, id: u64) {
+    crate::dialogs::confirm(app, id).unwrap();
+    run_pending(app, &egui::Context::default());
+}
+
+fn filter_dialog(app: &PhotocraftApp) -> Option<u64> {
+    app.ui.dialogs.iter().find(|d| d.fields.get("__command") == Some(&json!(BLUR)) && !owns(&d.fields)).map(|d| d.id)
+}
+
+/// #4303: Filter › Gaussian Blur… on a type layer is live and asks to rasterize first.
+#[test]
+fn a_filter_on_a_type_layer_asks_then_opens_on_the_rasterized_layer() {
+    let mut app = app_with(Kind::Type);
+    assert!(!app.session.is_enabled(BLUR), "the engine itself still needs pixels");
+    assert!(crate::menus::is_enabled(&app, BLUR));
+    let before = past(&app);
+    menu(&mut app, BLUR).unwrap();
+    let d = prompt(&app).expect("the prompt");
+    assert_eq!(d.fields["message"], json!(Kind::Type.message()));
+    assert!(filter_dialog(&app).is_none(), "the filter waits for the answer");
+    assert_eq!((past(&app), active_content(&app)), (before, "Type"));
+    let id = d.id;
+    answer(&mut app, id);
+    assert_eq!(active_content(&app), "Pixel");
+    assert_eq!(past(&app), before + 1);
+    let blur = filter_dialog(&app).expect("Gaussian Blur opens on the rasterized layer");
+    crate::dialogs::confirm(&mut app, blur).unwrap();
+    assert_eq!(past(&app), before + 2, "rasterize, then blur");
+    assert_eq!(app.session.journal.last().map(|(id, _)| id.as_str()), Some(BLUR));
+}
+
+#[test]
+fn cancelling_the_filter_prompt_keeps_the_type_layer() {
+    let mut app = app_with(Kind::Type);
+    let before = (past(&app), app.session.active().unwrap().doc.clone());
+    menu(&mut app, BLUR).unwrap();
+    // The menu again while it is up doesn't stack another prompt.
+    menu(&mut app, BLUR).unwrap();
+    assert_eq!(app.ui.dialogs.len(), 1);
+    let id = prompt(&app).unwrap().id;
+    crate::dialogs::cancel(&mut app, id).unwrap();
+    assert!(app.ui.dialogs.is_empty());
+    assert_eq!(past(&app), before.0);
+    assert_eq!(*app.session.active().unwrap().doc, *before.1);
+    assert_eq!(active_content(&app), "Type");
+}
+
+/// Convert to Smart Object keeps the text editable and applies the filter as a smart filter.
+#[test]
+fn convert_to_smart_object_applies_a_smart_filter() {
+    let mut app = app_with(Kind::Type);
+    menu(&mut app, BLUR).unwrap();
+    let id = prompt(&app).unwrap().id;
+    app.ui.dialog_mut(id).unwrap().fields.insert("choice".into(), json!("smartObject"));
+    answer(&mut app, id);
+    assert_eq!(active_content(&app), "Smart Object");
+    let blur = filter_dialog(&app).expect("Gaussian Blur opens on the Smart Object");
+    crate::dialogs::confirm(&mut app, blur).unwrap();
+    let st = app.session.active().unwrap();
+    let LayerContent::Smart(sm) = &st.doc.layer(st.active_layer.unwrap()).unwrap().content else { panic!("a Smart Object") };
+    assert_eq!(sm.smart_filters.iter().map(|f| f.command.as_str()).collect::<Vec<_>>(), [BLUR]);
+}
+
+/// A filter without a dialog runs straight after rasterizing.
+#[test]
+fn a_filter_without_a_dialog_runs_after_rasterizing() {
+    let mut app = app_with(Kind::Type);
+    let before = past(&app);
+    menu(&mut app, "filter.blur.blurMore").unwrap();
+    let id = prompt(&app).unwrap().id;
+    answer(&mut app, id);
+    assert!(app.ui.dialogs.is_empty());
+    assert_eq!(past(&app), before + 2);
+    assert_eq!(active_content(&app), "Pixel");
+}
+
+#[test]
+fn filters_stay_grey_where_rasterizing_would_not_help() {
+    // A locked type layer can't be rasterized either.
+    let mut app = app_with(Kind::Type);
+    app.run("layer.lockLayers", json!({"pixels": true})).unwrap();
+    assert!(!crate::menus::is_enabled(&app, BLUR));
+    // Only type layers ask: a shape layer's filters stay grey, as before.
+    let app = app_with(Kind::Shape);
+    assert!(!crate::menus::is_enabled(&app, BLUR));
+    // Non-filter commands a type layer greys are untouched.
+    let app = app_with(Kind::Type);
+    assert_eq!(crate::menus::is_enabled(&app, "edit.fill"), app.session.is_enabled("edit.fill"));
+}
+
+/// The dialogs, and the filter a prompt queued, frame by frame.
+fn harness(app: PhotocraftApp) -> egui_kittest::Harness<'static, PhotocraftApp> {
+    let h = egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 700.0)).build_ui_state(
+        |ui, app| {
+            crate::dialogs::show(app, ui.ctx());
+            run_pending(app, ui.ctx());
+        },
+        app,
+    );
+    PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+    h
+}
+
+/// The prompt's buttons, clicked: Rasterize, then the filter.
+#[test]
+fn the_filter_prompt_offers_convert_rasterize_and_cancel() {
+    use egui_kittest::kittest::Queryable;
+    let app = app_with(Kind::Type);
+    let mut h = harness(app);
+    menu(h.state_mut(), BLUR).unwrap();
+    h.run_steps(4);
+    h.get_by_label("Convert to Smart Object");
+    h.get_by_label("Cancel");
+    h.get_by_label("Rasterize").click();
+    h.run_steps(4);
+    assert_eq!(active_content(h.state()), "Pixel");
+    assert!(filter_dialog(h.state()).is_some());
+}
+
+#[test]
+fn the_convert_button_converts_to_a_smart_object() {
+    use egui_kittest::kittest::Queryable;
+    let app = app_with(Kind::Type);
+    let mut h = harness(app);
+    menu(h.state_mut(), BLUR).unwrap();
+    h.run_steps(4);
+    h.get_by_label("Convert to Smart Object").click();
+    h.run_steps(4);
+    assert_eq!(active_content(h.state()), "Smart Object");
+    assert!(filter_dialog(h.state()).is_some());
+}
+
+/// The filters with their own window or mode open on the rasterized layer, or on the Smart Object.
+#[test]
+fn filters_with_their_own_window_open_after_the_prompt() {
+    type IsOpen = fn(&PhotocraftApp) -> bool;
+    let open: [(&str, IsOpen); 4] = [
+        ("filter.liquify", |a| a.distort.liquify.is_some()),
+        ("filter.filterGallery", |a| a.distort.gallery.is_some()),
+        ("filter.cameraRaw", |a| a.camera_raw.is_some()),
+        ("filter.adaptiveWideAngle", |a| a.wide_angle.is_some()),
+    ];
+    for (filter, is_open) in open {
+        for choice in ["rasterize", "smartObject"] {
+            let mut app = app_with(Kind::Type);
+            assert!(crate::menus::is_enabled(&app, filter), "{filter}");
+            menu(&mut app, filter).unwrap();
+            assert!(!is_open(&app), "{filter}: waits for the answer");
+            let id = prompt(&app).unwrap_or_else(|| panic!("{filter}: no prompt")).id;
+            app.ui.dialog_mut(id).unwrap().fields.insert("choice".into(), json!(choice));
+            answer(&mut app, id);
+            assert!(!app.ui.status_error, "{filter}/{choice}: {}", app.ui.status);
+            assert_eq!(active_content(&app), if choice == "rasterize" { "Pixel" } else { "Smart Object" }, "{filter}");
+            assert!(is_open(&app), "{filter}/{choice}: its window opens");
+        }
+    }
+}
+
+/// Last Filter asks only when there is a filter to repeat, then repeats it on the rasterized layer.
+#[test]
+fn last_filter_on_a_type_layer_needs_a_filter_to_repeat() {
+    let mut app = app_with(Kind::Type);
+    assert!(!crate::menus::is_enabled(&app, "filter.lastFilter"), "nothing to repeat yet");
+    app.run("layer.new.layer", json!({})).unwrap();
+    app.run("edit.fill", json!({"color": "#00ff00"})).unwrap();
+    app.run("filter.blur.blurMore", json!({})).unwrap();
+    let st = app.session.active().unwrap();
+    let text = st.doc.layers.iter().find(|l| matches!(l.content, LayerContent::Text(_))).unwrap().id;
+    app.run("layer.select", json!({"layer": text.0})).unwrap();
+    assert!(crate::menus::is_enabled(&app, "filter.lastFilter"));
+    let before = past(&app);
+    menu(&mut app, "filter.lastFilter").unwrap();
+    let id = prompt(&app).expect("the prompt").id;
+    answer(&mut app, id);
+    assert!(!app.ui.status_error, "{}", app.ui.status);
+    assert_eq!(active_content(&app), "Pixel");
+    assert_eq!(past(&app), before + 2, "rasterize, then Blur More again");
+    assert_eq!(app.session.journal.iter().filter(|(id, _)| id == "filter.blur.blurMore").count(), 2);
+}
+
+/// Every Filter menu item live on a pixel layer is live on a type layer and gets there through the
+/// prompt (Flame, Tree, Picture Frame already run on a type layer: they render on a new layer).
+#[test]
+fn every_filter_live_on_pixels_asks_on_a_type_layer() {
+    let ids: Vec<&str> = crate::menu_catalog::CATALOG.iter().filter(|e| e.3.starts_with("filter.")).map(|e| e.3).collect();
+    let mut pixels = app_with(Kind::Type);
+    pixels.run("layer.rasterize.type", json!({})).unwrap();
+    let mut asked = 0;
+    for id in ids {
+        let mut app = app_with(Kind::Type);
+        if !crate::menus::is_enabled(&pixels, id) || app.session.is_enabled(id) {
+            continue;
+        }
+        assert!(crate::menus::is_enabled(&app, id), "{id}");
+        menu(&mut app, id).unwrap();
+        let d = prompt(&app).unwrap_or_else(|| panic!("{id}: no prompt")).id;
+        answer(&mut app, d);
+        assert!(!app.ui.status_error, "{id}: {}", app.ui.status);
+        assert_eq!(active_content(&app), "Pixel", "{id}");
+        asked += 1;
+    }
+    assert!(asked > 40, "{asked} filters");
+}
+
+/// Vanishing Point edits pixels only: its prompt offers Rasterize, not Convert to Smart Object.
+#[test]
+fn vanishing_point_offers_only_rasterize() {
+    use egui_kittest::kittest::Queryable;
+    let app = app_with(Kind::Type);
+    let mut h = harness(app);
+    assert!(crate::menus::is_enabled(h.state(), "filter.vanishingPoint"));
+    menu(h.state_mut(), "filter.vanishingPoint").unwrap();
+    h.run_steps(4);
+    assert!(h.query_by_label("Convert to Smart Object").is_none());
+    let id = prompt(h.state()).unwrap().id;
+    h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("choice".into(), json!("smartObject"));
+    assert!(crate::dialogs::confirm(h.state_mut(), id).is_err(), "no conversion behind its back");
+    assert_eq!(active_content(h.state()), "Type");
+    menu(h.state_mut(), "filter.vanishingPoint").unwrap();
+    h.run_steps(4);
+    h.get_by_label("Rasterize").click();
+    h.run_steps(4);
+    assert_eq!(active_content(h.state()), "Pixel");
+    assert!(h.state().distort.vanishing.is_some(), "Vanishing Point opens");
+}
diff --git a/crates/ui-egui/src/retouch_ui.rs b/crates/ui-egui/src/retouch_ui.rs
index 37168ab4b8..adf3c8cf69 100644
--- a/crates/ui-egui/src/retouch_ui.rs
+++ b/crates/ui-egui/src/retouch_ui.rs
@@ -29,6 +29,7 @@ pub(crate) fn clone_params(app: &PhotocraftApp) -> Option<Value> {
     let o = &app.ui.tool_options;
     let mut p = json!({"aligned": o.clone_aligned, "sampleLayer": o.clone_sample});
     if app.ui.tool == Tool::CloneStamp {
+        p["wrap"] = json!(app.ui.view.pattern_preview);
         p["opacity"] = json!(app.session.tools.brush.opacity * 100.0);
         p["flow"] = json!(app.session.tools.brush.flow * 100.0);
     }
@@ -84,7 +85,13 @@ pub fn finish_stroke(app: &mut PhotocraftApp, tool: Tool, points: &[[f64; 3]], m
     let pts = json!(points);
     let (cmd, mut p): (&str, Value) = match tool {
         Tool::SpotHealing => ("paint.spotHealing", json!({"type": o.spot_type, "sampleAllLayers": o.sample_all_layers})),
-        Tool::Remove => ("paint.remove", json!({"sampleAllLayers": o.sample_all_layers})),
+        Tool::Remove => {
+            if !o.remove_after_each_stroke {
+                remove_pending_add(app, points);
+                return true;
+            }
+            ("paint.remove", remove_params(&o))
+        }
         Tool::MixerBrush => ("paint.mixerBrush", json!({})),
         Tool::ColorReplacement => ("paint.colorReplacement", color_replacement_params(app)),
         Tool::PatternStamp => {
@@ -154,6 +161,87 @@ pub fn finish_stroke(app: &mut PhotocraftApp, tool: Tool, points: &[[f64; 3]], m
     true
 }
 
+/// `paint.remove` params from the options bar (without the strokes).
+fn remove_params(o: &crate::state::ToolOptions) -> Value {
+    json!({"sampleAllLayers": o.sample_all_layers, "newLayer": o.remove_new_layer})
+}
+
+/// Remove after each stroke off: a finished stroke waits with the others, tinted on the canvas,
+/// until ↩ or the options bar's ✓ applies them all as one removal (Esc or ⊘ drops them).
+pub fn remove_pending_add(app: &mut PhotocraftApp, points: &[[f64; 3]]) {
+    let Some(st) = app.session.active() else { return };
+    let (doc, size) = (st.doc.id, [st.doc.size.width, st.doc.size.height]);
+    if app.remove_pending_doc != Some(doc) {
+        app.remove_pending.clear();
+        app.remove_trail = None;
+        app.remove_pending_doc = Some(doc);
+    }
+    let diameter = app.session.tools.brush.size;
+    app.remove_trail.get_or_insert_with(|| crate::stroke_trail::Trail::new(size)).feed(points, diameter);
+    app.remove_pending.push(points.to_vec());
+    app.ui.status = crate::i18n::fmt(tl!("Strokes to remove: {n} (Enter applies, Esc cancels)"), &[("n", &app.remove_pending.len().to_string())]);
+    app.ui.status_error = false;
+}
+
+/// Apply the waiting strokes as one removal (one job, one undo step). False when none wait.
+pub fn remove_pending_commit(app: &mut PhotocraftApp) -> bool {
+    if app.remove_pending.is_empty() {
+        return false;
+    }
+    let strokes = std::mem::take(&mut app.remove_pending);
+    app.remove_trail = None;
+    app.remove_pending_doc = None;
+    let mut p = remove_params(&app.ui.tool_options);
+    p["strokes"] = json!(strokes);
+    p["target"] = crate::canvas::paint_target(app);
+    app.ui.status.clear();
+    if let Err(e) = app.run("paint.remove", p) {
+        app.ui.status = e;
+        app.ui.status_error = true;
+    }
+    true
+}
+
+/// Drop the waiting strokes. False when none wait.
+pub fn remove_pending_cancel(app: &mut PhotocraftApp) -> bool {
+    if app.remove_pending.is_empty() {
+        return false;
+    }
+    app.remove_pending.clear();
+    app.remove_trail = None;
+    app.remove_pending_doc = None;
+    app.ui.status.clear();
+    app.ui.status_error = false;
+    true
+}
+
+/// Whether Remove strokes are still waiting: they are dropped when the tool or the document
+/// changed under them (checked every frame).
+pub fn remove_pending_live(app: &mut PhotocraftApp) -> bool {
+    if app.remove_pending.is_empty() {
+        return false;
+    }
+    let doc = app.session.active().map(|st| st.doc.id);
+    if app.ui.tool == Tool::Remove && doc.is_some() && app.remove_pending_doc == doc {
+        return true;
+    }
+    remove_pending_cancel(app);
+    false
+}
+
+/// The tint of the waiting Remove strokes, drawn every frame.
+pub fn draw_remove_pending(app: &mut PhotocraftApp, painter: &egui::Painter, xf: &ViewXform) {
+    if !remove_pending_live(app) {
+        return;
+    }
+    let Some(bounds) = app.session.active().map(|st| st.doc.bounds()) else { return };
+    let doc_rect = xf.doc_rect(bounds);
+    let col = Tokens::get(painter.ctx()).danger.gamma_multiply(0.45);
+    if let Some(trail) = app.remove_trail.as_mut() {
+        trail.draw(painter, doc_rect, xf.flip, col);
+    }
+}
+
 /// Patch Tool and Content-Aware Move Tool: a drag that starts inside the selection (without ⇧ or
 /// ⌥) drags the selection; any other drag draws a lasso selection.
 pub fn patch_drags_selection(app: &PhotocraftApp, at: [f64; 2], mods: egui::Modifiers) -> bool {
@@ -255,13 +343,28 @@ pub fn content_aware_move_params(app: &PhotocraftApp, offset: [i64; 2]) -> Value
 }
 
 /// Object Selection: the dragged rectangle. A click (or a sub-2 px nudge) cannot be a
-/// rectangle: like Photoshop's click-to-select, it falls back to a Quick Selection dab at
+/// rectangle: with Object Finder on it selects the object under the pointer, the one hovering
+/// highlighted (#4087; ⇧ adds, ⌥ subtracts, ⇧⌥ intersects, otherwise replaces). With it off it
+/// falls back to a Quick Selection dab at
 /// the brush size instead of looking dead (⌥ subtracts, otherwise it adds). Larger drags
 /// run the rectangle GrabCut (⌥ subtracts, ⇧ adds, otherwise replaces).
 pub fn finish_object_selection(app: &mut PhotocraftApp, start: [f64; 2], end: [f64; 2], mods: egui::Modifiers) {
     let (x, y) = (start[0].min(end[0]), start[1].min(end[1]));
     let (w, h) = ((end[0] - start[0]).abs(), (end[1] - start[1]).abs());
     let sample_all = app.ui.tool_options.sample_all_layers;
+    if (w < 2.0 || h < 2.0) && app.ui.tool_options.object_finder {
+        // Object Finder (#4087): the object under the click, as hovering highlighted it.
+        let mode = match (mods.shift, mods.alt) {
+            (true, true) => "intersect",
+            (true, false) => "add",
+            (false, true) => "subtract",
+            (false, false) => "replace",
+        };
+        let r = app.run("select.object", json!({"point": [end[0], end[1]], "mode": mode, "sampleAllLayers": sample_all}));
+        crate::object_finder::clear(app);
+        report_smart_result(app, r, tl!("No object found there — drag a rectangle around it"));
+        return;
+    }
     if w < 2.0 || h < 2.0 {
         let size = app.session.tools.brush.size;
         let mode = if mods.alt { "subtract" } else { "add" };
@@ -356,7 +459,23 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
             crate::widgets::checkbox(ui, &mut o.sample_all_layers, tl!("Sample All Layers"));
         }
         Tool::Remove => {
+            // Photoshop's options bar: Sample All Layers, Create a new layer, Remove after each
+            // stroke; with strokes waiting, ✓ applies them and ⊘ drops them.
             crate::widgets::checkbox(ui, &mut o.sample_all_layers, tl!("Sample All Layers"));
+            crate::widgets::checkbox(ui, &mut o.remove_new_layer, tl!("Create a new layer"));
+            crate::widgets::checkbox(ui, &mut o.remove_after_each_stroke, tl!("Remove after each stroke"));
+            if !app.remove_pending.is_empty() {
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    if crate::widgets::primary_button(ui, "✓", 32.0)
+                        .on_hover_text(crate::i18n::fmt(tl!("Apply the removal ({key})"), &[("key", &crate::shortcuts::pretty("Enter"))]))
+                        .clicked()
+                    {
+                        remove_pending_commit(app);
+                    } else if crate::widgets::secondary_button(ui, "⊘", 32.0).on_hover_text(tl!("Cancel (Esc)")).clicked() {
+                        remove_pending_cancel(app);
+                    }
+                });
+            }
         }
         Tool::Patch => {
             // Photoshop's options bar: Patch: Normal (Source / Destination) or Content-Aware
@@ -497,6 +616,7 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
             }
         }
         Tool::ObjectSelection => {
+            crate::widgets::checkbox(ui, &mut o.object_finder, tl!("Object Finder"));
             crate::widgets::checkbox(ui, &mut o.sample_all_layers, tl!("Sample All Layers"));
             opt(ui, tl!("Drag a rectangle around the object"));
             crate::widgets::vline(ui, 22.0);
@@ -574,6 +694,30 @@ mod tests {
         }
     }
 
+    #[test]
+    fn clone_stamp_in_pattern_preview_wraps_a_dab_across_the_right_edge() {
+        for pattern_preview in [false, true] {
+            let mut app = app();
+            app.run("paint.pencil", json!({"points": [[10, 10]], "size": 24, "color": "#ff0000"})).unwrap();
+            app.ui.tool = Tool::CloneStamp;
+            app.ui.clone_source = Some([10.0, 10.0]);
+            app.ui.view.pattern_preview = pattern_preview;
+            let modifiers = egui::Modifiers::NONE;
+            tool_event(&mut app, ToolEvent::Down { x: 98.0, y: 30.0, pressure: 1.0 }, modifiers);
+            tool_event(&mut app, ToolEvent::Up { x: 98.0, y: 30.0 }, modifiers);
+            assert!(!app.ui.status_error, "{}", app.ui.status);
+            let surface = active(&app).surface().unwrap();
+            let center = surface.rgba(98, 30);
+            assert!(center[0] > 0.9 && center[1] < 0.1, "clone center: {center:?}");
+            let opposite = surface.rgba(1, 30);
+            if pattern_preview {
+                assert!(opposite[0] > 0.9 && opposite[1] < 0.1, "Pattern Preview must wrap the clone footprint: {opposite:?}");
+            } else {
+                assert!(opposite[0] > 0.9 && opposite[1] > 0.9, "ordinary cloning must not wrap: {opposite:?}");
+            }
+        }
+    }
+
     #[test]
     fn alt_flips_dodge_burn_and_blur_sharpen() {
         for (tool, flipped) in [(Tool::Dodge, Tool::Burn), (Tool::Burn, Tool::Dodge), (Tool::Blur, Tool::Sharpen), (Tool::Sharpen, Tool::Blur)] {
@@ -673,6 +817,7 @@ mod tests {
         // A click cannot be a rectangle: it selects at the cursor instead of looking dead.
         let mut app = app();
         app.ui.tool = Tool::ObjectSelection;
+        app.ui.tool_options.object_finder = false;
         let m = egui::Modifiers::NONE;
         tool_event(&mut app, ToolEvent::Down { x: 50.0, y: 30.0, pressure: 1.0 }, m);
         tool_event(&mut app, ToolEvent::Up { x: 50.0, y: 30.0 }, m);
@@ -955,6 +1100,76 @@ mod tests {
         assert!(px.iter().zip(bg).all(|(a, b)| (a - b).abs() < 0.02), "{px:?} vs {bg:?}");
     }
 
+    #[test]
+    fn remove_after_each_stroke_off_collects_strokes_until_enter_or_escape() {
+        let mut app = app();
+        app.run("paint.pencil", json!({"points": [[0, 30], [100, 30]], "size": 200, "color": "#808080"})).unwrap();
+        app.run("paint.pencil", json!({"points": [[30, 20], [30, 40]], "size": 4, "color": "#000000"})).unwrap();
+        app.ui.tool = Tool::Remove;
+        app.ui.tool_options.remove_after_each_stroke = false;
+        let m = egui::Modifiers::NONE;
+        let journal = app.session.journal.len();
+        for x in [28.0, 32.0] {
+            tool_event(&mut app, ToolEvent::Down { x, y: 18.0, pressure: 1.0 }, m);
+            tool_event(&mut app, ToolEvent::Move { x, y: 42.0, pressure: 1.0 }, m);
+            tool_event(&mut app, ToolEvent::Up { x, y: 42.0 }, m);
+        }
+        // Nothing ran yet: the strokes wait, tinted, and the status says so.
+        assert_eq!(app.session.journal.len(), journal, "no command before Enter");
+        assert_eq!(app.remove_pending.len(), 2);
+        assert!(app.remove_trail.is_some());
+        assert!(app.ui.status.contains("2") && !app.ui.status_error, "{}", app.ui.status);
+        // Esc drops them.
+        assert!(remove_pending_cancel(&mut app));
+        assert!(app.remove_pending.is_empty() && app.remove_trail.is_none());
+        assert!(!remove_pending_cancel(&mut app));
+        // Collected again, Enter applies them as one `paint.remove` with both strokes.
+        for x in [28.0, 32.0] {
+            tool_event(&mut app, ToolEvent::Down { x, y: 18.0, pressure: 1.0 }, m);
+            tool_event(&mut app, ToolEvent::Up { x, y: 42.0 }, m);
+        }
+        let bg = active(&app).surface().unwrap().rgba(70, 30);
+        assert!(remove_pending_commit(&mut app));
+        assert!(!app.ui.status_error, "{}", app.ui.status);
+        let (id, p) = app.session.journal.last().cloned().expect("a journaled command");
+        assert_eq!(id, "paint.remove");
+        assert_eq!(p["strokes"].as_array().map(Vec::len), Some(2));
+        assert!(p.get("points").is_none());
+        assert!(app.remove_pending.is_empty());
+        let px = active(&app).surface().unwrap().rgba(30, 30);
+        assert!(px.iter().zip(bg).all(|(a, b)| (a - b).abs() < 0.02), "{px:?} vs {bg:?}");
+        assert!(!remove_pending_commit(&mut app), "nothing left to apply");
+    }
+
+    #[test]
+    fn remove_strokes_waiting_are_dropped_when_the_tool_changes() {
+        let mut app = app();
+        app.ui.tool = Tool::Remove;
+        app.ui.tool_options.remove_after_each_stroke = false;
+        remove_pending_add(&mut app, &[[10.0, 10.0, 1.0], [20.0, 10.0, 1.0]]);
+        assert_eq!(app.remove_pending.len(), 1);
+        assert!(remove_pending_live(&mut app));
+        app.ui.tool = Tool::SpotHealing;
+        assert!(!remove_pending_live(&mut app));
+        assert!(app.remove_pending.is_empty(), "the strokes belong to the Remove tool");
+    }
+
+    #[test]
+    fn create_a_new_layer_sends_new_layer_to_the_command() {
+        let mut app = app();
+        app.run("paint.pencil", json!({"points": [[0, 30], [100, 30]], "size": 200, "color": "#808080"})).unwrap();
+        app.ui.tool = Tool::Remove;
+        app.ui.tool_options.remove_new_layer = true;
+        let layers = app.session.active().unwrap().doc.walk().len();
+        let m = egui::Modifiers::NONE;
+        tool_event(&mut app, ToolEvent::Down { x: 30.0, y: 18.0, pressure: 1.0 }, m);
+        tool_event(&mut app, ToolEvent::Up { x: 30.0, y: 42.0 }, m);
+        assert!(!app.ui.status_error, "{}", app.ui.status);
+        let (id, p) = app.session.journal.last().cloned().unwrap();
+        assert_eq!((id.as_str(), p["newLayer"].as_bool()), ("paint.remove", Some(true)));
+        assert_eq!(app.session.active().unwrap().doc.walk().len(), layers + 1, "the fill went to a new layer");
+    }
+
     #[test]
     fn red_eye_is_in_the_j_flyout() {
         let j = [Tool::Remove, Tool::SpotHealing, Tool::Healing, Tool::Patch, Tool::ContentAwareMove, Tool::RedEye];
diff --git a/crates/ui-egui/src/rotate_view.rs b/crates/ui-egui/src/rotate_view.rs
index eee0b29e56..5e173da5dc 100644
--- a/crates/ui-egui/src/rotate_view.rs
+++ b/crates/ui-egui/src/rotate_view.rs
@@ -1,6 +1,7 @@
 //! Rotate View tool: turn the canvas camera around its centre without rewriting pixels.
 //!
-//! Drag around the view centre (clockwise increases the angle). Shift snaps to 15°. Reset View,
+//! Drag around the view centre: the image follows the pointer (clockwise increases the angle, or
+//! decreases it in a flipped view). Shift snaps to 15°. Reset View,
 //! Escape, a double-click, or the on-canvas compass put the angle back to 0. History is not
 //! recorded. Trackpad rotate is gated by Preferences › Enhanced Controls › Rotate View with
 //! Trackpad.
@@ -59,6 +60,14 @@ pub fn snap_deg(a: f32, step: f32) -> f32 {
     wrap_deg((a / step).round() * step)
 }
 
+/// Turn a pointer or trackpad angle change (screen degrees, clockwise positive) into a change of
+/// `View::rotation`. [`ViewXform::to_screen`] mirrors x after rotating, so in a flipped view a
+/// larger angle turns the image the other way on screen; negating keeps it under the pointer.
+pub fn screen_delta(delta: f32, flip: bool) -> f32 {
+    let d = wrap_deg(delta);
+    if flip { wrap_deg(-d) } else { d }
+}
+
 /// Pointer angle in degrees around `pivot` (Y-down, so clockwise is positive).
 pub fn pointer_deg(p: Pos2, pivot: Pos2) -> f32 {
     let d = p - pivot;
@@ -71,7 +80,11 @@ pub fn pointer_deg(p: Pos2, pivot: Pos2) -> f32 {
 fn finite_number(p: &Value, key: &str) -> Result<Option<f32>, String> {
     match p.get(key) {
         None => Ok(None),
-        Some(v) => v.as_f64().filter(|n| n.is_finite()).map(|n| Some(n as f32)).ok_or_else(|| format!("{key} must be a finite number")),
+        Some(v) => v
+            .as_f64()
+            .filter(|n| n.is_finite() && n.abs() <= f64::from(f32::MAX))
+            .map(|n| Some(n as f32))
+            .ok_or_else(|| format!("{key} must be a finite number representable as f32")),
     }
 }
 
@@ -176,7 +189,7 @@ pub fn drag(ctx: &egui::Context, view: &mut View, xf: &ViewXform, b: &Buttons, p
         return b.started || b.dragged || b.stopped;
     };
     if let Some(p) = pointer.filter(|_| b.dragged || b.stopped) {
-        let delta = wrap_deg(pointer_deg(p, z.pivot) - z.start_pointer);
+        let delta = screen_delta(pointer_deg(p, z.pivot) - z.start_pointer, xf.flip);
         let mut angle = z.start_rotation + delta;
         if !angle.is_finite() {
             angle = z.start_rotation;
@@ -294,12 +307,32 @@ mod tests {
         assert!(apply_params(0.0, &json!({"angle": f64::NAN})).is_err());
         assert!(apply_params(0.0, &json!({"angle": f64::INFINITY})).is_err());
         assert!(apply_params(0.0, &json!({"delta": f64::INFINITY})).is_err());
+        // JSON can contain finite f64 values whose f32 conversion overflows to infinity.
+        // Silently wrapping infinity to 0 would reset a rotated view.
+        assert!(apply_params(32.0, &json!({"angle": 1.0e100})).is_err());
+        assert!(apply_params(32.0, &json!({"delta": -1.0e100})).is_err());
         assert!(apply_params(0.0, &json!({"reset": "yes"})).is_err());
         assert!(apply_params(0.0, &json!({"zoom": 1})).is_err());
         let huge = apply_params(0.0, &json!({"angle": 1.0e20})).unwrap();
         assert!(huge.is_finite() && huge.abs() <= 180.0);
     }
 
+    #[test]
+    fn native_rotate_event_reaches_canvas_when_trackpad_rotation_is_enabled() {
+        let ctx = egui::Context::default();
+        let mut enabled = None;
+        let mut disabled = None;
+        let raw = egui::RawInput { events: vec![Event::Rotate(std::f32::consts::FRAC_PI_6)], ..Default::default() };
+        let mut output = ctx.run_ui(raw, |ui| {
+            enabled = trackpad_delta(ui.ctx(), true);
+            disabled = trackpad_delta(ui.ctx(), false);
+        });
+        output.textures_delta.clear();
+
+        assert!(enabled.is_some_and(|degrees| (degrees - 30.0).abs() < 1e-3), "{enabled:?}");
+        assert_eq!(disabled, None);
+    }
+
     #[test]
     fn trackpad_pref_gates_rotation() {
         assert_eq!(apply_trackpad(10.0, false, 0.5), None);
@@ -350,6 +383,49 @@ mod tests {
         assert!((s.x - c.x).abs() < 1e-3 && (s.y - (c.y + 1.0)).abs() < 1e-3, "flip then rotate {s:?}");
     }
 
+    /// Screen angle, about the canvas centre, of the document point that was under `p0` at the press.
+    fn followed_angle(h: &Harness<'static, PhotocraftApp>, p0: Pos2, start_rotation: f32) -> f32 {
+        let st = h.state();
+        let (rect, v, flip) = (st.last_canvas_rect, &st.ui.views[0], st.ui.view.flip_horizontal);
+        let before = ViewXform { rect, zoom: 1.0, center: v.center, flip, rotation: start_rotation, aspect: 1.0 };
+        let d = before.to_doc(p0);
+        let after = ViewXform { rotation: v.rotation, ..before };
+        let s = after.to_screen(d[0] as f32, d[1] as f32) - rect.center();
+        wrap_deg(s.y.atan2(s.x).to_degrees() - pointer_deg(p0, rect.center()))
+    }
+
+    #[test]
+    fn drag_follows_the_pointer_in_a_flipped_view() {
+        for flip in [false, true] {
+            let mut h = harness();
+            h.state_mut().ui.view.flip_horizontal = flip;
+            h.run_steps(2);
+            let c = h.state().last_canvas_rect.center();
+            let p0 = c + vec2(120.0, 0.0);
+            h.event(Event::PointerMoved(p0));
+            h.step();
+            press(&mut h, p0, true, false);
+            // 30° clockwise about the pivot: the image turns 30° clockwise on screen.
+            let p1 = c + vec2(120.0 * 30f32.to_radians().cos(), 120.0 * 30f32.to_radians().sin());
+            h.event(Event::PointerMoved(p1));
+            h.step();
+            let got = followed_angle(&h, p0, 0.0);
+            assert!((got - 30.0).abs() < 0.75, "flip={flip}: the image turned {got}°, the pointer 30°");
+            press(&mut h, p1, false, false);
+        }
+    }
+
+    #[test]
+    fn screen_delta_mirrors_only_in_a_flipped_view() {
+        assert_eq!(screen_delta(12.5, false), 12.5);
+        assert_eq!(screen_delta(12.5, true), -12.5);
+        assert_eq!(screen_delta(-180.0, true), 180.0);
+        assert_eq!(screen_delta(f32::NAN, true), 0.0);
+        assert_eq!(screen_delta(f32::INFINITY, false), 0.0);
+        // A flipped view still lands on the snapped angle with Shift.
+        assert_eq!(snap_deg(0.0 + screen_delta(-40.0, true), SNAP_DEG), 45.0);
+    }
+
     fn app_docs(n: usize) -> PhotocraftApp {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
         for i in 0..n {
diff --git a/crates/ui-egui/src/rulers.rs b/crates/ui-egui/src/rulers.rs
index 58bcf04cf5..ff5f106bde 100644
--- a/crates/ui-egui/src/rulers.rs
+++ b/crates/ui-egui/src/rulers.rs
@@ -237,37 +237,86 @@ pub fn finish_drag(app: &mut PhotocraftApp, d: GuideDrag) {
 /// the document origin as the rotated view draws it, as in Photoshop. Tilted guides then meet the
 /// rulers near their numbers. Measuring along the rotated axes instead squeezed the ticks into a
 /// few pixels (or none at 90°) and left the rest of the ruler empty (#3233).
-fn ruler_xform(xf: &ViewXform) -> ViewXform {
+///
+/// The returned mapping measures from the rulers' zero point `zero` (document px, #2955): its
+/// document coordinates are distances from `zero`, and 0 sits where the canvas draws `zero`.
+fn ruler_xform(xf: &ViewXform, zero: [f64; 2]) -> ViewXform {
     let level = ViewXform { rotation: 0.0, ..*xf };
-    // The level view is an axis-aligned scale, so moving the origin by `shift` on screen moves
-    // every point by it: re-centre on the document point that sat `shift` before the centre.
-    let shift = xf.to_screen(0.0, 0.0) - level.to_screen(0.0, 0.0);
+    let (zx, zy) = (zero[0] as f32, zero[1] as f32);
+    // The level view is an axis-aligned scale, so moving the zero point by `shift` on screen moves
+    // every point by it: re-centre on the document point that sat `shift` before the centre, then
+    // count from the zero point.
+    let shift = xf.to_screen(zx, zy) - level.to_screen(zx, zy);
     let center = level.to_doc(xf.rect.center() - shift);
+    let center = [center[0] as f32 - zx, center[1] as f32 - zy];
     if !(center[0].is_finite() && center[1].is_finite()) {
         return level;
     }
-    ViewXform { center: [center[0] as f32, center[1] as f32], ..level }
+    ViewXform { center, ..level }
 }
 
 /// Visible ruler range in ruler units, normalised to `(min, max)` so the tick loop runs for
-/// flipped views too (#1814). `xf` is the canvas mapping; rotation is ignored (see
-/// [`ruler_xform`]). Shared by the renderer and its tests.
-fn ruler_range(xf: &ViewXform, a: Pos2, b: Pos2, axis: usize, px_per_unit: f64) -> (f64, f64) {
-    let rxf = ruler_xform(xf);
+/// flipped views too (#1814), measured from the zero point `zero`. `xf` is the canvas mapping;
+/// rotation is ignored (see [`ruler_xform`]). Shared by the renderer and its tests.
+fn ruler_range(xf: &ViewXform, a: Pos2, b: Pos2, axis: usize, px_per_unit: f64, zero: [f64; 2]) -> (f64, f64) {
+    let rxf = ruler_xform(xf, zero);
     let d0 = rxf.to_doc(a)[axis];
     let d1 = rxf.to_doc(b)[axis];
     let (u0, u1) = (d0 / px_per_unit, d1 / px_per_unit);
     (u0.min(u1), u0.max(u1))
 }
 
+/// Snap a document position to the nearest ruler tick, measured from the zero point `origin`
+/// (`tick` px apart). Shift-dragging the zero point lands it on a tick, as in Photoshop.
+fn snap_px_to_tick(px: f64, origin: f64, tick: f64) -> f64 {
+    if !(tick.is_finite() && tick > 0.0) {
+        return px;
+    }
+    origin + ((px - origin) / tick).round() * tick
+}
+
+/// Where a zero-point drag from the ruler corner lands for the pointer at document `d`: on the
+/// nearest ruler tick (`ticks`, px per axis) with Shift, else View › Snap To targets.
+fn origin_drop(app: &mut PhotocraftApp, d: [f64; 2], shift: bool, origin: [f64; 2], ticks: [f64; 2]) -> [f64; 2] {
+    if shift {
+        [snap_px_to_tick(d[0], origin[0], ticks[0]), snap_px_to_tick(d[1], origin[1], ticks[1])]
+    } else {
+        [crate::snap_ui::snap_guide(app, true, d[0]), crate::snap_ui::snap_guide(app, false, d[1])]
+    }
+}
+
 /// Screen coordinate along the ruler (x for the top ruler, y for the left one) of the value `u`
-/// in ruler units. The inverse of [`ruler_range`]'s mapping.
-fn ruler_pos(xf: &ViewXform, vertical: bool, u: f64, px_per_unit: f64) -> f32 {
+/// in ruler units from the zero point `zero`. The inverse of [`ruler_range`]'s mapping.
+fn ruler_pos(xf: &ViewXform, vertical: bool, u: f64, px_per_unit: f64, zero: [f64; 2]) -> f32 {
     let px = (u * px_per_unit) as f32;
-    let rxf = ruler_xform(xf);
+    let rxf = ruler_xform(xf, zero);
     if vertical { rxf.to_screen(0.0, px).y } else { rxf.to_screen(px, 0.0).x }
 }
 
+/// Document pixels per ruler unit and the labelled tick step (in ruler units) of the top ruler
+/// (`y_axis` false) or the left one, from Preferences › Units & Rulers and the zoom. Minor ticks
+/// sit at tenths of the step.
+fn ruler_scale(app: &PhotocraftApp, xf: &ViewXform, y_axis: bool) -> (f64, f64) {
+    let ur = &app.session.prefs().units_and_rulers;
+    let (unit, ppi) = (ur.rulers, ur.point_size.per_inch());
+    let (dpi, size) =
+        app.session.active().map_or((72.0, [1.0, 1.0]), |d| (d.doc.resolution_dpi.max(1.0) as f64, [d.doc.size.width as f64, d.doc.size.height as f64]));
+    let px_per_unit = unit.to_px(1.0, dpi, if y_axis { size[1] } else { size[0] }, ppi).max(1e-9);
+    // The top ruler runs along document x, which pixel aspect correction stretches.
+    let zoom = if y_axis { xf.zoom } else { xf.zoom_x() };
+    (px_per_unit, nice_step(60.0 / (zoom as f64 * px_per_unit).max(1e-6), unit == Unit::Pixels))
+}
+
+/// `pos` (document px) moved to the nearest tick mark the ruler draws (counted from the zero point): where a guide lands when
+/// Shift is held while dragging it out of a ruler, as in Photoshop (#3770).
+fn snap_to_tick(app: &PhotocraftApp, xf: &ViewXform, vertical: bool, pos: f64) -> f64 {
+    // A vertical guide sits at an x position, which the top ruler measures.
+    let (px_per_unit, step) = ruler_scale(app, xf, !vertical);
+    // Ticks count from the zero point (#2955), which a vertical guide measures along x.
+    let origin = app.session.active().map_or(0.0, |d| d.doc.ruler_origin[usize::from(!vertical)]);
+    snap_px_to_tick(pos, origin, step / 10.0 * px_per_unit)
+}
+
 /// The number a ruler prints at the tick `v` (in ruler units). Like Photoshop, rulers show the
 /// distance from the origin, so values left of / above it read without a minus sign.
 fn ruler_label(v: f64, step: f64, whole: bool) -> String {
@@ -292,25 +341,23 @@ pub fn draw_rulers(app: &mut PhotocraftApp, ui: &mut egui::Ui, full: Rect, xf: &
     let font = egui::FontId::proportional(9.0);
     let tick = Stroke::new(1.0, t.text_faint);
     // Preferences › Units & Rulers: labels in the ruler unit (percent of the document's side).
-    let ur = &app.session.prefs().units_and_rulers;
-    let (unit, ppi) = (ur.rulers, ur.point_size.per_inch());
-    let (dpi, size) =
-        app.session.active().map_or((72.0, [1.0, 1.0]), |d| (d.doc.resolution_dpi.max(1.0) as f64, [d.doc.size.width as f64, d.doc.size.height as f64]));
-    let whole = unit == photocraft_engine::prefs::Unit::Pixels;
-    for (vertical, extent) in [(false, size[0]), (true, size[1])] {
+    let unit = app.session.prefs().units_and_rulers.rulers;
+    let whole = unit == Unit::Pixels;
+    // The zero point (#2955): rulers read 0 there and count the distance from it.
+    let origin = app.session.active().map_or([0.0, 0.0], |d| d.doc.ruler_origin);
+    let mut ticks = [1.0; 2];
+    for vertical in [false, true] {
         let p = p.with_clip_rect(if vertical { left } else { top });
-        let px_per_unit = unit.to_px(1.0, dpi, extent, ppi).max(1e-9);
-        // The top ruler runs along document x, which pixel aspect correction stretches.
-        let zoom = if vertical { xf.zoom } else { xf.zoom_x() };
-        let step = nice_step(60.0 / (zoom as f64 * px_per_unit).max(1e-6), whole);
+        let (px_per_unit, step) = ruler_scale(app, xf, vertical);
+        ticks[usize::from(vertical)] = step * px_per_unit / 10.0;
         let (u0, u1) = if vertical {
-            ruler_range(xf, left.left_top(), left.left_bottom(), 1, px_per_unit)
+            ruler_range(xf, left.left_top(), left.left_bottom(), 1, px_per_unit, origin)
         } else {
-            ruler_range(xf, top.left_top(), top.right_top(), 0, px_per_unit)
+            ruler_range(xf, top.left_top(), top.right_top(), 0, px_per_unit, origin)
         };
         let mut v = (u0 / step).floor() * step;
         while v <= u1 {
-            let at = |u: f64| -> f32 { ruler_pos(xf, vertical, u, px_per_unit) };
+            let at = |u: f64| -> f32 { ruler_pos(xf, vertical, u, px_per_unit, origin) };
             let c = at(v);
             if vertical {
                 p.line_segment([pos2(left.right() - RULER, c), pos2(left.right(), c)], tick);
@@ -343,16 +390,18 @@ pub fn draw_rulers(app: &mut PhotocraftApp, ui: &mut egui::Ui, full: Rect, xf: &
     // Drag a new guide out of a ruler; right-click to switch the ruler unit.
     let mut chosen_unit: Option<&'static str> = None;
     for (r, vertical, salt) in [(top, false, "ruler-top"), (left, true, "ruler-left"), (corner, false, "ruler-corner")] {
-        // Guides drag out of the top/left rulers; all three sense clicks so the right-click unit
-        // menu opens anywhere on the ruler (the corner only needs the menu).
-        let sense = if salt == "ruler-corner" { Sense::click() } else { Sense::click_and_drag() };
-        let resp = ui.interact(r, ui.id().with(salt), sense);
-        if resp.hovered() && salt != "ruler-corner" {
+        // Guides drag out of the top/left rulers and the zero point out of the corner; all three
+        // sense clicks so the right-click unit menu opens anywhere on the ruler.
+        let resp = ui.interact(r, ui.id().with(salt), Sense::click_and_drag());
+        if salt == "ruler-corner" {
+            corner_origin(app, ui, &resp, &p, xf, origin, ticks);
+        } else if resp.hovered() {
             ui.ctx().set_cursor_icon(if vertical { egui::CursorIcon::ResizeHorizontal } else { egui::CursorIcon::ResizeVertical });
         }
-        if let Some(pos) = resp.interact_pointer_pos().filter(|_| resp.dragged() || resp.drag_started()) {
+        if let Some(pos) = resp.interact_pointer_pos().filter(|_| salt != "ruler-corner" && (resp.dragged() || resp.drag_started())) {
             let d = xf.to_doc(pos);
-            let pos = crate::snap_ui::snap_guide(app, vertical, if vertical { d[0] } else { d[1] });
+            let along = if vertical { d[0] } else { d[1] };
+            let pos = if ui.input(|i| i.modifiers.shift) { snap_to_tick(app, xf, vertical, along) } else { crate::snap_ui::snap_guide(app, vertical, along) };
             app.guide_drag = Some(GuideDrag { vertical, index: None, pos });
         }
         if resp.drag_stopped()
@@ -372,6 +421,41 @@ pub fn draw_rulers(app: &mut PhotocraftApp, ui: &mut egui::Ui, full: Rect, xf: &
     let _ = Pos2::ZERO;
 }
 
+/// The ruler corner: drag the zero point out of it (cross hairs mark where it lands; Shift snaps
+/// to the ruler ticks), double-click it to put the zero point back at the image's top-left.
+fn corner_origin(app: &mut PhotocraftApp, ui: &egui::Ui, resp: &egui::Response, p: &egui::Painter, xf: &ViewXform, origin: [f64; 2], ticks: [f64; 2]) {
+    let id = resp.id.with("origin-drag");
+    if resp.hovered() || resp.dragged() {
+        ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);
+    }
+    if resp.double_clicked() {
+        let _ = app.run("view.resetRulerOrigin", json!({}));
+        return;
+    }
+    // Dropped back on the corner (or a slow click), the zero point stays where it was.
+    if let Some(pos) = resp.interact_pointer_pos().filter(|_| resp.dragged() || resp.drag_started()) {
+        if resp.rect.contains(pos) {
+            ui.data_mut(|d| d.remove_temp::<[f64; 2]>(id));
+            return;
+        }
+        let shift = ui.input(|i| i.modifiers.shift);
+        let at = origin_drop(app, xf.to_doc(pos), shift, origin, ticks);
+        ui.data_mut(|d| d.insert_temp(id, at));
+        // Cross hairs along the document axes through the new zero point, drawn like guides so
+        // they turn with a rotated view.
+        let t = Tokens::get(ui.ctx());
+        for (vertical, pos) in [(true, at[0]), (false, at[1])] {
+            p.line_segment(guide_segment(xf, p.clip_rect(), vertical, pos), Stroke::new(1.0, t.text));
+        }
+    }
+    if resp.drag_stopped()
+        && let Some(at) = ui.data_mut(|d| d.remove_temp::<[f64; 2]>(id))
+    {
+        let round = |v: f64| (v * 1000.0).round() / 1000.0;
+        let _ = app.run("view.setRulerOrigin", json!({"x": round(at[0]), "y": round(at[1])}));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -415,6 +499,140 @@ mod tests {
         assert!(failures.is_empty(), "ruler drawing overlaps the origin corner: {failures:?}");
     }
 
+    #[test]
+    fn shift_snaps_the_zero_point_to_ruler_ticks_from_the_current_origin() {
+        assert_eq!(snap_px_to_tick(47.0, 0.0, 10.0), 50.0);
+        assert_eq!(snap_px_to_tick(44.9, 0.0, 10.0), 40.0);
+        // Ticks run from the current zero point, so they sit at 3 + 10k.
+        assert_eq!(snap_px_to_tick(47.0, 3.0, 10.0), 43.0);
+        assert_eq!(snap_px_to_tick(-8.0, 3.0, 10.0), -7.0);
+        // A degenerate tick never panics or moves the point.
+        for tick in [0.0, -1.0, f64::NAN, f64::INFINITY] {
+            assert_eq!(snap_px_to_tick(47.5, 3.0, tick), 47.5);
+        }
+    }
+
+    /// Rulers alone in a 400×300 frame at 100 %, centred on a 256×128 document.
+    fn ruler_harness(app: PhotocraftApp) -> (egui_kittest::Harness<'static, PhotocraftApp>, Rect, ViewXform) {
+        let full = Rect::from_min_size(pos2(0.0, 0.0), vec2(400.0, 300.0));
+        let rect = Rect::from_min_max(full.min + vec2(RULER, RULER), full.max);
+        let xf = ViewXform { rect, zoom: 1.0, center: [128.0, 64.0], flip: false, rotation: 0.0, aspect: 1.0 };
+        let h = egui_kittest::Harness::builder()
+            .with_size(vec2(400.0, 300.0))
+            .with_step_dt(1.0 / 60.0)
+            .build_ui_state(move |ui, app| draw_rulers(app, ui, full, &xf), app);
+        (h, full, xf)
+    }
+
+    fn press(h: &mut egui_kittest::Harness<'static, PhotocraftApp>, pos: Pos2, pressed: bool, modifiers: egui::Modifiers) {
+        h.event(egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers });
+        h.run_steps(2);
+    }
+
+    fn drag_corner_to(h: &mut egui_kittest::Harness<'static, PhotocraftApp>, full: Rect, to: Pos2, modifiers: egui::Modifiers) {
+        let corner = Rect::from_min_size(full.min, vec2(RULER, RULER)).center();
+        h.event(egui::Event::ModifiersChanged(modifiers));
+        h.event(egui::Event::PointerMoved(corner));
+        h.run_steps(1);
+        press(h, corner, true, modifiers);
+        for p in [corner + vec2(10.0, 10.0), to] {
+            h.event(egui::Event::PointerMoved(p));
+            h.run_steps(2);
+        }
+        press(h, to, false, modifiers);
+        h.event(egui::Event::ModifiersChanged(egui::Modifiers::NONE));
+        h.run_steps(1);
+    }
+
+    fn origin(h: &egui_kittest::Harness<'static, PhotocraftApp>) -> [f64; 2] {
+        h.state().session.active().unwrap().doc.ruler_origin
+    }
+
+    /// #2955: dragging out of the ruler corner sets the zero point (cross hairs while dragging),
+    /// the rulers then read 0 there, Shift snaps it to a tick, and double-clicking the corner
+    /// resets it.
+    #[test]
+    fn dragging_the_ruler_corner_sets_the_zero_point_and_double_click_resets_it() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 256, "height": 128})).unwrap();
+        app.ui.extras.snap = false;
+        let (mut h, full, xf) = ruler_harness(app);
+        h.run_steps(2);
+        let target = xf.to_screen(100.0, 40.0);
+        drag_corner_to(&mut h, full, target, egui::Modifiers::NONE);
+        let o = origin(&h);
+        assert!((o[0] - 100.0).abs() < 0.01 && (o[1] - 40.0).abs() < 0.01, "zero point lands under the pointer: {o:?}");
+        // The top ruler's "0" now sits at the new zero point, "100" (a distance, unsigned as in
+        // Photoshop) at the image's left edge.
+        h.run_steps(2);
+        let labels: Vec<(String, f32)> = h
+            .output()
+            .shapes
+            .iter()
+            .filter_map(|s| if let egui::Shape::Text(t) = &s.shape { Some((t.galley.text().to_string(), t.pos.x)) } else { None })
+            .collect();
+        let near = |text: &str, x: f32| labels.iter().any(|(t, lx)| t == text && (lx - (x + 2.0)).abs() < 1.0);
+        assert!(near("0", target.x), "a 0 label at the zero point: {labels:?}");
+        assert!(near("100", xf.to_screen(0.0, 0.0).x), "100 at the image's left edge: {labels:?}");
+
+        // Mid-drag, cross hairs run through the pointer across the canvas.
+        let corner = Rect::from_min_size(full.min, vec2(RULER, RULER)).center();
+        let mid = xf.to_screen(150.0, 90.0);
+        press(&mut h, corner, true, egui::Modifiers::NONE);
+        for p in [corner + vec2(10.0, 10.0), mid] {
+            h.event(egui::Event::PointerMoved(p));
+            h.run_steps(2);
+        }
+        let crosshair = h.output().shapes.iter().any(|s| {
+            matches!(s.shape, egui::Shape::LineSegment { points: [a, b], .. } if (a.x - mid.x).abs() < 0.5 && (b.x - mid.x).abs() < 0.5 && (b.y - a.y).abs() > 200.0)
+        });
+        assert!(crosshair, "a vertical cross-hair line through the pointer while dragging");
+        assert_eq!(origin(&h), o, "the zero point moves on release only");
+        press(&mut h, mid, false, egui::Modifiers::NONE);
+        assert_eq!(origin(&h), [150.0, 90.0]);
+        h.state_mut().run("edit.undo", json!({})).unwrap();
+        assert_eq!(origin(&h), o, "setting the zero point is undoable");
+
+        // A drag dropped back on the corner leaves it alone.
+        drag_corner_to(&mut h, full, full.min + vec2(4.0, 4.0), egui::Modifiers::NONE);
+        assert_eq!(origin(&h), o);
+
+        // Shift: ticks are 10 px apart at 100 %, measured from the current zero point (100, 40).
+        drag_corner_to(&mut h, full, xf.to_screen(123.0, 57.0), egui::Modifiers::SHIFT);
+        assert_eq!(origin(&h), [120.0, 60.0]);
+
+        for _ in 0..40 {
+            h.step();
+        }
+        let corner = Rect::from_min_size(full.min, vec2(RULER, RULER)).center();
+        h.event(egui::Event::PointerMoved(corner));
+        h.step();
+        for _ in 0..2 {
+            for pressed in [true, false] {
+                h.event(egui::Event::PointerButton { pos: corner, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
+                h.step();
+            }
+        }
+        h.run_steps(2);
+        assert_eq!(origin(&h), [0.0, 0.0], "double-clicking the corner resets the zero point");
+    }
+
+    /// #2955: the Info panel's X/Y are measured from the rulers' zero point.
+    #[test]
+    fn info_panel_position_reads_from_the_zero_point() {
+        use egui_kittest::kittest::Queryable;
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+        app.run("view.setRulerOrigin", json!({"x": 20, "y": 5})).unwrap();
+        app.hover_doc = Some([50.5, 20.5]);
+        let mut h = egui_kittest::Harness::builder()
+            .with_size(vec2(260.0, 240.0))
+            .build_ui_state(|ui, app| crate::panels::dock_body(app, ui, crate::dock::Group::Navigator, 2), app);
+        h.run_steps(2);
+        assert!(h.query_by_label("30").is_some() && h.query_by_label("15").is_some(), "X 30, Y 15 from the zero point at (20, 5)");
+        assert!(h.query_by_label("50").is_none(), "not the raw image x");
+    }
+
     #[test]
     fn percentage_grid_spacing_uses_both_canvas_dimensions() {
         let mut g = GuidesGridAndSlices { grid_unit: Unit::Percent, gridline_every: 20.0, subdivisions: 2, ..Default::default() };
@@ -597,23 +815,23 @@ mod tests {
         for rotation in [0.0f32, 30.0, 45.0, 90.0, -119.0, 180.0] {
             for flip in [false, true] {
                 let xf = ViewXform { rect, zoom: 0.5, center: [1000.0, 700.0], flip, rotation, aspect: 1.0 };
-                let (u0, u1) = ruler_range(&xf, a, b, 0, 1.0);
+                let (u0, u1) = ruler_range(&xf, a, b, 0, 1.0, [0.0; 2]);
                 assert!((u1 - u0 - 1600.0).abs() < 1e-2, "rotation {rotation}: top ruler covers {u0}..{u1}");
                 let (first, last) = if flip { (u1, u0) } else { (u0, u1) };
-                assert!((ruler_pos(&xf, false, first, 1.0) - a.x).abs() < 1e-2, "rotation {rotation}: first tick");
-                assert!((ruler_pos(&xf, false, last, 1.0) - b.x).abs() < 1e-2, "rotation {rotation}: last tick");
+                assert!((ruler_pos(&xf, false, first, 1.0, [0.0; 2]) - a.x).abs() < 1e-2, "rotation {rotation}: first tick");
+                assert!((ruler_pos(&xf, false, last, 1.0, [0.0; 2]) - b.x).abs() < 1e-2, "rotation {rotation}: last tick");
                 // 0 at the projected origin, 500 document px = 500 × zoom screen px further on.
                 let origin = xf.to_screen(0.0, 0.0);
-                assert!((ruler_pos(&xf, false, 0.0, 1.0) - origin.x).abs() < 1e-2, "rotation {rotation}: top ruler 0");
-                assert!((ruler_pos(&xf, true, 0.0, 1.0) - origin.y).abs() < 1e-2, "rotation {rotation}: left ruler 0");
+                assert!((ruler_pos(&xf, false, 0.0, 1.0, [0.0; 2]) - origin.x).abs() < 1e-2, "rotation {rotation}: top ruler 0");
+                assert!((ruler_pos(&xf, true, 0.0, 1.0, [0.0; 2]) - origin.y).abs() < 1e-2, "rotation {rotation}: left ruler 0");
                 let dir = if flip { -1.0 } else { 1.0 };
-                assert!((ruler_pos(&xf, false, 500.0, 1.0) - origin.x - dir * 250.0).abs() < 1e-2, "rotation {rotation}: top scale");
-                assert!((ruler_pos(&xf, true, 500.0, 1.0) - origin.y - 250.0).abs() < 1e-2, "rotation {rotation}: left scale");
+                assert!((ruler_pos(&xf, false, 500.0, 1.0, [0.0; 2]) - origin.x - dir * 250.0).abs() < 1e-2, "rotation {rotation}: top scale");
+                assert!((ruler_pos(&xf, true, 500.0, 1.0, [0.0; 2]) - origin.y - 250.0).abs() < 1e-2, "rotation {rotation}: left scale");
             }
         }
         // Distances left of / above the origin read without a minus sign, as in Photoshop.
         let xf = ViewXform { rect, zoom: 0.5, center: [0.0, 0.0], flip: false, rotation: 0.0, aspect: 1.0 };
-        let (u0, u1) = ruler_range(&xf, a, b, 0, 1.0);
+        let (u0, u1) = ruler_range(&xf, a, b, 0, 1.0, [0.0; 2]);
         assert!(u0 < -500.0 && u1 > 500.0, "the view spans the origin: {u0}..{u1}");
         for (step, whole) in [(100.0, true), (100.0, false), (0.25, false)] {
             let mut v = (u0 / step).floor() * step;
@@ -627,6 +845,31 @@ mod tests {
         assert_eq!(ruler_label(-0.25, 0.25, false), "0.25");
     }
 
+    /// #2955 with #3233: a zero point moved off the image's top-left reads 0 where the canvas draws
+    /// it, also on a rotated or flipped view, and the ruler keeps its full length and scale.
+    #[test]
+    fn rulers_count_from_the_zero_point_on_a_rotated_view() {
+        let rect = Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0));
+        let (a, b) = (rect.left_top(), rect.right_top());
+        let zero = [300.0, 120.0];
+        for rotation in [0.0f32, 30.0, 90.0, -119.0] {
+            for flip in [false, true] {
+                let xf = ViewXform { rect, zoom: 0.5, center: [1000.0, 700.0], flip, rotation, aspect: 1.0 };
+                let at = xf.to_screen(zero[0] as f32, zero[1] as f32);
+                assert!((ruler_pos(&xf, false, 0.0, 1.0, zero) - at.x).abs() < 1e-2, "rotation {rotation}: top ruler 0");
+                assert!((ruler_pos(&xf, true, 0.0, 1.0, zero) - at.y).abs() < 1e-2, "rotation {rotation}: left ruler 0");
+                let (u0, u1) = ruler_range(&xf, a, b, 0, 1.0, zero);
+                assert!((u1 - u0 - 1600.0).abs() < 1e-2, "rotation {rotation}: top ruler covers {u0}..{u1}");
+                let dir = if flip { -1.0 } else { 1.0 };
+                assert!((ruler_pos(&xf, false, 500.0, 1.0, zero) - at.x - dir * 250.0).abs() < 1e-2, "rotation {rotation}: top scale");
+            }
+        }
+        // Unrotated, ruler value u sits over document x = zero + u.
+        let xf = ViewXform { rect, zoom: 0.5, center: [1000.0, 700.0], flip: false, rotation: 0.0, aspect: 1.0 };
+        assert!((ruler_pos(&xf, false, -300.0, 1.0, zero) - xf.to_screen(0.0, 0.0).x).abs() < 1e-2);
+        assert!((ruler_pos(&xf, true, 80.0, 1.0, zero) - xf.to_screen(0.0, 200.0).y).abs() < 1e-2);
+    }
+
     /// #3277: guides belong to the document, so a rotated view draws them along the document
     /// line; unrotated they still span the whole clip rect.
     #[test]
@@ -656,9 +899,53 @@ mod tests {
         let top = Rect::from_min_size(rect.min, vec2(rect.width(), RULER));
         for flip in [false, true] {
             let xf = ViewXform { rect, zoom: 1.0, center: [400.0, 300.0], flip, rotation: 0.0, aspect: 1.0 };
-            let (u0, u1) = ruler_range(&xf, top.left_top(), top.right_top(), 0, 1.0);
+            let (u0, u1) = ruler_range(&xf, top.left_top(), top.right_top(), 0, 1.0, [0.0; 2]);
             assert!(u0 <= u1, "flip={flip}: u0 ({u0}) must be <= u1 ({u1})");
             assert!(u1 - u0 > 0.0, "flip={flip}: range is empty");
         }
     }
+
+    /// #3770: a guide Shift-dragged out of a ruler lands on the nearest tick the ruler draws
+    /// (tenths of the labelled step, in the ruler unit); without Shift it lands where it's dropped.
+    #[test]
+    fn shift_dragged_guides_land_on_ruler_ticks() {
+        let full = Rect::from_min_size(Pos2::ZERO, vec2(400.0, 300.0));
+        let rect = Rect::from_min_max(full.min + vec2(RULER, RULER), full.max);
+        let xf = ViewXform { rect, zoom: 1.0, center: [128.0, 64.0], flip: false, rotation: 0.0, aspect: 1.0 };
+        let new_app = || {
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            app.run("file.new", json!({"width": 256, "height": 128})).unwrap();
+            app
+        };
+        let drag_guide = |modifiers: egui::Modifiers| {
+            let builder = egui_kittest::Harness::builder().with_size(vec2(400.0, 300.0));
+            let mut h = builder.build_ui_state(move |ui, app| draw_rulers(app, ui, full, &xf), new_app());
+            // Out of the left ruler: a vertical guide, dropped at document x = 37.
+            let (from, to) = (pos2(RULER / 2.0, 100.0), xf.to_screen(37.0, 64.0));
+            h.event_modifiers(egui::Event::PointerMoved(from), modifiers);
+            h.event_modifiers(egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers }, modifiers);
+            h.run_steps(1);
+            h.event_modifiers(egui::Event::PointerMoved(to), modifiers);
+            h.run_steps(1);
+            h.event_modifiers(egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers }, modifiers);
+            h.run_steps(2);
+            h.state().session.active().unwrap().doc.guides.vertical.clone()
+        };
+        assert_eq!(drag_guide(egui::Modifiers::NONE), vec![37.0]);
+        // Pixels at 100%: labels every 100 px, ticks every 10 px.
+        assert_eq!(drag_guide(egui::Modifiers::SHIFT), vec![40.0]);
+
+        let mut app = new_app();
+        // At 200% the labels are every 50 px, so the ticks every 5 px.
+        assert_eq!(snap_to_tick(&app, &ViewXform { zoom: 2.0, ..xf }, true, 37.0), 35.0);
+        // Percent of each side: ticks every 2.5% of 256 px across, every 5% of 128 px down.
+        app.run("prefs.set", json!({"path": "unitsAndRulers.rulers", "value": "percent"})).unwrap();
+        assert!((snap_to_tick(&app, &xf, true, 37.0) - 38.4).abs() < 1e-9);
+        assert!((snap_to_tick(&app, &xf, false, 37.0) - 38.4).abs() < 1e-9);
+        // Ticks count from the zero point (#2955): a vertical guide follows the x origin only.
+        let mut app = new_app();
+        app.run("view.setRulerOrigin", json!({"x": 3, "y": 0})).unwrap();
+        assert_eq!(snap_to_tick(&app, &xf, true, 37.0), 33.0);
+        assert_eq!(snap_to_tick(&app, &xf, false, 37.0), 40.0);
+    }
 }
diff --git a/crates/ui-egui/src/save_identity_tests.rs b/crates/ui-egui/src/save_identity_tests.rs
index 1aed0fa5b7..c947afc9b6 100644
--- a/crates/ui-egui/src/save_identity_tests.rs
+++ b/crates/ui-egui/src/save_identity_tests.rs
@@ -204,3 +204,53 @@ fn image_previews_preference_reaches_the_exporter() {
         assert_eq!(*seen.borrow(), [expect; 3], "{value}");
     }
 }
+
+/// Preferences › File Handling › Maximize PSD and PSB File Compatibility reaches the exporter of
+/// Save As, Save and automation saves: Always and Ask When Saving keep the PSD's real merged
+/// image, Never doesn't.
+#[test]
+fn maximize_compatibility_preference_reaches_the_exporter() {
+    let seen = Rc::new(RefCell::new(Vec::new()));
+    let mut app = app();
+    let log = seen.clone();
+    app.services.export = Some(Box::new(move |_, _, settings: &ExportSettings| {
+        log.borrow_mut().push(settings.psd_maximize_compatibility);
+        Ok((b"out".to_vec(), Vec::new()))
+    }));
+    let ctx = egui::Context::default();
+    for (value, expect) in [("always", true), ("never", false), ("ask", true)] {
+        app.run("prefs.set", json!({"path": "fileHandling.maximizePsdCompatibility", "value": value})).unwrap();
+        seen.borrow_mut().clear();
+        menus::invoke(&mut app, &ctx, "file.saveAs", json!({"path": format!("{value}.psd")})).unwrap();
+        menus::invoke(&mut app, &ctx, "file.save", json!({})).unwrap();
+        app.save_automation(Some(format!("{value} agent.psd"))).unwrap();
+        assert_eq!(*seen.borrow(), [expect; 3], "{value}");
+    }
+}
+
+/// #2399: Save and Save As start at the opened file's own encoding: a JPEG's estimated quality,
+/// a WebP lossy (at its quality) or lossless; a new document keeps the codec defaults.
+#[test]
+fn save_settings_start_at_the_opened_files_encoding() {
+    use photocraft_codecs::{ChannelLayout, EncodeOptions, Format, Image, SampleType};
+    let px: Vec<u8> = (0..32u32 * 24).flat_map(|i| [(i * 3) as u8, (i / 32 * 9) as u8, (i % 97) as u8]).collect();
+    let img = Image::from_raw(32, 24, ChannelLayout::Rgb, SampleType::U8, px).unwrap();
+    let mut app = app();
+    assert_eq!(app.save_settings().jpeg_quality, None);
+    assert!(app.save_settings().webp_lossless);
+
+    let jpeg = photocraft_codecs::encode(&img, Format::Jpeg, &EncodeOptions { jpeg_quality: 65, ..Default::default() }).unwrap();
+    app.open_bytes("photo.jpg", &jpeg).unwrap();
+    let q = app.save_settings().jpeg_quality.unwrap();
+    assert!(q.abs_diff(65) <= 2, "estimated {q}");
+
+    let lossy = photocraft_codecs::encode(&img, Format::WebP, &EncodeOptions { webp_lossless: false, webp_quality: 80, ..Default::default() }).unwrap();
+    app.open_bytes("photo.webp", &lossy).unwrap();
+    let s = app.save_settings();
+    assert!(!s.webp_lossless);
+    assert!(s.webp_quality.unwrap().abs_diff(80) <= 2, "{:?}", s.webp_quality);
+
+    let lossless = photocraft_codecs::encode(&img, Format::WebP, &EncodeOptions::default()).unwrap();
+    app.open_bytes("art.webp", &lossless).unwrap();
+    assert!(app.save_settings().webp_lossless);
+}
diff --git a/crates/ui-egui/src/screen_picker.rs b/crates/ui-egui/src/screen_picker.rs
index 865f6537d1..944af8bff6 100644
--- a/crates/ui-egui/src/screen_picker.rs
+++ b/crates/ui-egui/src/screen_picker.rs
@@ -259,7 +259,9 @@ fn viewport_builder(ctx: &Context, image: &ScreenImage) -> egui::ViewportBuilder
         .with_resizable(false)
         .with_position(image.position / ctx.zoom_factor())
         .with_inner_size(image.size / ctx.zoom_factor())
-        .with_window_level(egui::WindowLevel::AlwaysOnTop)
+        // Not `AlwaysOnTop` here: a monitor-sized window created topmost makes the DX12 backend
+        // fail its swapchain creation (0x887A0001) and the app panics. The level is raised once
+        // the first frame has been painted, in `show`.
         // Do not expose the native window's empty first frame over the desktop.
         // The viewport is made visible after its snapshot has been painted below.
         .with_visible(false)
@@ -280,7 +282,10 @@ pub fn show(ctx: &Context) {
         let shared = r.clone();
         let vid = egui::ViewportId::from_hash_of(("screen-color", generation, n));
         let builder = viewport_builder(ctx, &image);
-        ctx.show_viewport_deferred(vid, builder, move |ui, _| {
+        // Immediate, so it paints inside the main window's own frame: as a deferred viewport the
+        // main window stopped being redrawn on Windows (OpenGL) once the picker was up, so a click
+        // or Esc was never turned into an answer and the overlay could not be left.
+        ctx.show_viewport_immediate(vid, builder, move |ui, _| {
             {
                 let s = lock(&shared);
                 if s.generation != generation || s.owner.is_none() {
@@ -288,55 +293,80 @@ pub fn show(ctx: &Context) {
                     return;
                 }
             }
-            if ui.ctx().input(|i| i.viewport().close_requested() || i.key_pressed(egui::Key::Escape)) {
-                lock(&shared).answer = Some(Ok(None));
-                ui.ctx().request_repaint_of(egui::ViewportId::ROOT);
-                return;
-            }
-            egui::CentralPanel::default().frame(egui::Frame::NONE).show(ui, |ui| {
-                let rect = ui.max_rect();
-                ui.painter().image(texture.id(), rect, Rect::from_min_max(Pos2::ZERO, egui::pos2(1.0, 1.0)), Color32::WHITE);
-                let response = ui.interact(rect, ui.id().with("screen-sample"), Sense::click());
-                ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);
-                let Some(pos) = ui.ctx().pointer_hover_pos() else {
-                    return;
-                };
-                let Some((x, y)) = image.at(rect, pos) else {
-                    return;
-                };
-                let zoom = {
-                    let delta = ui.input(|i| {
-                        i.raw
-                            .events
-                            .iter()
-                            .filter_map(|e| match e {
-                                egui::Event::MouseWheel { delta, .. } => Some(delta.y),
-                                _ => None,
-                            })
-                            .sum::<f32>()
-                    });
-                    let mut s = lock(&shared);
-                    if delta > 0.0 {
-                        s.zoom = (s.zoom + 2).min(24);
-                    }
-                    if delta < 0.0 {
-                        s.zoom = s.zoom.saturating_sub(2).max(4);
-                    }
-                    s.zoom
-                };
-                let picked = image.sample(x, y, conversion.as_deref());
-                loupe(ui, &image, rect, pos, (x, y), zoom, picked.as_ref().ok().copied());
-                if response.clicked() {
-                    lock(&shared).answer = Some(picked.map(Some));
-                    ui.ctx().request_repaint_of(egui::ViewportId::ROOT);
-                }
-            });
+            frame(ui, &shared, &image, &texture, conversion.as_deref());
             // Showing a new native viewport before this frame is painted can briefly cover
             // the screen with the window's default white clear color.
             ui.ctx().send_viewport_cmd(egui::ViewportCommand::Visible(true));
+            // Once per picker window (`show` runs every frame, so a local flag would resend it):
+            // raise it, and take the keyboard so Esc reaches the picker: a window shown later
+            // isn't always given focus by the OS, and the picker covers the screen (#4291).
+            let raised = Id::new(("screen-picker-raised", ui.ctx().viewport_id()));
+            if !ui.ctx().data_mut(|d| std::mem::replace(d.get_temp_mut_or_default::<bool>(raised), true)) {
+                ui.ctx().send_viewport_cmd(egui::ViewportCommand::WindowLevel(egui::WindowLevel::AlwaysOnTop));
+                ui.ctx().send_viewport_cmd(egui::ViewportCommand::Focus);
+            }
         });
     }
 }
+
+/// What the picker resolves to: the colour from a pick, or `Ok(None)` to cancel.
+type Answer = Result<Option<[f32; 3]>, String>;
+
+/// One frame of a picker window over its snapshot `image`. The picker covers the whole screen
+/// and stays on top, so every way out must work (#4291): Esc, closing the window, a right-click,
+/// and a left click (or a press and release that moved) anywhere, which picks the pixel under
+/// it, or cancels when there's none to sample. Nothing it gets leaves the user stuck in it.
+fn frame(ui: &mut egui::Ui, shared: &Shared, image: &ScreenImage, texture: &egui::TextureHandle, conversion: Option<&photocraft_cms::Transform>) {
+    let ctx = ui.ctx().clone();
+    let answer = |a: Answer| {
+        lock(shared).answer = Some(a);
+        ctx.request_repaint_of(egui::ViewportId::ROOT);
+    };
+    if ctx.input(|i| i.viewport().close_requested() || i.key_pressed(egui::Key::Escape) || i.pointer.secondary_released()) {
+        answer(Ok(None));
+        return;
+    }
+    egui::CentralPanel::default().frame(egui::Frame::NONE).show(ui, |ui| {
+        let rect = ui.max_rect();
+        ui.painter().image(texture.id(), rect, Rect::from_min_max(Pos2::ZERO, egui::pos2(1.0, 1.0)), Color32::WHITE);
+        let response = ui.interact(rect, ui.id().with("screen-sample"), Sense::click_and_drag());
+        ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);
+        let released = response.clicked() || response.drag_stopped();
+        let pixel = ui.ctx().pointer_latest_pos().and_then(|pos| Some((pos, image.at(rect, pos)?)));
+        let Some((pos, (x, y))) = pixel else {
+            // No pixel under the pointer to sample: a click still ends the picker.
+            if released {
+                answer(Ok(None));
+            }
+            return;
+        };
+        let zoom = {
+            let delta = ui.input(|i| {
+                i.raw
+                    .events
+                    .iter()
+                    .filter_map(|e| match e {
+                        egui::Event::MouseWheel { delta, .. } => Some(delta.y),
+                        _ => None,
+                    })
+                    .sum::<f32>()
+            });
+            let mut s = lock(shared);
+            if delta > 0.0 {
+                s.zoom = (s.zoom + 2).min(24);
+            }
+            if delta < 0.0 {
+                s.zoom = s.zoom.saturating_sub(2).max(4);
+            }
+            s.zoom
+        };
+        let picked = image.sample(x, y, conversion);
+        loupe(ui, image, rect, pos, (x, y), zoom, picked.as_ref().ok().copied());
+        if released {
+            answer(picked.map(Some));
+        }
+    });
+}
 fn loupe(ui: &egui::Ui, image: &ScreenImage, screen: Rect, pos: Pos2, pixel: (usize, usize), zoom: usize, rgb: Option<[f32; 3]>) {
     let (x, y) = pixel;
     let t = crate::theme::Tokens::get(ui.ctx());
@@ -393,6 +423,12 @@ mod tests {
         assert_eq!(builder.visible, Some(false));
     }
     #[test]
+    fn screen_picker_viewport_is_not_created_always_on_top() {
+        // Creating the monitor-sized window topmost fails DX12 swapchain creation (Windows).
+        let builder = viewport_builder(&Context::default(), &image());
+        assert_eq!(builder.window_level, None);
+    }
+    #[test]
     fn pixel_mapping_handles_display_edges_negative_origins_and_hidpi() {
         let i = image();
         let rect = Rect::from_min_size(i.position, i.size);
@@ -421,6 +457,67 @@ mod tests {
         i.profile = Some(photocraft_cms::Builtin::LabD50.profile().to_bytes().as_ref().clone());
         assert!(i.conversion().is_err());
     }
+    /// The picker window's frame over [`image`] (red | azure) filling a 200 × 100 window, with its
+    /// own runtime: what the frame answered after `act`.
+    fn picker_answer(act: impl FnOnce(&mut egui_kittest::Harness<'_>)) -> Option<Answer> {
+        let shared: Shared = Arc::default();
+        let inner = shared.clone();
+        let texture: std::cell::OnceCell<egui::TextureHandle> = std::cell::OnceCell::new();
+        let image = image();
+        let mut h = egui_kittest::Harness::builder().with_size(vec2(200.0, 100.0)).build_ui(move |ui| {
+            let tex = texture.get_or_init(|| {
+                ui.ctx().load_texture("test-snapshot", egui::ColorImage::new([2, 1], vec![Color32::RED, Color32::BLUE]), TextureOptions::NEAREST)
+            });
+            frame(ui, &inner, &image, tex, None);
+        });
+        h.run();
+        act(&mut h);
+        h.run();
+        lock(&shared).answer.take()
+    }
+    /// #4291: the picker covers the screen and stays on top, so every input ends it: Esc, a
+    /// right-click, a click (the pixel under it), a press dragged before its release (the pixel
+    /// where it's released).
+    #[test]
+    fn every_way_out_of_the_picker_ends_it() {
+        let left = egui::pos2(40.0, 50.0);
+        let right = egui::pos2(160.0, 50.0);
+        assert_eq!(picker_answer(|h| h.hover_at(left)), None, "hovering alone keeps it open");
+        assert_eq!(
+            picker_answer(|h| {
+                h.hover_at(left);
+                h.run();
+                h.drag_at(left);
+                h.run();
+                h.drop_at(left);
+            }),
+            Some(Ok(Some([1.0, 0.0, 0.0]))),
+            "a click picks the pixel under it"
+        );
+        assert_eq!(
+            picker_answer(|h| {
+                h.drag_at(left);
+                h.run();
+                h.hover_at(right);
+                h.run();
+                h.drop_at(right);
+            }),
+            Some(Ok(Some([0.0, 128.0 / 255.0, 1.0]))),
+            "a press dragged across picks where it's released, instead of being ignored"
+        );
+        assert_eq!(
+            picker_answer(|h| {
+                h.hover_at(left);
+                h.run();
+                h.event(egui::Event::PointerButton { pos: left, button: egui::PointerButton::Secondary, pressed: true, modifiers: Default::default() });
+                h.run();
+                h.event(egui::Event::PointerButton { pos: left, button: egui::PointerButton::Secondary, pressed: false, modifiers: Default::default() });
+            }),
+            Some(Ok(None)),
+            "a right-click cancels"
+        );
+        assert_eq!(picker_answer(|h| h.key_press(egui::Key::Escape)), Some(Ok(None)), "Esc cancels");
+    }
     fn app() -> PhotocraftApp {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
         app.run("file.new", serde_json::json!({"width":8,"height":8})).unwrap();
diff --git a/crates/ui-egui/src/scrollbars.rs b/crates/ui-egui/src/scrollbars.rs
index 2ab7cdeab6..e0867436c4 100644
--- a/crates/ui-egui/src/scrollbars.rs
+++ b/crates/ui-egui/src/scrollbars.rs
@@ -90,14 +90,40 @@ pub fn clamp_axis(center: f32, len: f32, size: f32, zoom: f32) -> f32 {
 /// Apply Preferences › Tools › Overscroll (off) to `view` for a canvas of `size` points on a
 /// display with `ppp` physical pixels per point. True when the view moved (then repaint).
 pub fn clamp_view(view: &mut View, size: egui::Vec2, ppp: f32) -> bool {
+    clamp_view_with_aspect(view, size, ppp, 1.0)
+}
+
+/// Clamp against the displayed image bounds, so rotated tool auto-scroll is not undone by
+/// the next frame's Overscroll-off clamp. `size` is the unmodified screen-space canvas size.
+pub fn clamp_view_with_aspect(view: &mut View, size: egui::Vec2, ppp: f32, aspect: f32) -> bool {
     let [w, h] = view.doc_size;
     if w == 0 || h == 0 {
         return false;
     }
     let zoom = view.zoom / if ppp.is_finite() && ppp > 0.0 { ppp } else { 1.0 };
-    let c = [clamp_axis(view.center[0], w as f32, size.x, zoom), clamp_axis(view.center[1], h as f32, size.y, zoom)];
+    let aspect = if aspect.is_finite() && aspect > 0.0 { aspect } else { 1.0 };
+    let c = if view.rotation.abs() < 1e-8 {
+        [clamp_axis(view.center[0], w as f32, size.x / aspect, zoom), clamp_axis(view.center[1], h as f32, size.y, zoom)]
+    } else {
+        if !zoom.is_finite() || zoom <= 0.0 || !size.is_finite() || size.x <= 0.0 || size.y <= 0.0 {
+            return false;
+        }
+        let center = [
+            if view.center[0].is_finite() { view.center[0] } else { w as f32 / 2.0 },
+            if view.center[1].is_finite() { view.center[1] } else { h as f32 / 2.0 },
+        ];
+        let xf = crate::canvas::ViewXform { rect: egui::Rect::from_min_size(Pos2::ZERO, size), zoom, center, flip: false, rotation: view.rotation, aspect };
+        let image = xf.image_bounds(view.doc_size);
+        if !image.is_finite() {
+            return false;
+        }
+        let offset = xf.rect.center() - image.min;
+        let delta = vec2(clamp_axis(offset.x, image.width(), size.x, 1.0), clamp_axis(offset.y, image.height(), size.y, 1.0)) - offset;
+        let d = xf.unmap_vec(delta) / zoom;
+        [center[0] + d.x, center[1] + d.y]
+    };
     // Ignore sub-pixel float noise so the clamp never keeps requesting frames.
-    let moved = (c[0] - view.center[0]).abs() > 1e-3 || (c[1] - view.center[1]).abs() > 1e-3;
+    let moved = !view.center[0].is_finite() || !view.center[1].is_finite() || (c[0] - view.center[0]).abs() > 1e-3 || (c[1] - view.center[1]).abs() > 1e-3;
     if moved {
         view.center = c;
     }
diff --git a/crates/ui-egui/src/scrub_wrap.rs b/crates/ui-egui/src/scrub_wrap.rs
new file mode 100644
index 0000000000..a188caa760
--- /dev/null
+++ b/crates/ui-egui/src/scrub_wrap.rs
@@ -0,0 +1,96 @@
+//! Fullscreen status-bar scrubbing, with absolute cursor-warp movement removed from the value.
+
+use egui::{Pos2, Rect, Response, Ui, Vec2};
+
+#[derive(Clone, Copy)]
+struct Scrub {
+    precise: f64,
+    pending: Option<(Pos2, Pos2)>,
+}
+
+pub(crate) fn active(ui: &Ui) -> bool {
+    !cfg!(target_arch = "wasm32") && ui.input(|i| i.focused && i.viewport().fullscreen == Some(true) && !i.any_touches())
+}
+
+fn wrap_target(pos: Pos2, viewport: Rect) -> Option<Pos2> {
+    if !viewport.is_finite() || viewport.width() < 32.0 || !pos.is_finite() || pos.y < viewport.top() || pos.y > viewport.bottom() {
+        return None;
+    }
+    if pos.x <= viewport.left() + 1.0 {
+        Some(Pos2::new(viewport.right() - 3.0, pos.y))
+    } else if pos.x >= viewport.right() - 1.0 {
+        Some(Pos2::new(viewport.left() + 3.0, pos.y))
+    } else {
+        None
+    }
+}
+
+fn unwarped(delta: Vec2, pos: Pos2, pending: &mut Option<(Pos2, Pos2)>) -> Vec2 {
+    if let Some((from, to)) = *pending {
+        let middle = (from.x + to.x) / 2.0;
+        if (to.x > from.x && pos.x > middle) || (to.x < from.x && pos.x < middle) {
+            *pending = None;
+            return delta - (to - from);
+        }
+    }
+    delta
+}
+
+pub(crate) fn update(ui: &Ui, resp: &Response, value: &mut f32, before: f32, range: std::ops::RangeInclusive<f32>, speed: f64, wrapping: bool) {
+    let key = resp.id.with("wrapped-scrub");
+    if !wrapping || !resp.dragged_by(egui::PointerButton::Primary) || !ui.input(|i| i.pointer.primary_down()) {
+        ui.data_mut(|d| d.remove::<Scrub>(key));
+        return;
+    }
+    let (pos, delta, viewport, slow, aim) = ui.input(|i| (i.pointer.latest_pos(), i.pointer.delta(), i.viewport_rect(), i.modifiers.shift, i.aim_radius()));
+    let Some(pos) = pos else { return };
+    let mut scrub = ui.data(|d| d.get_temp::<Scrub>(key)).unwrap_or(Scrub { precise: f64::from(before), pending: None });
+    let delta = unwarped(delta, pos, &mut scrub.pending);
+    let speed = if slow { speed / 10.0 } else { speed };
+    let change = f64::from(delta.x - delta.y) * speed;
+    let (lo, hi) = (f64::from(*range.start()), f64::from(*range.end()));
+    if change.is_finite() && change != 0.0 && lo <= hi {
+        scrub.precise = (scrub.precise + change).clamp(lo, hi);
+        let aim = f64::from(aim) * speed;
+        let rounded = egui::emath::smart_aim::best_in_range_f64(scrub.precise - aim, scrub.precise + aim);
+        *value = egui::emath::round_to_decimals(rounded, 3).clamp(lo, hi) as f32;
+    }
+    if scrub.pending.is_none()
+        && let Some(to) = wrap_target(pos, viewport)
+    {
+        ui.ctx().send_viewport_cmd(egui::ViewportCommand::CursorPosition(to));
+        scrub.pending = Some((pos, to));
+        ui.ctx().request_repaint();
+    }
+    ui.ctx().accesskit_node_builder(resp.id, |node| node.set_numeric_value_step(speed));
+    ui.data_mut(|d| d.insert_temp(key, scrub));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use egui::{pos2, vec2};
+
+    #[test]
+    fn warp_preserves_real_motion_in_the_acknowledgement_frame() {
+        for (from, to, motion) in [(pos2(0.5, 600.0), pos2(997.0, 600.0), vec2(-8.0, 2.0)), (pos2(999.5, 600.0), pos2(3.0, 600.0), vec2(8.0, -2.0))] {
+            let mut pending = Some((from, to));
+            assert_eq!(unwarped(Vec2::ZERO, from, &mut pending), Vec2::ZERO, "wait for an actual warp acknowledgement");
+            assert!(pending.is_some());
+            assert_eq!(unwarped(to - from + motion, to + motion, &mut pending), motion);
+            assert!(pending.is_none());
+            assert_eq!(unwarped(motion, to + motion * 2.0, &mut pending), motion, "ordinary movement after the warp");
+        }
+    }
+
+    #[test]
+    fn warp_uses_logical_viewport_edges_even_when_motion_crosses_the_edge() {
+        let rect = Rect::from_min_size(pos2(20.0, 30.0), vec2(800.0, 600.0));
+        assert_eq!(wrap_target(pos2(20.5, 500.0), rect), Some(pos2(817.0, 500.0)));
+        assert_eq!(wrap_target(pos2(819.5, 500.0), rect), Some(pos2(23.0, 500.0)));
+        assert_eq!(wrap_target(pos2(19.0, 500.0), rect), Some(pos2(817.0, 500.0)));
+        assert_eq!(wrap_target(pos2(20.5, 631.0), rect), None);
+        assert_eq!(wrap_target(rect.center(), rect), None);
+        assert_eq!(wrap_target(pos2(0.5, 10.0), Rect::from_min_size(Pos2::ZERO, vec2(8.0, 20.0))), None);
+    }
+}
diff --git a/crates/ui-egui/src/shape_dialog_tests.rs b/crates/ui-egui/src/shape_dialog_tests.rs
index fde2cf78c7..a0b5c61596 100644
--- a/crates/ui-egui/src/shape_dialog_tests.rs
+++ b/crates/ui-egui/src/shape_dialog_tests.rs
@@ -141,6 +141,20 @@ fn click_slop_scales_with_zoom() {
     assert!(is_click([10.0, 10.0], &[], 0.0));
 }
 
+/// #4205: the click slop is in screen points, so on a 2x (HiDPI) display at 100 % a 2 pt jitter
+/// (4 device px = 4 document px) is still a click that opens Create Rectangle, not a tiny shape.
+#[test]
+fn a_click_with_jitter_opens_the_dialog_on_hidpi() {
+    let mut app = app();
+    app.ppp = 2.0;
+    let i = app.session.active_index().unwrap();
+    app.ui.views[i].zoom = 1.0;
+    let before = layers(&app);
+    press(&mut app, Tool::Rectangle, [20.0, 30.0], [24.0, 30.0]);
+    only_dialog(&app);
+    assert_eq!(layers(&app), before, "a jittery click draws nothing");
+}
+
 #[test]
 fn cancel_draws_nothing_and_ok_remembers_the_size() {
     let mut app = app();
diff --git a/crates/ui-egui/src/shortcut_capture_tests.rs b/crates/ui-egui/src/shortcut_capture_tests.rs
index d02b9e6528..d68ae57d92 100644
--- a/crates/ui-egui/src/shortcut_capture_tests.rs
+++ b/crates/ui-egui/src/shortcut_capture_tests.rs
@@ -32,6 +32,94 @@ fn field(h: &Harness<'_, PhotocraftApp>, id: u64, name: &str) -> Value {
     h.state().ui.dialogs.iter().find(|d| d.id == id).unwrap().fields.get(name).cloned().unwrap_or(Value::Null)
 }
 
+#[test]
+fn toolbar_shortcut_can_be_captured_and_restored_on_restart() {
+    let (mut h, id) = dialog(1.0, "tools.select.pencil", "Pencil Tool");
+    h.get_by_role_and_label(egui::accesskit::Role::Button, "B").click();
+    h.run_steps(2);
+    h.key_press(Key::F6);
+    h.run_steps(2);
+    assert_eq!(field(&h, id, "overrides")["tools.select.pencil"], json!("F6"));
+    crate::dialogs::confirm(h.state_mut(), id).unwrap();
+    h.run_steps(2);
+    h.key_press(Key::F6);
+    h.run_steps(2);
+    assert_eq!(h.state().ui.tool, crate::state::Tool::Pencil);
+
+    let saved = h.state().session.prefs_to_json();
+    let mut session = photocraft_engine::Session::new();
+    session.load_prefs_json(&saved).unwrap();
+    let mut restarted = PhotocraftApp::new(session, crate::Services::default());
+    let ctx = egui::Context::default();
+    ctx.begin_pass(egui::RawInput {
+        events: vec![Event::Key { key: Key::F6, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }],
+        ..Default::default()
+    });
+    crate::shortcuts::handle(&mut restarted, &ctx);
+    ctx.end_pass().textures_delta.clear();
+    assert_eq!(restarted.ui.tool, crate::state::Tool::Pencil);
+}
+
+#[test]
+fn toolbar_shortcut_overrides_remove_old_keys_and_skip_removed_group_members() {
+    use crate::state::Tool;
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    let ctx = egui::Context::default();
+    let press = |app: &mut PhotocraftApp, key, modifiers| {
+        ctx.begin_pass(egui::RawInput {
+            // A tap: press and release, so the next press isn't a held key's repeat.
+            events: vec![
+                Event::ModifiersChanged(modifiers),
+                Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers },
+                Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers },
+            ],
+            ..Default::default()
+        });
+        crate::shortcuts::handle(app, &ctx);
+        ctx.end_pass().textures_delta.clear();
+    };
+    app.run("edit.keyboardShortcuts", json!({"set": {"tools.select.move": "F6", "tools.select.pencil": ""}, "allowUnknown": true})).unwrap();
+    app.ui.tool = Tool::Zoom;
+    press(&mut app, Key::V, Modifiers::NONE);
+    assert_eq!(app.ui.tool, Tool::Artboard, "the old key only selects unchanged tools");
+    press(&mut app, Key::F6, Modifiers::NONE);
+    assert_eq!(app.ui.tool, Tool::Move);
+
+    app.ui.tool = Tool::Pencil;
+    press(&mut app, Key::V, Modifiers::NONE);
+    press(&mut app, Key::B, Modifiers::NONE);
+    assert_eq!(app.ui.tool, Tool::Brush, "a removed tool cannot return through group memory");
+    press(&mut app, Key::B, Modifiers::SHIFT);
+    assert_eq!(app.ui.tool, Tool::MixerBrush, "Shift cycling skips a removed tool");
+
+    app.run("edit.keyboardShortcuts", json!({"reset": true})).unwrap();
+    app.ui.tool = Tool::Brush;
+    press(&mut app, Key::B, Modifiers::SHIFT);
+    assert_eq!(app.ui.tool, Tool::Pencil, "reset restores the default group");
+    app.session.edit_prefs(|p| p.tools.use_shift_key_for_tool_switch = false);
+    press(&mut app, Key::B, Modifiers::NONE);
+    assert_eq!(app.ui.tool, Tool::MixerBrush, "plain-key cycling still follows the preference");
+}
+
+#[test]
+fn toolbar_shortcuts_participate_in_conflict_resolution() {
+    let (mut h, id) = dialog(1.0, "edit.search", "search…");
+    capture(&mut h, &crate::shortcuts::pretty("Cmd+F"), Key::ControlLeft, Modifiers::COMMAND, Key::B);
+    // Remove Ctrl from the captured binding: a plain B belongs to the Brush group by default.
+    h.state_mut().ui.dialog_mut(id).unwrap().fields["overrides"]["edit.search"] = json!("B");
+    crate::dialogs::confirm(h.state_mut(), id).unwrap();
+    for tool in ["brush", "pencil", "mixerBrush", "colorReplacement"] {
+        assert_eq!(h.state().session.prefs().shortcuts.get(&format!("tools.select.{tool}")).map(String::as_str), Some(""));
+    }
+    let ctx = h.ctx.clone();
+    h.state_mut().ui.tool = crate::state::Tool::Move;
+    key(&mut h, Key::B, true, Modifiers::NONE);
+    h.run_steps(2);
+    assert!(h.state().ui.palette_open, "B now runs Search");
+    assert_eq!(h.state().ui.tool, crate::state::Tool::Move);
+    assert_eq!(crate::shortcut_dispatch::take_log(&ctx).last().map(|i| i.0.as_str()), Some("edit.search"));
+}
+
 /// Click the selected command's shortcut button, then press `modifier` and `k` like a keyboard:
 /// the modifier key goes down first (its own key event), then the key with the modifier held.
 fn capture(h: &mut Harness<'_, PhotocraftApp>, button: &str, modifier: Key, held: Modifiers, k: Key) {
diff --git a/crates/ui-egui/src/shortcut_dispatch.rs b/crates/ui-egui/src/shortcut_dispatch.rs
index b4bb1b2dc3..0a64437214 100644
--- a/crates/ui-egui/src/shortcut_dispatch.rs
+++ b/crates/ui-egui/src/shortcut_dispatch.rs
@@ -241,7 +241,7 @@ pub fn dispatch_pressed(app: &mut PhotocraftApp, ctx: &egui::Context, focus: Foc
             // panels instead, #1313): the shortcut took it, so cancel that move.
             ctx.memory_mut(|m| m.move_focus(egui::FocusDirection::None));
         }
-        let id = delete_key_command(app, id);
+        let id = clip_key_command(app, delete_key_command(app, id));
         let owner = key_owner(app, ctx);
         dispatch(app, ctx, &id);
         ran = true;
@@ -257,7 +257,8 @@ pub fn dispatch_pressed(app: &mut PhotocraftApp, ctx: &egui::Context, focus: Foc
 /// type or shape layer the key did nothing. A selection, a single channel or Quick Mask keeps Clear.
 /// With the active layer's mask targeted the key edits the mask, never the layer's pixels: a
 /// selection is filled with the background colour in the mask (Photoshop's Delete on a mask), and
-/// with no selection the mask itself is deleted, as Layer › Layer Mask › Delete.
+/// with no selection the mask itself is deleted, as Layer › Layer Mask › Delete, unless several
+/// layers are selected: then they are deleted.
 fn delete_key_command(app: &PhotocraftApp, id: String) -> String {
     if id != "edit.clear" {
         return id;
@@ -270,7 +271,10 @@ fn delete_key_command(app: &PhotocraftApp, id: String) -> String {
     let solo_mask = colors_off && has_mask && !alpha_on && st.doc.quick_mask.is_none();
     let layer_mask = st.channel_view.target == photocraft_engine::channel_cmds::ChannelTarget::LayerMask;
     let mask = (app.ui.mask_target || solo_mask || layer_mask) && has_mask;
-    if mask && (composite || layer_mask) {
+    // Several selected layers outrank the active one's targeted mask (#4025): a new adjustment
+    // layer targets its mask, so the first press used to delete only that mask.
+    let several = st.selected_layers().len() > 1;
+    if mask && (composite || layer_mask) && !(several && composite && st.doc.selection.is_none()) {
         let cmd = if st.doc.selection.is_some() { "edit.fillBackground" } else { "layer.layerMask.delete" };
         return cmd.into();
     }
@@ -280,6 +284,26 @@ fn delete_key_command(app: &PhotocraftApp, id: String) -> String {
     "layer.delete".into()
 }
 
+/// Create Clipping Mask's key (⌥⌘G) releases when there is nothing left to clip, as in Photoshop,
+/// whose Layer menu has one item that reads Create or Release Clipping Mask with the same
+/// shortcut: pressing it again takes the clip off. That is when the layers Create Clipping Mask
+/// would clip are all clipped already: the selected layer, or with several selected, every one
+/// above the lowest.
+pub(crate) fn clip_key_releases(app: &PhotocraftApp) -> bool {
+    let Some(st) = app.session.active() else { return false };
+    let selected = st.selected_layers();
+    let clips = match selected.as_slice() {
+        [] => return false,
+        [one] => std::slice::from_ref(one),
+        [_lowest, above @ ..] => above,
+    };
+    clips.iter().all(|id| st.doc.layer(*id).is_some_and(|l| l.clipped))
+}
+
+fn clip_key_command(app: &PhotocraftApp, id: String) -> String {
+    if id == "layer.createClippingMask" && clip_key_releases(app) { "layer.releaseClippingMask".into() } else { id }
+}
+
 /// Why `id` can't run now (the engine's reason when it has one).
 pub fn disabled_reason(app: &PhotocraftApp, id: &str) -> String {
     photocraft_engine::commands::find(id).and_then(|_| app.session.disabled_reason_with(id, &app.with_mask_target(id, serde_json::Value::Null))).unwrap_or_else(
@@ -298,6 +322,7 @@ fn label(id: &str) -> String {
         .map(|c| c.1)
         .or_else(|| crate::menus::UI_COMMANDS.iter().find(|c| c.0 == id).map(|c| c.1))
         .or_else(|| photocraft_engine::commands::find(id).map(|c| c.label))
+        .or_else(|| crate::tool_shortcuts::tool(id).map(|tool| tool.label()))
         .unwrap_or(id)
         .trim_end_matches('…')
         .to_string()
diff --git a/crates/ui-egui/src/shortcut_dispatch/tests.rs b/crates/ui-egui/src/shortcut_dispatch/tests.rs
index 9174da3ee9..458f22c050 100644
--- a/crates/ui-egui/src/shortcut_dispatch/tests.rs
+++ b/crates/ui-egui/src/shortcut_dispatch/tests.rs
@@ -135,9 +135,13 @@ fn put_focus(h: &mut Harness<'_, PhotocraftApp>, place: Place) {
 }
 
 /// Is `bound` the same action as the menu item `shown`? (Window › Layers is `window.panel.layers`
-/// in the catalogue and `window.toggle.layers` in the shell.)
+/// in the catalogue and `window.toggle.layers` in the shell; Release Clipping Mask shows Create
+/// Clipping Mask's key, which releases while it reads so.)
 fn same(shown: &str, bound: &str) -> bool {
-    shown == bound || crate::menus::panel_alias(shown) == Some(bound) || crate::menus::panel_alias(bound) == Some(shown)
+    shown == bound
+        || crate::menus::panel_alias(shown) == Some(bound)
+        || crate::menus::panel_alias(bound) == Some(shown)
+        || (shown == "layer.releaseClippingMask" && bound == "layer.createClippingMask")
 }
 
 /// Every shortcut shown in the menus (and the shell's unlisted ones), with whether it is live.
@@ -524,6 +528,36 @@ fn delete_without_a_selection_deletes_every_selected_layer() {
     assert_eq!(names(&h).len(), n - 2);
 }
 
+/// #4025: with several layers selected and no selection, a targeted mask on the active one doesn't
+/// take the key: Delete removes the selected layers in one press, as it does with the layer
+/// targeted. A selection still fills the targeted mask.
+#[test]
+fn delete_with_several_layers_selected_deletes_them_even_with_the_mask_targeted() {
+    let mut h = harness();
+    put_focus(&mut h, Place::Canvas);
+    let s = &mut h.state_mut().session;
+    let first = photocraft_doc::LayerId(s.execute("layer.newAdjustmentLayer.curves", json!({})).unwrap()["layer"].as_u64().unwrap());
+    let second = photocraft_doc::LayerId(s.execute("layer.newAdjustmentLayer.invert", json!({})).unwrap()["layer"].as_u64().unwrap());
+    s.execute("layer.select", json!({"layer": first.0, "mode": "add"})).unwrap();
+    let st = s.active().unwrap();
+    assert_eq!(st.selected_layers().len(), 2);
+    assert!(st.active_layer.and_then(|l| st.doc.layer(l)).is_some_and(|l| l.mask.is_some()), "the active adjustment layer has a mask");
+    assert!(st.doc.selection.is_some(), "the harness keeps a selection");
+    h.state_mut().ui.mask_target = true;
+    h.run_steps(2);
+    let n = names(&h).len();
+    press(&mut h, "Delete");
+    assert_eq!(logged(&h), ["edit.fillBackground"], "a selection edits the mask");
+    assert_eq!(names(&h).len(), n);
+    h.state_mut().session.execute("select.deselect", json!({})).unwrap();
+    h.run_steps(2);
+    press(&mut h, "Delete");
+    assert_eq!(logged(&h), ["layer.delete"]);
+    let doc = &h.state().session.active().unwrap().doc;
+    assert!(doc.layer(first).is_none() && doc.layer(second).is_none(), "both selected layers are gone");
+    assert_eq!(names(&h).len(), n - 2);
+}
+
 /// A selection keeps Edit › Clear: the selected pixels go, the layer stays.
 #[test]
 fn delete_with_a_selection_clears_it() {
@@ -536,6 +570,65 @@ fn delete_with_a_selection_clears_it() {
     assert_eq!(names(&h), before, "no layer was deleted");
 }
 
+fn is_clipped(h: &Harness<'_, PhotocraftApp>, id: photocraft_doc::LayerId) -> bool {
+    h.state().session.active().unwrap().doc.layer(id).unwrap().clipped
+}
+
+/// The Layer menu's clipping mask items: (id, label, shortcut, enabled).
+fn clip_items(h: &Harness<'_, PhotocraftApp>) -> Vec<(String, String, Option<String>, bool)> {
+    crate::menus::menu_items(h.state()).into_iter().filter(|i| i.id.ends_with("ClippingMask")).map(|i| (i.id, i.label, i.shortcut, i.enabled)).collect()
+}
+
+fn clip_item(id: &str, label: &str) -> Vec<(String, String, Option<String>, bool)> {
+    vec![(id.into(), label.into(), Some("Cmd+Alt+G".into()), true)]
+}
+
+/// ⌥⌘G clips the selected layer and pressing it again releases it, as Photoshop's one Create /
+/// Release Clipping Mask item does; the Layer menu reads Release Clipping Mask, with the same
+/// shortcut, while the key would release.
+#[test]
+fn clip_key_toggles_the_clipping_mask() {
+    let mut h = harness();
+    put_focus(&mut h, Place::Canvas);
+    let paint = h.state().session.active().unwrap().active_layer.unwrap();
+    assert_eq!(clip_items(&h), clip_item("layer.createClippingMask", "Create Clipping Mask"));
+    press(&mut h, "Cmd+Alt+G");
+    assert_eq!(logged(&h), ["layer.createClippingMask"]);
+    assert!(is_clipped(&h, paint));
+    assert_eq!(clip_items(&h), clip_item("layer.releaseClippingMask", "Release Clipping Mask"));
+    press(&mut h, "Cmd+Alt+G");
+    assert_eq!(logged(&h), ["layer.releaseClippingMask"]);
+    assert!(!is_clipped(&h, paint), "the second press releases it");
+    assert_eq!(clip_items(&h), clip_item("layer.createClippingMask", "Create Clipping Mask"));
+    press(&mut h, "Cmd+Z");
+    assert!(is_clipped(&h, paint), "one undo puts the clip back");
+}
+
+/// With several layers selected the key clips every one above the lowest, and releases them once
+/// they all are: a selection where only some are clipped clips the rest first.
+#[test]
+fn clip_key_toggles_several_selected_layers() {
+    let mut h = harness();
+    put_focus(&mut h, Place::Canvas);
+    let s = &mut h.state_mut().session;
+    let paint = s.active().unwrap().active_layer.unwrap();
+    let base = s.active().unwrap().doc.walk().into_iter().find(|(_, _, l)| l.name == "Hello").unwrap().2.id;
+    let top = photocraft_doc::LayerId(s.execute("layer.new.layer", json!({"name": "top"})).unwrap()["layer"].as_u64().unwrap());
+    s.execute("layer.createClippingMask", json!({"layer": paint.0})).unwrap();
+    s.execute("layer.select", json!({"layer": base.0, "mode": "replace"})).unwrap();
+    for id in [paint, top] {
+        s.execute("layer.select", json!({"layer": id.0, "mode": "add"})).unwrap();
+    }
+    assert_eq!(s.active().unwrap().selected_layers().len(), 3);
+    h.run_steps(2);
+    press(&mut h, "Cmd+Alt+G");
+    assert_eq!(logged(&h), ["layer.createClippingMask"], "the top layer isn't clipped yet");
+    assert!(is_clipped(&h, paint) && is_clipped(&h, top) && !is_clipped(&h, base));
+    press(&mut h, "Cmd+Alt+G");
+    assert_eq!(logged(&h), ["layer.releaseClippingMask"]);
+    assert!(!is_clipped(&h, paint) && !is_clipped(&h, top) && !is_clipped(&h, base));
+}
+
 #[test]
 fn named_action_function_key_replays_and_survives_preferences_roundtrip() {
     let mut h = harness();
@@ -543,6 +636,7 @@ fn named_action_function_key_replays_and_survives_preferences_roundtrip() {
         name: "LivePrint 2R".into(),
         steps: vec![("layer.new.layer".into(), json!({"name": "F6 overlay"}))],
         disabled: Default::default(),
+        ..Default::default()
     };
     h.state_mut().session.actions.list.push(action);
     crate::actions::assign_shortcut(h.state_mut(), "LivePrint 2R", "F6").unwrap();
@@ -568,6 +662,7 @@ fn assigning_action_function_key_moves_it_and_reports_failed_steps() {
             name: name.into(),
             steps: vec![("no.such.command".into(), json!({}))],
             disabled: Default::default(),
+            ..Default::default()
         });
     }
     crate::actions::assign_shortcut(h.state_mut(), "first", "F6").unwrap();
@@ -587,6 +682,7 @@ fn action_function_key_checks_automation_authorization() {
         name: "restricted".into(),
         steps: vec![("layer.new.layer".into(), json!({"name": "should not exist"}))],
         disabled: Default::default(),
+        ..Default::default()
     });
     crate::actions::assign_shortcut(h.state_mut(), "restricted", "F6").unwrap();
     h.state_mut().services.automation_command = Some(Box::new(|id, _| if id == "actions.play" { Err("denied action playback".into()) } else { Ok(()) }));
@@ -624,6 +720,7 @@ fn f6_while_recording_records_a_named_call_not_the_child_steps() {
         name: "LivePrint 2R".into(),
         steps: vec![("layer.new.layer".into(), json!({"name":"Nested overlay"})), ("view.fitOnScreen".into(), json!({}))],
         disabled: Default::default(),
+        ..Default::default()
     });
     crate::actions::assign_shortcut(h.state_mut(), "LivePrint 2R", "F6").unwrap();
     h.state_mut().run("actions.record", json!({"name":"Action 2"})).unwrap();
diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rs
index 00280102bc..bd3b1fe00c 100644
--- a/crates/ui-egui/src/shortcuts.rs
+++ b/crates/ui-egui/src/shortcuts.rs
@@ -108,6 +108,7 @@ pub fn default_shortcut(id: &str) -> Option<String> {
         .or_else(|| crate::menu_catalog::CATALOG.iter().find(|c| c.3 == id).and_then(|c| c.2))
         .or_else(|| photocraft_engine::prefs::TEMPORARY_TOOLS.iter().find(|t| t.0 == id).map(|t| t.2))
         .map(str::to_string)
+        .or_else(|| crate::tool_shortcuts::tool(id).and_then(crate::tool_shortcuts::default))
 }
 
 /// With ⇧ held the OS reports the shifted character as the logical key (US layout): ⇧; is `:`.
@@ -161,6 +162,31 @@ pub fn consume(ctx: &egui::Context, sc: &KeyboardShortcut) -> bool {
 pub const NAV_COMMANDS: [&str; 4] = ["view.zoomIn", "view.zoomOut", "view.fitOnScreen", "view.actualPixels"];
 
 /// ⌘+ / ⌘- / ⌘0 / ⌘1 (or their Edit › Keyboard Shortcuts overrides). Returns true when one ran.
+/// Layer › New › Layer's shortcut with ⌥ added (⌥⇧⌘N by default) makes the layer at once, as in
+/// Photoshop: the plain shortcut asks with the New Layer dialog first, like the menu item, and
+/// the Layers panel button's click and ⌥-click are the same pair the other way round (#4794).
+/// A command bound to that key itself keeps it.
+fn new_layer_without_dialog(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
+    const NEW_LAYER: &str = crate::new_layer_ui::COMMAND;
+    let Some(mut sc) = effective_shortcut(app, NEW_LAYER, default_shortcut(NEW_LAYER).as_deref()).and_then(|s| parse(&s)) else {
+        return false;
+    };
+    if sc.modifiers.alt {
+        return false;
+    }
+    sc.modifiers.alt = true;
+    let pressed =
+        ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Key { key, pressed: true, modifiers, .. } if key_matches(&sc, *key, *modifiers))));
+    if !pressed || crate::shortcut_dispatch::bindings(app).iter().any(|(_, b)| *b == sc) || !consume(ctx, &sc) {
+        return false;
+    }
+    if let Err(e) = app.run(NEW_LAYER, json!({})) {
+        app.ui.status = e;
+        app.ui.status_error = true;
+    }
+    true
+}
+
 fn nav_keys(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
     for id in NAV_COMMANDS {
         let sc = crate::menus::UI_COMMANDS.iter().find(|c| c.0 == id).and_then(|c| parse(app.session.prefs().shortcut(id, c.3)?));
@@ -297,6 +323,8 @@ pub fn clipboard_keys(ctx: &egui::Context, typing: bool, raw: &mut egui::RawInpu
 }
 
 pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    // A held tool letter released: a temporary tool gives the previous one back (#2672).
+    crate::spring_tools::tick(app, ctx);
     // However the tool was picked (toolbar, flyout, shortcut, automation), its group's key brings
     // it back later (#2608).
     app.ui.remember_group_tool();
@@ -311,6 +339,8 @@ pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context) {
     if crate::menu_nav::is_open(ctx) || crate::widgets::dropdown_list_open(ctx) {
         return;
     }
+    // ⌘Z in a filter or adjustment dialog steps the dialog's settings, not the document (#4697).
+    crate::edit_history::keys(app, ctx);
     // Stroke Options owns plain navigation/activation keys, including while its child
     // dropdown is open. This runs before Popup::show registers the current pass, so use
     // the editor's explicit state; otherwise Escape deselects or commits a pending Pen path.
@@ -335,8 +365,14 @@ pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context) {
     // Liquify is a full-window custom dialog with focusable sliders. egui can therefore claim
     // keyboard input before the distortion-mode handler below runs. Give Liquify's local
     // shortcuts first refusal (Undo, brush size, tool keys), but never steal keys from text edits.
-    if app.distort.liquify.is_some() && !ctx.text_edit_focused() {
-        crate::liquify_ui::keys(app, ctx);
+    if app.distort.liquify.is_some() {
+        // Undo and redo still apply while a numeric field (Size, Pressure, …) has focus.
+        // Other Liquify keys must not steal characters from that field (#4027).
+        if ctx.text_edit_focused() {
+            crate::liquify_ui::history_keys(app, ctx);
+        } else {
+            crate::liquify_ui::keys(app, ctx);
+        }
     }
     use crate::shortcut_dispatch::{Focus, dispatch_pressed};
     let focus = Focus::of(ctx);
@@ -456,8 +492,23 @@ pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context) {
             return;
         }
     }
+    // Space+F (⇧Space+F backwards) cycles the pasteboard colour, as in Photoshop: F while the
+    // Hand key is held, before F's own Cycle Screen Mode.
+    if !matches!(focus, Focus::Text) && app.ui.text_edit.is_none() && crate::hold_keys::reposition_held(app, ctx) {
+        let back = ctx.input_mut(|i| i.consume_key(Modifiers::SHIFT, Key::F));
+        if back || ctx.input_mut(|i| i.consume_key(Modifiers::NONE, Key::F)) {
+            if let Err(e) = crate::canvas_tool_menu::cycle_canvas_color(app, back) {
+                app.ui.status = e;
+            }
+            return;
+        }
+    }
     // Inline type editing eats text and navigation keys; ⌘-shortcuts still reach the menus.
     let editing = crate::type_tool::handle_keys(app, ctx);
+    // ⌥⇧⌘N: a new layer at once, without the New Layer dialog ⇧⌘N opens (#4794).
+    if new_layer_without_dialog(app, ctx) {
+        return;
+    }
     // Registry, UI and menu-catalogue shortcuts (see [`crate::shortcut_dispatch::bindings`]).
     if dispatch_pressed(app, ctx, focus, editing) {
         return;
@@ -481,6 +532,17 @@ pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context) {
     // brush keys [ ] ⇧[ ⇧] (`tools.decreaseBrushSize`…) are commands, dispatched above with any
     // Keyboard Shortcuts override.
     let pressed = |k: Key| ctx.input_mut(|i| i.consume_key(Modifiers::NONE, k));
+    // Remove tool with strokes waiting (Remove after each stroke off): ↩ applies them, Esc drops them.
+    if !app.remove_pending.is_empty() {
+        if pressed(Key::Enter) {
+            crate::retouch_ui::remove_pending_commit(app);
+            return;
+        }
+        if pressed(Key::Escape) {
+            crate::retouch_ui::remove_pending_cancel(app);
+            return;
+        }
+    }
     // Enter / Escape commit or cancel in-progress tool state (polygonal lasso, crop).
     if crate::lasso_ui::active(app) {
         let mods = ctx.input(|i| i.modifiers);
@@ -509,15 +571,13 @@ pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context) {
             return;
         }
     }
-    // Esc with no active operation deselects (#2674), like ⌘D. The key is only taken when a
-    // selection exists, and never from a state that handles Esc later in the frame: menus,
-    // dialogs and inline type returned above, transform, pen, lasso and crop consumed it, and
-    // these own theirs: full screen (Esc returns), the palette, the canvas and layer menus, the
-    // brush picker, Rotate View, Adaptive Wide Angle, the Filter Gallery, the TIFF prompt, any
-    // open egui popup and the toolbar tool flyout. A canvas drag in progress (a marquee being
-    // drawn) keeps the selection too.
-    let esc_taken = app.ui.view.hides_chrome()
-        || app.drag.is_some()
+    // Esc with no active operation leaves a full screen mode, else deselects (#2674), like ⌘D.
+    // The key is never taken from a state that handles Esc itself: menus, dialogs, text fields
+    // and inline type returned above, transform, pen, lasso and crop consumed it, and these own
+    // theirs later in the frame: the palette, the canvas and layer menus, the brush picker,
+    // Rotate View, Adaptive Wide Angle, the Filter Gallery, the TIFF prompt, any open egui popup
+    // and the toolbar tool flyout. A canvas drag in progress (a marquee being drawn) keeps it too.
+    let esc_taken = app.drag.is_some()
         || app.ui.palette_open
         || app.ui.canvas_tool_menu.is_some()
         || app.ui.layer_menu.is_some()
@@ -528,6 +588,15 @@ pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context) {
         || app.distort.gallery.is_some()
         || ctx.any_popup_open()
         || ctx.data(|d| d.get_temp::<(egui::Id, egui::Rect)>(egui::Id::new("tool-flyout")).is_some());
+    // Both full screen modes (with and without the menu bar) return to Standard, as in Photoshop
+    // (#4116), through the menu command so the window and the Screen Mode check follow.
+    if !esc_taken && app.ui.view.screen_mode != "standard" && pressed(Key::Escape) {
+        if let Err(e) = crate::menus::invoke(app, ctx, "view.screenMode.standard", json!({})) {
+            app.ui.status = e;
+            app.ui.status_error = true;
+        }
+        return;
+    }
     if !esc_taken && app.session.active().is_some_and(|st| st.doc.selection.is_some()) && pressed(Key::Escape) {
         if let Err(e) = app.run("select.deselect", json!({})) {
             app.ui.status = e;
@@ -538,17 +607,27 @@ pub fn handle(app: &mut PhotocraftApp, ctx: &egui::Context) {
     // Tool keys; pressing the key of the current group cycles within it. With Preferences ›
     // Tools › Use Shift Key for Tool Switch, only ⇧+key cycles and the plain key keeps the
     // group's current tool. From another group, the key picks the group's last-used tool.
+    // A held tool letter is a spring-loaded tool (#2672), not a burst of presses: its key
+    // repeats are dropped rather than cycling the group.
+    ctx.input_mut(|i| i.events.retain(|e| !matches!(e, egui::Event::Key { key, pressed: true, repeat: true, .. } if crate::spring_tools::is_tool_key(*key))));
     let shift_switch = app.session.prefs().tools.use_shift_key_for_tool_switch;
     for t in Tool::ALL {
-        let Some(k) = Key::from_name(&t.key().to_string()) else { continue };
+        if !crate::tool_shortcuts::uses_default(app, t) {
+            continue;
+        }
+        let Some(k) = crate::spring_tools::key_of(t.key()) else { continue };
         let cycle_shift = shift_switch && ctx.input_mut(|i| i.consume_key(Modifiers::SHIFT, k));
         if cycle_shift || pressed(k) {
-            let group: Vec<Tool> = Tool::ALL.iter().copied().filter(|x| x.key() == t.key()).collect();
+            let before = app.ui.tool;
+            let group: Vec<Tool> = Tool::ALL.iter().copied().filter(|x| x.key() == t.key() && crate::tool_shortcuts::uses_default(app, *x)).collect();
             app.ui.tool = match group.iter().position(|x| *x == app.ui.tool) {
                 Some(i) if shift_switch && !cycle_shift => group[i],
                 Some(i) => group[(i + 1) % group.len()],
-                None => app.ui.group_tool(t.key()).unwrap_or(group[0]),
+                None => app.ui.group_tool(t.key()).filter(|last| group.contains(last)).unwrap_or(group[0]),
             };
+            // `consume_key` ignores extra ⇧ and ⌥: a ⇧/⌥ switch is never spring-loaded.
+            let (plain, now) = ctx.input(|i| (!cycle_shift && !i.modifiers.shift && !i.modifiers.alt, i.time));
+            crate::spring_tools::pressed(app, t.key(), before, plain, now);
             return;
         }
     }
@@ -569,7 +648,11 @@ mod tests {
         let ctx = egui::Context::default();
         let press = |app: &mut PhotocraftApp, key, modifiers| {
             let raw = egui::RawInput {
-                events: vec![egui::Event::ModifiersChanged(modifiers), egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }],
+                events: vec![
+                    egui::Event::ModifiersChanged(modifiers),
+                    egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers },
+                    egui::Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers },
+                ],
                 ..Default::default()
             };
             ctx.begin_pass(raw);
@@ -609,6 +692,7 @@ mod tests {
                 events: vec![
                     egui::Event::ModifiersChanged(modifiers),
                     egui::Event::Key { key: Key::T, physical_key: None, pressed: true, repeat: false, modifiers },
+                    egui::Event::Key { key: Key::T, physical_key: None, pressed: false, repeat: false, modifiers },
                 ],
                 ..Default::default()
             };
diff --git a/crates/ui-egui/src/sizing.rs b/crates/ui-egui/src/sizing.rs
index a0fb7557b0..6cce7e0a5c 100644
--- a/crates/ui-egui/src/sizing.rs
+++ b/crates/ui-egui/src/sizing.rs
@@ -46,6 +46,28 @@ pub fn is_sizing(command: &str) -> bool {
     matches!(command, "image.imageSize" | "image.canvasSize")
 }
 
+/// Alt+Cancel (Reset): restore the dimensions and options from when the dialog opened.
+pub fn reset(f: &mut Map<String, Value>) {
+    if !f.contains_key("__sizing") {
+        return;
+    }
+    let w = num(f, "__origW");
+    let h = num(f, "__origH");
+    f.insert("width".into(), json!(w));
+    f.insert("height".into(), json!(h));
+    if f.get("__command").and_then(Value::as_str) == Some("image.imageSize") {
+        f.insert("resolution".into(), json!(num(f, "__origRes")));
+        f.insert("__constrain".into(), json!(true));
+        if let Some(r) = f.get("__resample").cloned() {
+            f.insert("resample".into(), r);
+        }
+    } else {
+        f.insert("relative".into(), json!(false));
+        f.insert("anchor".into(), json!("center"));
+        f.insert("extensionColor".into(), json!("background"));
+    }
+}
+
 pub fn open(app: &mut PhotocraftApp, command: &str) -> Option<u64> {
     let unit = pref_unit(app.session.prefs().units_and_rulers.rulers);
     let resample = pref_resample(app.session.prefs().general.image_interpolation);
@@ -144,7 +166,11 @@ fn dim_field(ui: &mut egui::Ui, f: &mut Map<String, Value>, key: &str, orig_key:
     let orig = num(f, orig_key);
     let px = num(f, key);
     let mut v = to_unit(px, &unit, orig, res) as f32;
-    let range = if unit == "px" { -300000.0..=300000.0 } else { -30000.0..=30000.0 };
+    // The engine's 300000 px limit in this unit (never below 30000), so a large document's size
+    // isn't clamped when the field is drawn: egui clamps the shown value to the range, and the
+    // field reports that as an edit (#4162).
+    let lim = if unit == "px" { 300000.0 } else { to_unit(300000.0, &unit, orig, res).max(30000.0) as f32 };
+    let range = -lim..=lim;
     // Each unit keeps its own precision: whole pixels, 3 places for inches, 2 for cm/mm/picas (#2434).
     // A typed unit (`2in` while in pixels) converts at the dialog's resolution.
     let units = crate::widgets::FieldUnits { unit: crate::widgets::unit_of_key(&unit), dpi: res, ppi: 72.0 };
@@ -443,6 +469,22 @@ mod tests {
         assert_eq!(app.session.active().unwrap().doc.size, photocraft_doc::Size::new(120, 50));
     }
 
+    #[test]
+    fn alt_reset_restores_open_dimensions() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        app.session.execute("file.new", json!({"width": 200, "height": 100, "resolution": 72})).unwrap();
+        let id = open(&mut app, "image.imageSize").unwrap();
+        let d = app.ui.dialog_mut(id).unwrap();
+        d.fields.insert("width".into(), json!(50));
+        d.fields.insert("height".into(), json!(25));
+        d.fields.insert("resolution".into(), json!(300));
+        d.fields.insert("__constrain".into(), json!(false));
+        reset(&mut d.fields);
+        assert_eq!((num(&d.fields, "width"), num(&d.fields, "height"), num(&d.fields, "resolution")), (200.0, 100.0, 72.0));
+        assert_eq!(d.fields.get("__constrain"), Some(&json!(true)));
+        assert!(app.ui.dialogs.iter().any(|x| x.id == id), "reset leaves the dialog open");
+    }
+
     /// The dialog starts on Preferences › General › Image Interpolation: Bicubic Automatic opens
     /// as Automatic and the others as themselves (Bicubic Sharper used to open as Lanczos).
     #[test]
@@ -558,6 +600,32 @@ mod tests {
         assert!((doc.resolution_dpi - 50.0).abs() < 1e-3, "{}", doc.resolution_dpi);
     }
 
+    /// #4162: a document wider than 30000 units in a physical unit (40000 px at 72 ppi is 40000 pt)
+    /// kept its size in the fields and on OK; the fields clamped it to 30000 on open, so OK with
+    /// no edit resized (Image Size) or cropped (Canvas Size) it.
+    #[test]
+    fn large_documents_in_physical_units_open_unchanged() {
+        use egui_kittest::Harness;
+        let mut wrong = Vec::new();
+        for command in ["image.imageSize", "image.canvasSize"] {
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            app.session.execute("file.new", json!({"width": 40000, "height": 4, "resolution": 72})).unwrap();
+            let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).build_ui_state(|ui, app| crate::dialogs::show(app, ui.ctx()), app);
+            PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+            let id = open(h.state_mut(), command).unwrap();
+            h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("__unit".into(), json!("pt"));
+            h.run_steps(3);
+            let f = fields(&h);
+            let shown = (num(&f, "width"), num(&f, "height"));
+            crate::dialogs::confirm(h.state_mut(), id).unwrap();
+            let size = h.state().session.active().unwrap().doc.size;
+            if shown != (40000.0, 4.0) || size != photocraft_doc::Size::new(40000, 4) {
+                wrong.push(format!("{command}: fields {shown:?}, document {size:?}"));
+            }
+        }
+        assert!(wrong.is_empty(), "{wrong:#?}");
+    }
+
     /// #2329: Image Size and Canvas Size open on Width with its value selected, as in Photoshop:
     /// typing replaces it and Enter applies it.
     #[test]
diff --git a/crates/ui-egui/src/smart_filter_rows_tests.rs b/crates/ui-egui/src/smart_filter_rows_tests.rs
new file mode 100644
index 0000000000..9db54bbe1e
--- /dev/null
+++ b/crates/ui-egui/src/smart_filter_rows_tests.rs
@@ -0,0 +1,231 @@
+//! Layers panel Smart Filters rows (#4271): a click selects a filter (and its smart object), a
+//! drag onto another smart object moves it there, ⌥-drag copies it, and a drag onto Delete
+//! removes it, as in Photoshop.
+
+use egui::accesskit::{Role, Toggled};
+use egui::{Modifiers, Pos2};
+use egui_kittest::kittest::{NodeT, Queryable};
+use photocraft_doc::{LayerContent, LayerId};
+use serde_json::json;
+
+use crate::PhotocraftApp;
+
+/// Smart objects "Smart A" (Gaussian Blur and Offset) and "Smart B" (no filters), and a pixel
+/// layer "Pixels" on top: (harness, A, B, pixels).
+fn panel() -> (egui_kittest::Harness<'static, PhotocraftApp>, u64, u64, u64) {
+    let mut s = photocraft_engine::Session::new();
+    s.execute("file.new", json!({"width": 16, "height": 16})).unwrap();
+    let smart = |s: &mut photocraft_engine::Session, name: &str| {
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("edit.fill", json!({"contents": "black"})).unwrap();
+        let id = s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("layer.setProps", json!({"layer": id, "name": name})).unwrap();
+        id
+    };
+    let a = smart(&mut s, "Smart A");
+    s.execute("filter.blur.gaussianBlur", json!({"radius": 1})).unwrap();
+    s.execute("filter.other.offset", json!({"horizontal": 2})).unwrap();
+    let b = smart(&mut s, "Smart B");
+    let c = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setProps", json!({"layer": c, "name": "Pixels"})).unwrap();
+    // 60 fps steps, so a double-click's two clicks fall inside egui's 0.3 s window.
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 900.0)).with_max_steps(64).with_step_dt(1.0 / 60.0).build_eframe(|cc| {
+        PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+        PhotocraftApp::new(s, crate::Services::default())
+    });
+    h.run_steps(4);
+    (h, a, b, c)
+}
+
+fn filters(h: &egui_kittest::Harness<'static, PhotocraftApp>, id: u64) -> Vec<String> {
+    match &h.state().session.active().unwrap().doc.layer(LayerId(id)).unwrap().content {
+        LayerContent::Smart(sm) => sm.smart_filters.iter().map(|f| f.command.clone()).collect(),
+        _ => Vec::new(),
+    }
+}
+
+/// The centre of the Layers panel row (or footer button) labelled `label`: rows are selectable
+/// labels, which AccessKit calls buttons, unlike the same name drawn elsewhere.
+fn at(h: &egui_kittest::Harness<'static, PhotocraftApp>, label: &str) -> Pos2 {
+    h.query_all_by_label(label).find(|n| n.accesskit_node().role() == Role::Button).unwrap_or_else(|| panic!("`{label}` drawn")).rect().center()
+}
+
+fn selected(h: &egui_kittest::Harness<'static, PhotocraftApp>, label: &str) -> bool {
+    h.get_by_role_and_label(Role::Button, label).accesskit_node().toggled() == Some(Toggled::True)
+}
+
+/// Press at `from`, move to `to` in steps and release there, with `modifiers` held on release.
+fn drag(h: &mut egui_kittest::Harness<'static, PhotocraftApp>, from: Pos2, to: Pos2, modifiers: Modifiers) {
+    h.hover_at(from);
+    h.run_steps(1);
+    h.drag_at(from);
+    h.run_steps(1);
+    for i in 1..=6 {
+        h.hover_at(from + (to - from) * (i as f32 / 6.0));
+        h.run_steps(1);
+    }
+    h.event(egui::Event::ModifiersChanged(modifiers));
+    h.run_steps(1);
+    h.event(egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers });
+    h.run_steps(4);
+    h.event(egui::Event::ModifiersChanged(Modifiers::NONE));
+    h.run_steps(2);
+}
+
+#[test]
+fn a_click_selects_the_filter_and_its_smart_object() {
+    let (mut h, a, _, c) = panel();
+    assert_eq!(h.state().session.active().unwrap().active_layer, Some(LayerId(c)));
+    h.get_by_role_and_label(Role::Button, "Gaussian Blur").click();
+    h.run_steps(4);
+    assert_eq!(h.state().session.active().unwrap().active_layer, Some(LayerId(a)), "the smart object becomes active");
+    assert!(selected(&h, "Gaussian Blur"));
+    assert!(!selected(&h, "Offset"));
+    // Another layer: the filter is no longer shown selected.
+    let pixels = at(&h, "Pixels");
+    h.hover_at(pixels);
+    h.run_steps(1);
+    h.drag_at(pixels);
+    h.run_steps(1);
+    h.drop_at(pixels);
+    h.run_steps(4);
+    assert_eq!(h.state().session.active().unwrap().active_layer, Some(LayerId(c)));
+    assert!(!selected(&h, "Gaussian Blur"));
+}
+
+#[test]
+fn dragging_a_filter_onto_another_smart_object_moves_it_and_alt_copies_it() {
+    let (mut h, a, b, _) = panel();
+    let (blur, offset) = ("filter.blur.gaussianBlur", "filter.other.offset");
+    let (from, to) = (at(&h, "Gaussian Blur"), at(&h, "Smart B"));
+    drag(&mut h, from, to, Modifiers::ALT);
+    assert_eq!(filters(&h, b), [blur], "⌥-drag copies");
+    assert_eq!(filters(&h, a), [blur, offset]);
+    let (from, to) = (at(&h, "Offset"), at(&h, "Smart B"));
+    drag(&mut h, from, to, Modifiers::NONE);
+    assert_eq!(filters(&h, b), [blur, offset], "a drag moves");
+    assert_eq!(filters(&h, a), [blur]);
+}
+
+#[test]
+fn a_pixel_layer_does_not_take_smart_filters() {
+    let (mut h, a, _, _) = panel();
+    let (from, to) = (at(&h, "Gaussian Blur"), at(&h, "Pixels"));
+    drag(&mut h, from, to, Modifiers::NONE);
+    assert_eq!(filters(&h, a).len(), 2);
+    assert!(!h.state().ui.status_error, "{}", h.state().ui.status);
+}
+
+#[test]
+fn dragging_filters_onto_delete_removes_them() {
+    let (mut h, a, _, _) = panel();
+    let (from, to) = (at(&h, "Offset"), at(&h, "Delete layer"));
+    drag(&mut h, from, to, Modifiers::NONE);
+    assert_eq!(filters(&h, a), ["filter.blur.gaussianBlur"]);
+    let (from, to) = (at(&h, "Smart Filters"), at(&h, "Delete layer"));
+    drag(&mut h, from, to, Modifiers::NONE);
+    assert!(filters(&h, a).is_empty());
+    assert_eq!(h.state().session.active().unwrap().doc.layers.len(), 4, "no layer was deleted");
+}
+
+/// The report's case: the Camera Raw Filter is ⌥-dragged to another smart object with its
+/// settings, and double-clicking the copy opens Camera Raw on that smart object's filter.
+#[test]
+fn a_camera_raw_filter_copies_and_its_copy_opens_on_the_target() {
+    let (mut h, a, b, _) = panel();
+    h.state_mut().run("layer.select", json!({"layer": a})).unwrap();
+    h.state_mut().run("filter.cameraRaw", json!({"exposure": 1.0, "contrast": 20})).unwrap();
+    h.run_steps(4);
+    let (from, to) = (at(&h, "Camera Raw Filter"), at(&h, "Smart B"));
+    drag(&mut h, from, to, Modifiers::ALT);
+    let raw = |h: &egui_kittest::Harness<'static, PhotocraftApp>, id: u64| match &h.state().session.active().unwrap().doc.layer(LayerId(id)).unwrap().content {
+        LayerContent::Smart(sm) => sm.smart_filters.iter().find(|f| f.command == "filter.cameraRaw").map(|f| f.params.clone()),
+        _ => None,
+    };
+    assert_eq!(raw(&h, b), raw(&h, a), "copied with its settings");
+    assert_eq!(raw(&h, b).unwrap()["exposure"], 1.0);
+    // B is above A in the panel, so its copy is the upper of the two Camera Raw rows.
+    let copy = h
+        .query_all_by_label("Camera Raw Filter")
+        .filter(|n| n.accesskit_node().role() == Role::Button)
+        .map(|n| n.rect().center())
+        .min_by(|p, q| p.y.total_cmp(&q.y))
+        .unwrap();
+    for _ in 0..2 {
+        h.hover_at(copy);
+        h.drag_at(copy);
+        h.run_steps(1);
+        h.drop_at(copy);
+        h.run_steps(1);
+    }
+    h.run_steps(3);
+    let dialog = h.state().camera_raw.as_ref().expect("Camera Raw opened");
+    assert_eq!(dialog.layer, LayerId(b));
+}
+
+/// Dragging a filter up or down its own stack reorders it (Photoshop), which changes the result:
+/// the bottom filter is applied first (`smart_cmds::tests::filter_stack_order_blend_disable_and_clear`). A drop on the upper half of a row lands above it, on the
+/// lower half below it, on the Smart Filters row on top; the moved filter stays selected.
+#[test]
+fn dragging_a_filter_up_or_down_its_stack_reorders_it() {
+    let (mut h, a, _, _) = panel();
+    let (blur, offset) = ("filter.blur.gaussianBlur", "filter.other.offset");
+    let half = |p: Pos2, up: bool| p + egui::vec2(0.0, if up { -6.0 } else { 6.0 });
+    // Gaussian Blur (bottom) onto the upper half of Offset's row: blur now on top.
+    let (from, to) = (at(&h, "Gaussian Blur"), at(&h, "Offset"));
+    drag(&mut h, from, half(to, true), Modifiers::NONE);
+    assert_eq!(filters(&h, a), [offset, blur]);
+    assert!(selected(&h, "Gaussian Blur"), "the moved filter stays selected");
+    assert!(!h.state().ui.status_error, "{}", h.state().ui.status);
+    // Its lower half: back under it.
+    let (from, to) = (at(&h, "Gaussian Blur"), at(&h, "Offset"));
+    drag(&mut h, from, half(to, false), Modifiers::NONE);
+    assert_eq!(filters(&h, a), [blur, offset]);
+    // The Smart Filters row: on top again.
+    let (from, to) = (at(&h, "Gaussian Blur"), at(&h, "Smart Filters"));
+    drag(&mut h, from, to, Modifiers::NONE);
+    assert_eq!(filters(&h, a), [offset, blur]);
+    // Each drag is one undo step.
+    h.state_mut().run("edit.undo", json!({})).unwrap();
+    h.run_steps(4);
+    assert_eq!(filters(&h, a), [blur, offset]);
+}
+
+fn click_at(h: &mut egui_kittest::Harness<'static, PhotocraftApp>, p: Pos2) {
+    h.hover_at(p);
+    h.run_steps(1);
+    h.drag_at(p);
+    h.run_steps(1);
+    h.drop_at(p);
+    h.run_steps(4);
+}
+
+/// #4751: with a filter's row selected, clicking Delete removes that filter, not the smart object.
+#[test]
+fn clicking_delete_removes_the_selected_filter() {
+    let (mut h, a, _, _) = panel();
+    let blur = at(&h, "Gaussian Blur");
+    click_at(&mut h, blur);
+    let trash = at(&h, "Delete layer");
+    click_at(&mut h, trash);
+    assert_eq!(filters(&h, a), ["filter.other.offset"]);
+    assert_eq!(h.state().session.active().unwrap().doc.layers.len(), 4, "no layer was deleted");
+    // The deleted row's selection doesn't carry over to Offset, now at its index.
+    click_at(&mut h, trash);
+    assert_eq!(filters(&h, a), ["filter.other.offset"]);
+}
+
+/// Clicking the smart object's own row leaves its filters: Delete then deletes the layer as usual.
+#[test]
+fn clicking_the_smart_object_row_deselects_its_filter() {
+    let (mut h, a, _, _) = panel();
+    let offset = at(&h, "Offset");
+    click_at(&mut h, offset);
+    let row = at(&h, "Smart A");
+    click_at(&mut h, row);
+    assert_eq!(h.state().session.active().unwrap().active_layer, Some(LayerId(a)));
+    assert!(!selected(&h, "Offset"));
+    let trash = at(&h, "Delete layer");
+    click_at(&mut h, trash);
+    assert_eq!(filters(&h, a).len(), 2, "the filters stay");
+}
diff --git a/crates/ui-egui/src/smart_ui.rs b/crates/ui-egui/src/smart_ui.rs
index 99deaa60fe..48b2f0a72f 100644
--- a/crates/ui-egui/src/smart_ui.rs
+++ b/crates/ui-egui/src/smart_ui.rs
@@ -1,23 +1,61 @@
 //! Layers-panel pieces for smart objects: the thumbnail badge and the Smart Filters sub-rows
-//! (eye toggles; double-click a filter to re-open its dialog with the recorded parameters).
+//! (eye toggles; double-click a filter to re-open its dialog with the recorded parameters; click
+//! to select one; drag onto another smart object to move it there, ⌥-drag to copy it, #4271;
+//! drag it up or down its own stack to reorder it).
 
-use egui::{Align2, Color32, Rect, Sense, Stroke, pos2, vec2};
-use photocraft_doc::{Layer, LayerContent, SmartObject};
+use egui::{Align2, Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
+use photocraft_doc::{Document, Layer, LayerContent, LayerId, SmartObject};
 use serde_json::{Value, json};
 
 use crate::theme::Tokens;
 use crate::{PhotocraftApp, icons};
 
-/// Smart-object badge in the bottom-right corner of a layer thumbnail.
-pub fn thumb_badge(ui: &egui::Ui, l: &Layer, thumb: Rect) {
-    if !matches!(l.content, LayerContent::Smart(_)) {
-        return;
+/// What the badge on a layer thumbnail marks the layer as.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum ThumbBadge {
+    Smart,
+    Shape,
+}
+
+/// The badge `l`'s thumbnail carries. Smart objects and shape layers (#4584) show their pixels
+/// like any other layer, so only the badge tells them apart.
+fn thumb_badge_kind(l: &Layer) -> Option<ThumbBadge> {
+    match l.content {
+        LayerContent::Smart(_) => Some(ThumbBadge::Smart),
+        LayerContent::Shape(_) => Some(ThumbBadge::Shape),
+        _ => None,
     }
+}
+
+/// Where the badge sits: over the bottom-right corner of the thumbnail.
+fn thumb_badge_rect(thumb: Rect) -> Rect {
+    Rect::from_min_size(pos2(thumb.right() - 9.0, thumb.bottom() - 9.0), vec2(11.0, 11.0))
+}
+
+/// The shape badge's path, inset from the badge so its corner anchors stay inside the frame.
+const SHAPE_PATH_INSET: f32 = 3.0;
+/// Side of an anchor point on the shape badge's path.
+const SHAPE_ANCHOR: f32 = 3.0;
+
+/// Smart-object or shape-layer badge in the bottom-right corner of a layer thumbnail.
+pub fn thumb_badge(ui: &egui::Ui, l: &Layer, thumb: Rect) {
+    let Some(kind) = thumb_badge_kind(l) else { return };
     let t = Tokens::get(ui.ctx());
-    let r = Rect::from_min_size(pos2(thumb.right() - 9.0, thumb.bottom() - 9.0), vec2(11.0, 11.0));
+    let r = thumb_badge_rect(thumb);
     ui.painter().rect_filled(r, 2.0, t.field);
     ui.painter().rect_stroke(r, 2.0, Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside);
-    icons::paint(ui, r, "app-window", 9.0, t.icon);
+    match kind {
+        ThumbBadge::Smart => icons::paint(ui, r, "app-window", 9.0, t.icon),
+        // Photoshop's shape mark: a path with an anchor point on each corner. Painted rather
+        // than an icon, so the anchors stay solid squares at this size.
+        ThumbBadge::Shape => {
+            let path = r.shrink(SHAPE_PATH_INSET);
+            ui.painter().rect_stroke(path, 0.0, Stroke::new(1.0, t.icon), egui::StrokeKind::Middle);
+            for anchor in [path.left_top(), path.right_top(), path.right_bottom(), path.left_bottom()] {
+                ui.painter().rect_filled(Rect::from_center_size(anchor, vec2(SHAPE_ANCHOR, SHAPE_ANCHOR)), 0.0, t.icon);
+            }
+        }
+    }
 }
 
 /// The display name of a smart filter (its command's label without the ellipsis). A Photoshop
@@ -41,10 +79,28 @@ pub fn filter_rows(app: &mut PhotocraftApp, ui: &mut egui::Ui, l: &Layer, depth:
     }
     let t = Tokens::get(ui.ctx());
     let indent = 30.0 + depth as f32 * 14.0 + 34.0;
+    let Some(st) = app.session.active() else { return };
+    let (active, doc) = (st.active_layer == Some(l.id), st.doc.id);
+    let picked = ui.ctx().data(|d| d.get_temp::<FilterDrag>(selected_key(doc)));
     let rows = std::iter::once(None).chain((0..sm.smart_filters.len()).rev().map(Some));
     for index in rows {
-        let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click());
-        if resp.hovered() {
+        let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click_and_drag());
+        if resp.drag_started() {
+            ui.ctx().data_mut(|d| d.insert_temp::<FilterDrag>(drag_key(), (l.id.0, index)));
+        }
+        if let Some((to, action)) = reorder_drop(ui, l, sm.smart_filters.len(), index, rect) {
+            // The moved filter ends up selected, with its smart object active, as after a click.
+            ui.ctx().data_mut(|d| d.insert_temp::<FilterDrag>(selected_key(doc), (l.id.0, Some(to))));
+            actions.push(action);
+            if !active {
+                actions.push(("layer.select".into(), json!({"layer": l.id.0})));
+            }
+        }
+        // Selected as in Photoshop: the row stays highlighted while its smart object is active.
+        let selected = active && picked == Some((l.id.0, index));
+        if selected {
+            ui.painter().rect_filled(rect, 0.0, if t.pro { t.row_selected } else { t.hover });
+        } else if resp.hovered() {
             ui.painter().rect_filled(rect, 0.0, t.hover.gamma_multiply(0.35));
         }
         if t.pro {
@@ -75,7 +131,14 @@ pub fn filter_rows(app: &mut PhotocraftApp, ui: &mut egui::Ui, l: &Layer, depth:
             ui.painter().rect_filled(sw, 1.0, if sm.filter_mask.as_ref().is_some_and(|m| m.enabled) { Color32::from_gray(200) } else { Color32::WHITE });
             ui.painter().rect_stroke(sw, 1.0, Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside);
         }
-        ui.painter().text(pos2(x, rect.center().y), Align2::LEFT_CENTER, name, egui::FontId::proportional(11.5), if on { t.text_dim } else { t.text_faint });
+        ui.painter().text(pos2(x, rect.center().y), Align2::LEFT_CENTER, &name, egui::FontId::proportional(11.5), if on { t.text_dim } else { t.text_faint });
+        resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::SelectableLabel, true, selected, &name));
+        if resp.clicked() {
+            ui.ctx().data_mut(|d| d.insert_temp::<FilterDrag>(selected_key(doc), (l.id.0, index)));
+            if !active {
+                actions.push(("layer.select".into(), json!({"layer": l.id.0})));
+            }
+        }
         if let Some(i) = index
             && resp.double_clicked()
         {
@@ -84,6 +147,134 @@ pub fn filter_rows(app: &mut PhotocraftApp, ui: &mut egui::Ui, l: &Layer, depth:
     }
 }
 
+/// Smart filter rows being dragged: the smart object and the filter index (`None` = the Smart
+/// Filters row, all of them). Also what a click selects.
+pub(crate) type FilterDrag = (u64, Option<usize>);
+
+pub(crate) fn drag_key() -> egui::Id {
+    egui::Id::new("smart-filter-drag")
+}
+
+/// The selected smart filter row of a document.
+fn selected_key(doc: photocraft_doc::DocId) -> egui::Id {
+    egui::Id::new(("smart-filter-selected", doc))
+}
+
+/// The selected smart filter row, while its smart object is active and the filter still exists.
+pub(crate) fn selected(ctx: &egui::Context, doc: &Document, active: Option<LayerId>) -> Option<FilterDrag> {
+    let (layer, filter) = ctx.data(|d| d.get_temp::<FilterDrag>(selected_key(doc.id)))?;
+    if active != Some(LayerId(layer)) {
+        return None;
+    }
+    let LayerContent::Smart(sm) = &doc.layer(LayerId(layer))?.content else { return None };
+    let exists = match filter {
+        Some(i) => i < sm.smart_filters.len(),
+        None => !sm.smart_filters.is_empty(),
+    };
+    exists.then_some((layer, filter))
+}
+
+/// Forgets the selected smart filter row: its smart object's own row was clicked, or the filter
+/// was deleted (its index would now name the next one).
+pub(crate) fn deselect(ctx: &egui::Context, doc: photocraft_doc::DocId) {
+    ctx.data_mut(|d| d.remove::<FilterDrag>(selected_key(doc)));
+}
+
+/// While smart filters are dragged: their name by the pointer, and the copy cursor while ⌥ is held.
+pub(crate) fn drag_feedback(ctx: &egui::Context, doc: &Document) {
+    let Some((from, filter)) = ctx.data(|d| d.get_temp::<FilterDrag>(drag_key())) else { return };
+    let Some(p) = ctx.input(|i| i.pointer.interact_pos()) else { return };
+    let label = match (filter, doc.layer(LayerId(from)).map(|l| &l.content)) {
+        (Some(i), Some(LayerContent::Smart(sm))) => sm.smart_filters.get(i).map_or_else(String::new, filter_label),
+        _ => "Smart Filters".to_string(),
+    };
+    crate::layer_transfer::ghost(ctx, p, &label);
+    if ctx.input(|i| i.modifiers.alt) {
+        ctx.set_cursor_icon(egui::CursorIcon::Copy);
+    }
+}
+
+/// The command for dropping the smart filters of `from` on the smart object `target`: they move
+/// there, or with ⌥ held on release are copied (Photoshop).
+pub(crate) fn drop_action(from: u64, filter: Option<usize>, target: LayerId, copy: bool) -> (String, Value) {
+    let mut payload = json!({"from": from, "to": target.0, "copy": copy});
+    if let (Some(i), Some(o)) = (filter, payload.as_object_mut()) {
+        o.insert("filter".into(), json!(i));
+    }
+    ("layer.smartFilter.transfer".into(), payload)
+}
+
+/// Another smart object's row accepts the smart filters being dragged: outlined while the pointer
+/// is over it, dropped on release. Other layers don't take them, as in Photoshop.
+pub(crate) fn drop_on_row(ctx: &egui::Context, ui: &egui::Ui, l: &Layer, rect: Rect, actions: &mut Vec<(String, Value)>) {
+    let Some((from, filter)) = ctx.data(|d| d.get_temp::<FilterDrag>(drag_key())) else { return };
+    let Some(p) = ctx.input(|i| i.pointer.interact_pos()) else { return };
+    if from == l.id.0 || !matches!(l.content, LayerContent::Smart(_)) || !rect.contains(p) {
+        return;
+    }
+    let t = Tokens::get(ctx);
+    ui.painter().rect_stroke(rect.shrink(1.0), t.radius_sm, Stroke::new(2.0, t.accent), StrokeKind::Inside);
+    if ctx.input(|i| i.pointer.any_released()) {
+        actions.push(drop_action(from, filter, l.id, ctx.input(|i| i.modifiers.alt)));
+    }
+}
+
+/// Where `layer.smartFilter.move` puts filter `src` (stack index, 0 = bottom) dropped on the row
+/// of filter `row` (`None`: the Smart Filters row, i.e. on top of the stack), `above` or below
+/// it, in a stack of `n`. `None` when the filter would stay where it is.
+fn reorder_target(src: usize, row: Option<usize>, above: bool, n: usize) -> Option<usize> {
+    let to = match row {
+        None => n.checked_sub(1)?,
+        Some(i) if i == src => return None,
+        // Above a row is just over it in the stack, below a row just under it. `move` removes
+        // the filter first, so the filters over `src` shift down by one.
+        Some(i) if above => {
+            if src < i {
+                i
+            } else {
+                i + 1
+            }
+        }
+        Some(i) => {
+            if src < i {
+                i - 1
+            } else {
+                i
+            }
+        }
+    };
+    (to < n && to != src).then_some(to)
+}
+
+/// A filter dragged up or down its own smart object's stack (Photoshop): over another row of the
+/// stack a line marks where it lands, above or below that row (the Smart Filters row: on top),
+/// and the release moves it there. The bottom filter is applied first, so the order changes the
+/// result (Unsharp Mask over a blur sharpens the blurred image; under it, the sharpening is
+/// blurred). Returns the filter's new index and the command.
+fn reorder_drop(ui: &egui::Ui, l: &Layer, n: usize, row: Option<usize>, rect: Rect) -> Option<(usize, (String, Value))> {
+    let ctx = ui.ctx();
+    let (from, src) = ctx.data(|d| d.get_temp::<FilterDrag>(drag_key()))?;
+    let (src, p) = (src?, ctx.input(|i| i.pointer.interact_pos())?);
+    if from != l.id.0 || !rect.contains(p) {
+        return None;
+    }
+    let above = p.y < rect.center().y;
+    let to = reorder_target(src, row, above, n)?;
+    let t = Tokens::get(ctx);
+    let y = if above && row.is_some() { rect.top() } else { rect.bottom() };
+    ui.painter().line_segment([pos2(rect.left() + 30.0, y), pos2(rect.right(), y)], Stroke::new(2.0, t.accent));
+    ctx.input(|i| i.pointer.any_released()).then(|| (to, ("layer.smartFilter.move".into(), json!({"layer": l.id.0, "index": src, "to": to}))))
+}
+
+/// Smart filters dropped on the footer's Delete button: a filter's row deletes that filter, the
+/// Smart Filters row clears them all.
+pub(crate) fn trash_action((layer, filter): FilterDrag) -> (String, Value) {
+    match filter {
+        Some(i) => ("layer.smartFilter.delete".into(), json!({"layer": layer, "index": i})),
+        None => ("layer.smartFilter.clearSmartFilters".into(), json!({"layer": layer})),
+    }
+}
+
 /// Re-opens a smart filter's dialog with its recorded parameters; OK runs
 /// `layer.smartFilter.setParams` instead of adding another filter (see `dialogs::confirm`).
 pub fn open_editor(app: &mut PhotocraftApp, ctx: &egui::Context, layer: u64, sm: &SmartObject, index: usize) {
@@ -121,3 +312,89 @@ pub fn confirm_command(fields: &serde_json::Map<String, Value>, command: String,
         None => (command, params),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A pixel layer, a shape layer and a smart object, in that order.
+    fn layers() -> [Layer; 3] {
+        let mut s = photocraft_engine::Session::new();
+        s.execute("file.new", json!({"width": 64, "height": 48})).unwrap();
+        // An empty layer can't become a smart object: fill it first.
+        s.execute("layer.new.layer", json!({})).unwrap();
+        s.execute("edit.fill", json!({"contents": "color", "color": "#336699"})).unwrap();
+        let smart = s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap()["layer"].as_u64().unwrap();
+        let shape = s.execute("shape.create", json!({"kind": "rect", "rect": [8, 8, 40, 24], "fill": "#cc3333"})).unwrap()["layer"].as_u64().unwrap();
+        let pixel = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+        let doc = &s.active().unwrap().doc;
+        [pixel, shape, smart].map(|id| doc.layer(photocraft_doc::LayerId(id)).unwrap().clone())
+    }
+
+    /// Stack [A, B, C] (A at the bottom, drawn last): where a dragged filter lands.
+    #[test]
+    fn a_filter_dropped_above_or_below_a_row_lands_next_to_it() {
+        // A over C: [B, C, A]. A under C: [B, A, C].
+        assert_eq!(reorder_target(0, Some(2), true, 3), Some(2));
+        assert_eq!(reorder_target(0, Some(2), false, 3), Some(1));
+        // C under A: [C, A, B]. C over A: [A, C, B].
+        assert_eq!(reorder_target(2, Some(0), false, 3), Some(0));
+        assert_eq!(reorder_target(2, Some(0), true, 3), Some(1));
+        // The Smart Filters row: on top.
+        assert_eq!(reorder_target(0, None, false, 3), Some(2));
+        // Next to where it already is, or on itself: nothing to do.
+        assert_eq!(reorder_target(1, Some(2), false, 3), None);
+        assert_eq!(reorder_target(1, Some(0), true, 3), None);
+        assert_eq!(reorder_target(1, Some(1), true, 3), None);
+        assert_eq!(reorder_target(2, None, true, 3), None);
+        assert_eq!(reorder_target(0, None, true, 0), None);
+    }
+
+    #[test]
+    fn shape_layers_and_smart_objects_carry_a_thumbnail_badge() {
+        let [pixel, shape, smart] = layers();
+        assert_eq!(thumb_badge_kind(&pixel), None);
+        assert_eq!(thumb_badge_kind(&shape), Some(ThumbBadge::Shape), "#4584");
+        assert_eq!(thumb_badge_kind(&smart), Some(ThumbBadge::Smart));
+    }
+
+    /// The rects `thumb_badge` fills for `l` over `thumb`, with their colours.
+    fn filled(l: &Layer, thumb: Rect) -> Vec<(Rect, Color32)> {
+        let l = l.clone();
+        let mut h = egui_kittest::Harness::new_ui(move |ui| thumb_badge(ui, &l, thumb));
+        h.run();
+        let badge = thumb_badge_rect(thumb).expand(0.5);
+        let rects = h.output().shapes.iter().filter_map(|s| match &s.shape {
+            egui::Shape::Rect(r) if badge.contains_rect(r.rect) && r.fill != Color32::TRANSPARENT => Some((r.rect, r.fill)),
+            _ => None,
+        });
+        rects.collect()
+    }
+
+    /// #4584: a shape layer's thumbnail shows a path with four anchor points in its corner.
+    #[test]
+    fn shape_badge_paints_a_path_with_an_anchor_on_each_corner() {
+        let [pixel, shape, smart] = layers();
+        let thumb = Rect::from_min_size(pos2(20.0, 20.0), vec2(34.0, 34.0));
+        let t = Tokens::get(&egui::Context::default());
+        let frame = thumb_badge_rect(thumb);
+        assert!(frame.right() > thumb.right() && frame.bottom() > thumb.bottom(), "over the bottom-right corner");
+        assert!(filled(&pixel, thumb).is_empty(), "a pixel layer has no badge");
+
+        let drawn = filled(&shape, thumb);
+        assert!(drawn.contains(&(frame, t.field)), "the badge's frame");
+        let anchors: Vec<Rect> = drawn.iter().filter(|(_, c)| *c == t.icon).map(|(r, _)| *r).collect();
+        let path = frame.shrink(SHAPE_PATH_INSET);
+        let corners = [path.left_top(), path.right_top(), path.right_bottom(), path.left_bottom()];
+        assert_eq!(anchors.iter().map(Rect::center).collect::<Vec<_>>(), corners);
+        for a in &anchors {
+            assert_eq!(a.size(), vec2(SHAPE_ANCHOR, SHAPE_ANCHOR));
+            assert!(frame.shrink(1.0).contains_rect(*a), "inside the frame's border");
+        }
+
+        // The smart-object badge keeps its frame and draws no anchors.
+        let drawn = filled(&smart, thumb);
+        assert!(drawn.contains(&(frame, t.field)));
+        assert!(drawn.iter().all(|(_, c)| *c != t.icon));
+    }
+}
diff --git a/crates/ui-egui/src/snap_ui.rs b/crates/ui-egui/src/snap_ui.rs
index 83d973739d..56fecd01eb 100644
--- a/crates/ui-egui/src/snap_ui.rs
+++ b/crates/ui-egui/src/snap_ui.rs
@@ -261,7 +261,7 @@ fn apply(app: &mut PhotocraftApp, p: [f64; 2], mods: egui::Modifiers) -> [f64; 2
         return p;
     }
     let (out, lines) = match &snap.gesture {
-        Gesture::Point => live_crop_handle(app, p, mods, &snap.targets, tol).unwrap_or_else(|| snap.targets.snap_point(p, tol)),
+        Gesture::Point => crop_handle(app, p, mods, &snap.targets, tol).unwrap_or_else(|| snap.targets.snap_point(p, tol)),
         Gesture::Guide => snap.targets.snap_point(p, tol),
         Gesture::Move { rect } | Gesture::TransformMove { rect } | Gesture::SelectionMove { rect } => {
             let d = [p[0] - snap.start[0], p[1] - snap.start[1]];
@@ -275,18 +275,26 @@ fn apply(app: &mut PhotocraftApp, p: [f64; 2], mods: egui::Modifiers) -> [f64; 2
     out
 }
 
-/// Snap the proposed handle on the image, calculated from the original camera. Snapping the
-/// pointer in the moving camera feeds the previous frame's pan back into the resize and makes
+/// Snap a crop handle being dragged: the handle itself (the frame's edge or corner), not the
+/// pointer, which grabbed it up to the grab radius away (#1919: snapping the pointer left a strip
+/// as wide as that offset between the frame and the edge it showed as snapped to). With Auto
+/// Center Preview the handle is found on the image, calculated from the original camera: snapping
+/// the pointer in the moving camera feeds the previous frame's pan back into the resize and makes
 /// a stationary pointer oscillate near the canvas edges.
-fn live_crop_handle(app: &PhotocraftApp, p: [f64; 2], mods: egui::Modifiers, targets: &SnapTargets, tol: f64) -> Option<([f64; 2], Vec<SnapLine>)> {
+fn crop_handle(app: &PhotocraftApp, p: [f64; 2], mods: egui::Modifiers, targets: &SnapTargets, tol: f64) -> Option<([f64; 2], Vec<SnapLine>)> {
     if app.ui.tool != Tool::Crop {
         return None;
     }
-    let crate::crop_ui::CropDrag::Resize { hx, hy, start, rect, view: Some(view) } = app.crop.drag? else { return None };
+    let crate::crop_ui::CropDrag::Resize { hx, hy, start, rect, view } = app.crop.drag? else { return None };
     let deg = crate::crop_ui::angle(app);
-    let q = crate::crop_mode::to_press(app, Some(view), p);
-    let g = crate::crop_mode::LiveResize { rect, deg, hx, hy, start, q, ratio: crate::crop_ui::resize_ratio(app, rect, mods), alt: mods.alt };
-    let (frame, _) = crate::crop_mode::resized_frame(g)?;
+    let ratio = crate::crop_ui::resize_ratio(app, rect, mods);
+    let q = view.map_or(p, |view| crate::crop_mode::to_press(app, Some(view), p));
+    // The frame for the pointer at `q`, as `crop_ui` resizes it.
+    let frame_at = |q: [f64; 2]| match view {
+        Some(_) => crate::crop_mode::resized_frame(crate::crop_mode::LiveResize { rect, deg, hx, hy, start, q, ratio, alt: mods.alt }).map(|(f, _)| f),
+        None => Some(crate::crop_ui::resized_turned(rect, deg, hx, hy, [q[0] - start[0], q[1] - start[1]], ratio, mods.alt)),
+    };
+    let frame = frame_at(q)?;
     let at = |r: [f64; 4]| {
         let c = crate::crop_ui::center(r);
         crate::crop_ui::turn([c[0] + f64::from(hx) * (r[2] - r[0]) / 2.0, c[1] + f64::from(hy) * (r[3] - r[1]) / 2.0], c, deg)
@@ -304,35 +312,39 @@ fn live_crop_handle(app: &PhotocraftApp, p: [f64; 2], mods: egui::Modifiers, tar
     if deg == 0.0 {
         lines.retain(|line| if line.vertical { hx != 0 } else { hy != 0 });
     }
-    // Auto Center Preview moves both screen edges. On the image the opposite edge stays put,
-    // so the grabbed edge travels twice as far as the pointer (once with Alt).
-    let scale = if mods.alt { 1.0 } else { 2.0 };
     if lines.is_empty() {
         return Some((p, lines));
     }
+    // Auto Center Preview moves both screen edges. On the image the opposite edge stays put,
+    // so the grabbed edge travels twice as far as the pointer (once with Alt). Without it the
+    // handle follows the pointer.
+    let scale = if view.is_some() && !mods.alt { 2.0 } else { 1.0 };
+    // How much the frame's extent grows per unit of pointer travel: both sides with Auto Center
+    // Preview or Alt, else the grabbed one.
+    let grow = if view.is_some() || mods.alt { 2.0 } else { 1.0 };
     let original = at(rect);
     let travel = crate::crop_ui::turn([handle[0] - original[0], handle[1] - original[1]], [0.0, 0.0], -deg);
     let mut local = [(travel[0] + d[0]) / scale, (travel[1] + d[1]) / scale];
     if deg == 0.0
         && hx != 0
         && hy != 0
-        && let Some(k) = g.ratio
+        && let Some(k) = ratio
     {
         // A corner with a ratio has one degree of freedom. Put the other axis on the same
         // ratio, rather than letting the raw pointer's unused axis override the snapped edge.
         if lines.iter().any(|line| line.vertical) {
-            local[1] = f64::from(hy) * ((rect[2] - rect[0] + 2.0 * f64::from(hx) * local[0]) / k - (rect[3] - rect[1])) / 2.0;
+            local[1] = f64::from(hy) * ((rect[2] - rect[0] + grow * f64::from(hx) * local[0]) / k - (rect[3] - rect[1])) / grow;
         } else {
-            local[0] = f64::from(hx) * ((rect[3] - rect[1] + 2.0 * f64::from(hy) * local[1]) * k - (rect[2] - rect[0])) / 2.0;
+            local[0] = f64::from(hx) * ((rect[3] - rect[1] + grow * f64::from(hy) * local[1]) * k - (rect[2] - rect[0])) / grow;
         }
     }
     let d = crate::crop_ui::turn(local, [0.0, 0.0], deg);
     let q = [start[0] + d[0], start[1] + d[1]];
-    if let Some((snapped_frame, _)) = crate::crop_mode::resized_frame(crate::crop_mode::LiveResize { q, ..g }) {
+    if let Some(snapped_frame) = frame_at(q) {
         let h = at(snapped_frame);
         lines.retain(|line| (if line.vertical { h[0] } else { h[1] } - line.pos).abs() < 1e-3);
     }
-    Some((crate::crop_mode::from_press(app, view, q), lines))
+    Some((view.map_or(q, |view| crate::crop_mode::from_press(app, view, q)), lines))
 }
 
 /// Snap a tool event's coordinates (called by `canvas::tool_event` before the tools see it).
diff --git a/crates/ui-egui/src/spring_tools.rs b/crates/ui-egui/src/spring_tools.rs
new file mode 100644
index 0000000000..5f51136cdb
--- /dev/null
+++ b/crates/ui-egui/src/spring_tools.rs
@@ -0,0 +1,127 @@
+//! Spring-loaded tool keys (#2672): hold a tool's letter for a temporary tool.
+//!
+//! A tool letter switches tools when it is pressed, as before (`shortcuts::handle`). If the key is
+//! then held for [`SPRING_HOLD_SECS`] or longer, or the canvas is used while it is down, the switch
+//! was only temporary: releasing the key gives back the tool in effect before the press, with its
+//! options. A quick tap with no canvas use stays a permanent switch.
+//!
+//! - ⇧+letter (cycling the group) and ⌥+letter never spring; nor do letters while typing in a
+//!   field, editing type or under a modal dialog, which never reach the tool keys.
+//! - Pressing the current group's own letter cycles the group, as a tap does, and doesn't spring.
+//! - A canvas drag still in progress when the key comes up finishes with the temporary tool; the
+//!   previous tool returns once the button is up (as `hold_keys` latches Space).
+//! - Another letter pressed while one is held wins (newest first); releasing every held letter
+//!   returns the original tool. Holding two letters at once counts as a hold.
+//! - Key repeats are not presses: `shortcuts::handle` drops them for tool letters.
+//!
+//! Z is one case: hold Z to zoom, add ⌥ to zoom out, as with the Zoom tool itself (and as
+//! `hold_keys` does for ⌥ with a held Zoom In).
+//!
+//! The state is [`crate::state::UiState::spring`], readable over the control channel.
+
+use egui::Key;
+use serde::{Deserialize, Serialize};
+
+use crate::PhotocraftApp;
+use crate::state::Tool;
+
+/// How long (seconds) a tool letter must stay down for its tool to be temporary.
+pub const SPRING_HOLD_SECS: f64 = 0.3;
+
+/// A tool switch made by a letter that is still down (or whose drag is still finishing).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Spring {
+    /// The tool to give back.
+    pub previous: Tool,
+    /// The tool the held letter picked. If the tool changes any other way while it's held (the
+    /// toolbar, a menu, automation), that choice stands and nothing springs back.
+    pub tool: Tool,
+    /// The tool letters held, oldest first.
+    pub keys: Vec<char>,
+    /// `egui` input time of the first press.
+    pub since: f64,
+    /// The canvas was pressed (or a second letter pressed) while held: the switch is temporary
+    /// however short the hold.
+    pub used: bool,
+    /// Every letter is up and the switch is temporary, but a drag is still in progress.
+    pub released: bool,
+}
+
+/// The egui key of a tool letter (`None` for the tools without one).
+pub fn key_of(letter: char) -> Option<Key> {
+    if letter == '\0' {
+        return None;
+    }
+    Key::from_name(&letter.to_string())
+}
+
+/// Is `k` some tool's single-key shortcut?
+pub fn is_tool_key(k: Key) -> bool {
+    Tool::ALL.iter().any(|t| key_of(t.key()) == Some(k))
+}
+
+/// A tool letter switched the tool from `before` (the switch is already made). `plain` is false
+/// when ⇧ or ⌥ was held: those switches are permanent. `now` is the input time.
+pub fn pressed(app: &mut PhotocraftApp, letter: char, before: Tool, plain: bool, now: f64) {
+    let active = app.ui.spring.as_ref().is_some_and(|s| !s.released);
+    if !plain {
+        app.ui.spring = None;
+        return;
+    }
+    if active {
+        if let Some(s) = app.ui.spring.as_mut() {
+            s.keys.retain(|k| *k != letter);
+            s.keys.push(letter);
+            s.used = true;
+            s.tool = app.ui.tool;
+        }
+        return;
+    }
+    // The current group's own key cycles it (or keeps it), as a tap always has.
+    let tool = app.ui.tool;
+    app.ui.spring = (before.key() != letter).then(|| Spring { previous: before, tool, keys: vec![letter], since: now, used: false, released: false });
+}
+
+/// The canvas was pressed: a held letter's tool becomes temporary.
+pub fn note_canvas_press(app: &mut PhotocraftApp) {
+    if let Some(s) = app.ui.spring.as_mut().filter(|s| !s.released) {
+        s.used = true;
+    }
+}
+
+/// Once a frame, before the key handling: notice released letters and give the previous tool
+/// back when the switch was temporary and no drag is in progress.
+pub fn tick(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    let Some(mut s) = app.ui.spring.take() else { return };
+    // Type editing begun with the temporary Type tool keeps it: the edit owns the tool now. So
+    // does a tool picked another way while the letter is down.
+    if app.ui.text_edit.is_some() || app.ui.tool != s.tool {
+        return;
+    }
+    let (now, button) = ctx.input(|i| (i.time, i.pointer.any_down()));
+    let dragging = app.drag.is_some() || button;
+    if !s.released {
+        if app.drag.is_some() {
+            s.used = true;
+        }
+        s.keys.retain(|k| key_of(*k).is_some_and(|k| ctx.input(|i| i.key_down(k))));
+        if !s.keys.is_empty() {
+            app.ui.spring = Some(s);
+            return;
+        }
+        if !s.used && now - s.since < SPRING_HOLD_SECS {
+            // A tap: the switch stands.
+            return;
+        }
+        s.released = true;
+    }
+    if dragging {
+        app.ui.spring = Some(s);
+        ctx.request_repaint();
+        return;
+    }
+    app.ui.tool = s.previous;
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/ui-egui/src/spring_tools/tests.rs b/crates/ui-egui/src/spring_tools/tests.rs
new file mode 100644
index 0000000000..eef327c096
--- /dev/null
+++ b/crates/ui-egui/src/spring_tools/tests.rs
@@ -0,0 +1,269 @@
+//! #2672 through the real key handling and canvas: a tapped tool letter switches for good, a held
+//! one (or one used on the canvas) springs back on release.
+
+use egui::{Event, Key, Modifiers, PointerButton, Pos2, vec2};
+use egui_kittest::Harness;
+use serde_json::json;
+
+use super::*;
+use crate::canvas::ViewXform;
+
+/// Frames are 1/60 s apart, so a hold is a count of frames.
+const DT: f32 = 1.0 / 60.0;
+
+fn harness(tool: Tool) -> Harness<'static, PhotocraftApp> {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+    app.sync_views();
+    app.ui.extras.rulers = false;
+    app.ui.tool = tool;
+    let mut h = Harness::builder().with_size(vec2(1000.0, 700.0)).with_step_dt(DT).build_ui_state(
+        |ui, app: &mut PhotocraftApp| {
+            let ctx = ui.ctx().clone();
+            if !ctx.fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                return;
+            }
+            crate::shortcuts::handle(app, &ctx);
+            egui::CentralPanel::default().show(ui, |ui| crate::canvas::document_area(app, ui));
+        },
+        app,
+    );
+    PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]);
+    h.run_steps(4);
+    let v = &mut h.state_mut().ui.views[0];
+    v.zoom = 1.0;
+    v.center = [200.0, 150.0];
+    v.fit_pending = false;
+    h.run_steps(2);
+    h
+}
+
+fn screen(h: &Harness<'static, PhotocraftApp>, x: f32, y: f32) -> Pos2 {
+    let app = h.state();
+    let v = &app.ui.views[0];
+    let xf = ViewXform {
+        rect: crate::rulers::content_rect(app, app.last_canvas_rect),
+        zoom: v.zoom,
+        center: v.center,
+        flip: app.ui.view.flip_horizontal,
+        rotation: v.rotation,
+        aspect: app.ui.view.display_aspect(),
+    };
+    xf.to_screen(x, y)
+}
+
+/// One key event with its modifiers, run as a frame.
+fn key_event(h: &mut Harness<'static, PhotocraftApp>, k: Key, pressed: bool, repeat: bool, m: Modifiers) {
+    h.event(Event::ModifiersChanged(m));
+    h.event(Event::Key { key: k, physical_key: None, pressed, repeat, modifiers: m });
+    h.run_steps(1);
+}
+
+fn down(h: &mut Harness<'static, PhotocraftApp>, k: Key) {
+    key_event(h, k, true, false, Modifiers::NONE);
+}
+
+fn up(h: &mut Harness<'static, PhotocraftApp>, k: Key) {
+    key_event(h, k, false, false, Modifiers::NONE);
+    h.run_steps(2);
+}
+
+/// Wait `secs` of input time.
+fn wait(h: &mut Harness<'static, PhotocraftApp>, secs: f64) {
+    h.run_steps((secs / f64::from(DT)).ceil() as usize);
+}
+
+fn button(h: &mut Harness<'static, PhotocraftApp>, p: Pos2, pressed: bool, m: Modifiers) {
+    h.event(Event::PointerButton { pos: p, button: PointerButton::Primary, pressed, modifiers: m });
+    h.run_steps(1);
+}
+
+fn move_to(h: &mut Harness<'static, PhotocraftApp>, x: f32, y: f32) {
+    let p = screen(h, x, y);
+    h.event(Event::PointerMoved(p));
+    h.run_steps(1);
+}
+
+fn click(h: &mut Harness<'static, PhotocraftApp>, x: f32, y: f32, m: Modifiers) {
+    move_to(h, x, y);
+    let p = screen(h, x, y);
+    button(h, p, true, m);
+    button(h, p, false, m);
+}
+
+#[test]
+fn a_tap_switches_tools_for_good() {
+    let mut h = harness(Tool::Brush);
+    down(&mut h, Key::E);
+    assert_eq!(h.state().ui.tool, Tool::Eraser);
+    assert!(h.state().ui.spring.is_some(), "the press is pending: tap or hold");
+    up(&mut h, Key::E);
+    assert_eq!(h.state().ui.tool, Tool::Eraser);
+    assert_eq!(h.state().ui.spring, None);
+}
+
+#[test]
+fn a_held_letter_gives_the_previous_tool_back() {
+    let mut h = harness(Tool::Brush);
+    down(&mut h, Key::E);
+    wait(&mut h, SPRING_HOLD_SECS + 0.1);
+    assert_eq!(h.state().ui.tool, Tool::Eraser, "the temporary tool is the tool shown meanwhile");
+    up(&mut h, Key::E);
+    assert_eq!(h.state().ui.tool, Tool::Brush);
+    assert_eq!(h.state().ui.spring, None);
+}
+
+#[test]
+fn hold_z_click_zooms_then_a_quick_release_restores() {
+    let mut h = harness(Tool::Brush);
+    let z0 = h.state().ui.views[0].zoom;
+    down(&mut h, Key::Z);
+    click(&mut h, 200.0, 150.0, Modifiers::NONE);
+    up(&mut h, Key::Z);
+    let z1 = h.state().ui.views[0].zoom;
+    assert!(z1 > z0, "{z0} -> {z1}");
+    assert_eq!(h.state().ui.tool, Tool::Brush, "a canvas click makes even a short hold temporary");
+    assert!(!h.state().session.active().unwrap().history.can_undo(), "nothing was painted");
+    // ⌥ with a held Z zooms out, as ⌥ does with the Zoom tool.
+    down(&mut h, Key::Z);
+    h.event(Event::ModifiersChanged(Modifiers::ALT));
+    click(&mut h, 200.0, 150.0, Modifiers::ALT);
+    h.event(Event::ModifiersChanged(Modifiers::NONE));
+    up(&mut h, Key::Z);
+    assert!(h.state().ui.views[0].zoom < z1);
+    assert_eq!(h.state().ui.tool, Tool::Brush);
+}
+
+#[test]
+fn shift_letter_cycles_and_never_springs() {
+    let mut h = harness(Tool::Brush);
+    h.state_mut().session.edit_prefs(|p| p.tools.use_shift_key_for_tool_switch = true);
+    key_event(&mut h, Key::B, true, false, Modifiers::SHIFT);
+    assert_eq!(h.state().ui.tool, Tool::Pencil);
+    assert_eq!(h.state().ui.spring, None);
+    wait(&mut h, SPRING_HOLD_SECS + 0.1);
+    key_event(&mut h, Key::B, false, false, Modifiers::SHIFT);
+    h.event(Event::ModifiersChanged(Modifiers::NONE));
+    h.run_steps(2);
+    assert_eq!(h.state().ui.tool, Tool::Pencil);
+
+    // Without the preference ⇧E is still a permanent switch, however long it is held.
+    let mut h = harness(Tool::Brush);
+    key_event(&mut h, Key::E, true, false, Modifiers::SHIFT);
+    wait(&mut h, SPRING_HOLD_SECS + 0.1);
+    key_event(&mut h, Key::E, false, false, Modifiers::SHIFT);
+    h.run_steps(2);
+    assert_eq!(h.state().ui.tool, Tool::Eraser);
+    assert_eq!(h.state().ui.spring, None);
+}
+
+#[test]
+fn key_repeats_are_not_presses() {
+    let mut h = harness(Tool::Brush);
+    down(&mut h, Key::L);
+    assert_eq!(h.state().ui.tool, Tool::Lasso);
+    for _ in 0..8 {
+        key_event(&mut h, Key::L, true, true, Modifiers::NONE);
+        wait(&mut h, 0.05);
+    }
+    assert_eq!(h.state().ui.tool, Tool::Lasso, "repeats don't cycle the group");
+    up(&mut h, Key::L);
+    assert_eq!(h.state().ui.tool, Tool::Brush);
+}
+
+#[test]
+fn a_drag_keeps_the_temporary_tool_until_the_button_is_up() {
+    let mut h = harness(Tool::Brush);
+    down(&mut h, Key::M);
+    assert_eq!(h.state().ui.tool, Tool::RectMarquee);
+    move_to(&mut h, 50.0, 50.0);
+    let p = screen(&h, 50.0, 50.0);
+    button(&mut h, p, true, Modifiers::NONE);
+    move_to(&mut h, 100.0, 90.0);
+    up(&mut h, Key::M);
+    assert_eq!(h.state().ui.tool, Tool::RectMarquee, "the drag finishes with the temporary tool");
+    move_to(&mut h, 150.0, 110.0);
+    let p = screen(&h, 150.0, 110.0);
+    button(&mut h, p, false, Modifiers::NONE);
+    h.run_steps(2);
+    assert_eq!(h.state().ui.tool, Tool::Brush);
+    assert_eq!(h.state().ui.spring, None);
+    let sel = h.state().session.active().unwrap().doc.selection.as_ref().map(|s| s.content_bounds());
+    assert!(sel.is_some_and(|r| r.width() > 50 && r.height() > 30), "{sel:?}");
+}
+
+#[test]
+fn the_newest_letter_wins_and_release_restores_the_original() {
+    let mut h = harness(Tool::Brush);
+    down(&mut h, Key::E);
+    down(&mut h, Key::L);
+    assert_eq!(h.state().ui.tool, Tool::Lasso);
+    up(&mut h, Key::E);
+    assert_eq!(h.state().ui.tool, Tool::Lasso, "L is still held");
+    up(&mut h, Key::L);
+    assert_eq!(h.state().ui.tool, Tool::Brush);
+}
+
+#[test]
+fn letters_type_while_editing_text() {
+    let mut h = harness(Tool::Type);
+    let id = h.state_mut().run("type.create", json!({"x": 20, "y": 80, "text": "a", "size": 40})).unwrap()["layer"].as_u64().unwrap();
+    h.state_mut().ui.text_edit = Some(crate::state::TextEdit {
+        layer: id,
+        caret: 1,
+        anchor: 1,
+        session: "spring-test".into(),
+        created: false,
+        mask: false,
+        dragging: false,
+        resize: None,
+        preedit: None,
+    });
+    h.run_steps(2);
+    h.event(Event::Key { key: Key::B, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
+    h.event(Event::Text("b".into()));
+    h.run_steps(1);
+    wait(&mut h, SPRING_HOLD_SECS + 0.1);
+    up(&mut h, Key::B);
+    assert_eq!(h.state().ui.tool, Tool::Type);
+    assert_eq!(h.state().ui.spring, None);
+    let st = h.state().session.active().unwrap();
+    match &st.doc.layer(photocraft_doc::LayerId(id)).unwrap().content {
+        photocraft_doc::LayerContent::Text(t) => assert_eq!(t.text, "ab"),
+        _ => panic!("not text"),
+    }
+}
+
+/// A tool picked another way while a letter is held (here, as the toolbar would) stands: the release
+/// doesn't take it back.
+#[test]
+fn a_tool_picked_while_a_letter_is_held_stands() {
+    let mut h = harness(Tool::Brush);
+    down(&mut h, Key::E);
+    wait(&mut h, SPRING_HOLD_SECS + 0.1);
+    h.state_mut().ui.tool = Tool::Lasso;
+    up(&mut h, Key::E);
+    assert_eq!(h.state().ui.tool, Tool::Lasso);
+    assert_eq!(h.state().ui.spring, None);
+}
+
+#[test]
+fn plain_functions_follow_the_rules() {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.ui.tool = Tool::Eraser;
+    // The current group's own key cycles; no spring.
+    pressed(&mut app, 'E', Tool::Eraser, true, 0.0);
+    assert_eq!(app.ui.spring, None);
+    // A ⇧ switch clears any pending spring.
+    pressed(&mut app, 'B', Tool::Eraser, true, 0.0);
+    assert!(app.ui.spring.is_some());
+    pressed(&mut app, 'L', Tool::Brush, false, 0.1);
+    assert_eq!(app.ui.spring, None);
+    // A canvas press marks a pending spring used; nothing to mark without one.
+    note_canvas_press(&mut app);
+    pressed(&mut app, 'B', Tool::Eraser, true, 0.0);
+    note_canvas_press(&mut app);
+    assert!(app.ui.spring.as_ref().is_some_and(|s| s.used && s.previous == Tool::Eraser));
+    assert_eq!(key_of('\0'), None);
+    assert!(is_tool_key(Key::Z) && !is_tool_key(Key::F1));
+}
diff --git a/crates/ui-egui/src/stack_dialog.rs b/crates/ui-egui/src/stack_dialog.rs
new file mode 100644
index 0000000000..8eb8717e80
--- /dev/null
+++ b/crates/ui-egui/src/stack_dialog.rs
@@ -0,0 +1,243 @@
+//! File › Scripts › Load Files into Stack… and Statistics: shared Source Files controls
+//! with Use (Files or Folder), the list of what will be loaded, Browse…, Remove, Add Open Files and
+//! Sort By Name, then Attempt to Automatically Align Source Images and Create Smart Object after
+//! Loading Layers. Statistics adds Stack Mode and always creates a smart object. OK runs the
+//! corresponding engine command with the list or the folder.
+use egui::{RichText, vec2};
+use serde_json::{Map, Value, json};
+
+use crate::file_dialog::{FileDialogAnswer, FileDialogRequest};
+use crate::{PhotocraftApp, state::DialogKind, theme::Tokens, widgets};
+
+const MARK: &str = "__loadStack";
+pub const COMMAND: &str = "file.scripts.loadFilesIntoStack";
+const STATISTICS: &str = "file.scripts.statistics";
+
+pub fn owns(fields: &Map<String, Value>) -> bool {
+    fields.contains_key(MARK)
+}
+
+/// Open the dialog with an empty Files list. Returns its id.
+pub fn open(app: &mut PhotocraftApp) -> u64 {
+    open_for(app, COMMAND, "Load Files into Stack…")
+}
+
+pub fn open_statistics(app: &mut PhotocraftApp) -> u64 {
+    open_for(app, STATISTICS, "Image Statistics")
+}
+
+fn statistics(f: &Map<String, Value>) -> bool {
+    f.get("__command").and_then(Value::as_str) == Some(STATISTICS)
+}
+
+fn open_for(app: &mut PhotocraftApp, command: &str, label: &str) -> u64 {
+    let mut f = Map::new();
+    f.insert(MARK.into(), json!(true));
+    f.insert("__command".into(), json!(command));
+    f.insert("__label".into(), json!(label));
+    f.insert("use".into(), json!("files"));
+    f.insert("files".into(), json!([]));
+    f.insert("folder".into(), json!(""));
+    f.insert("align".into(), json!(false));
+    f.insert("smartObject".into(), json!(false));
+    if command == STATISTICS {
+        f.insert("mode".into(), json!("median"));
+    }
+    app.ui.open_dialog(DialogKind::Command, f)
+}
+
+fn folder_mode(f: &Map<String, Value>) -> bool {
+    f.get("use").and_then(Value::as_str) == Some("folder")
+}
+
+fn files(f: &Map<String, Value>) -> Vec<String> {
+    f.get("files").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect()).unwrap_or_default()
+}
+
+fn folder(f: &Map<String, Value>) -> &str {
+    f.get("folder").and_then(Value::as_str).unwrap_or("")
+}
+
+fn selected(f: &Map<String, Value>) -> Option<usize> {
+    f.get("selected").and_then(Value::as_u64).map(|i| i as usize)
+}
+
+/// Add `paths` to the Files list, skipping those already in it, in their order.
+fn add(f: &mut Map<String, Value>, paths: impl IntoIterator<Item = String>) {
+    let mut list = files(f);
+    for p in paths {
+        if !list.contains(&p) {
+            list.push(p);
+        }
+    }
+    f.insert("files".into(), json!(list));
+}
+
+fn file_name(p: &str) -> &str {
+    std::path::Path::new(p).file_name().and_then(|n| n.to_str()).unwrap_or(p)
+}
+
+/// The open documents that have a file, in tab order (what Add Open Files adds).
+fn open_files(app: &PhotocraftApp) -> Vec<String> {
+    app.session.documents().iter().filter_map(|d| d.path.clone()).collect()
+}
+
+/// OK needs files to load: some in the list, or a chosen folder.
+pub fn can_confirm(f: &Map<String, Value>) -> bool {
+    !owns(f) || if folder_mode(f) { !folder(f).is_empty() } else { !files(f).is_empty() }
+}
+
+/// Browse…: files to add (Files) or the folder to load (Folder), into dialog `id` once the file
+/// dialog answers.
+fn browse(app: &mut PhotocraftApp, id: u64, folder: bool) {
+    let r = if folder {
+        app.ask_folder(move |app, path| {
+            let d = app.ui.dialog_mut(id).ok_or("the dialog was closed")?;
+            d.fields.insert("folder".into(), json!(path));
+            Ok(Value::Null)
+        })
+    } else {
+        let initial_dir = crate::file_dialog::last_used_dir(&app.ui.recent_files);
+        app.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: None }, move |app, answer| {
+            let FileDialogAnswer::Paths(paths) = answer else { return Err("Load Files into Stack reads files from disk".into()) };
+            let d = app.ui.dialog_mut(id).ok_or("the dialog was closed")?;
+            add(&mut d.fields, paths);
+            Ok(Value::Null)
+        })
+    };
+    if let Err(e) = r.map(|_| ()).or_else(|e| if e == crate::file_dialog::CANCELLED { Ok(()) } else { Err(e) }) {
+        app.ui.status = e;
+    }
+}
+
+/// The dialog's body (dialog `id`); OK and Cancel are the standard ones below it.
+pub fn body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map<String, Value>, id: u64) {
+    let t = Tokens::get(ui.ctx());
+    if statistics(f) {
+        ui.horizontal(|ui| {
+            ui.label(tl!("Choose Stack Mode:"));
+            let mut mode = f.get("mode").and_then(Value::as_str).unwrap_or("median").to_string();
+            let options: Vec<_> = photocraft_doc::StackMode::ALL.iter().map(|m| (m.id().to_string(), m.label())).collect();
+            if widgets::dropdown(ui, "statistics-stack-mode", &mut mode, &options, 180.0) {
+                f.insert("mode".into(), json!(mode));
+            }
+        });
+        ui.add_space(8.0);
+    }
+    ui.label(RichText::new(tl!("Source Files")).font(crate::theme::semibold(13.0)));
+    ui.add_space(4.0);
+    ui.horizontal(|ui| {
+        ui.label(tl!("Use:"));
+        let mut mode = usize::from(folder_mode(f));
+        let options = [(0, tl!("Files")), (1, tl!("Folder"))];
+        if widgets::dropdown(ui, "load-stack-use", &mut mode, &options, 120.0) {
+            f.insert("use".into(), json!(if mode == 1 { "folder" } else { "files" }));
+            f.remove("selected");
+        }
+    });
+    ui.add_space(6.0);
+    let folder_mode = folder_mode(f);
+    let mut browse_now = false;
+    ui.horizontal_top(|ui| {
+        // The list: the chosen files, or the images in the chosen folder.
+        let shown: Vec<String> = if folder_mode {
+            if folder(f).is_empty() { Vec::new() } else { photocraft_engine::file_cmds::list_images(folder(f)).unwrap_or_default() }
+        } else {
+            files(f)
+        };
+        let sel = selected(f);
+        egui::Frame::NONE.fill(t.field).stroke(egui::Stroke::new(1.0, t.field_border)).corner_radius(t.radius_sm).inner_margin(4.0).show(ui, |ui| {
+            ui.set_min_size(vec2(300.0, 160.0));
+            ui.set_max_width(300.0);
+            egui::ScrollArea::vertical().id_salt("load-stack-files").max_height(160.0).auto_shrink([false, false]).show(ui, |ui| {
+                ui.with_layout(egui::Layout::top_down(egui::Align::Min), |ui| {
+                    if folder_mode && !folder(f).is_empty() {
+                        ui.label(RichText::new(folder(f)).color(t.text_dim));
+                    }
+                    for (i, p) in shown.iter().enumerate() {
+                        let row = ui.add(egui::Button::selectable(!folder_mode && sel == Some(i), file_name(p))).on_hover_text(p.as_str());
+                        if row.clicked() && !folder_mode {
+                            f.insert("selected".into(), json!(i));
+                        }
+                    }
+                });
+            });
+        });
+        ui.add_space(8.0);
+        ui.vertical(|ui| {
+            ui.spacing_mut().item_spacing.y = 4.0;
+            if widgets::secondary_button(ui, tl!("Browse…"), 120.0).clicked() {
+                browse_now = true;
+            }
+            let can_remove = !folder_mode && sel.is_some_and(|i| i < files(f).len());
+            if ui.add_enabled_ui(can_remove, |ui| widgets::secondary_button(ui, tl!("Remove"), 120.0)).inner.clicked()
+                && let Some(i) = sel
+            {
+                let mut list = files(f);
+                list.remove(i);
+                f.insert("files".into(), json!(list));
+                f.remove("selected");
+            }
+            let open = open_files(app);
+            if ui.add_enabled_ui(!folder_mode && !open.is_empty(), |ui| widgets::secondary_button(ui, tl!("Add Open Files"), 120.0)).inner.clicked() {
+                add(f, open);
+            }
+            if ui.add_enabled_ui(!folder_mode && files(f).len() > 1, |ui| widgets::secondary_button(ui, tl!("Sort By Name"), 120.0)).inner.clicked() {
+                let mut list = files(f);
+                list.sort_by_key(|p| file_name(p).to_lowercase());
+                f.insert("files".into(), json!(list));
+                f.remove("selected");
+            }
+        });
+    });
+    ui.add_space(8.0);
+    for (key, label) in [("align", tl!("Attempt to Automatically Align Source Images")), ("smartObject", tl!("Create Smart Object after Loading Layers"))] {
+        if statistics(f) && key == "smartObject" {
+            continue;
+        }
+        let mut on = f.get(key).and_then(Value::as_bool).unwrap_or(false);
+        if widgets::checkbox(ui, &mut on, label).changed() {
+            f.insert(key.into(), json!(on));
+        }
+    }
+    if browse_now {
+        // The file dialog's answer lands in the dialog's own fields: save this frame's edits first.
+        if let Some(d) = app.ui.dialog_mut(id) {
+            d.fields = f.clone();
+        }
+        browse(app, id, folder_mode);
+    }
+}
+
+/// OK: load the list (or the folder) into a new document.
+pub fn confirm(app: &mut PhotocraftApp, f: &Map<String, Value>) -> Result<Value, String> {
+    let paths = if folder_mode(f) {
+        let dir = folder(f);
+        if dir.is_empty() {
+            return Err("Choose a folder to load".into());
+        }
+        json!(dir)
+    } else {
+        let list = files(f);
+        if list.is_empty() {
+            return Err("Add the files to load".into());
+        }
+        json!(list)
+    };
+    let align = f.get("align").and_then(Value::as_bool).unwrap_or(false);
+    let smart = f.get("smartObject").and_then(Value::as_bool).unwrap_or(false);
+    let r = if statistics(f) {
+        let mode = f.get("mode").and_then(Value::as_str).unwrap_or("median");
+        app.run(STATISTICS, json!({"paths": paths, "align": align, "mode": mode}))
+    } else {
+        app.run(COMMAND, json!({"paths": paths, "align": align, "createSmartObject": smart}))
+    };
+    if r.is_ok() {
+        app.sync_views();
+    }
+    r
+}
+
+#[cfg(test)]
+#[path = "stack_dialog_tests.rs"]
+mod tests;
diff --git a/crates/ui-egui/src/stack_dialog_tests.rs b/crates/ui-egui/src/stack_dialog_tests.rs
new file mode 100644
index 0000000000..164e9e3671
--- /dev/null
+++ b/crates/ui-egui/src/stack_dialog_tests.rs
@@ -0,0 +1,230 @@
+use egui::vec2;
+use egui_kittest::Harness;
+use egui_kittest::kittest::{NodeT, Queryable};
+
+use super::*;
+use crate::file_dialog::{FileDialogAnswer, FileDialogRequest};
+
+/// `n` small PNGs named `names` in a fresh folder for `tag`: (folder, paths).
+fn pngs(tag: &str, names: &[&str]) -> (String, Vec<String>) {
+    let dir = std::env::temp_dir().join(format!("photocraft-load-stack-{tag}-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let mut s = photocraft_engine::Session::new();
+    s.execute("file.new", json!({"width": 8, "height": 6, "background": "#406080"})).unwrap();
+    let paths = names
+        .iter()
+        .map(|n| {
+            let p = dir.join(n).to_string_lossy().into_owned();
+            s.execute("file.saveACopy", json!({"path": p})).unwrap();
+            p
+        })
+        .collect();
+    (dir.to_string_lossy().into_owned(), paths)
+}
+
+fn harness(answers: Vec<Option<FileDialogAnswer>>) -> (Harness<'static, PhotocraftApp>, std::rc::Rc<std::cell::RefCell<Vec<FileDialogRequest>>>) {
+    let (show, asked) = crate::file_dialog::fake(answers);
+    let h = Harness::builder().with_size(vec2(1440.0, 900.0)).with_max_steps(64).build_eframe(move |cc| {
+        PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+        PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services { file_dialog: Some(show), ..Default::default() })
+    });
+    (h, asked)
+}
+
+fn dialog(h: &Harness<'_, PhotocraftApp>) -> Option<(u64, Map<String, Value>)> {
+    h.state().ui.dialogs.iter().find(|d| owns(&d.fields)).map(|d| (d.id, d.fields.clone()))
+}
+
+fn listed(h: &Harness<'_, PhotocraftApp>) -> Vec<String> {
+    dialog(h).map(|(_, f)| files(&f).iter().map(|p| file_name(p).to_string()).collect()).unwrap_or_default()
+}
+
+#[test]
+fn statistics_menu_opens_a_source_file_list_with_stack_mode() {
+    let (mut h, _) = harness(vec![]);
+    let ctx = h.ctx.clone();
+    crate::menus::invoke(h.state_mut(), &ctx, "file.scripts.statistics", json!({})).unwrap();
+    h.run_steps(4);
+    for label in ["Choose Stack Mode:", "Source Files", "Browse…", "Remove", "Add Open Files", "Sort By Name", "Attempt to Automatically Align Source Images"]
+    {
+        assert!(h.query_by_label(label).is_some(), "Statistics is missing {label}");
+    }
+    assert!(h.get_by_label("OK").accesskit_node().is_disabled(), "choose source files before running statistics");
+    assert!(h.query_by_label("Create Smart Object after Loading Layers").is_none(), "Statistics always creates its stack smart object");
+    assert!(!dialog(&h).unwrap().1.contains_key("input"), "no generic Input field");
+    h.get_by_label("Cancel").click();
+    h.run_steps(2);
+    assert!(dialog(&h).is_none());
+    assert!(h.state().session.documents().is_empty());
+}
+
+#[test]
+fn statistics_browse_and_mode_selection_compute_the_chosen_statistic() {
+    let (_, paths) = pngs("statistics-mean", &["first.png", "second.png"]);
+    let mut source = photocraft_engine::Session::new();
+    source.execute("file.new", json!({"width": 8, "height": 6, "background": "#80a0c0"})).unwrap();
+    source.execute("file.saveACopy", json!({"path": paths[1]})).unwrap();
+    let (mut h, _) = harness(vec![Some(FileDialogAnswer::Paths(paths))]);
+    let ctx = h.ctx.clone();
+    crate::menus::invoke(h.state_mut(), &ctx, STATISTICS, json!({})).unwrap();
+    h.run_steps(3);
+    h.get_by_label("Browse…").click();
+    h.run_steps(4);
+    assert_eq!(listed(&h), ["first.png", "second.png"]);
+    assert!(h.get_by_label("first.png").rect().bottom() <= h.get_by_label("second.png").rect().top(), "source files must be vertical rows");
+    h.get_by_value("Median").click();
+    h.run_steps(2);
+    for mode in photocraft_doc::StackMode::ALL {
+        assert!(h.query_by_label(mode.label()).is_some(), "missing {}", mode.label());
+    }
+    h.get_by_label("Mean").click();
+    h.run_steps(2);
+    h.get_by_label("OK").click();
+    h.run_steps(4);
+    assert!(dialog(&h).is_none());
+    assert_eq!(h.state().session.documents().len(), 1);
+    let doc = &h.state().session.active().unwrap().doc;
+    assert_eq!(doc.layers.len(), 1);
+    let photocraft_doc::LayerContent::Smart(smart) = &doc.layers[0].content else { panic!("expected a stack smart object") };
+    assert_eq!(smart.stack_mode, Some(photocraft_doc::StackMode::Mean));
+    let pixel = photocraft_compose::flatten(doc).px[0];
+    for (actual, expected) in pixel.iter().zip([96.0, 128.0, 160.0, 255.0]) {
+        assert!((actual * 255.0 - expected).abs() < 1.5, "{pixel:?}");
+    }
+}
+
+#[test]
+fn statistics_explicit_parameters_bypass_the_dialog() {
+    let (_, paths) = pngs("statistics-script", &["one.png", "two.png"]);
+    let (mut h, _) = harness(vec![]);
+    let ctx = h.ctx.clone();
+    let result = crate::menus::invoke(h.state_mut(), &ctx, STATISTICS, json!({"input": paths, "mode": "maximum"})).unwrap();
+    assert_eq!(result["images"], 2);
+    assert_eq!(result["mode"], "maximum");
+    assert!(dialog(&h).is_none());
+}
+
+#[test]
+fn statistics_folder_and_alignment_reach_the_engine() {
+    let (dir, paths) = pngs("statistics-folder", &["one.png", "two.png"]);
+    // Auto-Align needs identifiable detail, not a uniform tiny colour swatch.
+    let mut source = photocraft_engine::Session::new();
+    source.execute("file.new", json!({"width": 96, "height": 72, "background": "#606060"})).unwrap();
+    source
+        .edit("texture", |doc, active| {
+            let surface = doc.layer_mut(active.unwrap()).unwrap().surface_mut().unwrap();
+            for k in 0..40 {
+                let (x, y, v) = ((k * 37) % 88, (k * 23) % 66, (k % 7) as f32 / 6.0);
+                surface.fill_rect(photocraft_geom::Rect::new(x, y, x + 3 + k % 5, y + 2 + k % 4), &[v, 1.0 - v, 0.5, 1.0]);
+            }
+            Ok(())
+        })
+        .unwrap();
+    for path in paths {
+        source.execute("file.saveACopy", json!({"path": path})).unwrap();
+    }
+    let (mut h, _) = harness(vec![Some(FileDialogAnswer::FolderTo(dir))]);
+    let id = open_statistics(h.state_mut());
+    h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("use".into(), json!("folder"));
+    h.run_steps(3);
+    h.get_by_label("Browse…").click();
+    h.run_steps(4);
+    h.get_by_label("Attempt to Automatically Align Source Images").click();
+    h.run_steps(2);
+    assert_eq!(dialog(&h).unwrap().1["align"], true);
+    let result = crate::dialogs::confirm(h.state_mut(), id).unwrap();
+    assert_eq!(result["images"], 2);
+    assert_eq!(result["mode"], "median");
+    let doc = &h.state().session.active().unwrap().doc;
+    let photocraft_doc::LayerContent::Smart(smart) = &doc.layers[0].content else { panic!("expected a stack smart object") };
+    assert_eq!(smart.stack_mode, Some(photocraft_doc::StackMode::Median));
+}
+
+/// #4671 / #4696: the menu opens Photoshop's dialog, Browse… adds files (once each), Remove,
+/// Sort By Name and Add Open Files edit the list, and OK loads it.
+#[test]
+fn source_files_list_is_built_with_browse_remove_sort_and_open_files() {
+    let (_, paths) = pngs("files", &["b.png", "c.png", "a.png"]);
+    let (mut h, asked) = harness(vec![
+        Some(FileDialogAnswer::Paths(vec![paths[0].clone(), paths[1].clone()])),
+        Some(FileDialogAnswer::Paths(vec![paths[2].clone(), paths[0].clone()])),
+    ]);
+    let ctx = h.ctx.clone();
+    crate::menus::invoke(h.state_mut(), &ctx, COMMAND, json!({})).unwrap();
+    h.run_steps(4);
+    assert!(dialog(&h).is_some(), "the menu opens the dialog");
+    for label in [
+        "Source Files",
+        "Browse…",
+        "Remove",
+        "Add Open Files",
+        "Sort By Name",
+        "Attempt to Automatically Align Source Images",
+        "Create Smart Object after Loading Layers",
+    ] {
+        assert!(h.query_by_label(label).is_some(), "{label}");
+    }
+    assert!(h.get_by_label("OK").accesskit_node().is_disabled(), "nothing to load yet");
+    assert!(h.get_by_label("Remove").accesskit_node().is_disabled());
+
+    h.get_by_label("Browse…").click();
+    h.run_steps(4);
+    assert!(matches!(asked.borrow()[0], FileDialogRequest::Open { multiple: true, .. }), "{:?}", asked.borrow());
+    assert_eq!(listed(&h), ["b.png", "c.png"]);
+    assert!(h.get_by_label("b.png").rect().bottom() <= h.get_by_label("c.png").rect().top(), "source files must be vertical rows");
+    h.get_by_label("Browse…").click();
+    h.run_steps(4);
+    assert_eq!(listed(&h), ["b.png", "c.png", "a.png"], "b.png only once");
+
+    h.get_by_label("Sort By Name").click();
+    h.run_steps(2);
+    assert_eq!(listed(&h), ["a.png", "b.png", "c.png"]);
+    h.get_by_label("b.png").click();
+    h.run_steps(2);
+    h.get_by_label("Remove").click();
+    h.run_steps(2);
+    assert_eq!(listed(&h), ["a.png", "c.png"]);
+
+    // Add Open Files: the open documents that have a file (b.png, already saved; not the untitled one).
+    h.state_mut().run("file.new", json!({"width": 4, "height": 4})).unwrap();
+    h.state_mut().session.active_mut().unwrap().path = Some(paths[0].clone());
+    h.state_mut().run("file.new", json!({"width": 4, "height": 4})).unwrap();
+    h.run_steps(3);
+    h.get_by_label("Add Open Files").click();
+    h.run_steps(2);
+    assert_eq!(listed(&h), ["a.png", "c.png", "b.png"]);
+
+    let docs = h.state().session.documents().len();
+    h.get_by_label("OK").click();
+    h.run_steps(4);
+    assert!(dialog(&h).is_none());
+    assert_eq!(h.state().session.documents().len(), docs + 1, "a new document");
+    let d = &h.state().session.active().unwrap().doc;
+    let names: Vec<&str> = d.layers.iter().map(|l| l.name.as_str()).collect();
+    assert_eq!(names, ["a.png", "c.png", "b.png"], "one layer per file, in the list's order");
+}
+
+/// Use: Folder loads the images of the folder Browse… chose, listed in the dialog; with Create
+/// Smart Object they go into one smart object.
+#[test]
+fn a_folder_loads_its_images() {
+    let (dir, _) = pngs("folder", &["one.png", "two.png"]);
+    let (mut h, asked) = harness(vec![Some(FileDialogAnswer::FolderTo(dir.clone()))]);
+    let id = open(h.state_mut());
+    h.run_steps(3);
+    h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("use".into(), json!("folder"));
+    h.run_steps(2);
+    assert!(h.get_by_label("Remove").accesskit_node().is_disabled() && h.get_by_label("Add Open Files").accesskit_node().is_disabled());
+    h.get_by_label("Browse…").click();
+    h.run_steps(4);
+    assert!(matches!(asked.borrow()[0], FileDialogRequest::Folder { .. }));
+    assert!(h.query_by_label("one.png").is_some() && h.query_by_label("two.png").is_some(), "the folder's images are listed");
+    // Create Smart Object after Loading Layers: both images inside one smart object.
+    h.get_by_label("Create Smart Object after Loading Layers").click();
+    h.run_steps(2);
+    crate::dialogs::confirm(h.state_mut(), id).unwrap();
+    let d = &h.state().session.active().unwrap().doc;
+    assert_eq!(d.layers.len(), 1);
+    assert!(matches!(d.layers[0].content, photocraft_doc::LayerContent::Smart(_)));
+}
diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs
index 8d84b55157..42997fe62c 100644
--- a/crates/ui-egui/src/state.rs
+++ b/crates/ui-egui/src/state.rs
@@ -494,6 +494,10 @@ pub struct DocWindow {
     pub document: usize,
     pub view: View,
     pub open: bool,
+    /// Where the window opens on screen (outer top-left, in points); `None` lets the OS place it.
+    /// A tab dragged off the tab strip opens its window where it was dropped (#3733).
+    #[serde(default)]
+    pub position: Option<[f32; 2]>,
 }
 
 /// Options-bar state for tools (Photoshop keeps these per tool).
@@ -504,6 +508,13 @@ pub struct ToolOptions {
     pub contiguous: bool,
     pub anti_alias: bool,
     pub sample_all_layers: bool,
+    /// Object Selection › Object Finder: hovering highlights the object a click selects (#4087).
+    pub object_finder: bool,
+    /// Remove tool: the fill goes to a new layer above the target (Photoshop's Create a new layer).
+    pub remove_new_layer: bool,
+    /// Remove tool: each stroke is filled when released (Photoshop's default). Off, the strokes
+    /// collect as a tint on the canvas and ↩ applies them together (Esc drops them).
+    pub remove_after_each_stroke: bool,
     pub feather: f32,
     /// linear | radial | angle | reflected | diamond
     pub gradient_style: String,
@@ -577,6 +588,10 @@ pub struct ToolOptions {
     /// Freeform Pen › Curve Fit: how far (px) the fitted path may stray from the pointer trace.
     #[serde(default = "default_curve_fit")]
     pub curve_fit: f32,
+    /// Pen › Auto Add/Delete: a Pen click on a segment of the active path adds an anchor there,
+    /// on one of its anchors deletes it (#4144).
+    #[serde(default = "yes")]
+    pub pen_auto_add_delete: bool,
     /// Marquee options bar: "normal" | "fixedRatio" | "fixedSize", with the ratio or size.
     #[serde(default = "default_marquee_style")]
     pub marquee_style: String,
@@ -585,7 +600,8 @@ pub struct ToolOptions {
     #[serde(default = "one")]
     pub marquee_height: f32,
     /// Move tool: Auto-Select (with "layer" or "group" target) and Show Transform Controls.
-    /// Auto-Select is on by default, as in current Photoshop; ⌘/Ctrl-click inverts it.
+    /// Auto-Select is on with the "group" target by default, as in current Photoshop;
+    /// ⌘/Ctrl-click inverts it.
     #[serde(default = "yes")]
     pub move_auto_select: bool,
     #[serde(default = "default_move_target")]
@@ -697,7 +713,7 @@ fn default_crop_resolution_unit() -> String {
 }
 
 fn default_move_target() -> String {
-    "layer".into()
+    "group".into()
 }
 
 fn default_curve_fit() -> f32 {
@@ -740,6 +756,9 @@ impl Default for ToolOptions {
             contiguous: true,
             anti_alias: true,
             sample_all_layers: false,
+            object_finder: true,
+            remove_new_layer: false,
+            remove_after_each_stroke: true,
             feather: 0.0,
             gradient_style: "linear".into(),
             gradient_reverse: false,
@@ -785,6 +804,7 @@ impl Default for ToolOptions {
             polygon_sides: 5,
             line_weight: 3.0,
             curve_fit: default_curve_fit(),
+            pen_auto_add_delete: true,
             marquee_style: default_marquee_style(),
             marquee_width: 1.0,
             marquee_height: 1.0,
@@ -836,10 +856,12 @@ impl Default for ToolOptions {
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum TransformMode {
-    /// Free Transform, Scale and Rotate.
+    /// Free Transform and Scale: handles scale, drag outside rotates.
     #[default]
     Free,
-    /// Edge handles skew.
+    /// Edit › Transform › Rotate: handle drags rotate about the reference point (#3941).
+    Rotate,
+    /// Edge and corner handles skew: each moves along one axis.
     Skew,
     /// Corner handles move freely, one at a time; nothing else moves them (no rotating, no
     /// edges) and nothing snaps.
@@ -852,6 +874,7 @@ impl TransformMode {
     /// The mode an `edit.transform.*` / `edit.freeTransform` menu id starts.
     pub fn for_command(id: &str) -> Self {
         match id {
+            "edit.transform.rotate" => Self::Rotate,
             "edit.transform.skew" => Self::Skew,
             "edit.transform.distort" => Self::Distort,
             "edit.transform.perspective" => Self::Perspective,
@@ -889,13 +912,17 @@ pub struct TransformSession {
     /// Cancel takes it back and OK folds it into one history step with the transform.
     #[serde(default)]
     pub made: Option<MadeLayer>,
-    /// Edit › Transform › Skew / Distort / Perspective (`Free` for Free Transform).
+    /// Edit › Transform › Rotate / Skew / Distort / Perspective (`Free` for Free Transform and Scale).
     #[serde(default)]
     pub mode: TransformMode,
     /// Edit › Content-Aware Scale (#3096): the box only scales and moves, and OK runs
     /// `edit.contentAwareScale` with these options instead of `edit.transform`.
     #[serde(default)]
     pub content_aware: Option<ContentAwareOptions>,
+    /// The options bar's V (vertical skew, degrees) last typed. Any box can be read as scale,
+    /// skew and rotation with any vertical skew, so the bar keeps showing the typed one.
+    #[serde(default)]
+    pub skew_v: f64,
 }
 
 /// Content-Aware Scale's options bar: Amount, Protect and Protect Skin Tones.
@@ -1021,6 +1048,10 @@ pub struct UiState {
     /// one per group: the group's key brings it back, as in Photoshop (#2608).
     #[serde(default)]
     pub group_tools: Vec<Tool>,
+    /// A tool letter still held (spring-loaded tool, #2672): the tool to give back on release.
+    /// Exposed to automation, never restored from settings.
+    #[serde(default, skip_deserializing)]
+    pub spring: Option<crate::spring_tools::Spring>,
     /// Recently opened file paths, most-recent first (File › Open Recent). Capped; de-duplicated.
     #[serde(default)]
     pub recent_files: Vec<String>,
@@ -1039,6 +1070,10 @@ pub struct UiState {
     /// Free Transform session, if any.
     #[serde(default)]
     pub transform: Option<TransformSession>,
+    /// The options bar's Maintain Aspect Ratio link is off: W/H change on their own, and handle
+    /// drags stretch freely (⇧ keeps the proportions), as in Photoshop (#4174).
+    #[serde(default)]
+    pub transform_unlinked: bool,
     /// Temporary symmetry-axis editing, exposed to automation but never restored from settings.
     #[serde(default, skip_deserializing)]
     pub symmetry_transform: Option<crate::symmetry_ui::Transform>,
@@ -1187,6 +1222,10 @@ pub struct UiState {
     /// modifiers held at its first click.
     #[serde(default)]
     pub polygon_mode: String,
+    /// The document the polygon is drawn on (set at its first click): another document becoming
+    /// active drops it (`canvas::polygon_cancel_stale`).
+    #[serde(default)]
+    pub polygon_doc: Option<photocraft_doc::DocId>,
     /// Magnetic Lasso border in progress (`magnetic_lasso_ui`).
     #[serde(default)]
     pub magnetic: crate::magnetic_lasso_ui::MagneticLasso,
@@ -1232,12 +1271,14 @@ impl Default for UiState {
         Self {
             tool: Tool::Brush,
             group_tools: Vec::new(),
+            spring: None,
             recent_files: Vec::new(),
             text_edit: None,
             type_transform: None,
             type_transform_pivot: None,
             cam_transform: None,
             transform: None,
+            transform_unlinked: false,
             symmetry_transform: None,
             layer_picker: None,
             mask_target: false,
@@ -1292,6 +1333,7 @@ impl Default for UiState {
             tool_options: ToolOptions::default(),
             polygon: Vec::new(),
             polygon_mode: String::new(),
+            polygon_doc: None,
             magnetic: Default::default(),
             crop_rect: None,
             crop_angle: 0.0,
diff --git a/crates/ui-egui/src/status_bar_tests.rs b/crates/ui-egui/src/status_bar_tests.rs
index 4e4f4a0db5..eebd7e84bc 100644
--- a/crates/ui-egui/src/status_bar_tests.rs
+++ b/crates/ui-egui/src/status_bar_tests.rs
@@ -61,3 +61,160 @@ fn status_bar_controls_sit_inside_the_bar_with_even_margins() {
         assert!((fit.height() - control_h).abs() < 0.01, "{kind:?}: Fit {fit:?}");
     }
 }
+
+fn cursor_warp(h: &Harness<'_, PhotocraftApp>) -> Option<egui::Pos2> {
+    h.output().viewport_output.values().flat_map(|v| &v.commands).find_map(|c| match c {
+        egui::ViewportCommand::CursorPosition(p) => Some(*p),
+        _ => None,
+    })
+}
+
+fn fullscreen(h: &mut Harness<'_, PhotocraftApp>, on: bool) {
+    h.input_mut().viewports.entry(egui::ViewportId::ROOT).or_default().fullscreen = Some(on);
+    h.state_mut().ui.views[0].zoom = 10.0;
+    h.run_steps(2);
+}
+
+fn begin_zoom_drag(h: &mut Harness<'_, PhotocraftApp>) -> egui::Pos2 {
+    let start = h.get_by_role(egui::accesskit::Role::SpinButton).rect().center();
+    h.hover_at(start);
+    h.run_steps(1);
+    h.drag_at(start);
+    h.run_steps(1);
+    start
+}
+
+/// #3344: both status-bar layouts can scrub across either fullscreen edge. Simulate the native
+/// CursorPosition acknowledgement as a PointerMoved, then keep dragging in the same direction.
+#[test]
+fn fullscreen_status_zoom_wraps_without_turning_the_warp_into_a_value_change() {
+    for kind in ThemeKind::ALL {
+        for left in [true, false] {
+            let mut h = harness(kind);
+            fullscreen(&mut h, true);
+            let start = begin_zoom_drag(&mut h);
+            let edge = pos2(if left { 0.5 } else { SIZE.x - 0.5 }, start.y);
+            h.hover_at(edge);
+            h.run_steps(1);
+            let target = cursor_warp(&h).unwrap_or_else(|| panic!("{kind:?}: wrap at {edge:?}"));
+            assert_eq!(target.y, edge.y, "{kind:?}: preserve Y");
+            assert_eq!(target.x, if left { SIZE.x - 3.0 } else { 3.0 });
+            let at_edge = h.state().ui.views[0].zoom;
+            h.hover_at(target);
+            h.run_steps(1);
+            assert_eq!(h.state().ui.views[0].zoom, at_edge, "{kind:?}: cursor teleport must not change zoom");
+            assert!(cursor_warp(&h).is_none(), "{kind:?}: landing margin must not bounce");
+            let next = target + vec2(if left { -40.0 } else { 40.0 }, 0.0);
+            h.hover_at(next);
+            h.run_steps(1);
+            let continued = h.state().ui.views[0].zoom;
+            assert!((continued - at_edge - if left { -0.2 } else { 0.2 }).abs() < 0.015, "{kind:?}: {at_edge} -> {continued}");
+            h.drop_at(next);
+            h.run_steps(2);
+            h.hover_at(edge);
+            h.run_steps(1);
+            assert_eq!(h.state().ui.views[0].zoom, continued, "{kind:?}: pointer movement after release is not scrubbing");
+            assert!(cursor_warp(&h).is_none());
+        }
+    }
+}
+
+#[test]
+fn status_zoom_does_not_warp_for_windowed_scrubbing_or_hovering() {
+    for kind in [ThemeKind::ProMedium, ThemeKind::Studio] {
+        let mut h = harness(kind);
+        fullscreen(&mut h, true);
+        h.hover_at(pos2(0.5, SIZE.y - 10.0));
+        h.run_steps(1);
+        assert!(cursor_warp(&h).is_none(), "hovering the edge");
+        fullscreen(&mut h, false);
+        let start = begin_zoom_drag(&mut h);
+        let edge = pos2(0.5, start.y);
+        h.hover_at(edge);
+        h.run_steps(1);
+        assert!(cursor_warp(&h).is_none(), "ordinary windowed DragValue");
+        assert!(h.state().ui.views[0].zoom < 10.0);
+        h.drop_at(edge);
+        h.run_steps(2);
+    }
+}
+
+#[test]
+fn fullscreen_status_zoom_keeps_typing_and_clears_a_pending_warp_on_release() {
+    let mut h = harness(ThemeKind::ProMedium);
+    fullscreen(&mut h, true);
+    let start = begin_zoom_drag(&mut h);
+    h.hover_at(pos2(0.5, start.y));
+    h.run_steps(1);
+    let target = cursor_warp(&h).expect("wrap");
+    let before = h.state().ui.views[0].zoom;
+    h.drop_at(target);
+    h.run_steps(2);
+    assert_eq!(h.state().ui.views[0].zoom, before);
+    h.get_by_role(egui::accesskit::Role::SpinButton).click();
+    h.run_steps(2);
+    h.event(egui::Event::Text("250%".into()));
+    h.key_press(egui::Key::Enter);
+    h.run_steps(3);
+    assert_eq!(h.state().ui.views[0].zoom, 2.5);
+    assert!(cursor_warp(&h).is_none());
+    h.get_by_role(egui::accesskit::Role::SpinButton).click();
+    h.run_steps(2);
+    h.key_press(egui::Key::ArrowUp);
+    h.run_steps(2);
+    assert!((h.state().ui.views[0].zoom - 2.51).abs() < 0.0001, "keep keyboard stepping in fullscreen");
+}
+
+#[test]
+fn fullscreen_status_zoom_preserves_shift_precision_and_recovers_from_the_minimum() {
+    let mut h = harness(ThemeKind::ProMedium);
+    fullscreen(&mut h, true);
+    let start = begin_zoom_drag(&mut h);
+    h.event(egui::Event::ModifiersChanged(egui::Modifiers::SHIFT));
+    let to = start + vec2(40.0, 0.0);
+    h.hover_at(to);
+    h.run_steps(1);
+    assert!((h.state().ui.views[0].zoom - 10.02).abs() < 0.005, "Shift reduces sensitivity by ten");
+    h.drop_at(to);
+    h.event(egui::Event::ModifiersChanged(egui::Modifiers::NONE));
+    h.run_steps(2);
+    h.state_mut().ui.views[0].zoom = 0.01;
+    h.run_steps(2);
+    let start = begin_zoom_drag(&mut h);
+    h.hover_at(pos2(0.5, start.y));
+    h.run_steps(1);
+    let target = cursor_warp(&h).expect("wrap");
+    let minimum = crate::zoom_levels::min(h.state().ui.views[0].doc_size);
+    assert_eq!(h.state().ui.views[0].zoom, minimum);
+    h.hover_at(target);
+    h.run_steps(1);
+    let next = target - vec2(100.0, 0.0);
+    h.hover_at(next);
+    h.run_steps(1);
+    assert_eq!(h.state().ui.views[0].zoom, minimum);
+    h.hover_at(next + vec2(20.0, 0.0));
+    h.run_steps(1);
+    assert!(h.state().ui.views[0].zoom > minimum, "reversing direction responds immediately after reaching a bound");
+}
+
+/// #5016: toggling appearance between dark and light with default settings preserves the Pro
+/// layout and does not make a Fit button appear.
+#[test]
+fn appearance_toggle_preserves_pro_layout_and_has_no_fit_button() {
+    let mut h = harness(ThemeKind::ProMedium);
+    assert!(h.query_by_label("Fit").is_none());
+    assert!(Tokens::get(&h.ctx).pro);
+
+    // Switch to Light mode (top-bar appearance button).
+    let ctx = h.ctx.clone();
+    crate::prefs_ui::cycle_appearance(h.state_mut(), &ctx);
+    if h.state().session.prefs().interface.appearance_mode == photocraft_engine::prefs::AppearanceMode::Auto {
+        crate::prefs_ui::cycle_appearance(h.state_mut(), &ctx);
+    }
+    crate::prefs_ui::tick(h.state_mut(), &ctx);
+    h.run_steps(3);
+    assert_eq!(h.state().session.prefs().interface.appearance_mode, photocraft_engine::prefs::AppearanceMode::Light);
+    assert_eq!(h.state().ui.theme, ThemeKind::ProLight);
+    assert!(Tokens::get(&h.ctx).pro);
+    assert!(h.query_by_label("Fit").is_none(), "Fit button must not appear in light mode (#5016)");
+}
diff --git a/crates/ui-egui/src/stroke_timing_tests.rs b/crates/ui-egui/src/stroke_timing_tests.rs
index 5c369370ff..fc6d0c7e78 100644
--- a/crates/ui-egui/src/stroke_timing_tests.rs
+++ b/crates/ui-egui/src/stroke_timing_tests.rs
@@ -337,3 +337,49 @@ fn a_committed_stroke_refreshes_only_what_each_cache_had_not_shown() {
     assert_eq!(c.since(0), Some(r(0).union(&r(20)).union(&r(40))), "never showed the stroke: all of it");
     assert_eq!(c.since(99), None, "not a key of this stroke");
 }
+
+/// A Clone Stamp stroke through the canvas renders the points its commit gets (position and
+/// pressure, no tilt or times), so the commit can take the live pixels; they are what replaying
+/// the journaled command paints.
+#[test]
+fn releasing_a_clone_stamp_stroke_commits_what_a_replay_paints() {
+    let setup = |run: &mut dyn FnMut(&str, Value)| {
+        run("tools.setBrush", json!({"brush": {"size": 16, "hardness": 0.4}}));
+        run("paint.stroke", json!({"points": [[10, 20], [190, 80]], "size": 30, "hardness": 0.5, "color": "#2060c0"}));
+        run("cloneSource.set", json!({"source": [40, 30]}));
+    };
+    let mut h = harness();
+    setup(&mut |id, p| {
+        h.state_mut().run(id, p).unwrap();
+    });
+    h.state_mut().ui.tool = Tool::CloneStamp;
+    h.run_steps(1);
+    move_to(&mut h, 60.0, 50.0);
+    button(&mut h, 60.0, 50.0, true);
+    for (x, y) in [(80.0, 40.0), (110.0, 60.0), (140.0, 45.0), (170.0, 65.0)] {
+        move_to(&mut h, x, y);
+    }
+    let shown = crate::canvas::live_retouch_points(h.state()).expect("a live Clone Stamp stroke");
+    button(&mut h, 170.0, 65.0, false);
+    h.run_steps(2);
+    let app = h.state();
+    let (_, p) = app.session.journal.iter().rev().find(|(id, _)| id == "paint.cloneStamp").cloned().expect("a committed Clone Stamp stroke");
+    let committed: Vec<_> = p["points"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|q| photocraft_engine::paint::StrokePoint::new(q[0].as_f64().unwrap(), q[1].as_f64().unwrap(), q[2].as_f64().unwrap() as f32))
+        .collect();
+    assert!(shown.len() > 1 && committed.starts_with(&shown), "live {shown:?} vs committed {committed:?}");
+    let mut fresh = photocraft_engine::Session::new();
+    fresh.execute("file.new", json!({"width": 200, "height": 100, "background": "white"})).unwrap();
+    setup(&mut |id, p| {
+        fresh.execute(id, p).unwrap();
+    });
+    fresh.execute("paint.cloneStamp", p).unwrap();
+    let st = app.session.active().unwrap();
+    let a = photocraft_compose::render(&st.doc, st.doc.bounds());
+    let b = photocraft_compose::render(&fresh.active().unwrap().doc, st.doc.bounds());
+    assert_eq!(a.px.len(), b.px.len());
+    assert!(a.px.iter().zip(&b.px).all(|(x, y)| x == y), "live commit and replay differ");
+}
diff --git a/crates/ui-egui/src/stylus.rs b/crates/ui-egui/src/stylus.rs
index 6bee705147..8460c31ea2 100644
--- a/crates/ui-egui/src/stylus.rs
+++ b/crates/ui-egui/src/stylus.rs
@@ -6,7 +6,9 @@
 //! - **Windows**: winit turns `WM_POINTER` pen and touch input into `WindowEvent::Touch` with a
 //!   normalised force (`POINTER_PEN_INFO::pressure / 1024`); egui-winit forwards it as
 //!   `egui::Event::Touch { force }` alongside the emulated pointer. [`Stylus::update`] reads it.
-//!   winit drops the pen's tilt and rotation, so those stay 0.
+//!   winit drops the pen's tilt and rotation, so those stay 0, and reports pressure 0 (a tap
+//!   lighter than the pen's first pressure level) as no force, which [`Stylus::update`] reads as
+//!   pressure 0 once it knows a pen is in use.
 //! - **Web**: eframe forwards touch force but not pen pointer events, so the web runner listens
 //!   to `pointerdown`/`pointermove` itself and writes `pressure`, `tiltX`, `tiltY`, `twist` and
 //!   the eraser button of `pointerType == "pen"` events into the [`StylusFeed`].
@@ -120,6 +122,11 @@ pub struct Stylus {
     pub(crate) tool_before_eraser: Option<crate::state::Tool>,
     /// Force of the touch/pen contact currently down (egui `Event::Touch`).
     touch: Option<f32>,
+    /// The touch contacts currently down, so a touch move outside them is a hovering pen.
+    contacts: Vec<egui::TouchId>,
+    /// A pen reported through touch events (it hovered, or a contact carried a force): its
+    /// contacts without a force are at pressure 0, not a finger's full pressure.
+    touch_pen: bool,
     /// The contact ended this frame: keep its force for this frame's last tool events, clear next frame.
     lifted: bool,
     /// This frame's pen samples, oldest first (the feed's queue and the touch forces).
@@ -130,6 +137,8 @@ pub struct Stylus {
     current: Option<PenSample>,
     /// The highest pen pressure (before the curve) since the drag began, for a tap's one dab.
     peak: f32,
+    /// The pen's touch contacts in the raw input, so a held pen is no press-and-hold right click.
+    pub(crate) pen_contacts: PenContacts,
     /// The egui frame [`Self::update_for_frame`] last ran in.
     updated_frame: Option<u64>,
     /// Tilt X, tilt Y, rotation of each point of the current drag (parallel to its points).
@@ -152,11 +161,14 @@ impl Default for Stylus {
             end: None,
             tool_before_eraser: None,
             touch: None,
+            contacts: Vec::new(),
+            touch_pen: false,
             lifted: false,
             frame: Vec::new(),
             prev: None,
             current: None,
             peak: 0.0,
+            pen_contacts: PenContacts::default(),
             updated_frame: None,
             stroke: Vec::new(),
             times: Vec::new(),
@@ -186,15 +198,42 @@ impl Stylus {
         self.frame = self.feed.drain();
         self.current = None;
         for e in events {
-            if let egui::Event::Touch { phase, force, .. } = e {
+            if let egui::Event::Touch { id, phase, force, .. } = e {
+                let force = force.filter(|f| f.is_finite()).map(|f| f.clamp(0.0, 1.0));
                 match phase {
                     egui::TouchPhase::Start | egui::TouchPhase::Move => {
-                        if let Some(f) = force.filter(|f| f.is_finite()) {
-                            self.touch = Some(f.clamp(0.0, 1.0));
-                            self.frame.push(PenSample { pressure: f.clamp(0.0, 1.0), ..Default::default() });
+                        let start = *phase == egui::TouchPhase::Start;
+                        if start {
+                            // A new contact keeps its force into the next frame, even when an
+                            // earlier contact lifted in this one.
+                            self.lifted = false;
+                            if !self.contacts.contains(id) {
+                                if self.contacts.len() >= 16 {
+                                    self.contacts.remove(0);
+                                }
+                                self.contacts.push(*id);
+                            }
+                        }
+                        let down = start || self.contacts.contains(id);
+                        // Only a pen moves without touching, and only a pen (or a force-sensing
+                        // screen) reports a force.
+                        if !down || force.is_some() {
+                            self.touch_pen = true;
+                        }
+                        // Windows reports a pen pressed lighter than its first pressure level with
+                        // no force at all (winit maps pressure 0 to `None`): a light tap is
+                        // pressure 0, never a mouse click's full pressure. A finger on a screen
+                        // without force sensing stays at full pressure.
+                        let force = force.or((down && self.touch_pen && (start || self.touch.is_none())).then_some(0.0));
+                        if let Some(f) = force {
+                            self.touch = Some(f);
+                            self.frame.push(PenSample { pressure: f, ..Default::default() });
                         }
                     }
-                    egui::TouchPhase::End | egui::TouchPhase::Cancel => self.lifted = true,
+                    egui::TouchPhase::End | egui::TouchPhase::Cancel => {
+                        self.lifted = true;
+                        self.contacts.retain(|c| c != id);
+                    }
                 }
             }
         }
@@ -380,10 +419,143 @@ impl Stylus {
     }
 }
 
+/// The touch contacts a pen makes, read from the raw input. egui takes every touch contact held
+/// still past `max_click_duration` (0.8 s) for a touch screen's press-and-hold: a secondary click
+/// (a context menu) that also drops the drag. On Windows a pen arrives as touch events, so a pen
+/// held still opened a context menu. A pen held still is just a pen, as in Photoshop.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct PenContacts {
+    /// Touch ids that moved without touching: only a pen hovers.
+    hovering: Vec<egui::TouchId>,
+    /// The contacts down, and whether each is a pen.
+    down: Vec<(egui::TouchId, bool)>,
+}
+
+/// Most touch ids [`PenContacts`] remembers (the oldest go first).
+const CONTACTS: usize = 16;
+
+impl PenContacts {
+    /// Follow a frame's touch events. True when a pen contact was down at any point of the frame.
+    pub(crate) fn observe(&mut self, events: &[egui::Event]) -> bool {
+        let pressed = |f: &Option<f32>| f.is_some_and(|f| f > 0.0);
+        let mut pen = self.down.iter().any(|(_, p)| *p);
+        for e in events {
+            let egui::Event::Touch { id, phase, force, .. } = e else { continue };
+            match phase {
+                egui::TouchPhase::Start => {
+                    let is_pen = self.hovering.contains(id) || pressed(force);
+                    self.down.retain(|(c, _)| c != id);
+                    if self.down.len() >= CONTACTS {
+                        self.down.remove(0);
+                    }
+                    self.down.push((*id, is_pen));
+                    pen |= is_pen;
+                }
+                egui::TouchPhase::Move => match self.down.iter_mut().find(|(c, _)| c == id) {
+                    Some(c) if pressed(force) => {
+                        c.1 = true;
+                        pen = true;
+                    }
+                    Some(_) => {}
+                    None if !self.hovering.contains(id) => {
+                        if self.hovering.len() >= CONTACTS {
+                            self.hovering.remove(0);
+                        }
+                        self.hovering.push(*id);
+                    }
+                    None => {}
+                },
+                egui::TouchPhase::End | egui::TouchPhase::Cancel => self.down.retain(|(c, _)| c != id),
+            }
+        }
+        pen
+    }
+}
+
+/// Turn egui's touch press-and-hold off while a pen contact is down (and through the frame it
+/// lifts in, so the release is the click a quick tap would be), back on otherwise for fingers.
+pub(crate) fn pen_hold_is_no_right_click(ctx: &egui::Context, pen_down: bool) {
+    let want = if pen_down { f64::INFINITY } else { egui::InputOptions::default().max_click_duration };
+    if ctx.options(|o| o.input_options.max_click_duration) != want {
+        ctx.options_mut(|o| o.input_options.max_click_duration = want);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    /// Hold a touch contact still for 1.2 s over a click-sensing area, with the press-and-hold
+    /// handling the app does in `raw_input_hook`. Did the area see a secondary click?
+    fn held_contact_right_clicks(hover_first: bool, force: Option<f32>) -> bool {
+        let ctx = egui::Context::default();
+        let mut contacts = PenContacts::default();
+        let mut right_clicked = false;
+        let ev = |phase, force| egui::Event::Touch { device_id: egui::TouchDeviceId(1), id: egui::TouchId(3), phase, pos: egui::pos2(50.0, 50.0), force };
+        // A first frame lays the area out, so the press hits it.
+        let mut frames = vec![(0.0, vec![])];
+        if hover_first {
+            frames.push((0.05, vec![ev(egui::TouchPhase::Move, None), egui::Event::PointerMoved(egui::pos2(50.0, 50.0))]));
+        }
+        frames.push((
+            0.1,
+            vec![
+                ev(egui::TouchPhase::Start, force),
+                egui::Event::PointerMoved(egui::pos2(50.0, 50.0)),
+                egui::Event::PointerButton {
+                    pos: egui::pos2(50.0, 50.0),
+                    button: egui::PointerButton::Primary,
+                    pressed: true,
+                    modifiers: egui::Modifiers::NONE,
+                },
+            ],
+        ));
+        for t in [0.4, 0.7, 1.0, 1.3] {
+            frames.push((t, vec![]));
+        }
+        for (time, mut events) in frames {
+            // egui-winit emits the touch and its emulated pointer events together.
+            let mut raw = egui::RawInput {
+                time: Some(time),
+                screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(200.0, 200.0))),
+                ..Default::default()
+            };
+            raw.events.append(&mut events);
+            let pen = contacts.observe(&raw.events);
+            pen_hold_is_no_right_click(&ctx, pen);
+            let mut out = ctx.run_ui(raw, |ui| {
+                let r = ui.allocate_rect(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(200.0, 200.0)), egui::Sense::click_and_drag());
+                right_clicked |= r.secondary_clicked();
+            });
+            out.textures_delta.clear();
+        }
+        right_clicked
+    }
+
+    #[test]
+    fn a_held_pen_is_not_a_right_click_but_a_held_finger_still_is() {
+        assert!(held_contact_right_clicks(false, None), "a finger's press-and-hold is egui's context menu");
+        assert!(!held_contact_right_clicks(true, None), "a pen that hovered first");
+        assert!(!held_contact_right_clicks(false, Some(0.4)), "a contact that reports pressure");
+    }
+
+    #[test]
+    fn pen_contacts_follow_hover_force_and_lift() {
+        use egui::TouchPhase::{Cancel, End, Move, Start};
+        let t = |id, phase, force| egui::Event::Touch { device_id: egui::TouchDeviceId(1), id: egui::TouchId(id), phase, pos: egui::pos2(1.0, 1.0), force };
+        let mut c = PenContacts::default();
+        assert!(!c.observe(&[t(1, Move, None)]), "hovering is no contact");
+        assert!(c.observe(&[t(1, Start, None)]));
+        assert!(c.observe(&[]), "still down");
+        assert!(c.observe(&[t(1, End, None)]), "the lift frame still counts");
+        assert!(!c.observe(&[]));
+        // A finger, until it reports a force.
+        assert!(!c.observe(&[t(9, Start, None), t(9, Move, None)]));
+        assert!(c.observe(&[t(9, Move, Some(0.5))]));
+        assert!(c.observe(&[t(9, Cancel, None)]));
+        assert!(!c.observe(&[]));
+    }
+
     fn touch(phase: egui::TouchPhase, force: Option<f32>) -> egui::Event {
         egui::Event::Touch { device_id: egui::TouchDeviceId(1), id: egui::TouchId(0), phase, pos: egui::pos2(1.0, 1.0), force }
     }
@@ -525,6 +697,59 @@ mod tests {
         assert_eq!(s.pressure(), 1.0);
     }
 
+    fn touch_id(id: u64, phase: egui::TouchPhase, force: Option<f32>) -> egui::Event {
+        egui::Event::Touch { device_id: egui::TouchDeviceId(1), id: egui::TouchId(id), phase, pos: egui::pos2(1.0, 1.0), force }
+    }
+
+    #[test]
+    fn a_light_windows_pen_tap_is_not_full_pressure() {
+        use egui::TouchPhase::{End, Move, Start};
+        // winit on Windows reports a pen pressed below its first pressure level with no force
+        // (pressure 0 maps to `None`). The pen hovered first, so the tap is pressure 0, not a
+        // mouse click's 1.
+        let mut s = Stylus::default();
+        s.update(&[touch_id(5, Move, None)]);
+        assert_eq!(s.pressure(), 1.0, "hovering is no contact");
+        s.update(&[touch_id(5, Start, None), touch_id(5, End, None)]);
+        assert_eq!(s.pressure(), 0.0);
+        assert_eq!(s.tap_pressure(), 0.0);
+        s.update(&[]);
+        assert_eq!(s.pressure(), 1.0, "lifted");
+        // A pen known from an earlier force: a stroke pressed before its first level starts at 0
+        // and then follows the pen.
+        let mut s = Stylus::default();
+        s.update(&[touch_id(7, Start, Some(0.5)), touch_id(7, End, None)]);
+        s.update(&[]);
+        s.update(&[touch_id(8, Start, None)]);
+        assert_eq!(s.pressure(), 0.0);
+        s.update(&[touch_id(8, Move, Some(0.3))]);
+        assert_eq!(s.pressure(), 0.3);
+        // A force-less move mid-stroke keeps the last force.
+        s.update(&[touch_id(8, Move, None)]);
+        assert_eq!(s.pressure(), 0.3);
+    }
+
+    #[test]
+    fn a_finger_without_force_still_paints_at_full_pressure() {
+        use egui::TouchPhase::{End, Move, Start};
+        let mut s = Stylus::default();
+        s.update(&[touch_id(1, Start, None), touch_id(1, Move, None)]);
+        assert_eq!(s.pressure(), 1.0);
+        s.update(&[touch_id(1, End, None)]);
+        s.update(&[]);
+        assert_eq!(s.pressure(), 1.0);
+    }
+
+    #[test]
+    fn a_new_tap_in_the_frame_an_old_one_lifted_keeps_its_force() {
+        use egui::TouchPhase::{End, Start};
+        let mut s = Stylus::default();
+        s.update(&[touch_id(1, Start, Some(0.6)), touch_id(1, End, None), touch_id(2, Start, Some(0.2))]);
+        assert_eq!(s.pressure(), 0.2);
+        s.update(&[]);
+        assert_eq!(s.pressure(), 0.2, "the second contact is still down");
+    }
+
     #[test]
     fn feed_wins_and_is_sanitized() {
         let mut s = Stylus::default();
diff --git a/crates/ui-egui/src/swatches_ui.rs b/crates/ui-egui/src/swatches_ui.rs
index d8fd9caa47..749ab4a059 100644
--- a/crates/ui-egui/src/swatches_ui.rs
+++ b/crates/ui-egui/src/swatches_ui.rs
@@ -286,6 +286,20 @@ mod tests {
         h.run_steps(1);
     }
 
+    /// Drag from `from` to `to` in steps, as when a user drags a group header.
+    fn drag(h: &mut Harness<'_, PhotocraftApp>, from: egui::Pos2, to: egui::Pos2) {
+        h.event(egui::Event::PointerMoved(from));
+        h.run_steps(1);
+        h.event(egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+        h.run_steps(1);
+        for i in 1..=6 {
+            h.event(egui::Event::PointerMoved(from + (to - from) * (i as f32 / 6.0)));
+            h.run_steps(1);
+        }
+        h.event(egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+        h.run_steps(3);
+    }
+
     /// The first swatch: below the first group header (22 px), after the 8 px grid inset.
     fn first_cell(h: &Harness<'_, PhotocraftApp>) -> egui::Pos2 {
         h.ctx.input(|i| i.viewport_rect()).min + vec2(8.0 + 12.0 + 8.0, 22.0 + 2.0 + 12.0 + 8.0)
@@ -325,6 +339,23 @@ mod tests {
         assert_eq!(runs[1].style.color.to_rgba8(), [255, 255, 255, 255]);
     }
 
+    /// #4790: the footer (size slider, New Group, New, Delete) stays inside the panel however short
+    /// the dock makes it: the list scrolls instead of pushing the footer out of view.
+    #[test]
+    fn the_footer_fits_below_a_full_list() {
+        use egui_kittest::kittest::Queryable;
+        for h_px in [80.0, 100.0, 120.0, 160.0, 300.0] {
+            let app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+            let mut h = Harness::builder().with_size(vec2(260.0, h_px)).build_ui_state(|ui, app: &mut PhotocraftApp| panel(app, ui), app);
+            PhotocraftApp::setup_context(&h.ctx, Default::default());
+            h.run_steps(3);
+            let bottom = h.ctx.input(|i| i.viewport_rect()).max.y;
+            let slider = h.get_by_role(egui::accesskit::Role::Slider).rect().max.y;
+            let delete = h.get_by_label("Delete").rect().max.y;
+            assert!(slider <= bottom + 0.5 && delete <= bottom + 0.5, "{h_px} px panel: slider ends at {slider}, Delete at {delete}, panel at {bottom}");
+        }
+    }
+
     #[test]
     fn alt_click_sets_the_background_and_selects() {
         let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
@@ -397,4 +428,26 @@ mod tests {
         assert_eq!(out[0].0, "out/Swatches.ase");
         assert!(out[0].1.starts_with(b"ASEF"));
     }
+
+    /// #3658: dragging a group header reorders the folders, and the new order sticks in the UI
+    /// state (UI state is serde, so it saves and reloads with the rest of the panel state).
+    #[test]
+    fn dragging_a_group_header_reorders_and_persists() {
+        let app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let mut h = Harness::builder().with_size(vec2(300.0, 4000.0)).build_ui_state(|ui, app: &mut PhotocraftApp| panel(app, ui), app);
+        h.run_steps(2);
+        let headers = crate::preset_panels::last_group_headers(&h.ctx, PANEL);
+        assert!(headers.len() >= 2, "the default library has folders: {headers:?}");
+        let names: Vec<String> = headers.iter().map(|(n, _)| n.clone()).collect();
+        let (first, first_r) = &headers[0];
+        let (last, last_r) = headers.last().unwrap();
+        // Drag the last folder's header above the first; the insertion lands before it.
+        drag(&mut h, last_r.center(), egui::pos2(first_r.center().x, first_r.top() + 1.0));
+        let order = h.state().ui.presets_ui.display_order(PANEL, &names);
+        assert_eq!(order.len(), names.len());
+        assert_eq!(names.get(order[0]).map(String::as_str), Some(last.as_str()), "the dragged folder moved to the front: {order:?}");
+        assert_eq!(names.get(order[1]).map(String::as_str), Some(first.as_str()));
+        // The reorder is remembered by name (not by the positions it happened to have).
+        assert_eq!(h.state().ui.presets_ui.group_order.get(PANEL).and_then(|o| o.first()), Some(last));
+    }
 }
diff --git a/crates/ui-egui/src/symmetry_ui.rs b/crates/ui-egui/src/symmetry_ui.rs
index 5441f8aa96..4ccdc2277c 100644
--- a/crates/ui-egui/src/symmetry_ui.rs
+++ b/crates/ui-egui/src/symmetry_ui.rs
@@ -83,6 +83,44 @@ pub fn commit(app: &mut PhotocraftApp) {
         let _ = app.run("paint.setSymmetry", json!({"mode":t.preview.mode.id(), "center":t.preview.center,"rotation":t.preview.rotation}));
     }
 }
+/// While the symmetry is being transformed, the options bar names the edit and gives it ✓ and ⊘
+/// buttons, as Free Transform's bar does: Enter and Esc aren't the only ways out, which a pen or
+/// touch user may have no key for (#4495). False (nothing drawn) when no transform is open.
+pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) -> bool {
+    if app.ui.symmetry_transform.is_none() {
+        return false;
+    }
+    ui.label(egui::RichText::new(tl!("Transform Symmetry")).color(Tokens::get(ui.ctx()).text_dim));
+    widgets::vline(ui, 22.0);
+    let tip = crate::i18n::fmt(tl!("Commit transform ({key})"), &[("key", &crate::shortcuts::pretty("Enter"))]);
+    let commit_btn = icons::button(ui, "check", 26.0, false, &tip);
+    commit_btn.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, "Commit transform"));
+    if commit_btn.clicked() {
+        commit(app);
+    }
+    let cancel = icons::button(ui, "ban", 26.0, false, tl!("Cancel transform (Esc)"));
+    cancel.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, "Cancel transform"));
+    if cancel.clicked() {
+        app.ui.symmetry_transform = None;
+    }
+    true
+}
+/// The canvas cursor while the symmetry is being transformed: the move cursor over the centre,
+/// the rotate cursor over the rotation handle and the arrow elsewhere, never the brush outline,
+/// since a press there doesn't paint (#4495). `None` when no transform is open on this document.
+pub fn cursor(app: &PhotocraftApp, xf: &ViewXform, p: [f64; 2]) -> Option<egui::CursorIcon> {
+    let t = app.ui.symmetry_transform.as_ref().filter(|t| app.session.active_index() == Some(t.document))?;
+    let size = app.session.active().map(|s| [f64::from(s.doc.size.width), f64::from(s.doc.size.height)]).unwrap_or([1.0, 1.0]);
+    let tol = 8.0 / f64::from(xf.zoom.max(0.001));
+    let distance = |a: [f64; 2], b: [f64; 2]| (a[0] - b[0]).hypot(a[1] - b[1]);
+    Some(match t.gesture {
+        Some(Gesture::Move { .. }) => egui::CursorIcon::Move,
+        Some(Gesture::Rotate { .. }) => egui::CursorIcon::Alias,
+        None if distance(p, t.preview.center) <= tol => egui::CursorIcon::Move,
+        None if distance(p, rotation_handle(t.preview, size)) <= tol => egui::CursorIcon::Alias,
+        None => egui::CursorIcon::Default,
+    })
+}
 fn valid(app: &PhotocraftApp, t: &Transform) -> bool {
     app.session.active_index() == Some(t.document)
         && app.ui.tool == t.tool
diff --git a/crates/ui-egui/src/symmetry_ui/tests.rs b/crates/ui-egui/src/symmetry_ui/tests.rs
index 3510e4c83b..9f66449572 100644
--- a/crates/ui-egui/src/symmetry_ui/tests.rs
+++ b/crates/ui-egui/src/symmetry_ui/tests.rs
@@ -188,3 +188,56 @@ fn overlays_follow_document_view_transforms_in_every_theme() {
     assert_eq!(crate::i18n::tr(de, "Dual Axis"), "Duale Achse");
     assert_eq!(crate::i18n::tr(de, "Transform Symmetry"), "Symmetrie transformieren");
 }
+/// #4495: while the symmetry is transformed the options bar has ✓ and ⊘ (Enter and Esc were the
+/// only ways out), and the canvas shows the move, rotate or arrow cursor instead of the brush.
+#[test]
+fn transform_has_commit_and_cancel_buttons_and_its_own_cursors() {
+    let mut h = Harness::builder().with_size(vec2(1280.0, 800.0)).with_max_steps(64).build_eframe(|cc| {
+        PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+        PhotocraftApp::new(Session::new(), crate::Services::default())
+    });
+    h.state_mut().run("file.new", json!({"width":400,"height":300})).unwrap();
+    h.state_mut().ui.tool = Tool::Brush;
+    h.state_mut().run("paint.setSymmetry", json!({"mode":"dual"})).unwrap();
+    h.run_steps(4);
+    let cursor = |h: &Harness<'_, PhotocraftApp>| h.output().platform_output.cursor_icon;
+    let begin_transform = |h: &mut Harness<'_, PhotocraftApp>| {
+        let ctx = h.ctx.clone();
+        crate::menus::invoke(h.state_mut(), &ctx, "ui.symmetryTransform", json!({})).unwrap();
+        h.run_steps(3);
+    };
+    let xf = ViewXform::active(h.state()).expect("a canvas");
+    let off_handles = xf.to_screen(40.0, 260.0);
+    // Painting: the brush outline replaces the pointer.
+    h.hover_at(off_handles);
+    h.run_steps(2);
+    assert_ne!(cursor(&h), egui::CursorIcon::Default, "the brush cursor while painting");
+    assert!(h.query_by_label("Commit transform").is_none(), "no ✓ outside the transform");
+
+    begin_transform(&mut h);
+    h.hover_at(off_handles);
+    h.run_steps(2);
+    assert_eq!(cursor(&h), egui::CursorIcon::Default, "an arrow, not the brush, away from the handles");
+    let p = h.state().ui.symmetry_transform.as_ref().unwrap().preview;
+    h.hover_at(xf.to_screen(p.center[0] as f32, p.center[1] as f32));
+    h.run_steps(2);
+    assert_eq!(cursor(&h), egui::CursorIcon::Move, "the centre moves");
+    let r = rotation_handle(p, [400.0, 300.0]);
+    h.hover_at(xf.to_screen(r[0] as f32, r[1] as f32));
+    h.run_steps(2);
+    assert_eq!(cursor(&h), egui::CursorIcon::Alias, "the handle rotates");
+
+    // ⊘ drops the preview; ✓ applies it.
+    h.state_mut().ui.symmetry_transform.as_mut().unwrap().preview = PresetSymmetry::new(p.mode, [120.0, 90.0], 30.0).unwrap();
+    h.get_by_label("Cancel transform").click();
+    h.run_steps(3);
+    assert!(h.state().ui.symmetry_transform.is_none());
+    assert_eq!(preset(h.state()).unwrap().center, [200.0, 150.0], "cancel keeps the original");
+    begin_transform(&mut h);
+    h.state_mut().ui.symmetry_transform.as_mut().unwrap().preview = PresetSymmetry::new(p.mode, [120.0, 90.0], 30.0).unwrap();
+    h.get_by_label("Commit transform").click();
+    h.run_steps(3);
+    assert!(h.state().ui.symmetry_transform.is_none());
+    let done = preset(h.state()).unwrap();
+    assert_eq!((done.center, done.rotation), ([120.0, 90.0], 30.0), "commit applies the preview");
+}
diff --git a/crates/ui-egui/src/targa_options_ui.rs b/crates/ui-egui/src/targa_options_ui.rs
index afc7f60ba2..c2161a0c9b 100644
--- a/crates/ui-egui/src/targa_options_ui.rs
+++ b/crates/ui-egui/src/targa_options_ui.rs
@@ -20,9 +20,10 @@ pub struct Prompt {
     pub bits: TgaBits,
     /// Save a Copy: the document keeps its path and unsaved changes.
     pub copy: bool,
-    /// File › Save As: the answered save is recorded as a `file.saveAs` step, so an action being
-    /// recorded keeps it (#2032). The dialog's Save a Copy isn't recorded.
-    pub record: bool,
+    /// The step the answered save is recorded as, so an action being recorded keeps it:
+    /// `file.saveAs` for Save As (#2032, even when a flat Targa is written as a copy) and
+    /// `file.saveACopy` for Save a Copy (#4373).
+    pub record: &'static str,
 }
 
 /// `true` when `path` names a Targa (`.tga`, and the rarer `.icb`, `.vda`, `.vst`).
@@ -43,7 +44,7 @@ pub fn bits_param(params: &serde_json::Value, cmd: &str) -> Result<Option<TgaBit
 
 /// Parks the save behind the prompt, starting at 32 bits when the document has an alpha channel.
 /// A prompt already waiting is never replaced (a shortcut can still reach Save a Copy).
-pub fn park(app: &mut PhotocraftApp, path: String, copy: bool, record: bool) -> Result<(), String> {
+pub fn park(app: &mut PhotocraftApp, path: String, copy: bool, record: &'static str) -> Result<(), String> {
     if app.save_options_open() {
         return Err("Answer TIFF or Targa Options before starting another save".into());
     }
@@ -80,9 +81,9 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
         let settings = ExportSettings { tga_bits: Some(p.bits), ..app.save_settings() };
         let step = serde_json::json!({"path": p.path, "tgaBits": p.bits.bits()});
         let written = app.with_document(p.doc, |app| app.write_document(p.path, &settings, p.copy));
-        if written.is_ok() && p.record {
-            // An action being recorded keeps the Save As with this answer (#2032).
-            app.session.journal.push(("file.saveAs".into(), step));
+        if written.is_ok() {
+            // An action being recorded keeps the Save As or Save a Copy with this answer (#2032).
+            app.session.journal.push((p.record.into(), step));
         }
         match written {
             Err(e) => {
diff --git a/crates/ui-egui/src/text_field_menu.rs b/crates/ui-egui/src/text_field_menu.rs
index 420263e7ef..6556c68cfc 100644
--- a/crates/ui-egui/src/text_field_menu.rs
+++ b/crates/ui-egui/src/text_field_menu.rs
@@ -17,9 +17,9 @@
 //! caret to the pointer on any press), so Copy and Cut act on it.
 //!
 //! The right-click belongs to the field: the canvas and its tool menus only see pointer presses
-//! on the canvas, which a field drawn above it takes. Spelling suggestions are not in this menu
-//! yet: the spell checker (`edit.checkSpelling`, whose `suggest` action lists them) is not wired
-//! into text fields.
+//! on the canvas, which a field drawn above it takes. Spelling suggestions are not in this menu:
+//! the spell checker (`edit.checkSpelling`) checks type layers, so they head the Type tool's edit
+//! menu instead (`canvas_tool_menu`, over a misspelled word of the text being edited, #4370).
 
 use egui::text::CCursorRange;
 use egui::{Context, Event, Id, Key, Modifiers, PointerButton, Pos2, RawInput, SurrenderFocusOn, Ui};
diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs
index 259e5e006d..0b2cc7c044 100644
--- a/crates/ui-egui/src/theme.rs
+++ b/crates/ui-egui/src/theme.rs
@@ -48,10 +48,14 @@ pub enum ThemeKind {
     BreezeLight,
     /// An adaptation of KDE Plasma's Breeze Dark look.
     BreezeDark,
+    /// A low-contrast dark theme: muted violet-grey surfaces, softened text and a periwinkle accent.
+    SoftDark,
+    /// A low-contrast light theme: pale violet-grey surfaces, softened dark text and a periwinkle accent.
+    SoftLight,
 }
 
 impl ThemeKind {
-    pub const ALL: [ThemeKind; 12] = [
+    pub const ALL: [ThemeKind; 14] = [
         ThemeKind::Pro,
         ThemeKind::ProMedium,
         ThemeKind::ProLightGray,
@@ -64,6 +68,8 @@ impl ThemeKind {
         ThemeKind::AdwaitaDark,
         ThemeKind::BreezeLight,
         ThemeKind::BreezeDark,
+        ThemeKind::SoftDark,
+        ThemeKind::SoftLight,
     ];
     pub fn label(self) -> &'static str {
         match self {
@@ -79,6 +85,8 @@ impl ThemeKind {
             ThemeKind::SolarizedDark => "Solarized Dark",
             ThemeKind::BreezeLight => "Breeze Light",
             ThemeKind::BreezeDark => "Breeze Dark",
+            ThemeKind::SoftDark => "Soft Dark",
+            ThemeKind::SoftLight => "Soft Light",
         }
     }
     /// The canonical name: `ui.set {theme}` accepts it and the Window › Theme commands are
@@ -97,6 +105,8 @@ impl ThemeKind {
             ThemeKind::SolarizedDark => "solarizedDark",
             ThemeKind::BreezeLight => "breezeLight",
             ThemeKind::BreezeDark => "breezeDark",
+            ThemeKind::SoftDark => "softDark",
+            ThemeKind::SoftLight => "softLight",
         }
     }
     /// Photoshop-grammar layout (tab strips, flat panels): the four Pro brightness levels.
@@ -112,15 +122,17 @@ impl ThemeKind {
             "pro" | "prodark" | "photoshop" | "dark" => Some(ThemeKind::Pro),
             "promedium" | "promediumgray" | "medium" | "mediumgray" => Some(ThemeKind::ProMedium),
             "prolightgray" | "lightgray" | "mediumlight" => Some(ThemeKind::ProLightGray),
-            "prolight" | "prolightest" | "lightest" => Some(ThemeKind::ProLight),
+            "prolight" | "prolightest" | "lightest" | "light" => Some(ThemeKind::ProLight),
             "studio" | "studiodark" => Some(ThemeKind::Studio),
-            "studiolight" | "light" => Some(ThemeKind::StudioLight),
+            "studiolight" => Some(ThemeKind::StudioLight),
             "classic" | "win2000" | "retro" => Some(ThemeKind::Classic),
             "adwaita" | "adwaitalight" | "gnome" | "gnomelight" => Some(ThemeKind::Adwaita),
             "adwaitadark" | "gnomedark" => Some(ThemeKind::AdwaitaDark),
             "solarizeddark" | "solarized" => Some(ThemeKind::SolarizedDark),
             "breezelight" | "breeze" | "kde" | "kdelight" | "plasma" | "plasmalight" => Some(ThemeKind::BreezeLight),
             "breezedark" | "kdedark" | "plasmadark" => Some(ThemeKind::BreezeDark),
+            "softdark" => Some(ThemeKind::SoftDark),
+            "softlight" => Some(ThemeKind::SoftLight),
             _ => None,
         }
     }
@@ -602,6 +614,91 @@ impl Tokens {
                 caption_close_text: Color32::WHITE,
                 scrim: Color32::from_black_alpha(110),
             },
+            // Soft Dark: our own low-contrast palette on the Studio layout. Muted violet-grey
+            // surfaces (never near-black), softened off-white text and a periwinkle accent; the
+            // text colours still hold 4.5:1 on every surface (checked by the tests).
+            ThemeKind::SoftDark => Tokens {
+                kind,
+                chrome: Color32::from_rgb(58, 58, 68),
+                canvas: Color32::from_rgb(40, 40, 48),
+                canvas_dot: Color32::from_rgb(40, 40, 48),
+                dock: Color32::from_rgb(47, 47, 56),
+                card: Color32::from_rgb(54, 54, 64),
+                card_border: Color32::from_rgb(70, 70, 82),
+                field: Color32::from_rgb(64, 64, 75),
+                field_border: Color32::from_rgb(84, 84, 98),
+                hover: Color32::from_rgb(68, 68, 80),
+                pressed: Color32::from_rgb(74, 74, 88),
+                text: Color32::from_rgb(238, 238, 246),
+                text_dim: Color32::from_rgb(212, 212, 224),
+                text_faint: Color32::from_rgb(190, 190, 206),
+                icon: Color32::from_rgb(214, 214, 226),
+                accent: Color32::from_rgb(138, 154, 232),
+                accent_soft: Color32::from_rgba_unmultiplied(138, 154, 232, 48),
+                accent_border: Color32::from_rgba_unmultiplied(138, 154, 232, 150),
+                accent_text: Color32::from_rgb(190, 200, 252),
+                separator: Color32::from_rgb(36, 36, 44),
+                shadow: Color32::from_black_alpha(110),
+                primary_bg: Color32::from_rgb(86, 104, 196),
+                primary_text: Color32::WHITE,
+                danger: Color32::from_rgb(250, 160, 172),
+                warning: Color32::from_rgb(240, 200, 130),
+                radius_sm: 7.0,
+                radius: 10.0,
+                radius_lg: 14.0,
+                bevel: false,
+                pro: false,
+                round_chips: true,
+                tab_strip: Color32::TRANSPARENT,
+                row_selected: Color32::TRANSPARENT,
+                histogram_bg: Color32::from_rgb(40, 40, 48),
+                histogram_level: 220,
+                caption_close: Color32::from_rgb(200, 72, 86),
+                caption_close_text: Color32::WHITE,
+                scrim: Color32::from_black_alpha(100),
+            },
+            // Soft Light: pale violet-grey surfaces, softened dark-violet text (not black) and a
+            // periwinkle accent, with the same generous radii as Soft Dark.
+            ThemeKind::SoftLight => Tokens {
+                kind,
+                chrome: Color32::from_rgb(232, 230, 236),
+                canvas: Color32::from_rgb(218, 216, 224),
+                canvas_dot: Color32::from_rgb(218, 216, 224),
+                dock: Color32::from_rgb(226, 224, 231),
+                card: Color32::from_rgb(240, 238, 243),
+                card_border: Color32::from_rgb(208, 205, 215),
+                field: Color32::from_rgb(250, 249, 252),
+                field_border: Color32::from_rgb(190, 187, 201),
+                hover: Color32::from_rgb(228, 226, 234),
+                pressed: Color32::from_rgb(212, 209, 221),
+                text: Color32::from_rgb(44, 42, 56),
+                text_dim: Color32::from_rgb(62, 60, 76),
+                text_faint: Color32::from_rgb(80, 78, 96),
+                icon: Color32::from_rgb(64, 62, 80),
+                accent: Color32::from_rgb(110, 128, 216),
+                accent_soft: Color32::from_rgba_unmultiplied(110, 128, 216, 44),
+                accent_border: Color32::from_rgba_unmultiplied(110, 128, 216, 170),
+                accent_text: Color32::from_rgb(46, 58, 146),
+                separator: Color32::from_rgb(210, 207, 218),
+                shadow: Color32::from_black_alpha(40),
+                primary_bg: Color32::from_rgb(80, 98, 190),
+                primary_text: Color32::WHITE,
+                danger: Color32::from_rgb(166, 44, 62),
+                warning: Color32::from_rgb(140, 72, 0),
+                radius_sm: 7.0,
+                radius: 10.0,
+                radius_lg: 14.0,
+                bevel: false,
+                pro: false,
+                round_chips: true,
+                tab_strip: Color32::TRANSPARENT,
+                row_selected: Color32::TRANSPARENT,
+                histogram_bg: Color32::from_rgb(44, 42, 56),
+                histogram_level: 240,
+                caption_close: Color32::from_rgb(200, 60, 72),
+                caption_close_text: Color32::WHITE,
+                scrim: Color32::from_black_alpha(90),
+            },
             // Ethan Schoonover's Solarized Dark palette: base03 canvas, base02 surfaces, base0
             // body text and the Solarized blue accent. https://ethanschoonover.com/solarized/
             // (MIT; see LICENSE-solarized.txt)
@@ -702,10 +799,25 @@ impl Tokens {
         self.histogram_bg
     }
 
+    /// The background behind selected text in a text field (#3789): a subtle shade rather than
+    /// egui's default blue. The monochrome Pro themes use a grey so a selection doesn't read as a
+    /// second accent; coloured themes keep their own accent. Scoped to text fields by
+    /// [`crate::widgets::text_field`], because `Visuals::selection` also fills selected list rows
+    /// and slider trails, which must keep the theme's.
+    pub fn field_selection(&self) -> Color32 {
+        if self.pro { Color32::from_gray(if self.dark() { 96 } else { 201 }) } else { self.accent_soft }
+    }
+
     pub fn dark(&self) -> bool {
         matches!(
             self.kind,
-            ThemeKind::Studio | ThemeKind::Pro | ThemeKind::ProMedium | ThemeKind::SolarizedDark | ThemeKind::AdwaitaDark | ThemeKind::BreezeDark
+            ThemeKind::Studio
+                | ThemeKind::Pro
+                | ThemeKind::ProMedium
+                | ThemeKind::SolarizedDark
+                | ThemeKind::AdwaitaDark
+                | ThemeKind::BreezeDark
+                | ThemeKind::SoftDark
         )
     }
 }
@@ -717,7 +829,8 @@ pub fn install_fonts(ctx: &egui::Context) {
 
 /// [`install_fonts`] with the CJK and other-script fallback fonts taken from `cjk` (tests swap the sources).
 pub fn install_fonts_with(ctx: &egui::Context, cjk: crate::cjk_fonts::Sources) {
-    let mut fonts = FontDefinitions::default();
+    // egui's default fonts stay last in the stack, for symbols and emoji Inter lacks.
+    let mut fonts = crate::egui_fonts::definitions();
     // The bundled fonts are inflated on first use (photocraft_text::fonts). Should one ever fail
     // to inflate (empty bytes), it is left out and egui's default fonts draw that text.
     let add = |fonts: &mut FontDefinitions, name: &str, bytes: &'static [u8]| -> Option<String> {
@@ -925,7 +1038,15 @@ pub fn apply(ctx: &egui::Context, kind: ThemeKind) {
         s.visuals.indent_has_left_vline = false;
         s.interaction.tooltip_delay = TOOLTIP_DELAY;
         // Thin overlay scrollbars that appear on hover (Photoshop/macOS style).
-        s.spacing.scroll = if t.bevel { egui::style::ScrollStyle::solid() } else { egui::style::ScrollStyle::thin() };
+        // Thin bars stay visible, including while the pointer is on them. The stock thin
+        // style fades the handle to the same opacity as the track, so the thumb disappears (#4611).
+        let mut scroll = if t.bevel { egui::style::ScrollStyle::solid() } else { egui::style::ScrollStyle::thin() };
+        if scroll.floating {
+            scroll.interact_handle_opacity = 1.0;
+            scroll.interact_background_opacity = 0.4;
+            scroll.floating_width = 4.0;
+        }
+        s.spacing.scroll = scroll;
         s.spacing.tooltip_width = 280.0;
     });
     // egui selects its style branch using OS appearance, independently of PhotoCraft's fixed
@@ -1066,11 +1187,22 @@ mod tests {
         assert_eq!(ThemeKind::from_name("lightest"), Some(ThemeKind::ProLight));
     }
 
+    #[test]
+    fn field_selection_is_grey_only_for_the_monochrome_pro_themes() {
+        // #3789: a text field's selection is a subtle grey in the monochrome Pro themes, not a
+        // second blue accent; coloured themes keep their accent.
+        assert_eq!(Tokens::for_kind(ThemeKind::Pro).field_selection(), Color32::from_gray(96));
+        assert_eq!(Tokens::for_kind(ThemeKind::ProLight).field_selection(), Color32::from_gray(201));
+        assert_eq!(Tokens::for_kind(ThemeKind::Studio).field_selection(), Tokens::for_kind(ThemeKind::Studio).accent_soft);
+        assert_eq!(Tokens::for_kind(ThemeKind::Classic).field_selection(), Tokens::for_kind(ThemeKind::Classic).accent_soft);
+    }
+
     #[test]
     fn theme_names_parse() {
         assert_eq!(ThemeKind::from_name("Classic"), Some(ThemeKind::Classic));
         assert_eq!(ThemeKind::from_name("studio (light)"), Some(ThemeKind::StudioLight));
         assert_eq!(ThemeKind::from_name("dark"), Some(ThemeKind::Pro));
+        assert_eq!(ThemeKind::from_name("light"), Some(ThemeKind::ProLight));
         assert_eq!(ThemeKind::from_name("studio"), Some(ThemeKind::Studio));
         assert_eq!(ThemeKind::from_name("Pro (Medium Gray)"), Some(ThemeKind::ProMedium));
         assert_eq!(ThemeKind::from_name("Solarized Dark"), Some(ThemeKind::SolarizedDark));
@@ -1148,6 +1280,42 @@ mod tests {
         assert_eq!(ThemeKind::from_name("gnome dark"), Some(ThemeKind::AdwaitaDark));
     }
 
+    #[test]
+    fn soft_themes_parse_and_hold_text_contrast() {
+        for (kind, alias) in [(ThemeKind::SoftDark, "soft dark"), (ThemeKind::SoftLight, "Soft_Light")] {
+            assert_eq!(ThemeKind::from_name(kind.id()), Some(kind));
+            assert_eq!(ThemeKind::from_name(kind.label()), Some(kind));
+            assert_eq!(ThemeKind::from_name(alias), Some(kind));
+            assert!(ThemeKind::ALL.contains(&kind));
+            let t = Tokens::for_kind(kind);
+            assert_eq!(t.kind, kind);
+            assert_eq!(t.dark(), kind == ThemeKind::SoftDark);
+            assert!(!t.pro && !t.bevel);
+            // Soft means no extremes: surfaces stay off black and white.
+            for c in [t.chrome, t.canvas, t.dock, t.card, t.field] {
+                let (hi, lo) = (c.r().max(c.g()).max(c.b()), c.r().min(c.g()).min(c.b()));
+                assert!(if t.dark() { (32..96).contains(&hi) } else { hi < 255 && lo > 200 }, "{kind:?}: {c:?}");
+            }
+            let tint = |under: Color32| {
+                let k = f32::from(t.accent_soft.a()) / 255.0;
+                let ch = |over: u8, under: u8| (f32::from(over) * k + f32::from(under) * (1.0 - k)).round() as u8;
+                Color32::from_rgb(ch(t.accent.r(), under.r()), ch(t.accent.g(), under.g()), ch(t.accent.b(), under.b()))
+            };
+            let surfaces = [t.chrome, t.canvas, t.dock, t.card, t.field, t.hover, t.pressed, tint(t.dock), tint(t.card)];
+            for (i, surface) in surfaces.into_iter().enumerate() {
+                for (name, colour) in [("text", t.text), ("dim", t.text_dim), ("faint", t.text_faint), ("accent text", t.accent_text)] {
+                    assert!(contrast(colour, surface) >= 4.5, "{kind:?}: {name} on {surface:?}");
+                }
+                // Status colours are marks on hovered or selected surfaces (3:1), text on resting ones.
+                let floor = if i < 5 { 4.5 } else { 3.0 };
+                assert!(contrast(t.danger, surface) >= floor && contrast(t.warning, surface) >= floor, "{kind:?}: status on {surface:?}");
+            }
+            for k in [1.0, 0.93, 0.85] {
+                assert!(contrast(t.primary_text, t.primary_bg.gamma_multiply(k)) >= 4.5, "{kind:?}: primary at {k}");
+            }
+        }
+    }
+
     #[test]
     fn breeze_themes_parse_and_meet_text_contrast() {
         for (kind, aliases) in [
diff --git a/crates/ui-egui/src/tile_overlay.rs b/crates/ui-egui/src/tile_overlay.rs
new file mode 100644
index 0000000000..731ddc06b8
--- /dev/null
+++ b/crates/ui-egui/src/tile_overlay.rs
@@ -0,0 +1,301 @@
+//! The developer tile grid: the active layer's storage tiles over the canvas, turned on with the
+//! control channel's `ui.set {"tileGrid": true}` ([`crate::view_cmds::ViewOptions::tile_grid`]).
+//! It shows how sparse a layer is, which tiles copy-on-write shares, and which ones `.pcraft`
+//! saves once.
+//!
+//! A layer's pixels live in a sparse [`Surface`] of [`TILE_SIZE`] tiles; cells with no stored
+//! tile read as the surface's default pixel and cost nothing. The overlay draws the tile grid
+//! faintly over the document, fills every stored tile, and labels it `tx,ty` once it is large
+//! enough on screen. Tiles with identical pixels share a hue; a tile whose pixels appear nowhere
+//! else is plain blue.
+//!
+//! Grouping reads every stored tile, so it is cached per document revision and active layer,
+//! never redone per frame (AGENTS.md rule 8). Tile identity can't stand in for the revision: a
+//! tile nothing else shares is written in place. Each allocation is hashed once, and tiles are
+//! grouped by that 64-bit hash of their bytes.
+
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+use egui::{Align2, Color32, FontId, Painter, Shape, Stroke};
+use photocraft_geom::{Rect as DRect, TILE_SIZE, TileCoord};
+use photocraft_raster::{Surface, Tile};
+#[cfg(not(target_arch = "wasm32"))]
+use rayon::prelude::*;
+
+use crate::PhotocraftApp;
+use crate::canvas::ViewXform;
+
+/// Outline and fill of a tile whose pixels appear nowhere else in the layer.
+const UNIQUE: Color32 = Color32::from_rgb(0x2d, 0x8c, 0xeb);
+/// Alpha of a stored tile's fill; low so the image stays readable underneath.
+const FILL_ALPHA: u8 = 40;
+/// The grid over cells with no stored tile: a translucent mid grey, seen on light and dark pixels.
+const EMPTY_LINE: Color32 = Color32::from_rgba_premultiplied(32, 32, 32, 64);
+/// Tile labels show once a tile is at least this many points across.
+const LABEL_MIN: f32 = 56.0;
+
+/// One stored tile and the group of tiles it shares its pixels with (`None` = unique).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TileInfo {
+    pub coord: TileCoord,
+    pub group: Option<usize>,
+}
+
+/// The tiles of one layer, valid for one document revision.
+#[derive(Clone)]
+struct Cached {
+    revision: u64,
+    tiles: Arc<Vec<TileInfo>>,
+}
+
+/// A tile's allocation as a plain address, so it can cross to the Rayon pool.
+fn ptr(t: &Arc<Tile>) -> usize {
+    Arc::as_ptr(t) as usize
+}
+
+fn content_hash(t: &Tile) -> u64 {
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    t.bytes().hash(&mut h);
+    h.finish()
+}
+
+/// Every stored tile of `s` with its shared-pixels group. Groups are numbered in tile order, so
+/// the same surface always gets the same colours. `parallel` hashes on the Rayon pool; pass
+/// false while jobs hold it, so the UI thread never waits on them (#1554).
+pub fn tile_infos(s: &Surface, parallel: bool) -> Vec<TileInfo> {
+    // Hash each distinct allocation once; copy-on-write clones share one.
+    let mut by_ptr: HashMap<usize, &Arc<Tile>> = HashMap::new();
+    for (_, t) in s.tiles() {
+        by_ptr.entry(ptr(t)).or_insert(t);
+    }
+    let distinct: Vec<(usize, &Arc<Tile>)> = by_ptr.into_iter().collect();
+    // rayon is a native-only dependency; the web build hashes serially.
+    #[cfg(not(target_arch = "wasm32"))]
+    let hashed: Vec<(usize, u64)> = if parallel {
+        distinct.par_iter().map(|(p, t)| (*p, content_hash(t))).collect()
+    } else {
+        distinct.iter().map(|(p, t)| (*p, content_hash(t))).collect()
+    };
+    #[cfg(target_arch = "wasm32")]
+    let hashed: Vec<(usize, u64)> = {
+        let _ = parallel;
+        distinct.iter().map(|(p, t)| (*p, content_hash(t))).collect()
+    };
+    let hash_of: HashMap<usize, u64> = hashed.into_iter().collect();
+    let mut count: HashMap<u64, usize> = HashMap::new();
+    for (_, t) in s.tiles() {
+        if let Some(h) = hash_of.get(&ptr(t)) {
+            *count.entry(*h).or_default() += 1;
+        }
+    }
+    let mut group_of: HashMap<u64, usize> = HashMap::new();
+    s.tiles()
+        .map(|(c, t)| {
+            let group = hash_of.get(&ptr(t)).filter(|h| count.get(h).is_some_and(|&n| n > 1)).map(|h| {
+                let next = group_of.len();
+                *group_of.entry(*h).or_insert(next)
+            });
+            TileInfo { coord: *c, group }
+        })
+        .collect()
+}
+
+/// Hues (0..1) left to unique tiles: shared groups never land in the blues, nor in the
+/// blue-violets that read as blue next to them ([`UNIQUE`] is about 0.58).
+const BLUE_HUES: (f32, f32) = (0.45, 0.75);
+/// Gap kept from either end of the allowed range, as a share of it.
+const HUE_MARGIN: f32 = 0.05;
+
+/// The hue of shared group `g`: golden-ratio steps keep neighbouring group numbers far apart,
+/// spread over the wheel outside [`BLUE_HUES`] and clear of its edges.
+fn group_hue(g: usize) -> f32 {
+    let step = (g as f32 * 0.618_034).fract();
+    let span = 1.0 - (BLUE_HUES.1 - BLUE_HUES.0);
+    (BLUE_HUES.1 + (HUE_MARGIN + step * (1.0 - 2.0 * HUE_MARGIN)) * span).fract()
+}
+
+/// The colour of a tile group: blue for unique tiles, an evenly spread hue per shared group.
+pub fn group_color(group: Option<usize>) -> Color32 {
+    let Some(g) = group else { return UNIQUE };
+    egui::ecolor::Hsva::new(group_hue(g), 0.85, 0.95, 1.0).into()
+}
+
+/// The tile cells of the grid that touch `r`, as an inclusive (tx0, ty0, tx1, ty1) range.
+pub fn cell_range(r: DRect) -> Option<(i32, i32, i32, i32)> {
+    if r.is_empty() {
+        return None;
+    }
+    let (a, b) = (TileCoord::containing(r.x0, r.y0), TileCoord::containing(r.x1 - 1, r.y1 - 1));
+    Some((a.tx, a.ty, b.tx, b.ty))
+}
+
+fn quad(xf: &ViewXform, r: DRect) -> [egui::Pos2; 4] {
+    let (x0, y0, x1, y1) = (r.x0 as f32, r.y0 as f32, r.x1 as f32, r.y1 as f32);
+    [xf.to_screen(x0, y0), xf.to_screen(x1, y0), xf.to_screen(x1, y1), xf.to_screen(x0, y1)]
+}
+
+/// Draw the active layer's tiles of document `idx`. `visible` is the document area in view.
+pub fn paint(app: &PhotocraftApp, ctx: &egui::Context, painter: &Painter, xf: &ViewXform, idx: usize, visible: DRect) {
+    let Some(st) = app.session.documents().get(idx) else { return };
+    let Some(surface) = st.active_layer.and_then(|id| st.doc.layer(id)).and_then(|l| l.surface()) else { return };
+    let revision = st.revision;
+    let mem = egui::Id::new(("pc-tile-overlay", st.doc.id.0, st.active_layer.map(|l| l.0)));
+    let cached = ctx.data(|d| d.get_temp::<Cached>(mem)).filter(|c| c.revision == revision);
+    let tiles = match cached {
+        Some(c) => c.tiles,
+        None => {
+            let tiles = Arc::new(tile_infos(surface, !app.session.has_jobs()));
+            ctx.data_mut(|d| d.insert_temp(mem, Cached { revision, tiles: tiles.clone() }));
+            tiles
+        }
+    };
+
+    // The grid over the document, so the cells without a stored tile show too.
+    let bounds = st.doc.bounds();
+    if let Some((tx0, ty0, tx1, ty1)) = cell_range(visible.intersect(&bounds)) {
+        let line = Stroke::new(1.0, EMPTY_LINE);
+        let edge = |t: i32| t.saturating_mul(TILE_SIZE);
+        let (top, bottom) = (bounds.y0.max(edge(ty0)) as f32, bounds.y1.min(edge(ty1.saturating_add(1))) as f32);
+        let (left, right) = (bounds.x0.max(edge(tx0)) as f32, bounds.x1.min(edge(tx1.saturating_add(1))) as f32);
+        for tx in tx0..=tx1.saturating_add(1) {
+            let x = edge(tx).clamp(bounds.x0, bounds.x1) as f32;
+            painter.line_segment([xf.to_screen(x, top), xf.to_screen(x, bottom)], line);
+        }
+        for ty in ty0..=ty1.saturating_add(1) {
+            let y = edge(ty).clamp(bounds.y0, bounds.y1) as f32;
+            painter.line_segment([xf.to_screen(left, y), xf.to_screen(right, y)], line);
+        }
+    }
+
+    // Stored tiles, which may lie past the canvas edge.
+    let size = TILE_SIZE as f32 * xf.zoom;
+    for t in tiles.iter() {
+        let r = t.coord.rect();
+        if r.intersect(&visible).is_empty() {
+            continue;
+        }
+        let c = group_color(t.group);
+        let pts = quad(xf, r).to_vec();
+        let fill = Color32::from_rgba_unmultiplied(c.r(), c.g(), c.b(), FILL_ALPHA);
+        painter.add(Shape::convex_polygon(pts.clone(), fill, Stroke::NONE));
+        painter.add(Shape::closed_line(pts, Stroke::new(1.0, c)));
+        if size >= LABEL_MIN {
+            let mid = xf.to_screen(r.x0 as f32 + TILE_SIZE as f32 / 2.0, r.y0 as f32 + TILE_SIZE as f32 / 2.0);
+            let label = format!("{},{}", t.coord.tx, t.coord.ty);
+            let font = FontId::monospace((size / 8.0).clamp(10.0, 16.0));
+            // A dark drop shadow keeps the label readable over light pixels.
+            painter.text(mid + egui::vec2(1.0, 1.0), Align2::CENTER_CENTER, &label, font.clone(), Color32::from_black_alpha(180));
+            painter.text(mid, Align2::CENTER_CENTER, label, font, Color32::WHITE);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use photocraft_color::PixelFormat;
+
+    /// The document rect of tile cell (tx, ty).
+    fn cell(tx: i32, ty: i32) -> DRect {
+        TileCoord::new(tx, ty).rect()
+    }
+
+    #[test]
+    fn empty_surface_has_no_tiles() {
+        assert!(tile_infos(&Surface::new(PixelFormat::RGBA8), true).is_empty());
+    }
+
+    #[test]
+    fn identical_pixels_share_a_group_and_unique_tiles_have_none() {
+        for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA16, PixelFormat::RGBA32F] {
+            identical_pixels_share_a_group_in(fmt);
+        }
+    }
+
+    fn identical_pixels_share_a_group_in(fmt: PixelFormat) {
+        let mut s = Surface::new(fmt);
+        // Two separately allocated tiles with the same red pixels, as after loading a .pcraft.
+        s.fill_rect(cell(0, 0), &[1.0, 0.0, 0.0, 1.0]);
+        s.fill_rect(cell(2, 0), &[1.0, 0.0, 0.0, 1.0]);
+        // One shared allocation in two cells (copy-on-write), and a lone green tile.
+        let blue = s.solid_tile(&[0.0, 0.0, 1.0, 1.0]);
+        s.put_tiles([(TileCoord::new(0, 1), blue.clone()), (TileCoord::new(1, 1), blue)]);
+        s.fill_rect(cell(1, 0), &[0.0, 1.0, 0.0, 1.0]);
+        for parallel in [true, false] {
+            let infos = tile_infos(&s, parallel);
+            let group = |tx, ty| infos.iter().find(|i| i.coord == TileCoord::new(tx, ty)).map(|i| i.group);
+            assert_eq!(infos.len(), 5);
+            assert_eq!(group(1, 0), Some(None), "green is unique");
+            let (red, blue) = (group(0, 0).flatten(), group(0, 1).flatten());
+            assert!(red.is_some() && blue.is_some() && red != blue);
+            assert_eq!(group(2, 0).flatten(), red);
+            assert_eq!(group(1, 1).flatten(), blue);
+        }
+    }
+
+    #[test]
+    fn groups_get_distinct_colours_and_unique_tiles_stay_blue() {
+        assert_eq!(group_color(None), UNIQUE);
+        let colours: Vec<Color32> = (0..6).map(|g| group_color(Some(g))).collect();
+        for (i, a) in colours.iter().enumerate() {
+            assert_ne!(*a, UNIQUE);
+            assert!(colours.iter().skip(i + 1).all(|b| b != a));
+        }
+        // Huge group numbers still map to a colour.
+        let _ = group_color(Some(usize::MAX));
+    }
+
+    #[test]
+    fn shared_groups_never_take_the_blue_of_unique_tiles() {
+        for g in (0..10_000).chain([usize::MAX]) {
+            let h = group_hue(g);
+            assert!((0.0..1.0).contains(&h), "group {g}: hue {h}");
+            assert!(!(BLUE_HUES.0..=BLUE_HUES.1).contains(&h), "group {g}: hue {h} is blue");
+            // Clear of the range's edges too, where hues still read as blue.
+            assert!((h - BLUE_HUES.1).abs() > 0.01 && (h - BLUE_HUES.0).abs() > 0.01, "group {g}: hue {h} is at the edge");
+        }
+    }
+
+    /// `cargo test --release -p photocraft-ui-egui --lib tile_grouping_36mp -- --ignored --nocapture`
+    #[test]
+    #[ignore = "benchmark"]
+    fn tile_grouping_36mp() {
+        let (w, h) = (7360, 4912);
+        for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA16] {
+            // Every tile different, the worst case: each one is hashed and none share.
+            let mut s = Surface::new(fmt);
+            let Some((tx1, ty1)) = cell_range(DRect::from_xywh(0, 0, w, h)).map(|(_, _, tx1, ty1)| (tx1, ty1)) else { return };
+            for ty in 0..=ty1 {
+                for tx in 0..=tx1 {
+                    let seed = (tx * 31 + ty * 17) as usize;
+                    for (i, b) in s.tile_mut(TileCoord::new(tx, ty)).bytes_mut().iter_mut().enumerate() {
+                        *b = (i ^ seed) as u8;
+                    }
+                }
+            }
+            for parallel in [true, false] {
+                let mut best = f64::MAX;
+                for _ in 0..8 {
+                    let t = std::time::Instant::now();
+                    std::hint::black_box(tile_infos(&s, parallel));
+                    best = best.min(t.elapsed().as_secs_f64() * 1000.0);
+                }
+                let mode = if parallel { "parallel" } else { "serial" };
+                println!("36 MP {fmt:?}, {} tiles, {mode}: {best:.1} ms", s.tile_count());
+            }
+        }
+    }
+
+    #[test]
+    fn cell_range_covers_the_cells_a_rect_touches() {
+        let t = TILE_SIZE;
+        // Exactly one cell, then a partial cell past whole ones (a canvas not a multiple of it).
+        assert_eq!(cell_range(cell(0, 0)), Some((0, 0, 0, 0)));
+        assert_eq!(cell_range(DRect::new(0, 0, 7 * t + t / 2, 4 * t + 1)), Some((0, 0, 7, 4)));
+        // One pixel either side of a cell edge, including left of the origin.
+        assert_eq!(cell_range(DRect::new(-1, t - 1, t + 1, t + 4)), Some((-1, 0, 1, 1)));
+        assert_eq!(cell_range(DRect::EMPTY), None);
+    }
+}
diff --git a/crates/ui-egui/src/titlebar.rs b/crates/ui-egui/src/titlebar.rs
index d02536aeef..c45baa2f0d 100644
--- a/crates/ui-egui/src/titlebar.rs
+++ b/crates/ui-egui/src/titlebar.rs
@@ -1,35 +1,244 @@
 //! The window's own title bar on Windows and Linux, where the window has no OS decorations
 //! ([`PhotocraftApp::custom_titlebar`]): the app's top bar (`panels::title_bar`) is the title bar,
 //! as in Photoshop on Windows. The free gap between its menus and controls drags the window and a
-//! double-click there maximizes it (`panels::title_bar`, on every platform); caption buttons at
-//! the far right minimize, maximize/restore and close, and thin invisible zones along the window's
-//! edges resize it.
+//! double-click there maximizes it (`panels::title_bar`, on every platform); caption buttons
+//! minimize, maximize/restore and close, and thin invisible zones along the window's edges resize
+//! it.
+//!
+//! The caption buttons follow the desktop ([`CaptionStyle`], from `Services::caption_style`):
+//! Windows' 46 pt buttons at the right end by default; on Linux libadwaita's round buttons (GNOME),
+//! Breeze's (KDE) or a plain round set elsewhere, with the set of buttons and their side taken
+//! from the desktop's button layout. The shapes are drawn here, not read from the icon theme.
 
-use egui::{CursorIcon, Id, LayerId, Order, PointerButton, Rect, ResizeDirection, Sense, Stroke, Ui, ViewportCommand, pos2, vec2};
+use egui::{Color32, CursorIcon, Id, LayerId, Order, PointerButton, Pos2, Rect, ResizeDirection, Sense, Stroke, Ui, ViewportCommand, pos2, vec2};
 use serde_json::json;
 
 use crate::PhotocraftApp;
 use crate::theme::Tokens;
 
-/// One caption button: as wide as the native Windows ones.
+/// One Windows caption button: as wide as the native ones.
 pub const BUTTON_WIDTH: f32 = 46.0;
-/// The three caption buttons together.
-pub const WIDTH: f32 = 3.0 * BUTTON_WIDTH;
 /// Resize zone thickness along an edge, and the side of a corner zone. 5 pt was hard to find
 /// (#1581); 8 pt is about a native resize border, and only trims the toolbar buttons' outer 3 pt.
 const EDGE: f32 = 8.0;
 const CORNER: f32 = 12.0;
+const MODAL_DRAG_AREA: &str = "titlebar-modal-drag-area";
+/// Breeze's Close button on hover and press (KDE's Breeze decoration colours).
+const BREEZE_CLOSE_HOVER: Color32 = Color32::from_rgb(0xff, 0x98, 0xa2);
+const BREEZE_CLOSE_PRESSED: Color32 = Color32::from_rgb(0x6d, 0x22, 0x29);
 
-#[derive(Clone, Copy, PartialEq, Debug)]
-enum Caption {
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Caption {
     Minimize,
     Maximize,
     Close,
 }
 
-/// Left to right.
+/// Windows' order, left to right.
 const CAPTIONS: [Caption; 3] = [Caption::Minimize, Caption::Maximize, Caption::Close];
 
+/// Which desktop's caption buttons to look like.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
+pub enum CaptionFamily {
+    /// Windows 10/11: full-height buttons 46 pt wide; Close turns red on hover.
+    #[default]
+    Windows,
+    /// GNOME (libadwaita): 24 pt round buttons on a faint disc that darkens on hover and press.
+    Adwaita,
+    /// KDE (Breeze decoration): smaller round buttons, bare at rest, inverted on hover.
+    Breeze,
+    /// Other Linux desktops: libadwaita's buttons without the disc at rest.
+    Generic,
+}
+
+/// The title bar's unused gap, saved by `panels::title_bar` for drags that begin while a modal
+/// backdrop is on top of the normal title-bar widgets.
+pub(crate) fn modal_drag_area_id() -> Id {
+    Id::new(MODAL_DRAG_AREA)
+}
+
+/// Restore window dragging over the title bar's empty gap after a modal has blocked the normal
+/// title-bar layer. The hit target stays limited to the same gap, so menus and caption controls
+/// remain owned by their widgets.
+pub(crate) fn modal_drag_overlay(ctx: &egui::Context) {
+    let Some(area) = ctx.data(|d| d.get_temp::<Rect>(modal_drag_area_id())) else { return };
+    if !area.is_positive() || egui::Popup::is_any_open(ctx) || !crate::dialogs::titlebar_drag_area_is_clear(ctx, area) {
+        return;
+    }
+    egui::Area::new(Id::new("titlebar-modal-drag-overlay")).order(Order::Tooltip).fixed_pos(area.min).movable(false).sense(Sense::hover()).show(ctx, |ui| {
+        let response = ui.allocate_rect(area, Sense::click_and_drag());
+        if response.drag_started() {
+            ctx.send_viewport_cmd(ViewportCommand::StartDrag);
+        }
+        if response.double_clicked() {
+            let max = ctx.input(|i| i.viewport().maximized.unwrap_or(false));
+            ctx.send_viewport_cmd(ViewportCommand::Maximized(!max));
+        }
+    });
+}
+
+impl CaptionFamily {
+    /// `windows`, `adwaita`, `breeze` or `generic`, in any case.
+    pub fn parse(name: &str) -> Option<Self> {
+        match name.trim().to_ascii_lowercase().as_str() {
+            "windows" => Some(Self::Windows),
+            "adwaita" => Some(Self::Adwaita),
+            "breeze" => Some(Self::Breeze),
+            "generic" => Some(Self::Generic),
+            _ => None,
+        }
+    }
+
+    /// The button side, gap on each side of it, and gap between the outermost button and the
+    /// window's edge. libadwaita: 24 pt buttons 13 pt apart, 10 pt from the edge (the gap is split
+    /// between neighbours, so the hit areas touch). Breeze sizes buttons by the font (about 1.3 em,
+    /// 18 pt at KDE's default 10 pt font), half a button apart, 8 pt from the edge.
+    fn metrics(self) -> (f32, f32, f32) {
+        match self {
+            Self::Windows => (BUTTON_WIDTH, 0.0, 0.0),
+            Self::Adwaita | Self::Generic => (24.0, 6.5, 10.0),
+            Self::Breeze => (18.0, 4.5, 8.0),
+        }
+    }
+}
+
+/// The caption buttons' look and placement.
+#[derive(Clone, PartialEq, Debug)]
+pub struct CaptionStyle {
+    pub family: CaptionFamily,
+    /// The buttons at the bar's left end, left to right.
+    pub left: Vec<Caption>,
+    /// The buttons at the bar's right end, left to right.
+    pub right: Vec<Caption>,
+    /// The round buttons' glyphs from the desktop's icon theme; `None`, or an icon it lacks, draws
+    /// the family's own.
+    pub icons: Option<CaptionIcons>,
+}
+
+/// A caption button glyph, as the icon themes name them (`window-restore-symbolic`, …).
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub enum CaptionIcon {
+    Minimize,
+    Maximize,
+    Restore,
+    Close,
+}
+
+/// Renders an icon as a square coverage mask (`side` × `side` bytes, row by row), or `None`.
+pub type RenderIconFn = dyn Fn(CaptionIcon, u32) -> Option<Vec<u8>> + Send + Sync;
+
+/// Glyphs from an icon theme (Linux: `window-*-symbolic`), drawn in the button's ink colour as
+/// symbolic icons are.
+#[derive(Clone)]
+pub struct CaptionIcons {
+    /// The theme's name; the cached textures follow it.
+    pub theme: String,
+    pub render: std::sync::Arc<RenderIconFn>,
+}
+
+impl PartialEq for CaptionIcons {
+    fn eq(&self, other: &Self) -> bool {
+        self.theme == other.theme && std::sync::Arc::ptr_eq(&self.render, &other.render)
+    }
+}
+
+impl std::fmt::Debug for CaptionIcons {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CaptionIcons").field("theme", &self.theme).finish_non_exhaustive()
+    }
+}
+
+impl Default for CaptionStyle {
+    fn default() -> Self {
+        Self { family: CaptionFamily::Windows, left: vec![], right: CAPTIONS.to_vec(), icons: None }
+    }
+}
+
+impl CaptionStyle {
+    /// `family` with the buttons a GTK decoration layout names (`gtk-decoration-layout`, GNOME's
+    /// `button-layout`, e.g. `appmenu:minimize,maximize,close`): those before the colon go left,
+    /// those after it right; without a colon all go left, as in GTK. Names other than `minimize`,
+    /// `maximize` and `close` (`appmenu`, `icon`, `spacer`, …) are skipped, and a button named
+    /// twice is placed once.
+    pub fn from_gtk_layout(family: CaptionFamily, layout: &str) -> Self {
+        let (left, right) = layout.split_once(':').unwrap_or((layout, ""));
+        let mut seen = vec![];
+        let mut side = |names: &str| {
+            let mut v = vec![];
+            for name in names.split(',') {
+                let c = match name.trim() {
+                    "minimize" => Caption::Minimize,
+                    "maximize" => Caption::Maximize,
+                    "close" => Caption::Close,
+                    _ => continue,
+                };
+                if !seen.contains(&c) {
+                    seen.push(c);
+                    v.push(c);
+                }
+            }
+            v
+        };
+        let left = side(left);
+        let right = side(right);
+        Self { family, left, right, icons: None }
+    }
+}
+
+/// The caption style the platform reports, or Windows' when it reports none.
+fn style(app: &PhotocraftApp, ctx: &egui::Context) -> CaptionStyle {
+    app.services.caption_style.as_ref().map(|read| read(ctx)).unwrap_or_default()
+}
+
+/// The title bar's height: `base`, or with GNOME's buttons at least libadwaita's header bar
+/// (46 pt, plus the bar's 1 pt separator), so the bar is as tall as its neighbours' title bars.
+pub fn bar_height(app: &PhotocraftApp, ctx: &egui::Context, base: f32) -> f32 {
+    if app.custom_titlebar && style(app, ctx).family == CaptionFamily::Adwaita { base.max(47.0) } else { base }
+}
+
+/// The width the caption buttons take at the bar's (left, right) end: zero for a side without
+/// buttons, and for both without the custom title bar.
+pub fn reserved(app: &PhotocraftApp, ctx: &egui::Context) -> (f32, f32) {
+    if !app.custom_titlebar {
+        return (0.0, 0.0);
+    }
+    let s = style(app, ctx);
+    let width = |side: &[Caption]| slots(s.family, side, 0.0, true).last().map_or(0.0, |(_, r, _)| r.1);
+    (width(&s.left), width(&s.right))
+}
+
+/// Each button's horizontal extent (left, right) and face centre on a side starting at `from`, in
+/// order. `outer_left` puts the edge gap on the first button's left (the left end) instead of the
+/// last button's right.
+fn slots(family: CaptionFamily, side: &[Caption], from: f32, outer_left: bool) -> Vec<(Caption, (f32, f32), f32)> {
+    let (size, gap, end) = family.metrics();
+    let mut x = from;
+    let n = side.len();
+    side.iter()
+        .enumerate()
+        .map(|(i, &c)| {
+            let before = if outer_left && i == 0 { end } else { gap };
+            let after = if !outer_left && i + 1 == n { end } else { gap };
+            let slot = (x, x + before + size + after);
+            let centre = x + before + size / 2.0;
+            x = slot.1;
+            (c, slot, centre)
+        })
+        .collect()
+}
+
+/// Every caption button's hit rect (full bar height, flush with the window's edge) and face
+/// centre, for a bar `bar` between the window's `left` and `right` edges.
+fn layout(s: &CaptionStyle, bar: Rect, left: f32, right: f32) -> Vec<(Caption, Rect, Pos2)> {
+    let rect = |(c, (l, r), centre): (Caption, (f32, f32), f32)| {
+        (c, Rect::from_min_max(pos2(l, bar.top()), pos2(r, bar.bottom() - 1.0)), pos2(centre, bar.center().y))
+    };
+    let lefts = slots(s.family, &s.left, left, true);
+    let width = slots(s.family, &s.right, 0.0, false).last().map_or(0.0, |(_, r, _)| r.1);
+    let rights = slots(s.family, &s.right, right - width, false);
+    lefts.into_iter().chain(rights).map(rect).collect()
+}
+
 /// Caption button ids (stable, so tests and agents can find them).
 fn caption_id(c: Caption) -> Id {
     Id::new(("titlebar-caption", c as u8))
@@ -43,29 +252,38 @@ fn toggle_maximize(ctx: &egui::Context) {
     ctx.send_viewport_cmd(ViewportCommand::Maximized(!maximized(ctx)));
 }
 
-/// Minimize, Maximize/Restore and Close at the right end of `bar` (the title bar's outer rect),
-/// full bar height, flush with the window's edge (even if the bar's contents run wider) so a
-/// maximized window's corner hits Close. Close runs File › Exit, which asks about unsaved
-/// documents first.
+/// The caption buttons at the ends of `bar` (the title bar's outer rect), full bar height, flush
+/// with the window's edges (even if the bar's contents run wider) so a maximized window's corner
+/// hits the outermost one. Close runs File › Exit, which asks about unsaved documents first. On
+/// Linux the buttons drag the window too, as GTK's and KDE's do.
 pub fn caption_buttons(app: &mut PhotocraftApp, ui: &mut Ui, bar: Rect) {
     let t = Tokens::get(ui.ctx());
+    let s = style(app, ui.ctx());
     let max = maximized(ui.ctx());
-    let right = bar.right().min(ui.ctx().content_rect().right());
+    let content = ui.ctx().content_rect();
+    let windows = s.family == CaptionFamily::Windows;
     let mut clicked = None;
-    for (i, c) in CAPTIONS.into_iter().enumerate() {
-        let r = Rect::from_min_size(pos2(right - WIDTH + i as f32 * BUTTON_WIDTH, bar.top()), vec2(BUTTON_WIDTH, bar.height() - 1.0));
-        let resp = ui.interact(r, caption_id(c), Sense::click());
-        let close = c == Caption::Close;
-        let fill = match (resp.is_pointer_button_down_on(), resp.hovered()) {
-            (true, _) if close => t.caption_close.gamma_multiply(0.8),
-            (_, true) if close => t.caption_close,
-            (true, _) => t.pressed,
-            (_, true) => t.hover,
-            _ => egui::Color32::TRANSPARENT,
-        };
-        ui.painter().rect_filled(r, 0.0, fill);
-        let ink = if close && resp.hovered() { t.caption_close_text } else { t.icon };
-        paint_glyph(ui, c, max, r.center(), Stroke::new(1.0, ink));
+    for (c, r, centre) in layout(&s, bar, bar.left().max(content.left()), bar.right().min(content.right())) {
+        let resp = ui.interact(r, caption_id(c), if windows { Sense::click() } else { Sense::click_and_drag() });
+        if resp.drag_started_by(PointerButton::Primary) {
+            ui.ctx().send_viewport_cmd(ViewportCommand::StartDrag);
+        }
+        let pressed = resp.is_pointer_button_down_on() && resp.hovered();
+        if windows {
+            let close = c == Caption::Close;
+            let fill = match (resp.is_pointer_button_down_on(), resp.hovered()) {
+                (true, _) if close => t.caption_close.gamma_multiply(0.8),
+                (_, true) if close => t.caption_close,
+                (true, _) => t.pressed,
+                (_, true) => t.hover,
+                _ => Color32::TRANSPARENT,
+            };
+            ui.painter().rect_filled(r, 0.0, fill);
+            let ink = if close && resp.hovered() { t.caption_close_text } else { t.icon };
+            paint_windows_glyph(ui, c, max, r.center(), Stroke::new(1.0, ink));
+        } else {
+            paint_round(ui, &t, &s, c, max, centre, resp.hovered(), pressed);
+        }
         let tip = match c {
             Caption::Minimize => tl!("Minimize"),
             Caption::Maximize if max => tl!("Restore"),
@@ -88,8 +306,8 @@ pub fn caption_buttons(app: &mut PhotocraftApp, ui: &mut Ui, bar: Rect) {
     }
 }
 
-/// The 10 pt line glyphs of the caption buttons.
-fn paint_glyph(ui: &Ui, c: Caption, maximized: bool, at: egui::Pos2, s: Stroke) {
+/// The 10 pt line glyphs of the Windows caption buttons.
+fn paint_windows_glyph(ui: &Ui, c: Caption, maximized: bool, at: egui::Pos2, s: Stroke) {
     let p = ui.painter();
     let g = Rect::from_center_size(at, vec2(10.0, 10.0));
     match c {
@@ -112,6 +330,119 @@ fn paint_glyph(ui: &Ui, c: Caption, maximized: bool, at: egui::Pos2, s: Stroke)
     }
 }
 
+/// A round Linux caption button centred at `centre`: its disc, then its glyph on a 16 pt grid.
+/// The disc is the icon colour at a fraction of its opacity (libadwaita's `alpha(currentColor)`),
+/// so it suits light and dark themes alike; Breeze instead fills it with the icon colour on hover
+/// and draws the glyph in the bar's colour.
+#[allow(clippy::too_many_arguments)]
+fn paint_round(ui: &Ui, t: &Tokens, s: &CaptionStyle, c: Caption, maximized: bool, centre: Pos2, hovered: bool, pressed: bool) {
+    let family = s.family;
+    let (size, _, _) = family.metrics();
+    // Whole pixels, so the glyphs' edges stay sharp.
+    let ppp = ui.ctx().pixels_per_point();
+    let centre = pos2((centre.x * ppp).round() / ppp, (centre.y * ppp).round() / ppp);
+    let close = c == Caption::Close;
+    let (fill, ink) = if family == CaptionFamily::Breeze {
+        match (hovered, pressed) {
+            (_, true) if close => (BREEZE_CLOSE_PRESSED, t.chrome),
+            (true, _) if close => (BREEZE_CLOSE_HOVER, t.chrome),
+            (_, true) => (t.icon.gamma_multiply(0.5), t.chrome),
+            (true, _) => (t.icon, t.chrome),
+            _ => (Color32::TRANSPARENT, t.icon),
+        }
+    } else {
+        let rest = if family == CaptionFamily::Adwaita { 0.10 } else { 0.0 };
+        let target = if pressed {
+            0.30
+        } else if hovered {
+            0.15
+        } else {
+            rest
+        };
+        // libadwaita eases the disc over 0.2 s.
+        let a = ui.ctx().animate_value_with_time(caption_id(c).with("disc"), target, 0.2);
+        (t.icon.gamma_multiply(a), t.icon)
+    };
+    let p = ui.painter();
+    if fill.a() > 0 {
+        p.circle_filled(centre, size / 2.0, fill);
+    }
+    // The glyph grid: 16 pt, or 2 pt less than a smaller button.
+    let k = (size - 2.0).min(16.0) / 16.0;
+    let icon = match c {
+        Caption::Minimize => CaptionIcon::Minimize,
+        Caption::Maximize if maximized => CaptionIcon::Restore,
+        Caption::Maximize => CaptionIcon::Maximize,
+        Caption::Close => CaptionIcon::Close,
+    };
+    if let Some(icons) = &s.icons
+        && let Some(tex) = theme_icon(ui.ctx(), icons, icon, (16.0 * k * ppp).round() as u32)
+    {
+        let side = tex.size_vec2() / ppp;
+        let min = centre - side / 2.0;
+        let rect = Rect::from_min_size(pos2((min.x * ppp).round() / ppp, (min.y * ppp).round() / ppp), side);
+        p.image(tex.id(), rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), ink);
+        return;
+    }
+    let at = |x: f32, y: f32| centre + vec2(x - 8.0, y - 8.0) * k;
+    if family == CaptionFamily::Breeze {
+        // Breeze: 1 pt chevrons (down to minimize, up to maximize), a diamond to restore, an X.
+        let s = Stroke::new(1.0, ink);
+        match c {
+            Caption::Minimize => {
+                p.line(vec![at(2.5, 5.5), at(8.0, 11.0), at(13.5, 5.5)], s);
+            }
+            Caption::Maximize if maximized => {
+                p.add(egui::Shape::closed_line(vec![at(8.0, 3.0), at(13.0, 8.0), at(8.0, 13.0), at(3.0, 8.0)], s));
+            }
+            Caption::Maximize => {
+                p.line(vec![at(2.5, 10.5), at(8.0, 5.0), at(13.5, 10.5)], s);
+            }
+            Caption::Close => {
+                let s = Stroke::new(1.2, ink);
+                p.line_segment([at(3.6, 3.6), at(12.4, 12.4)], s);
+                p.line_segment([at(12.4, 3.6), at(3.6, 12.4)], s);
+            }
+        }
+    } else {
+        // libadwaita: a 2 pt bar low down, a 2 pt square outline (smaller to restore), an X.
+        let frame = |a: f32, b: f32| Rect::from_min_max(at(a, a), at(b, b));
+        match c {
+            Caption::Minimize => {
+                p.rect_filled(Rect::from_min_max(at(4.0, 10.0), at(12.0, 12.0)), 0.0, ink);
+            }
+            Caption::Maximize => {
+                let square = if maximized { frame(5.0, 11.0) } else { frame(4.0, 12.0) };
+                p.rect_stroke(square, 0.0, Stroke::new(2.0 * k, ink), egui::StrokeKind::Inside);
+            }
+            Caption::Close => {
+                let s = Stroke::new(1.5 * k, ink);
+                p.line_segment([at(4.5, 4.5), at(11.5, 11.5)], s);
+                p.line_segment([at(11.5, 4.5), at(4.5, 11.5)], s);
+            }
+        }
+    }
+}
+
+/// `icon` from the theme at `px` device pixels, uploaded once per theme and size; `None` (also
+/// remembered) when the theme lacks it or it doesn't render.
+fn theme_icon(ctx: &egui::Context, icons: &CaptionIcons, icon: CaptionIcon, px: u32) -> Option<egui::TextureHandle> {
+    let id = Id::new(("caption-icon", &icons.theme, icon, px));
+    if let Some(cached) = ctx.data(|d| d.get_temp::<Option<egui::TextureHandle>>(id)) {
+        return cached;
+    }
+    let side = usize::try_from(px).ok().filter(|&s| (1..=256).contains(&s));
+    let tex = side.and_then(|side| {
+        let mask = (icons.render)(icon, px).filter(|m| m.len() == side * side)?;
+        // White at the mask's coverage, tinted with the ink when drawn.
+        let pixels = mask.into_iter().map(Color32::from_white_alpha).collect();
+        let image = egui::ColorImage { size: [side, side], source_size: vec2(px as f32, px as f32), pixels };
+        Some(ctx.load_texture(format!("caption-{icon:?}-{px}"), image, egui::TextureOptions::LINEAR))
+    });
+    ctx.data_mut(|d| d.insert_temp(id, tex.clone()));
+    tex
+}
+
 /// The edge and corner zones of a window with content rect `w`: (zone, direction, cursor). Corners
 /// come last so they win where they overlap the edges. Edges use the one-sided cursors
 /// (`w-resize`, …), as GTK and KDE window borders do: some cursor themes ship no `ew-resize` /
@@ -226,6 +557,10 @@ mod tests {
         }
 
         fn frame(&mut self, events: Vec<Event>) -> egui::FullOutput {
+            self.frame_with_modal(events, false)
+        }
+
+        fn frame_with_modal(&mut self, events: Vec<Event>, modal: bool) -> egui::FullOutput {
             self.time += 0.05;
             let mut input =
                 RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(self.width, 600.0))), time: Some(self.time), events, ..Default::default() };
@@ -237,6 +572,12 @@ mod tests {
             let app = &mut self.app;
             let mut out = self.ctx.run_ui(input, |ui| {
                 crate::panels::title_bar(app, ui);
+                if modal {
+                    egui::Modal::new(Id::new("titlebar-drag-test-modal")).backdrop_color(Color32::TRANSPARENT).show(ui.ctx(), |ui| {
+                        ui.label("Modal dialog");
+                    });
+                    modal_drag_overlay(ui.ctx());
+                }
                 resize_zones(ui);
             });
             out.textures_delta.clear();
@@ -246,10 +587,17 @@ mod tests {
         /// Frames for a pointer gesture: move to `path[0]`, press, move along `path`, release. The
         /// viewport commands the frames sent.
         fn gesture(&mut self, path: &[Pos2]) -> Vec<ViewportCommand> {
+            self.gesture_with_modal(path, false)
+        }
+
+        fn gesture_with_modal(&mut self, path: &[Pos2], modal: bool) -> Vec<ViewportCommand> {
             let mut events = vec![vec![Event::PointerMoved(path[0])], vec![button(path[0], true)]];
             events.extend(path[1..].iter().map(|p| vec![Event::PointerMoved(*p)]));
             events.push(vec![button(*path.last().unwrap_or(&path[0]), false)]);
-            events.into_iter().flat_map(|e| self.frame(e).viewport_output.remove(&ViewportId::ROOT).map(|v| v.commands).unwrap_or_default()).collect()
+            events
+                .into_iter()
+                .flat_map(|e| self.frame_with_modal(e, modal).viewport_output.remove(&ViewportId::ROOT).map(|v| v.commands).unwrap_or_default())
+                .collect()
         }
 
         fn click(&mut self, p: Pos2) -> Vec<ViewportCommand> {
@@ -371,6 +719,31 @@ mod tests {
         assert!(!cmds.iter().any(|c| matches!(c, ViewportCommand::StartDrag)), "{cmds:?}");
     }
 
+    #[test]
+    fn empty_bar_space_still_drags_with_a_modal_open() {
+        let mut w = Win::new(1440.0);
+        w.frame(vec![]);
+        w.frame_with_modal(vec![], true);
+        let empty = pos2(980.0, 16.0);
+        let drag_area = w.ctx.data(|d| d.get_temp::<Rect>(modal_drag_area_id()));
+        assert!(drag_area.is_some_and(|r| r.contains(empty)), "the test point must be in the current title-bar gap: {drag_area:?}");
+        assert!(w.bar_widgets().iter().all(|r| !r.contains(empty)), "the probe point must be empty bar space");
+        let cmds = w.gesture_with_modal(&[empty, empty + vec2(12.0, 4.0), empty + vec2(30.0, 8.0)], true);
+        assert_eq!(cmds.iter().filter(|c| matches!(c, ViewportCommand::StartDrag)).count(), 1, "{cmds:?}");
+    }
+
+    #[test]
+    fn modal_drag_overlay_does_not_cover_a_dialog_moved_into_the_gap() {
+        let mut w = Win::new(1440.0);
+        w.frame(vec![]);
+        w.frame_with_modal(vec![], true);
+        let area = w.ctx.data(|d| d.get_temp::<Rect>(modal_drag_area_id())).unwrap_or(Rect::NOTHING);
+        assert!(area.contains(pos2(980.0, 16.0)), "the probe point must be in the gap: {area:?}");
+        w.ctx.data_mut(|d| d.insert_temp(Id::new("pc-dialog-rects"), vec![area]));
+        let cmds = w.gesture_with_modal(&[area.center(), area.center() + vec2(12.0, 4.0)], true);
+        assert!(!cmds.iter().any(|c| matches!(c, ViewportCommand::StartDrag)), "{cmds:?}");
+    }
+
     /// #1581: KDE Wayland keeps the button release of an OS resize. egui then kept the edge
     /// pressed (no hover until the next click) and egui-winit never re-sent the resize cursor that
     /// the compositor had replaced: the cursor came back only on every other press.
@@ -465,4 +838,100 @@ mod tests {
         assert!(!cmds.iter().any(|c| matches!(c, ViewportCommand::BeginResize(_))), "{cmds:?}");
         assert!(w.click(pos2(999.5, 0.5)).iter().any(|c| matches!(c, ViewportCommand::Close)));
     }
+
+    #[test]
+    fn gtk_layouts_pick_the_buttons_and_their_sides() {
+        use Caption::*;
+        let s = CaptionStyle::from_gtk_layout(CaptionFamily::Adwaita, "appmenu:minimize,maximize,close");
+        assert_eq!((s.left, s.right), (vec![], vec![Minimize, Maximize, Close]));
+        // Unknown names are skipped, spaces trimmed, a repeat placed once, a second colon is a name.
+        let s = CaptionStyle::from_gtk_layout(CaptionFamily::Adwaita, "close,close , minimize:icon,maximize:close");
+        assert_eq!((s.left, s.right), (vec![Close, Minimize], vec![]));
+        let s = CaptionStyle::from_gtk_layout(CaptionFamily::Breeze, "minimize,close");
+        assert_eq!((s.left, s.right), (vec![Minimize, Close], vec![]), "no colon: GTK puts them all at the start");
+        let s = CaptionStyle::from_gtk_layout(CaptionFamily::Breeze, "");
+        assert!(s.left.is_empty() && s.right.is_empty());
+        assert_eq!(CaptionFamily::parse(" Breeze "), Some(CaptionFamily::Breeze));
+        assert_eq!(CaptionFamily::parse("aqua"), None);
+        assert_eq!(CaptionStyle::default(), CaptionStyle { family: CaptionFamily::Windows, left: vec![], right: CAPTIONS.to_vec(), icons: None });
+    }
+
+    #[test]
+    fn linux_buttons_sit_where_the_layout_says_and_drag_the_window() {
+        use Caption::*;
+        for (family, size, gap, end) in [(CaptionFamily::Adwaita, 24.0, 6.5, 10.0), (CaptionFamily::Breeze, 18.0, 4.5, 8.0)] {
+            let width = 1100.0;
+            let mut w = Win::new(width);
+            w.app.services.caption_style = Some(Box::new(move |_| CaptionStyle { family, left: vec![Close], right: vec![Minimize, Maximize], icons: None }));
+            w.frame(vec![]);
+            w.frame(vec![]);
+            let [min, max, close] = CAPTIONS.map(|c| w.caption(c));
+            // Flush with the window's edges, the edge gap outermost, the hit areas touching.
+            assert_eq!((close.left(), close.width()), (0.0, end + size + gap), "{family:?}");
+            assert_eq!((max.right(), max.width()), (width, gap + size + end), "{family:?}");
+            assert_eq!((min.right(), min.width()), (max.left(), 2.0 * gap + size), "{family:?}");
+            // GNOME's header bars are taller than Photoshop's bar; KDE's are not.
+            if family == CaptionFamily::Adwaita {
+                assert_eq!(close.height(), 46.0);
+            } else {
+                assert!((31.0..46.0).contains(&close.height()), "{close:?}");
+            }
+            let mark = crate::brand::mark_rect(&w.ctx).expect("the brand mark is painted");
+            assert!(mark.left() > close.right(), "the bar starts after the left buttons: {mark:?} {close:?}");
+            for a in w.bar_widgets() {
+                assert!(a.left() >= close.right() && a.right() <= min.left(), "{a:?} runs into the caption buttons ({family:?})");
+            }
+            assert!(w.click(max.center()).contains(&ViewportCommand::Maximized(true)));
+            assert!(w.click(close.center()).iter().any(|c| matches!(c, ViewportCommand::Close)));
+            // A drag that starts on a button moves the window instead of pressing it.
+            let at = min.center();
+            let cmds = w.gesture(&[at, at + vec2(12.0, 4.0), at + vec2(30.0, 8.0)]);
+            assert_eq!(cmds.iter().filter(|c| matches!(c, ViewportCommand::StartDrag)).count(), 1, "{cmds:?}");
+            assert!(!cmds.contains(&ViewportCommand::Minimized(true)), "{cmds:?}");
+        }
+    }
+
+    /// A side without buttons reserves nothing; without the custom title bar, neither does any.
+    #[test]
+    fn only_sides_with_buttons_take_room() {
+        let mut w = Win::new(1000.0);
+        w.app.services.caption_style = Some(Box::new(|_| CaptionStyle::from_gtk_layout(CaptionFamily::Adwaita, "appmenu:close")));
+        assert_eq!(reserved(&w.app, &w.ctx), (0.0, 6.5 + 24.0 + 10.0));
+        w.app.custom_titlebar = false;
+        assert_eq!(reserved(&w.app, &w.ctx), (0.0, 0.0));
+        w.app.custom_titlebar = true;
+        w.app.services.caption_style = None;
+        assert_eq!(reserved(&w.app, &w.ctx), (0.0, 3.0 * BUTTON_WIDTH));
+    }
+
+    /// Theme glyphs upload once per theme and size; an icon the theme lacks, a wrong-sized mask or
+    /// an absurd size gives `None`, so the button draws its own glyph.
+    #[test]
+    fn theme_icons_are_cached_and_fall_back() {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        let calls = std::sync::Arc::new(AtomicUsize::new(0));
+        let counter = std::sync::Arc::clone(&calls);
+        let render = move |icon: CaptionIcon, px: u32| {
+            counter.fetch_add(1, Ordering::Relaxed);
+            match icon {
+                CaptionIcon::Close => Some(vec![255; (px * px) as usize]),
+                CaptionIcon::Minimize => Some(vec![255; 3]),
+                _ => None,
+            }
+        };
+        let icons = CaptionIcons { theme: "Test".into(), render: std::sync::Arc::new(render) };
+        let ctx = egui::Context::default();
+        let mut out = ctx.run_ui(RawInput::default(), |ui| {
+            let tex = theme_icon(ui.ctx(), &icons, CaptionIcon::Close, 16).expect("rendered");
+            assert_eq!(tex.size(), [16, 16]);
+            assert!(theme_icon(ui.ctx(), &icons, CaptionIcon::Close, 16).is_some());
+            assert!(theme_icon(ui.ctx(), &icons, CaptionIcon::Restore, 16).is_none());
+            assert!(theme_icon(ui.ctx(), &icons, CaptionIcon::Restore, 16).is_none());
+            assert!(theme_icon(ui.ctx(), &icons, CaptionIcon::Minimize, 16).is_none(), "a mask of the wrong size");
+            assert!(theme_icon(ui.ctx(), &icons, CaptionIcon::Close, 0).is_none());
+            assert!(theme_icon(ui.ctx(), &icons, CaptionIcon::Close, 100_000).is_none());
+        });
+        out.textures_delta.clear();
+        assert_eq!(calls.load(Ordering::Relaxed), 3, "each icon and size rendered once; absurd sizes never");
+    }
 }
diff --git a/crates/ui-egui/src/tool_cursor.rs b/crates/ui-egui/src/tool_cursor.rs
index da78f1160b..6539ddb860 100644
--- a/crates/ui-egui/src/tool_cursor.rs
+++ b/crates/ui-egui/src/tool_cursor.rs
@@ -10,21 +10,26 @@ use std::sync::Arc;
 use egui::{CursorIcon, CustomCursorImage, Painter, Pos2, Stroke, Vec2, vec2};
 
 mod hand;
+mod zoom;
 
-/// The largest cursor bitmap, in physical pixels; a larger tip paints its outline instead (with a
-/// small OS crosshair at the hotspot). Windows takes winit's limit. Elsewhere, X servers and
-/// hardware cursor planes commonly cap cursors at 256 px and fall back to slow software cursors
-/// (or reject them) past that, so stay within it there (#968 used 128). Either way it keeps
-/// allocations bounded for hostile brush sizes or zooms.
-const MAX_SIDE: u16 = if cfg!(target_os = "windows") { 2048 } else { 255 };
+/// The largest cursor bitmap (physical pixels; points on macOS, see [`native_scale`]); a larger tip
+/// paints its outline instead, with a small OS crosshair at the hotspot, and that outline trails
+/// the pointer by a frame or two (26 ms on a 120 Hz Mac, #1343). Windows takes winit's limit, and
+/// so does macOS: AppKit sets no size limit on an `NSCursor` image. On Linux, X servers and
+/// hardware cursor planes commonly cap cursors at 256 px and fall back to slow software cursors (or
+/// reject them) past that, so stay within it there (#968 used 128). Either way it keeps allocations
+/// bounded for hostile brush sizes or zooms.
+const MAX_SIDE: u16 = if cfg!(any(target_os = "windows", target_os = "macos")) { 2048 } else { 255 };
 
-/// What a bitmap cursor shows. `Hand` is the Hand tool's open hand, or its fist while it drags.
-/// `Outline` is a brush tip outline: closed rings of logical-point offsets from the hotspot.
+/// What a bitmap cursor shows. `Hand` is the Hand tool's open hand, or its fist while it drags;
+/// `Zoom` is the Zoom tool's magnifier, with a minus when it zooms out. `Outline` is a brush tip
+/// outline: closed rings of logical-point offsets from the hotspot.
 #[derive(Clone, Debug, PartialEq)]
 enum Shape {
     Circle { radius: f32, centre: bool },
     Crosshair { length: f32, gap: f32 },
     Hand { closed: bool },
+    Zoom { out: bool },
     Outline { rings: Arc<[Vec<Vec2>]>, centre: bool },
 }
 
@@ -75,6 +80,16 @@ pub(crate) fn outline(painter: &Painter, at: Pos2, rings: Vec<Vec<Vec2>>, centre
     show(painter, at, Shape::Outline { rings: rings.into(), centre })
 }
 
+/// The Pen's pointer over the anchor a click would close the path on (#4596): the centre cross
+/// with a small ring below right, as Photoshop's pen shows a small circle there.
+pub(crate) fn close_path(painter: &Painter, at: Pos2) -> CursorIcon {
+    outline(painter, at, vec![close_ring()], true)
+}
+
+fn close_ring() -> Vec<Vec2> {
+    (0..16).map(|i| (i as f32 / 16.0 * std::f32::consts::TAU, vec2(9.0, 9.0))).map(|(a, c)| c + vec2(a.cos(), a.sin()) * 3.5).collect()
+}
+
 /// Can this pass show an OS cursor bitmap? eframe's immediate viewports and its web integration
 /// don't upload cursor images; every desktop root viewport does (winit custom cursors).
 fn native(ctx: &egui::Context) -> bool {
@@ -104,6 +119,21 @@ fn hand_with(ctx: &egui::Context, closed: bool, bitmap: bool) -> CursorIcon {
     if closed { CursorIcon::Grabbing } else { CursorIcon::Grab }
 }
 
+/// The Zoom tool's pointer: a magnifier with a plus, or a minus when it zooms `out`. winit maps
+/// `ZoomIn` and `ZoomOut` to the plain arrow on Windows (#3735), so there it is a bitmap; macOS and
+/// the Linux themes already draw magnifiers.
+pub(crate) fn zoom(ctx: &egui::Context, out: bool) -> CursorIcon {
+    zoom_with(ctx, out, cfg!(target_os = "windows") && ctx.viewport_id() == egui::ViewportId::ROOT)
+}
+
+fn zoom_with(ctx: &egui::Context, out: bool, bitmap: bool) -> CursorIcon {
+    if bitmap && let Some(image) = cached_image(ctx, &Shape::Zoom { out }, native_scale(ctx)) {
+        ctx.set_cursor_image(Some(image));
+        return CursorIcon::None;
+    }
+    if out { CursorIcon::ZoomOut } else { CursorIcon::ZoomIn }
+}
+
 fn show(painter: &Painter, at: Pos2, shape: Shape) -> CursorIcon {
     let ctx = painter.ctx();
     // Where cursor images can't be uploaded (immediate viewports, the web), paint the shape.
@@ -164,7 +194,7 @@ fn paint(painter: &Painter, at: Pos2, shape: &Shape) {
                 }
             }
             // Only ever a bitmap: without one the OS draws its own grab cursors.
-            Shape::Hand { .. } => {}
+            Shape::Hand { .. } | Shape::Zoom { .. } => {}
         }
     }
 }
@@ -212,6 +242,7 @@ fn extent(shape: &Shape) -> Option<f32> {
             if *centre { e.max(3.0) } else { e }
         }
         Shape::Hand { .. } => hand::HALF,
+        Shape::Zoom { .. } => zoom::HALF,
     })
 }
 
@@ -253,15 +284,25 @@ fn coverage(shape: &Shape, dx: f32, dy: f32, scale: f32) -> (f32, f32) {
         }
         Shape::Hand { closed } => {
             let (lx, ly) = (dx / scale, dy / scale);
-            let edge = hand::shape(*closed, lx, ly) * scale;
-            let inside = (0.5 - edge).clamp(0.0, 1.0);
-            let outline = (scale + 0.5 - edge).clamp(0.0, 1.0);
-            let crease = (0.45 * scale + 0.5 - hand::crease(*closed, lx, ly) * scale).clamp(0.0, 1.0);
-            (inside * (1.0 - crease), outline.max(inside * crease))
+            silhouette(hand::shape(*closed, lx, ly), hand::crease(*closed, lx, ly), 0.45, scale)
+        }
+        Shape::Zoom { out } => {
+            let (lx, ly) = (dx / scale, dy / scale);
+            silhouette(zoom::shape(lx, ly), zoom::glyph(*out, lx, ly), 0.75, scale)
         }
     }
 }
 
+/// A light filled shape with a 1 px dark outline and dark lines `half_width` logical pixels either
+/// side of its creases, from their signed distances in logical pixels.
+fn silhouette(edge: f32, crease: f32, half_width: f32, scale: f32) -> (f32, f32) {
+    let edge = edge * scale;
+    let inside = (0.5 - edge).clamp(0.0, 1.0);
+    let outline = (scale + 0.5 - edge).clamp(0.0, 1.0);
+    let crease = (half_width * scale + 0.5 - crease * scale).clamp(0.0, 1.0);
+    (inside * (1.0 - crease), outline.max(inside * crease))
+}
+
 /// A 1 px light line with a 1 px dark one on each side, `distance` physical pixels from its centre.
 fn stroke_coverage(distance: f32, scale: f32) -> (f32, f32) {
     ((0.5 * scale + 0.5 - distance).clamp(0.0, 1.0), (1.5 * scale + 0.5 - distance).clamp(0.0, 1.0))
@@ -308,13 +349,27 @@ fn splat_cross(dist: &mut [f32], side: usize, hot: f32, arm: f32) {
 }
 
 /// One bitmap pixel from its distance to the stroke centre, in straight RGBA (winit form).
-fn push_stroke_pixel(rgba: &mut Vec<u8>, distance: f32, scale: f32, dark: egui::Color32, light: egui::Color32) {
-    let (fill, outline) = stroke_coverage(distance, scale);
+/// A pixel with light `fill` over a dark `outline` (coverages 0 to 1), in straight RGBA as winit
+/// requires (not egui's premultiplied). No coverage is `[0; 4]`.
+fn stroke_pixel((fill, outline): (f32, f32), dark: egui::Color32, light: egui::Color32) -> [u8; 4] {
     let a_dark = outline * f32::from(dark.a()) / 255.0;
     let a_light = fill * f32::from(light.a()) / 255.0;
     let alpha = a_light + a_dark * (1.0 - a_light);
     let white = if alpha > 0.0 { (255.0 * a_light / alpha).round() as u8 } else { 0 };
-    rgba.extend_from_slice(&[white, white, white, (255.0 * alpha).round() as u8]);
+    [white, white, white, (255.0 * alpha).round() as u8]
+}
+
+/// The columns of row offset `dy` (from the hotspot, in pixels) that can be painted by a ring of
+/// radius `r` drawn `reach` wide either side: the left and right arcs of the annulus, padded by
+/// a pixel. Every other pixel of the row is transparent.
+fn ring_spans(dy: f32, r: f32, reach: f32) -> Option<[(f32, f32); 2]> {
+    let (ro, ri) = (r + reach + 1.0, (r - reach - 1.0).max(0.0));
+    if dy.abs() > ro {
+        return None;
+    }
+    let xo = (ro * ro - dy * dy).max(0.0).sqrt();
+    let xi = if dy.abs() < ri { (ri * ri - dy * dy).sqrt() } else { 0.0 };
+    Some([(-xo, -xi), (xi, xo)])
 }
 
 fn rasterize(shape: &Shape, scale: f32) -> Option<CustomCursorImage> {
@@ -331,13 +386,20 @@ fn rasterize(shape: &Shape, scale: f32) -> Option<CustomCursorImage> {
     let hot = half as u16;
     let side = hot * 2 + 1;
     let bytes = usize::from(side).checked_mul(usize::from(side))?.checked_mul(4)?;
-    let mut rgba = Vec::with_capacity(bytes);
+    // Transparent to start; only pixels a shape can reach are evaluated below (a big tip's
+    // outline is a thin ring in a large square, #1343).
+    let mut rgba = vec![0u8; bytes];
     let [dark, light] = crate::theme::Tokens::cursor_outline();
+    let n = usize::from(side);
+    let hotf = f32::from(hot);
+    let mut put = |col: usize, row: usize, cov: (f32, f32)| {
+        if let Some(px) = row.checked_mul(n).and_then(|i| i.checked_add(col)).and_then(|i| rgba.get_mut(i * 4..i * 4 + 4)) {
+            px.copy_from_slice(&stroke_pixel(cov, dark, light));
+        }
+    };
     if let Shape::Outline { rings, centre } = shape {
         // Splat each segment into its bounding box instead of measuring every ring per pixel:
         // tip outlines may carry hundreds of points.
-        let hotf = f32::from(hot);
-        let n = usize::from(side);
         let reach = 1.5 * scale + 2.0;
         let mut dist = vec![f32::INFINITY; n * n];
         for ring in rings.iter() {
@@ -352,22 +414,36 @@ fn rasterize(shape: &Shape, scale: f32) -> Option<CustomCursorImage> {
         if *centre {
             splat_cross(&mut dist, n, hotf, 3.0 * scale);
         }
-        for &d in &dist {
-            push_stroke_pixel(&mut rgba, d, scale, dark, light);
+        for (i, &d) in dist.iter().enumerate() {
+            if d.is_finite() {
+                put(i % n, i / n, stroke_coverage(d, scale));
+            }
         }
         return Some(CustomCursorImage { rgba: Arc::from(rgba), size: [side, side], hotspot: [hot, hot] });
     }
-    for row in 0..side {
-        let dy = f32::from(row) - f32::from(hot);
-        for col in 0..side {
-            let dx = f32::from(col) - f32::from(hot);
-            let (fill, outline) = coverage(shape, dx, dy, scale);
-            let a_dark = outline * f32::from(dark.a()) / 255.0;
-            let a_light = fill * f32::from(light.a()) / 255.0;
-            let alpha = a_light + a_dark * (1.0 - a_light);
-            // Straight RGBA, as required by winit, not egui's premultiplied representation.
-            let white = if alpha > 0.0 { (255.0 * a_light / alpha).round() as u8 } else { 0 };
-            rgba.extend_from_slice(&[white, white, white, (255.0 * alpha).round() as u8]);
+    // Columns to evaluate in each row: the ring's two arcs (and the centre mark) for a circle,
+    // the whole row otherwise.
+    let last = f32::from(side - 1);
+    for row in 0..n {
+        let dy = row as f32 - hotf;
+        let mut spans: [Option<(f32, f32)>; 3] = [None; 3];
+        if let Shape::Circle { radius, centre } = shape {
+            let reach = 1.5 * scale + 0.5;
+            if let Some([l, r]) = ring_spans(dy, radius * scale, reach) {
+                spans = [Some(l), Some(r), None];
+            }
+            let cross = 3.0 * scale + reach + 1.0;
+            if *centre && dy.abs() <= cross {
+                spans[2] = Some((-cross, cross));
+            }
+        } else {
+            spans[0] = Some((-hotf, hotf));
+        }
+        for (a, b) in spans.into_iter().flatten() {
+            let (c0, c1) = ((hotf + a).floor().clamp(0.0, last) as usize, (hotf + b).ceil().clamp(0.0, last) as usize);
+            for col in c0..=c1 {
+                put(col, row, coverage(shape, col as f32 - hotf, dy, scale));
+            }
         }
     }
     Some(CustomCursorImage { rgba: Arc::from(rgba), size: [side, side], hotspot: [hot, hot] })
diff --git a/crates/ui-egui/src/tool_cursor/hand.rs b/crates/ui-egui/src/tool_cursor/hand.rs
index 2ae3ad0af0..063331f669 100644
--- a/crates/ui-egui/src/tool_cursor/hand.rs
+++ b/crates/ui-egui/src/tool_cursor/hand.rs
@@ -7,7 +7,7 @@
 pub(super) const HALF: f32 = 12.5;
 
 /// Distance to the segment `a`–`b`, minus `r` (a capsule; a bare line when `r` is 0).
-fn capsule(x: f32, y: f32, a: [f32; 2], b: [f32; 2], r: f32) -> f32 {
+pub(super) fn capsule(x: f32, y: f32, a: [f32; 2], b: [f32; 2], r: f32) -> f32 {
     let (px, py) = (x - a[0], y - a[1]);
     let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
     let len2 = dx * dx + dy * dy;
diff --git a/crates/ui-egui/src/tool_cursor/tests.rs b/crates/ui-egui/src/tool_cursor/tests.rs
index 3a8bd1f010..8a240fa70c 100644
--- a/crates/ui-egui/src/tool_cursor/tests.rs
+++ b/crates/ui-egui/src/tool_cursor/tests.rs
@@ -48,14 +48,17 @@ fn precise_and_tip_centre_crosshairs_have_distinct_hotspots() {
     assert!(alpha(&solid, solid.hotspot[0], solid.hotspot[1]) > 230);
 }
 
-/// Off Windows a tip stays within what X servers and hardware cursor planes take (256 px); a
-/// larger one falls back to the painted outline. Windows takes far larger cursors.
+/// On Linux a tip stays within what X servers and hardware cursor planes take (256 px); a larger
+/// one falls back to the painted outline. Windows and macOS take far larger cursors.
 #[test]
 fn cursor_bitmaps_stay_within_the_platform_limit() {
     let fits = |radius: f32| rasterize(&Shape::Circle { radius, centre: false }, 1.0).map(|i| i.size[0]);
+    let large = cfg!(any(target_os = "windows", target_os = "macos"));
     assert!(fits(100.0).is_some_and(|side| side <= 255));
-    assert_eq!(fits(200.0).is_some(), cfg!(target_os = "windows"));
+    assert_eq!(fits(200.0).is_some(), large);
+    assert_eq!(fits(1000.0).is_some(), large, "a 2000 px brush at 100 % still has a native outline");
     assert!(fits(200.0).is_none_or(|side| side <= 2048));
+    assert!(fits(1100.0).is_none(), "nothing past 2048 px");
 }
 
 #[test]
@@ -153,6 +156,65 @@ fn the_hand_is_a_bitmap_only_where_the_os_has_none() {
     assert_eq!((open, fist), (CursorIcon::None, CursorIcon::None));
 }
 
+#[test]
+fn zoom_bitmaps_are_outlined_magnifiers_centred_on_the_lens_at_each_dpi() {
+    for scale in [1.0, 1.25, 1.5, 2.0, 3.0] {
+        let plus = rasterize(&Shape::Zoom { out: false }, scale).unwrap();
+        let minus = rasterize(&Shape::Zoom { out: true }, scale).unwrap();
+        for image in [&plus, &minus] {
+            let [x, y] = image.hotspot;
+            assert_eq!(image.size, [2 * x + 1, 2 * y + 1]);
+            assert_eq!(image.rgba.len(), usize::from(image.size[0]).pow(2) * 4);
+            assert!(image.size[0] <= (34.0 * scale) as u16, "no bigger than a stock cursor at {scale}: {:?}", image.size);
+            assert_eq!(alpha(image, 0, 0), 0, "nothing at the corners");
+            let handle = (9.0 * scale) as u16;
+            assert!(alpha(image, x + handle, y + handle) > 230, "the handle reaches down and right");
+            assert_eq!(alpha(image, x - handle, y - handle), 0, "and only that way");
+            let pixels = image.rgba.as_chunks::<4>().0;
+            assert!(pixels.iter().any(|p| p[3] > 230 && p[0] > 230), "a white lens");
+            assert!(pixels.iter().any(|p| p[3] > 100 && p[0] < 25), "with a black outline, readable on white");
+        }
+        let side = usize::from(plus.size[0]);
+        let red = |image: &CustomCursorImage, x: u16, y: u16| image.rgba[(usize::from(y) * side + usize::from(x)) * 4];
+        let [x, y] = plus.hotspot;
+        let up = y - (2.5 * scale) as u16;
+        assert!(red(&plus, x, y) < 60 && red(&minus, x, y) < 60, "both glyphs cross the hotspot");
+        assert!(red(&plus, x, up) < 60, "the plus has a vertical arm");
+        assert!(red(&minus, x, up) > 200, "the minus does not");
+    }
+}
+
+#[test]
+fn hostile_scales_get_no_zoom_bitmap() {
+    for scale in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -1.0, 0.0, f32::MAX, 500.0] {
+        assert!(rasterize(&Shape::Zoom { out: false }, scale).is_none(), "{scale}");
+        assert!(rasterize(&Shape::Zoom { out: true }, scale).is_none(), "{scale}");
+    }
+}
+
+/// winit shows the plain arrow for `ZoomIn` and `ZoomOut` on Windows (#3735).
+#[test]
+fn the_magnifier_is_a_bitmap_only_where_the_os_has_none() {
+    let ctx = egui::Context::default();
+    ctx.add_plugin(CursorLifecycle);
+    for out in [false, true] {
+        let native = frame(&ctx, |ui| {
+            let icon = zoom_with(ui.ctx(), out, false);
+            ui.ctx().set_cursor_icon(icon);
+        });
+        assert_eq!(native.platform_output.cursor_icon, if out { CursorIcon::ZoomOut } else { CursorIcon::ZoomIn });
+        assert!(native.platform_output.cursor_image.is_none(), "macOS and the Linux themes draw their own magnifiers");
+
+        let bitmap = frame(&ctx, |ui| {
+            let icon = zoom_with(ui.ctx(), out, true);
+            ui.ctx().set_cursor_icon(icon);
+        });
+        let image = bitmap.platform_output.cursor_image.expect("Windows has no stock magnifier");
+        assert_eq!(image.rgba, rasterize(&Shape::Zoom { out }, 1.0).unwrap().rgba);
+        assert_eq!(bitmap.platform_output.cursor_icon, CursorIcon::Crosshair, "visible fallback if the OS rejects a bitmap");
+    }
+}
+
 #[test]
 fn unchanged_geometry_reuses_the_os_upload_and_dpi_invalidates_it() {
     let ctx = egui::Context::default();
@@ -224,6 +286,9 @@ fn write_cursor_preview() {
         (Shape::Hand { closed: true }, 1.0),
         (Shape::Hand { closed: false }, 1.5),
         (Shape::Hand { closed: true }, 2.0),
+        (Shape::Zoom { out: false }, 1.0),
+        (Shape::Zoom { out: true }, 1.0),
+        (Shape::Zoom { out: false }, 2.0),
     ];
     let (width, height) = (600_usize, cases.len() * 100);
     let mut rgba = vec![255; width * height * 4];
@@ -312,6 +377,24 @@ fn brush_hover_uses_an_os_bitmap_that_survives_motion_but_not_tool_or_panel_chan
         assert_eq!(h.output().platform_output.cursor_icon, CursorIcon::Grab);
     }
 
+    // Likewise the Zoom tool's magnifier, a minus while ⌥ is held (#3735).
+    h.state_mut().ui.tool = crate::Tool::Zoom;
+    for out in [false, true] {
+        let modifiers = if out { Modifiers::ALT } else { Modifiers::NONE };
+        h.event(Event::ModifiersChanged(modifiers));
+        h.event(Event::PointerMoved(p + vec2(1.0, 0.0)));
+        h.run_steps(2);
+        let image = h.output().platform_output.cursor_image.clone();
+        if cfg!(target_os = "windows") {
+            let image = image.expect("the magnifier reaches the OS as a bitmap");
+            assert_eq!(image.rgba, rasterize(&Shape::Zoom { out }, h.ctx.pixels_per_point()).unwrap().rgba, "out: {out}");
+        } else {
+            assert!(image.is_none(), "the OS draws the magnifier");
+            assert_eq!(h.output().platform_output.cursor_icon, if out { CursorIcon::ZoomOut } else { CursorIcon::ZoomIn });
+        }
+    }
+    h.event(Event::ModifiersChanged(Modifiers::NONE));
+
     h.state_mut().ui.tool = crate::Tool::Brush;
     h.state_mut().run("prefs.set", json!({"path": "cursors.painting", "value": "standard"})).unwrap();
     h.run_steps(2);
@@ -340,3 +423,38 @@ fn painting_preference_and_zoom_change_the_native_cursor_without_changing_pointe
     h.run_steps(2);
     assert!(h.output().platform_output.cursor_image.as_ref().unwrap().size[0] > cross_size);
 }
+
+/// #4596: the close-path pointer is the centre cross with a ring below right.
+#[test]
+fn close_path_bitmap_has_the_centre_cross_and_a_ring_beside_it() {
+    for scale in [1.0, 2.0] {
+        let image = rasterize(&Shape::Outline { rings: vec![close_ring()].into(), centre: true }, scale).unwrap();
+        let [x, y] = image.hotspot;
+        let at = |dx: f32, dy: f32| alpha(&image, x + (dx * scale) as u16, y + (dy * scale) as u16);
+        assert!(at(0.0, 0.0) > 230 && at(2.0, 0.0) > 0, "the centre cross");
+        assert!(at(12.5, 9.0) > 0 && at(9.0, 12.5) > 0, "the ring around (9, 9)");
+        assert_eq!(at(9.0, 9.0), 0, "open in the middle");
+        assert_eq!(at(0.0, 9.0), 0, "and apart from the cross");
+    }
+}
+
+/// A big tip's outline is a thin ring in a large square: only the ring (and the centre mark) is
+/// evaluated, and the bitmap is exactly what evaluating every pixel gives.
+#[test]
+fn circle_bitmaps_evaluate_only_the_ring_and_match_every_pixel() {
+    let [dark, light] = crate::theme::Tokens::cursor_outline();
+    for (radius, scale, centre) in [(0.4, 1.0, true), (3.0, 1.0, false), (20.0, 1.25, true), (57.3, 2.0, false), (90.0, 1.0, true)] {
+        let shape = Shape::Circle { radius, centre };
+        let image = rasterize(&shape, scale).unwrap();
+        let [hot, _] = image.hotspot;
+        let side = usize::from(image.size[0]);
+        for row in 0..side {
+            for col in 0..side {
+                let (dx, dy) = (col as f32 - f32::from(hot), row as f32 - f32::from(hot));
+                let want = stroke_pixel(coverage(&shape, dx, dy, scale), dark, light);
+                let i = (row * side + col) * 4;
+                assert_eq!(image.rgba[i..i + 4], want, "radius {radius} at {scale}×, pixel ({col}, {row})");
+            }
+        }
+    }
+}
diff --git a/crates/ui-egui/src/tool_cursor/zoom.rs b/crates/ui-egui/src/tool_cursor/zoom.rs
new file mode 100644
index 0000000000..0a0dcd0000
--- /dev/null
+++ b/crates/ui-egui/src/tool_cursor/zoom.rs
@@ -0,0 +1,26 @@
+//! The Zoom tool's pointer as signed distance fields (negative inside), in logical pixels from the
+//! hotspot with y pointing down: a magnifying glass with a plus, or a minus while ⌥ zooms out, as
+//! in Photoshop. The hotspot is the centre of the lens. Only Windows needs it: winit maps `ZoomIn`
+//! and `ZoomOut` to the plain arrow there (#3735), while macOS and the Linux themes draw their own.
+
+use super::hand::capsule;
+
+/// Half the side of the square the glass fits in, outline excluded.
+pub(super) const HALF: f32 = 13.0;
+
+const LENS: f32 = 6.5;
+const HANDLE: ([f32; 2], [f32; 2], f32) = ([5.2, 5.2], [10.8, 10.8], 2.2);
+/// Half the length of the plus and minus arms.
+const ARM: f32 = 3.4;
+
+/// The glass's silhouette (lens and handle): negative inside it.
+pub(super) fn shape(x: f32, y: f32) -> f32 {
+    let (a, b, r) = HANDLE;
+    (x.hypot(y) - LENS).min(capsule(x, y, a, b, r))
+}
+
+/// The plus (or the minus, `out`) inside the lens: distance to its nearest arm.
+pub(super) fn glyph(out: bool, x: f32, y: f32) -> f32 {
+    let across = capsule(x, y, [-ARM, 0.0], [ARM, 0.0], 0.0);
+    if out { across } else { across.min(capsule(x, y, [0.0, -ARM], [0.0, ARM], 0.0)) }
+}
diff --git a/crates/ui-egui/src/tool_feedback.rs b/crates/ui-egui/src/tool_feedback.rs
index bc993a7ae6..eda03b305e 100644
--- a/crates/ui-egui/src/tool_feedback.rs
+++ b/crates/ui-egui/src/tool_feedback.rs
@@ -105,6 +105,10 @@ pub fn badge(app: &PhotocraftApp, tool: Tool, m: egui::Modifiers) -> Option<Badg
     if let Some(t) = crate::anchor_tools::effective(tool, m) {
         return (!m.command).then_some(if t == Tool::AddAnchorPoint { Badge::Add } else { Badge::Subtract });
     }
+    // The Pen over the active path with Auto Add/Delete on: what a click would do (#4144).
+    if let Some(p) = app.hover_doc.filter(|_| tool == Tool::Pen) {
+        return crate::anchor_tools::pen_auto(app, tool, m, p).map(|(t, ..)| if t == Tool::AddAnchorPoint { Badge::Add } else { Badge::Subtract });
+    }
     if !is_selection_tool(tool) {
         return None;
     }
diff --git a/crates/ui-egui/src/tool_reset.rs b/crates/ui-egui/src/tool_reset.rs
index 646af4f7a3..8de3fe4ec7 100644
--- a/crates/ui-egui/src/tool_reset.rs
+++ b/crates/ui-egui/src/tool_reset.rs
@@ -92,6 +92,7 @@ fn reset_session_brush(app: &mut PhotocraftApp) {
     app.session.tools.brush = crate::paint_mouse::fresh_brush(&app.session.tools.brush);
     app.session.tools.brush_gesture = None;
     app.session.tools.current_preset = None;
+    app.session.tools.brush_changed();
 }
 
 fn is_selection_tool(tool: Tool) -> bool {
@@ -124,7 +125,8 @@ pub fn reset_options(o: &mut ToolOptions, tool: Tool) {
         Tool::Lasso | Tool::PolygonLasso => reset!(feather, anti_alias),
         Tool::MagneticLasso => reset!(feather, anti_alias, magnetic_width, magnetic_contrast, magnetic_frequency, magnetic_pressure),
         Tool::MagicWand => reset!(tolerance, anti_alias, contiguous, sample_all_layers),
-        Tool::QuickSelection | Tool::ObjectSelection => reset!(sample_all_layers, enhance_edge),
+        Tool::QuickSelection => reset!(sample_all_layers, enhance_edge),
+        Tool::ObjectSelection => reset!(sample_all_layers, enhance_edge, object_finder),
         Tool::Crop => reset!(
             crop_ratio,
             crop_delete,
@@ -160,7 +162,8 @@ pub fn reset_options(o: &mut ToolOptions, tool: Tool) {
         Tool::Smudge => reset!(strength, sample_all_layers, finger_painting),
         Tool::Dodge | Tool::Burn => reset!(tone_range, exposure, protect_tones),
         Tool::Sponge => reset!(sponge_mode, vibrance),
-        Tool::Pen | Tool::CurvaturePen => reset!(vector_mode),
+        Tool::Pen => reset!(vector_mode, pen_auto_add_delete),
+        Tool::CurvaturePen => reset!(vector_mode),
         Tool::FreeformPen => reset!(vector_mode, curve_fit),
         Tool::Rectangle | Tool::EllipseShape | Tool::Triangle | Tool::Polygon | Tool::Line | Tool::CustomShape => {
             reset!(vector_mode, shape_fill, stroke_width, shape_stroke, corner_radius, polygon_sides, line_weight)
diff --git a/crates/ui-egui/src/tool_shortcut_tests.rs b/crates/ui-egui/src/tool_shortcut_tests.rs
new file mode 100644
index 0000000000..712e7765a2
--- /dev/null
+++ b/crates/ui-egui/src/tool_shortcut_tests.rs
@@ -0,0 +1,39 @@
+//! Photoshop's tool keys that aren't plain shortcuts: Space+F cycles the pasteboard colour.
+
+use egui::{Key, Modifiers};
+use serde_json::json;
+
+use crate::PhotocraftApp;
+
+fn app() -> PhotocraftApp {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({"width": 20, "height": 10})).unwrap();
+    app
+}
+
+/// Space+F steps the pasteboard colour forward and ⇧Space+F back, round and round; F alone is
+/// still Cycle Screen Mode.
+#[test]
+fn space_f_cycles_the_canvas_colour() {
+    use photocraft_engine::prefs::CanvasColor;
+    let mut app = app();
+    let ctx = egui::Context::default();
+    let frame = |app: &mut PhotocraftApp, events: Vec<egui::Event>| {
+        ctx.begin_pass(egui::RawInput { events, ..Default::default() });
+        crate::shortcuts::handle(app, &ctx);
+        ctx.end_pass().textures_delta.clear();
+    };
+    let key = |key, pressed, modifiers| egui::Event::Key { key, physical_key: None, pressed, repeat: false, modifiers };
+    let color = |app: &PhotocraftApp| app.session.prefs().interface.canvas_color;
+    frame(&mut app, vec![key(Key::Space, true, Modifiers::NONE)]);
+    frame(&mut app, vec![key(Key::F, true, Modifiers::NONE), key(Key::F, false, Modifiers::NONE)]);
+    assert_eq!(color(&app), CanvasColor::Black);
+    frame(&mut app, vec![egui::Event::ModifiersChanged(Modifiers::SHIFT), key(Key::F, true, Modifiers::SHIFT), key(Key::F, false, Modifiers::SHIFT)]);
+    frame(&mut app, vec![key(Key::F, true, Modifiers::SHIFT), key(Key::F, false, Modifiers::SHIFT)]);
+    assert_eq!(color(&app), CanvasColor::Custom, "backwards past Default wraps round");
+    frame(&mut app, vec![egui::Event::ModifiersChanged(Modifiers::NONE), key(Key::Space, false, Modifiers::NONE)]);
+    let mode = app.ui.view.screen_mode.clone();
+    frame(&mut app, vec![key(Key::F, true, Modifiers::NONE), key(Key::F, false, Modifiers::NONE)]);
+    assert_eq!(color(&app), CanvasColor::Custom, "F alone leaves the canvas colour");
+    assert_ne!(app.ui.view.screen_mode, mode, "and cycles the screen mode");
+}
diff --git a/crates/ui-egui/src/tool_shortcuts.rs b/crates/ui-egui/src/tool_shortcuts.rs
new file mode 100644
index 0000000000..345b7f57b3
--- /dev/null
+++ b/crates/ui-egui/src/tool_shortcuts.rs
@@ -0,0 +1,96 @@
+//! Toolbar tools in Edit › Keyboard Shortcuts (#4086). Explicit assignments select an
+//! individual tool; unchanged tools keep Photoshop's shared keys and Shift cycling.
+
+use crate::{PhotocraftApp, state::Tool};
+
+pub(crate) fn id(tool: Tool) -> String {
+    let mut name = format!("{tool:?}");
+    if let Some(first) = name.get_mut(..1) {
+        first.make_ascii_lowercase();
+    }
+    format!("tools.select.{name}")
+}
+
+pub(crate) fn tool(id: &str) -> Option<Tool> {
+    let name = id.strip_prefix("tools.select.")?;
+    let tool = Tool::from_name(name)?;
+    (id == self::id(tool)).then_some(tool)
+}
+
+pub(crate) fn default(tool: Tool) -> Option<String> {
+    (tool.key() != '\0').then(|| tool.key().to_string())
+}
+
+pub(crate) fn shortcut(app: &PhotocraftApp, tool: Tool) -> Option<String> {
+    crate::shortcuts::effective_shortcut(app, &id(tool), default(tool).as_deref())
+}
+
+pub(crate) fn uses_default(app: &PhotocraftApp, tool: Tool) -> bool {
+    !app.session.prefs().shortcuts.contains_key(&id(tool))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn every_toolbar_tool_has_a_unique_live_shortcut_row() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        let ctx = egui::Context::default();
+        let items = crate::prefs_ui::shortcut_items(&app);
+        let mut ids = std::collections::HashSet::new();
+        for t in Tool::ALL {
+            let id = id(t);
+            assert!(ids.insert(id.clone()));
+            assert_eq!(tool(&id), Some(t));
+            assert!(crate::menus::is_live(&id));
+            assert!(crate::menus::is_enabled(&app, &id));
+            let rows: Vec<_> = items.iter().filter(|i| i.0 == id).collect();
+            assert_eq!(rows.len(), 1);
+            assert_eq!(rows[0].1, t.label());
+            assert_eq!(rows[0].2, ["Tools"]);
+            assert_eq!(rows[0].3, default(t));
+            assert_eq!(crate::shortcuts::default_shortcut(&id), default(t));
+            crate::menus::invoke(&mut app, &ctx, &id, json!({})).unwrap();
+            assert_eq!(app.ui.tool, t);
+        }
+        for id in ["tools.select.", "tools.select.missing", "tools.select.Brush"] {
+            assert!(!crate::menus::is_live(id));
+            assert!(crate::menus::invoke(&mut app, &ctx, id, json!({})).is_err());
+        }
+    }
+
+    #[test]
+    fn toolbar_hints_follow_assignments_removal_and_reset() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        assert_eq!(shortcut(&app, Tool::Pencil).as_deref(), Some("B"));
+        assert_eq!(shortcut(&app, Tool::SingleRowMarquee), None);
+        app.run("prefs.set", json!({"path": "shortcuts.tools.select.pencil", "value": "F6"})).unwrap();
+        assert_eq!(shortcut(&app, Tool::Pencil).as_deref(), Some("F6"));
+        app.run("prefs.set", json!({"path": "shortcuts.tools.select.pencil", "value": ""})).unwrap();
+        assert_eq!(shortcut(&app, Tool::Pencil), None);
+        app.run("prefs.reset", json!({"path": "shortcuts.tools.select.pencil"})).unwrap();
+        assert_eq!(shortcut(&app, Tool::Pencil).as_deref(), Some("B"));
+    }
+
+    #[test]
+    fn a_remapped_tool_letter_does_not_steal_text_input() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.run("prefs.set", json!({"path": "shortcuts.tools.select.pencil", "value": "Q"})).unwrap();
+        let mut h = egui_kittest::Harness::builder().build_ui_state(
+            |ui, app: &mut PhotocraftApp| {
+                ui.text_edit_singleline(&mut app.ui.status).request_focus();
+                crate::shortcuts::handle(app, ui.ctx());
+            },
+            app,
+        );
+        h.run_steps(3);
+        assert!(h.ctx.text_edit_focused());
+        h.key_press(egui::Key::Q);
+        h.event(egui::Event::Text("q".into()));
+        h.run_steps(2);
+        assert_eq!(h.state().ui.tool, Tool::Brush);
+        assert_eq!(h.state().ui.status, "q");
+    }
+}
diff --git a/crates/ui-egui/src/transform_fx.rs b/crates/ui-egui/src/transform_fx.rs
new file mode 100644
index 0000000000..3b56225efa
--- /dev/null
+++ b/crates/ui-egui/src/transform_fx.rs
@@ -0,0 +1,693 @@
+//! Layer styles in the Free Transform live preview (#3653).
+//!
+//! The box previews the moving pixels as a texture on a mesh (transform_tex.rs), which leaves
+//! the layer's style out: Stroke, Drop Shadow and the rest vanished while the box was open.
+//! Baking the style into that texture would go wrong as soon as the box scales or turns, because
+//! a style isn't transformed with its layer: it is drawn again from the layer's new shape (a
+//! stroke keeps its width, a shadow its angle and distance). So a styled layer is composited
+//! here instead. The moving texels are resampled through the box, the style is laid over them by
+//! the CPU compositor's `composite_with_effects` (the code that draws the layer once the
+//! transform is applied), and the result is drawn in place of the mesh.
+//!
+//! The work follows the screen, not the document: the composite is made at the resolution it is
+//! shown at (never finer than the document), with the style's sizes scaled to match, and within
+//! a pixel [`budget`] that keeps a rebuild near [`DRAG_MS`] while the pointer is down and near
+//! [`REST_MS`] once the box rests. Past the budget the resolution drops instead of the frame
+//! rate, and comes back when the pointer is released. It is rebuilt only when the box, the zoom
+//! or the layer changes.
+//!
+//! The composite is drawn over transparency with Normal blending, like the mesh it replaces: a
+//! layer's or an effect's blend mode shows against the layers under it only after the commit.
+
+use std::sync::{Arc, Mutex, PoisonError};
+
+use egui::{Color32, ColorImage, TextureHandle, TextureId, TextureOptions};
+use photocraft_algo::transform::Homography;
+use photocraft_color::{BlendMode, PixelFormat};
+use photocraft_compose::Buffer;
+use photocraft_compose::effects::{self, TextureCtx};
+use photocraft_doc::{Document, Effect, Layer, LayerContent};
+use photocraft_geom::Rect;
+use photocraft_raster::Surface;
+
+use crate::transform_tex::PreviewTextures;
+
+/// What a rebuild should take while the pointer is down (a drag rebuilds every frame), in
+/// milliseconds on the machine [`pixel_cost_ns`] was measured on.
+pub const DRAG_MS: f64 = 30.0;
+/// What a rebuild should take once the box rests.
+pub const REST_MS: f64 = 120.0;
+/// The fewest work pixels a budget asks for, however costly the style.
+pub const MIN_PIXELS: f64 = 0.25e6;
+/// The most work pixels in a composite, whatever was asked for.
+pub const MAX_PIXELS: f64 = 8.0e6;
+/// Work coordinates stay within this, so rectangle arithmetic on them cannot overflow.
+const COORD_LIMIT: f64 = 5.0e8;
+/// At this many screen pixels per document pixel the composite is shown with crisp texels,
+/// like the canvas around it.
+const CRISP_ZOOM: f32 = 2.0;
+
+/// Where and how finely a styled preview is composited. Rectangles are in work pixels: document
+/// pixels times `scale`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Plan {
+    /// Work pixels per document pixel, at most 1.
+    pub scale: f64,
+    /// The box: the layer's bounds after the transform.
+    pub bounds: Rect,
+    /// What is composited and drawn: the bounds grown by the style's reach, inside the canvas.
+    pub shown: Rect,
+    /// The moving texels resampled for it: `shown` grown by twice the reach, so every effect
+    /// over `shown` sees all of the shape it depends on, also past the canvas edge.
+    pub content: Rect,
+}
+
+impl Plan {
+    /// `shown` in document pixels: where the composite is drawn.
+    pub fn doc_rect(&self) -> [f32; 4] {
+        let k = 1.0 / self.scale;
+        [self.shown.x0, self.shown.y0, self.shown.x1, self.shown.y1].map(|v| (f64::from(v) * k) as f32)
+    }
+}
+
+/// Rough cost of compositing one work pixel with `layer`'s style, in nanoseconds: measured per
+/// effect at default settings on an Apple M3 Pro, release build. A Stroke costs the most by far
+/// (two chamfer distance fields over the whole composite, 46 ns whatever its width); shadows and
+/// glows build one blurred map (5 to 7 ns), Satin and Bevel & Emboss a little more (8 to 14 ns)
+/// and overlays next to nothing. Resampling, laying the style on and the upload add about 12 ns.
+pub fn pixel_cost_ns(layer: &Layer) -> f64 {
+    let enabled = || layer.effects.items.iter().filter(|e| e.enabled());
+    let maps: f64 = enabled()
+        .map(|e| match e {
+            Effect::Stroke(_) | Effect::ColorOverlay { .. } | Effect::GradientOverlay { .. } | Effect::PatternOverlay { .. } => 1.0,
+            Effect::Satin(_) | Effect::BevelEmboss(_) => 12.0,
+            Effect::DropShadow(_) | Effect::InnerShadow(_) | Effect::OuterGlow(_) | Effect::InnerGlow(_) => 6.0,
+        })
+        .sum();
+    // Every Stroke reads the same two distance fields.
+    let fields = if enabled().any(|e| matches!(e, Effect::Stroke(_))) { 46.0 } else { 0.0 };
+    12.0 + maps + fields
+}
+
+/// Work pixels a composite of `layer` may have: what fits in [`DRAG_MS`] while the pointer is
+/// down and in [`REST_MS`] once the box rests.
+pub fn budget(layer: &Layer, dragging: bool) -> f64 {
+    let ms = if dragging { DRAG_MS } else { REST_MS };
+    (ms * 1.0e6 / pixel_cost_ns(layer)).clamp(MIN_PIXELS, MAX_PIXELS)
+}
+
+/// The moving layer as the compositor styles it at `scale`: its style at that scale with its
+/// opacity, fill and Advanced Blending, over plain pixels (the texels are rendered already, with
+/// the masks applied).
+pub fn work_layer(layer: &Layer, scale: f64) -> Layer {
+    let mut l = layer.clone();
+    l.content = LayerContent::Raster(Surface::new(PixelFormat::RGBA8));
+    l.mask = None;
+    l.vector_mask = None;
+    l.fill_cache = None;
+    l.blend = BlendMode::Normal;
+    photocraft_engine::image_cmds::scale_effects(&mut l.effects, scale as f32);
+    l.effects.reference = l.effects.reference.map(|(x, y)| (x * scale, y * scale));
+    l
+}
+
+/// Plan the composite of `layer` moved onto `quad` (document pixels, clockwise from top-left) in
+/// a document of `canvas` pixels, shown at `zoom` screen pixels per document pixel, within
+/// `budget` work pixels. `None` when nothing of it is on the canvas or the box isn't finite.
+pub fn plan(layer: &Layer, canvas: [u32; 2], quad: [[f64; 2]; 4], zoom: f32, budget: f64) -> Option<(Plan, Layer)> {
+    if quad.iter().flatten().any(|v| !v.is_finite()) {
+        return None;
+    }
+    let (min, max) = quad.iter().fold(([f64::MAX; 2], [f64::MIN; 2]), |(lo, hi), q| ([lo[0].min(q[0]), lo[1].min(q[1])], [hi[0].max(q[0]), hi[1].max(q[1])]));
+    let budget = if budget.is_finite() { budget.clamp(1.0, MAX_PIXELS) } else { MIN_PIXELS };
+    let mut scale = if zoom.is_finite() && zoom > 0.0 { f64::from(zoom).min(1.0) } else { 1.0 };
+    // The reach of the style is in work pixels too, so the area isn't simply the scale squared:
+    // shrink until it fits (a few rounds settle it).
+    for round in 0..6 {
+        let work = work_layer(layer, scale);
+        let reach = effects::margin(&work);
+        let edge = |v: f64, up: bool| {
+            let v = (v * scale).clamp(-COORD_LIMIT, COORD_LIMIT);
+            (if up { v.ceil() } else { v.floor() }) as i32
+        };
+        let bounds = Rect::new(edge(min[0], false), edge(min[1], false), edge(max[0], true), edge(max[1], true));
+        let canvas = Rect::new(0, 0, edge(f64::from(canvas[0]), true), edge(f64::from(canvas[1]), true));
+        let shown = bounds.inflate(reach).intersect(&canvas);
+        if bounds.is_empty() || shown.is_empty() {
+            return None;
+        }
+        let content = shown.inflate(2 * reach);
+        let area = f64::from(content.width()) * f64::from(content.height());
+        if area <= budget {
+            return Some((Plan { scale, bounds, shown, content }, work));
+        }
+        if round == 5 {
+            break;
+        }
+        scale *= (budget / area).sqrt() * 0.98;
+        if !(scale.is_finite() && scale > 0.0) {
+            return None;
+        }
+    }
+    None
+}
+
+/// One row of `out` per `y`, in parallel on native targets.
+fn rows<T: Send>(out: &mut [T], width: usize, y0: i32, row: impl Fn(i32, &mut [T]) + Sync) {
+    bands(out, width, |i, o| row(y0.saturating_add(i as i32), o));
+}
+
+/// The moving texels (`image`, premultiplied, of which `uv` covers the box's source rectangle)
+/// drawn over `rect` as straight-alpha floats. `to_unit` takes a work pixel to the unit square
+/// of the source rectangle, and `inside` is a work point within the box. The edges of the
+/// rectangle fade over one texel, as a resampled layer's do; `nearest` keeps texels whole.
+pub fn resample(image: &ColorImage, uv: [f32; 2], to_unit: &Homography, inside: [f64; 2], rect: Rect, nearest: bool) -> Buffer {
+    let mut out = Buffer::transparent(rect);
+    let [iw, ih] = image.size;
+    let (tw, th) = (f64::from(uv[0]) * iw as f64, f64::from(uv[1]) * ih as f64);
+    let m = to_unit.0;
+    // The side of the horizon the box is on: a projective map sends the far side elsewhere.
+    let side = (m[6] * inside[0] + m[7] * inside[1] + m[8]).signum();
+    if iw == 0 || ih == 0 || !(tw > 0.0 && th > 0.0) || !side.is_finite() {
+        return out;
+    }
+    let texel = |x: i64, y: i64| -> [f32; 4] {
+        let (x, y) = (x.clamp(0, iw as i64 - 1) as usize, y.clamp(0, ih as i64 - 1) as usize);
+        image.pixels.get(y * iw + x).map_or([0.0; 4], |c| c.to_array().map(f32::from))
+    };
+    let fade = |t: f64, n: f64| (t + 0.5).min(n - t + 0.5).clamp(0.0, 1.0) as f32;
+    let straight = |p: [f32; 4]| -> [f32; 4] {
+        let c = Color32::from_rgba_premultiplied(p[0].round() as u8, p[1].round() as u8, p[2].round() as u8, p[3].round() as u8);
+        let [r, g, b, _] = c.to_srgba_unmultiplied();
+        // The alpha keeps its fraction: a soft edge would band at 8 bits.
+        [f32::from(r) / 255.0, f32::from(g) / 255.0, f32::from(b) / 255.0, (p[3] / 255.0).clamp(0.0, 1.0)]
+    };
+    let width = rect.width() as usize;
+    rows(&mut out.px, width, rect.y0, |y, row| {
+        let py = f64::from(y) + 0.5;
+        for (i, o) in row.iter_mut().enumerate() {
+            let px = f64::from(rect.x0) + i as f64 + 0.5;
+            let w = m[6] * px + m[7] * py + m[8];
+            if w * side <= 1e-12 {
+                continue;
+            }
+            let (tx, ty) = ((m[0] * px + m[1] * py + m[2]) / w * tw, (m[3] * px + m[4] * py + m[5]) / w * th);
+            if !(tx.is_finite() && ty.is_finite()) {
+                continue;
+            }
+            if nearest {
+                if tx >= 0.0 && ty >= 0.0 && tx < tw && ty < th {
+                    *o = straight(texel(tx as i64, ty as i64));
+                }
+                continue;
+            }
+            let cover = fade(tx, tw) * fade(ty, th);
+            if cover <= 0.0 {
+                continue;
+            }
+            let (fx, fy) = (tx - 0.5, ty - 0.5);
+            let (x0, y0) = (fx.floor(), fy.floor());
+            let (ax, ay) = ((fx - x0) as f32, (fy - y0) as f32);
+            let (x0, y0) = (x0 as i64, y0 as i64);
+            let (a, b, c, d) = (texel(x0, y0), texel(x0 + 1, y0), texel(x0, y0 + 1), texel(x0 + 1, y0 + 1));
+            let mut p = [0.0f32; 4];
+            for (k, v) in p.iter_mut().enumerate() {
+                let (top, bottom) = (a[k] + (b[k] - a[k]) * ax, c[k] + (d[k] - c[k]) * ax);
+                *v = (top + (bottom - top) * ay) * cover;
+            }
+            if p[3] > 0.0 {
+                *o = straight(p);
+            }
+        }
+    });
+    out
+}
+
+/// The texels a composite reads and how they map onto the box.
+pub struct Source<'a> {
+    /// The moving texels at some level of their mip chain, premultiplied.
+    pub image: &'a ColorImage,
+    /// The extent of `image` covering the box's source rectangle.
+    pub uv: [f32; 2],
+    /// The box (document pixels, clockwise from top-left).
+    pub quad: [[f64; 2]; 4],
+    /// Nearest Neighbor interpolation.
+    pub nearest: bool,
+}
+
+/// Composite the moving texels with `work`'s style over `plan.shown`, on transparency. `work`
+/// and `plan` come from [`plan`]; `doc` gives the global light and the patterns.
+pub fn compose(doc: &Document, work: &Layer, plan: &Plan, source: &Source) -> Option<Buffer> {
+    let s = plan.scale;
+    let to_quad = Homography::rect_to_quad([0.0, 0.0, 1.0, 1.0], source.quad.map(|q| [q[0] * s, q[1] * s]))?;
+    let to_unit = to_quad.inverse()?;
+    let inside = source.quad.iter().fold([0.0; 2], |c, q| [c[0] + q[0] * s / 4.0, c[1] + q[1] * s / 4.0]);
+    let content = resample(source.image, source.uv, &to_unit, inside, plan.content, source.nearest);
+    let shape: Vec<f32> = content.px.iter().map(|p| p[3]).collect();
+    let anchor = work.effects.reference.unwrap_or((f64::from(plan.bounds.x0), f64::from(plan.bounds.y0)));
+    let maps = effects::build_maps(work, shape, plan.content, &doc.global_light, &TextureCtx { rect: plan.content, patterns: &doc.patterns, anchor });
+    // The maps hold what every pixel needs of its surroundings, so the style is laid over the
+    // content band by band, in parallel, as the compositor does tile by tile.
+    let shown = plan.shown;
+    let width = shown.width() as usize;
+    let mut out = Buffer::transparent(shown);
+    bands(&mut out.px, width * BAND_ROWS, |i, px| {
+        let y0 = shown.y0.saturating_add((i * BAND_ROWS) as i32);
+        let band = Rect::new(shown.x0, y0, shown.x1, y0.saturating_add((px.len() / width.max(1)) as i32));
+        let mut over = Buffer::transparent(band);
+        effects::composite_with_effects(work, &crop(&content, band), &mut over, &maps, plan.bounds, &doc.patterns);
+        for (o, p) in px.iter_mut().zip(over.px) {
+            *o = p;
+        }
+    });
+    Some(out)
+}
+
+/// Rows composited per parallel band.
+const BAND_ROWS: usize = 64;
+
+/// `rect` of `buf` (transparent where `buf` doesn't reach).
+fn crop(buf: &Buffer, rect: Rect) -> Buffer {
+    let mut out = Buffer::transparent(rect);
+    let part = rect.intersect(&buf.rect);
+    if part.is_empty() {
+        return out;
+    }
+    let (sw, dw, n) = (buf.rect.width() as usize, rect.width() as usize, part.width() as usize);
+    for y in part.y0..part.y1 {
+        let s0 = (y - buf.rect.y0) as usize * sw + (part.x0 - buf.rect.x0) as usize;
+        let d0 = (y - rect.y0) as usize * dw + (part.x0 - rect.x0) as usize;
+        if let (Some(src), Some(dst)) = (buf.px.get(s0..s0 + n), out.px.get_mut(d0..d0 + n)) {
+            dst.copy_from_slice(src);
+        }
+    }
+    out
+}
+
+/// `out` in chunks of `len`, each with its index, in parallel on native targets.
+fn bands<T: Send>(out: &mut [T], len: usize, band: impl Fn(usize, &mut [T]) + Sync) {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        use rayon::prelude::*;
+        out.par_chunks_mut(len.max(1)).enumerate().for_each(|(i, o)| band(i, o));
+    }
+    #[cfg(target_arch = "wasm32")]
+    for (i, o) in out.chunks_mut(len.max(1)).enumerate() {
+        band(i, o);
+    }
+}
+
+/// `buf` as premultiplied texels.
+fn image(buf: &Buffer) -> ColorImage {
+    let (w, h) = (buf.rect.width() as usize, buf.rect.height() as usize);
+    let mut px = vec![Color32::TRANSPARENT; w * h];
+    rows(&mut px, w, 0, |y, row| {
+        let src = buf.px.get(y as usize * w..).unwrap_or(&[]);
+        for (o, p) in row.iter_mut().zip(src) {
+            let v = p.map(|c| (c.clamp(0.0, 1.0) * 255.0 + 0.5) as u8);
+            *o = Color32::from_rgba_unmultiplied(v[0], v[1], v[2], v[3]);
+        }
+    });
+    ColorImage::new([w, h], px)
+}
+
+/// What a styled preview is drawn from this frame.
+pub struct Frame<'a> {
+    /// The document: its size, global light and patterns.
+    pub doc: &'a Document,
+    /// The moving layer as it is now: its style, opacity, fill and Advanced Blending.
+    pub layer: &'a Layer,
+    /// Changes whenever `doc` does.
+    pub revision: u64,
+    pub texels: &'a PreviewTextures,
+    pub quad: [[f64; 2]; 4],
+    /// How much the box enlarges its source (1 = same size).
+    pub quad_scale: f32,
+    pub nearest: bool,
+    /// Screen pixels per document pixel.
+    pub zoom: f32,
+    /// The pointer is down: composite within the smaller [`budget`].
+    pub dragging: bool,
+}
+
+impl Frame<'_> {
+    /// The plan for this frame, the layer it composites and the texel level it reads.
+    pub fn plan(&self) -> Option<(Plan, Layer, u32)> {
+        let (plan, work) = plan(self.layer, [self.doc.size.width, self.doc.size.height], self.quad, self.zoom, budget(self.layer, self.dragging))?;
+        let level = PreviewTextures::choose(plan.scale as f32, self.quad_scale, self.nearest).0;
+        Some((plan, work, level))
+    }
+
+    /// The composite a [`Frame::plan`] describes.
+    pub fn compose(&self, plan: &Plan, work: &Layer, level: u32) -> Option<Buffer> {
+        let (texels, uv): (Arc<ColorImage>, [f32; 2]) = self.texels.level_image(level)?;
+        compose(self.doc, work, plan, &Source { image: &texels, uv, quad: self.quad, nearest: self.nearest })
+    }
+}
+
+#[derive(Clone, PartialEq)]
+struct Key {
+    revision: u64,
+    quad: [u64; 8],
+    plan: Plan,
+    level: u32,
+    nearest: bool,
+    crisp: bool,
+}
+
+struct Shown {
+    key: Key,
+    tex: TextureHandle,
+    rect: [f32; 4],
+}
+
+#[derive(Default)]
+struct State {
+    shown: Option<Shown>,
+    /// Composites made so far.
+    builds: u64,
+}
+
+/// The styled composite of a Free Transform session's moving layer, kept until the box, the
+/// zoom or the layer changes.
+pub struct StyledPreview {
+    name: String,
+    state: Mutex<State>,
+}
+
+impl StyledPreview {
+    /// `name` keys the texture in egui.
+    pub fn new(name: String) -> Self {
+        Self { name, state: Mutex::new(State::default()) }
+    }
+
+    /// How many times the composite was made: once per change of the box, the zoom or the layer.
+    pub fn builds(&self) -> u64 {
+        self.state.lock().unwrap_or_else(PoisonError::into_inner).builds
+    }
+
+    /// The composite for `frame` and the document rectangle it covers (x0, y0, x1, y1),
+    /// compositing it again if anything it depends on changed. `None` when there is nothing to
+    /// draw this way: the caller falls back to the plain texels.
+    pub fn texture(&self, ctx: &egui::Context, frame: &Frame) -> Option<(TextureId, [f32; 4])> {
+        let (plan, work, level) = frame.plan()?;
+        let crisp = plan.scale >= 1.0 && frame.zoom >= CRISP_ZOOM;
+        let q = frame.quad.map(|q| q.map(f64::to_bits));
+        let key = Key {
+            revision: frame.revision,
+            quad: [q[0][0], q[0][1], q[1][0], q[1][1], q[2][0], q[2][1], q[3][0], q[3][1]],
+            plan,
+            level,
+            nearest: frame.nearest,
+            crisp,
+        };
+        let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+        if let Some(s) = state.shown.as_ref().filter(|s| s.key == key) {
+            return Some((s.tex.id(), s.rect));
+        }
+        let out = frame.compose(&plan, &work, level)?;
+        let options = if crisp { TextureOptions::NEAREST } else { TextureOptions::LINEAR };
+        let tex = ctx.load_texture(self.name.clone(), image(&out), options);
+        let (id, rect) = (tex.id(), plan.doc_rect());
+        state.shown = Some(Shown { key, tex, rect });
+        state.builds += 1;
+        Some((id, rect))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use photocraft_color::Color;
+    use photocraft_doc::{Contour, FxCommon, FxPaint, Shadow, StrokeFx, StrokePosition};
+
+    const BLUE: Color32 = Color32::from_rgb(0, 0, 255);
+
+    fn stroke(size: f32) -> Effect {
+        Effect::Stroke(StrokeFx {
+            common: FxCommon::new(BlendMode::Normal, 1.0),
+            size,
+            position: StrokePosition::Outside,
+            paint: FxPaint::Color(Color::rgb(1.0, 0.0, 0.0)),
+        })
+    }
+
+    fn shadow(distance: f32) -> Effect {
+        Effect::DropShadow(Shadow {
+            common: FxCommon::new(BlendMode::Normal, 1.0),
+            color: Color::rgb(0.0, 1.0, 0.0),
+            // Lit from the top-left: the shadow falls to the bottom-right.
+            angle: 135.0,
+            use_global_light: false,
+            distance,
+            spread: 1.0,
+            size: 0.0,
+            contour: Contour::Linear,
+            anti_alias: false,
+            noise: 0.0,
+            knocks_out: true,
+        })
+    }
+
+    fn styled(effects: Vec<Effect>) -> Layer {
+        let mut l = Layer::raster("styled", PixelFormat::RGBA8);
+        l.effects.items = effects;
+        l
+    }
+
+    fn doc() -> Document {
+        Document::new("t", photocraft_geom::Size::new(200, 200), photocraft_color::ColorMode::Rgb, photocraft_color::SampleType::U8)
+    }
+
+    fn rect_quad(r: [f64; 4]) -> [[f64; 2]; 4] {
+        [[r[0], r[1]], [r[2], r[1]], [r[2], r[3]], [r[0], r[3]]]
+    }
+
+    /// The composite of a blue `w`×`h` block of texels moved onto `quad`, and its plan.
+    fn composite(layer: &Layer, w: usize, h: usize, quad: [[f64; 2]; 4], zoom: f32) -> (Buffer, Plan) {
+        let texels = ColorImage::new([w, h], vec![BLUE; w * h]);
+        let (plan, work) = plan(layer, [200, 200], quad, zoom, budget(layer, false)).expect("on the canvas");
+        let out = compose(&doc(), &work, &plan, &Source { image: &texels, uv: [1.0, 1.0], quad, nearest: false }).expect("composited");
+        (out, plan)
+    }
+
+    /// The composite at a document point.
+    fn at(out: &Buffer, plan: &Plan, x: f64, y: f64) -> [f32; 4] {
+        let (x, y) = ((x * plan.scale).floor() as i32, (y * plan.scale).floor() as i32);
+        if out.rect.contains(x, y) { out.get(x, y) } else { [0.0; 4] }
+    }
+
+    fn is(p: [f32; 4], rgb: [f32; 3]) -> bool {
+        p[3] > 0.99 && p.iter().zip(rgb).all(|(a, b)| (a - b).abs() < 0.02)
+    }
+
+    const RED: [f32; 3] = [1.0, 0.0, 0.0];
+    const GREEN: [f32; 3] = [0.0, 1.0, 0.0];
+    const FILL: [f32; 3] = [0.0, 0.0, 1.0];
+
+    #[test]
+    fn the_style_is_drawn_around_the_moved_pixels() {
+        // Moved, not resized: the block at 60..100 × 80..100 with a 4 px stroke around it.
+        let l = styled(vec![stroke(4.0)]);
+        let (out, plan) = composite(&l, 40, 20, rect_quad([60.0, 80.0, 100.0, 100.0]), 1.0);
+        assert_eq!(plan.scale, 1.0);
+        assert!(is(at(&out, &plan, 80.0, 90.0), FILL), "the pixels themselves");
+        assert!(is(at(&out, &plan, 60.0, 80.0), FILL) && is(at(&out, &plan, 99.0, 99.0), FILL), "exact at the corners: no resampling blur");
+        for (x, y) in [(57.0, 90.0), (102.0, 90.0), (80.0, 77.0), (80.0, 102.0)] {
+            assert!(is(at(&out, &plan, x, y), RED), "stroke at {x},{y}: {:?}", at(&out, &plan, x, y));
+        }
+        for (x, y) in [(54.0, 90.0), (105.0, 90.0), (80.0, 74.0), (80.0, 105.0)] {
+            assert_eq!(at(&out, &plan, x, y)[3], 0.0, "nothing past the stroke at {x},{y}");
+        }
+    }
+
+    #[test]
+    fn a_stroke_keeps_its_width_when_the_box_is_enlarged() {
+        // The 20×20 block enlarged four times: the stroke stays 4 px wide, not 16.
+        let l = styled(vec![stroke(4.0)]);
+        let (out, plan) = composite(&l, 20, 20, rect_quad([60.0, 60.0, 140.0, 140.0]), 1.0);
+        assert!(is(at(&out, &plan, 100.0, 100.0), FILL));
+        assert!(is(at(&out, &plan, 57.0, 100.0), RED) && is(at(&out, &plan, 142.0, 100.0), RED));
+        assert_eq!(at(&out, &plan, 53.0, 100.0)[3], 0.0, "{:?}", at(&out, &plan, 53.0, 100.0));
+        assert_eq!(at(&out, &plan, 146.0, 100.0)[3], 0.0);
+    }
+
+    #[test]
+    fn a_shadow_keeps_its_direction_when_the_box_is_turned() {
+        // Turned a half turn (the quad's corners swapped round): the shadow still falls to the
+        // bottom-right of the block, not to the top-left with the pixels.
+        let l = styled(vec![shadow(10.0)]);
+        let upright = rect_quad([80.0, 80.0, 120.0, 120.0]);
+        let turned = [upright[2], upright[3], upright[0], upright[1]];
+        for quad in [upright, turned] {
+            let (out, plan) = composite(&l, 40, 40, quad, 1.0);
+            assert!(is(at(&out, &plan, 100.0, 100.0), FILL));
+            assert!(is(at(&out, &plan, 124.0, 124.0), GREEN), "{:?}", at(&out, &plan, 124.0, 124.0));
+            assert_eq!(at(&out, &plan, 76.0, 76.0)[3], 0.0, "no shadow on the lit side");
+        }
+    }
+
+    #[test]
+    fn a_zoomed_out_view_composites_at_screen_resolution() {
+        // At 50 % the work is a quarter of the pixels and the 4 px stroke is 2 work pixels,
+        // still 4 document pixels where it is drawn.
+        let l = styled(vec![stroke(4.0)]);
+        let (out, plan) = composite(&l, 40, 40, rect_quad([60.0, 60.0, 100.0, 100.0]), 0.5);
+        assert_eq!(plan.scale, 0.5);
+        assert_eq!(plan.bounds, Rect::new(30, 30, 50, 50));
+        assert_eq!(out.rect, plan.shown);
+        assert!(is(at(&out, &plan, 80.0, 80.0), FILL));
+        assert!(is(at(&out, &plan, 57.0, 80.0), RED) && is(at(&out, &plan, 103.0, 80.0), RED));
+        assert_eq!(at(&out, &plan, 53.0, 80.0)[3], 0.0);
+        let r = plan.doc_rect();
+        assert!(r[0] <= 56.0 && r[2] >= 104.0, "{r:?}");
+        // Zoomed in, the work is never finer than the document.
+        assert_eq!(composite(&l, 40, 40, rect_quad([60.0, 60.0, 100.0, 100.0]), 8.0).1.scale, 1.0);
+    }
+
+    #[test]
+    fn the_part_past_the_canvas_is_left_out_but_still_shapes_the_style() {
+        // The block hangs over the left edge: nothing is composited past the canvas, and no
+        // stroke is drawn along the canvas edge, where the layer goes on.
+        let l = styled(vec![stroke(4.0)]);
+        let (out, plan) = composite(&l, 40, 20, rect_quad([-20.0, 80.0, 20.0, 100.0]), 1.0);
+        assert_eq!(plan.shown.x0, 0);
+        assert!(is(at(&out, &plan, 0.0, 90.0), FILL), "{:?}", at(&out, &plan, 0.0, 90.0));
+        assert!(is(at(&out, &plan, 22.0, 90.0), RED));
+        // Wholly off the canvas: nothing to composite.
+        assert!(plan_of(&l, rect_quad([-90.0, 0.0, -50.0, 20.0])).is_none());
+    }
+
+    fn plan_of(l: &Layer, quad: [[f64; 2]; 4]) -> Option<Plan> {
+        plan(l, [200, 200], quad, 1.0, budget(l, false)).map(|p| p.0)
+    }
+
+    #[test]
+    fn opacity_and_fill_apply_as_in_the_compositor() {
+        // Fill 0 %: the pixels go, the stroke stays. Opacity 50 %: all of it at half strength.
+        let mut l = styled(vec![stroke(4.0)]);
+        l.fill_opacity = 0.0;
+        let (out, plan) = composite(&l, 40, 40, rect_quad([60.0, 60.0, 100.0, 100.0]), 1.0);
+        assert_eq!(at(&out, &plan, 80.0, 80.0)[3], 0.0);
+        assert!(is(at(&out, &plan, 57.0, 80.0), RED));
+        l.fill_opacity = 1.0;
+        l.opacity = 0.5;
+        let (out, plan) = composite(&l, 40, 40, rect_quad([60.0, 60.0, 100.0, 100.0]), 1.0);
+        assert!((at(&out, &plan, 80.0, 80.0)[3] - 0.5).abs() < 0.01 && (at(&out, &plan, 57.0, 80.0)[3] - 0.5).abs() < 0.01);
+    }
+
+    #[test]
+    fn the_work_stays_within_the_budget() {
+        // A box over a huge canvas at 100 %: the scale drops until the composite fits.
+        let l = styled(vec![stroke(8.0), shadow(40.0)]);
+        let quad = rect_quad([0.0, 0.0, 12_000.0, 8_000.0]);
+        for budget in [budget(&l, true), budget(&l, false)] {
+            let (p, work) = plan(&l, [12_000, 8_000], quad, 1.0, budget).expect("planned");
+            let area = f64::from(p.content.width()) * f64::from(p.content.height());
+            assert!(area <= budget && area > budget * 0.5, "{area} of {budget}");
+            assert!(p.scale < 1.0);
+            // The style shrank with it.
+            let Some(Effect::Stroke(s)) = work.effects.items.first() else { panic!("stroke") };
+            assert!((f64::from(s.size) - 8.0 * p.scale).abs() < 1e-3);
+        }
+    }
+
+    #[test]
+    fn hostile_boxes_are_refused_not_composited() {
+        let l = styled(vec![stroke(4.0)]);
+        let ok = rect_quad([60.0, 60.0, 100.0, 100.0]);
+        for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+            let mut q = ok;
+            q[2][0] = bad;
+            assert!(plan_of(&l, q).is_none());
+        }
+        // Astronomically large or far away: planned within the budget or refused, never a huge
+        // allocation or an overflow.
+        for q in [rect_quad([-1e300, -1e300, 1e300, 1e300]), rect_quad([1e18, 1e18, 1e18 + 40.0, 1e18 + 40.0]), rect_quad([0.0, 0.0, 1e12, 1.0])] {
+            if let Some(p) = plan_of(&l, q) {
+                assert!(f64::from(p.content.width()) * f64::from(p.content.height()) <= budget(&l, false), "{p:?}");
+            }
+        }
+        // A collapsed box, a zero or NaN zoom and an absurd budget.
+        assert!(plan_of(&l, [[80.0, 80.0]; 4]).is_none());
+        for zoom in [0.0, -1.0, f32::NAN, f32::INFINITY] {
+            assert_eq!(plan(&l, [200, 200], ok, zoom, budget(&l, false)).map(|p| p.0.scale), Some(1.0));
+        }
+        for budget in [f64::NAN, f64::INFINITY, -5.0, 0.0] {
+            if let Some((p, _)) = plan(&l, [200, 200], ok, 1.0, budget) {
+                assert!(f64::from(p.content.width()) * f64::from(p.content.height()) <= MAX_PIXELS);
+            }
+        }
+        // A degenerate quad that passes the plan (a bow tie collapsed onto a line) composites
+        // to nothing instead of dividing by zero.
+        let line = [[60.0, 60.0], [100.0, 100.0], [60.0, 60.0], [100.0, 100.0]];
+        if let Some((p, work)) = plan(&l, [200, 200], line, 1.0, budget(&l, false)) {
+            let texels = ColorImage::new([4, 4], vec![BLUE; 16]);
+            assert!(compose(&doc(), &work, &p, &Source { image: &texels, uv: [1.0, 1.0], quad: line, nearest: false }).is_none());
+        }
+    }
+
+    /// The style is laid on in parallel bands: the result is the one a single pass gives.
+    #[test]
+    fn bands_join_without_a_seam() {
+        let l = styled(vec![stroke(5.0), shadow(12.0)]);
+        let quad = [[40.0, 20.0], [150.0, 40.0], [130.0, 180.0], [20.0, 150.0]];
+        let texels = ColorImage::new([30, 40], (0..1200).map(|i| if i % 7 == 0 { Color32::TRANSPARENT } else { BLUE }).collect());
+        let (plan, work) = plan(&l, [200, 200], quad, 1.0, budget(&l, false)).expect("planned");
+        assert!(plan.shown.height() as usize > 2 * BAND_ROWS, "{:?}", plan.shown);
+        let source = Source { image: &texels, uv: [1.0, 1.0], quad, nearest: false };
+        let banded = compose(&doc(), &work, &plan, &source).expect("composited");
+        // The same in one pass.
+        let to_unit = Homography::rect_to_quad([0.0, 0.0, 1.0, 1.0], quad).and_then(|h| h.inverse()).expect("invertible");
+        let content = resample(&texels, [1.0, 1.0], &to_unit, [85.0, 97.5], plan.content, false);
+        let shape = content.px.iter().map(|p| p[3]).collect();
+        let anchor = (f64::from(plan.bounds.x0), f64::from(plan.bounds.y0));
+        let maps = effects::build_maps(&work, shape, plan.content, &doc().global_light, &TextureCtx { rect: plan.content, patterns: &[], anchor });
+        let mut whole = Buffer::transparent(plan.shown);
+        effects::composite_with_effects(&work, &crop(&content, plan.shown), &mut whole, &maps, plan.bounds, &[]);
+        assert_eq!(banded.rect, whole.rect);
+        assert!(banded.px == whole.px, "banded and whole composites differ");
+        assert!(whole.px.iter().any(|p| is(*p, RED)) && whole.px.iter().any(|p| is(*p, GREEN)) && whole.px.iter().any(|p| is(*p, FILL)));
+    }
+
+    #[test]
+    fn the_budget_follows_what_the_style_costs() {
+        // A drag gets a quarter of the time a resting box does, and a Stroke (two distance
+        // fields) far fewer pixels than a shadow.
+        let (stroked, shadowed) = (styled(vec![stroke(4.0)]), styled(vec![shadow(10.0)]));
+        assert!(budget(&stroked, true) < budget(&stroked, false));
+        assert!((budget(&shadowed, false) / budget(&shadowed, true) - REST_MS / DRAG_MS).abs() < 1e-9);
+        assert!(budget(&stroked, true) * 3.0 < budget(&shadowed, true), "{} vs {}", budget(&stroked, true), budget(&shadowed, true));
+        // Two strokes share their distance fields; an effect switched off costs nothing.
+        assert!(pixel_cost_ns(&styled(vec![stroke(4.0), stroke(9.0)])) < pixel_cost_ns(&stroked) + 2.0);
+        let mut off = styled(vec![stroke(4.0), shadow(10.0)]);
+        if let Some(Effect::Stroke(s)) = off.effects.items.first_mut() {
+            s.common.enabled = false;
+        }
+        assert_eq!(pixel_cost_ns(&off), pixel_cost_ns(&shadowed));
+        // However heavy or light the style, the budget stays within its limits.
+        let heavy = styled((0..200).map(|_| shadow(10.0)).collect());
+        assert_eq!(budget(&heavy, true), MIN_PIXELS);
+        assert_eq!(budget(&styled(Vec::new()), false), MAX_PIXELS);
+    }
+
+    #[test]
+    fn resampling_handles_empty_texels_and_nearest_neighbor() {
+        let unit = Homography::rect_to_quad([0.0, 0.0, 1.0, 1.0], rect_quad([0.0, 0.0, 8.0, 8.0])).and_then(|h| h.inverse()).expect("invertible");
+        let r = Rect::new(-2, -2, 10, 10);
+        let empty = ColorImage::new([0, 0], Vec::new());
+        assert!(resample(&empty, [1.0, 1.0], &unit, [4.0, 4.0], r, false).px.iter().all(|p| p[3] == 0.0));
+        // A 2×2 checker enlarged four times: Nearest Neighbor keeps hard texels, bilinear blends.
+        let checker = ColorImage::new([2, 2], vec![Color32::WHITE, Color32::BLACK, Color32::BLACK, Color32::WHITE]);
+        let hard = resample(&checker, [1.0, 1.0], &unit, [4.0, 4.0], r, true);
+        assert_eq!(hard.get(3, 0), [1.0, 1.0, 1.0, 1.0]);
+        assert_eq!(hard.get(4, 0), [0.0, 0.0, 0.0, 1.0]);
+        assert_eq!(hard.get(-1, 0)[3], 0.0);
+        let soft = resample(&checker, [1.0, 1.0], &unit, [4.0, 4.0], r, false);
+        let mid = soft.get(3, 0);
+        assert!(mid[0] > 0.2 && mid[0] < 0.8, "{mid:?}");
+        // The uv extent limits what is read: half the texels, so only the left column shows.
+        let half = resample(&checker, [0.5, 1.0], &unit, [4.0, 4.0], r, true);
+        assert_eq!(half.get(7, 0), [1.0, 1.0, 1.0, 1.0]);
+    }
+}
diff --git a/crates/ui-egui/src/transform_fx_tests.rs b/crates/ui-egui/src/transform_fx_tests.rs
new file mode 100644
index 0000000000..0eb860dadd
--- /dev/null
+++ b/crates/ui-egui/src/transform_fx_tests.rs
@@ -0,0 +1,277 @@
+//! Free Transform previews a styled layer with its style (#3653), through the real session and
+//! canvas: at every bit depth and colour mode, for pixel layers and groups, following edits made
+//! while the box is open, and matching what the commit leaves.
+
+use photocraft_compose::Buffer;
+use photocraft_doc::{Layer, LayerId};
+use serde_json::json;
+
+use crate::PhotocraftApp;
+use crate::transform_fx::Plan;
+
+/// A 200 × 160 document with a 40 × 20 blue block at (60, 60) on its own layer, wearing a 4 px
+/// red outside Stroke.
+fn app(mode: &str, depth: u32) -> PhotocraftApp {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({"width": 200, "height": 160, "mode": mode, "depth": depth})).unwrap();
+    app.run("layer.new.layer", json!({"name": "styled"})).unwrap();
+    app.run("select.rect", json!({"x": 60, "y": 60, "width": 40, "height": 20})).unwrap();
+    app.run("edit.fill", json!({"color": "#0000ff"})).unwrap();
+    app.run("select.deselect", json!({})).unwrap();
+    app.run("layer.layerStyle.stroke", json!({"size": 4, "color": "#ff0000", "position": "outside"})).unwrap();
+    app.sync_views();
+    app
+}
+
+fn begin(app: &mut PhotocraftApp) {
+    crate::transform_tool::begin(app, &egui::Context::default()).unwrap();
+}
+
+/// What the box draws for the styled layer at `zoom`: `None` when it draws the bare pixels.
+fn composite(app: &PhotocraftApp, zoom: f32) -> Option<(Buffer, Plan)> {
+    let (_, frame) = crate::transform_tool::styled_frame(app, zoom, false)?;
+    let (plan, work, level) = frame.plan()?;
+    Some((frame.compose(&plan, &work, level)?, plan))
+}
+
+/// The composite at a document point.
+fn at(c: &(Buffer, Plan), x: f64, y: f64) -> [f32; 4] {
+    let (x, y) = ((x * c.1.scale).floor() as i32, (y * c.1.scale).floor() as i32);
+    if c.0.rect.contains(x, y) { c.0.get(x, y) } else { [0.0; 4] }
+}
+
+fn set_quad(app: &mut PhotocraftApp, quad: [[f64; 2]; 4]) {
+    app.ui.transform.as_mut().unwrap().quad = quad;
+}
+
+fn active(app: &PhotocraftApp) -> LayerId {
+    app.session.active().unwrap().active_layer.unwrap()
+}
+
+fn edit_layer(app: &mut PhotocraftApp, f: impl FnOnce(&mut Layer)) {
+    let id = active(app);
+    app.session
+        .edit("edit", |doc, _| {
+            f(doc.layer_mut(id).unwrap());
+            Ok(())
+        })
+        .unwrap();
+}
+
+#[test]
+fn the_style_shows_while_the_box_is_open_at_every_depth_and_mode() {
+    for (mode, depth) in [("rgb", 8), ("rgb", 16), ("rgb", 32), ("gray", 8), ("gray", 16), ("cmyk", 8), ("cmyk", 16), ("lab", 8)] {
+        let mut app = app(mode, depth);
+        begin(&mut app);
+        let c = composite(&app, 1.0).unwrap_or_else(|| panic!("{mode}/{depth}: styled"));
+        let (fill, stroke) = (at(&c, 80.0, 70.0), at(&c, 57.0, 70.0));
+        assert!(fill[3] > 0.99 && stroke[3] > 0.99, "{mode}/{depth}: {fill:?} {stroke:?}");
+        assert!(fill.iter().zip(stroke).any(|(a, b)| (a - b).abs() > 0.1), "{mode}/{depth}: the stroke has its own colour: {fill:?} {stroke:?}");
+        if mode == "rgb" {
+            assert!(stroke[0] > 0.9 && stroke[2] < 0.1 && fill[2] > 0.9 && fill[0] < 0.1, "{depth}: {fill:?} {stroke:?}");
+        }
+        assert_eq!(at(&c, 53.0, 70.0)[3], 0.0, "{mode}/{depth}: nothing past the stroke");
+        // Twice the size about the middle: the block is 40..120 × 50..90 and the stroke is
+        // still 4 px, drawn round the new edge.
+        set_quad(&mut app, [[40.0, 50.0], [120.0, 50.0], [120.0, 90.0], [40.0, 90.0]]);
+        let c = composite(&app, 1.0).unwrap();
+        assert!(at(&c, 80.0, 70.0)[3] > 0.99 && at(&c, 37.0, 70.0)[3] > 0.99 && at(&c, 122.0, 70.0)[3] > 0.99, "{mode}/{depth}");
+        assert!(at(&c, 37.0, 70.0).iter().zip(stroke).all(|(a, b)| (a - b).abs() < 0.02), "{mode}/{depth}: the same stroke");
+        assert_eq!(at(&c, 33.0, 70.0)[3], 0.0, "{mode}/{depth}: the stroke did not grow with the box");
+        assert_eq!(at(&c, 126.0, 70.0)[3], 0.0, "{mode}/{depth}");
+    }
+}
+
+/// The preview is the layer as the commit leaves it: same stroke, same shadow, same place.
+#[test]
+fn the_preview_matches_the_committed_layer() {
+    for (mode, depth) in [("rgb", 8), ("rgb", 16), ("rgb", 32), ("gray", 8)] {
+        let mut app = app(mode, depth);
+        app.run("layer.layerStyle.dropShadow", json!({"distance": 9, "size": 4, "opacity": 80, "add": true})).unwrap();
+        begin(&mut app);
+        // One and a half times the size, turned 20° about the middle of the block (80, 70).
+        let (sin, cos) = 20f64.to_radians().sin_cos();
+        let quad = [[-30.0, -15.0], [30.0, -15.0], [30.0, 15.0], [-30.0, 15.0]].map(|[x, y]: [f64; 2]| [80.0 + x * cos - y * sin, 70.0 + x * sin + y * cos]);
+        set_quad(&mut app, quad);
+        let (shown, plan) = composite(&app, 1.0).unwrap();
+        crate::transform_tool::commit(&mut app);
+        assert!(app.ui.transform.is_none(), "{mode}/{depth}: committed");
+        // The committed layer alone, over transparency.
+        let st = app.session.active().unwrap();
+        let mut solo = (*st.doc).clone();
+        let id = st.active_layer.unwrap();
+        for l in solo.layers.iter_mut() {
+            l.visible = l.id == id;
+        }
+        let committed = photocraft_compose::render(&solo, plan.shown);
+        let premultiplied = |p: &[f32; 4]| [p[0] * p[3], p[1] * p[3], p[2] * p[3], p[3]];
+        let (mut sum, mut off) = (0.0f64, 0usize);
+        for (a, b) in shown.px.iter().zip(&committed.px) {
+            let d = premultiplied(a).iter().zip(premultiplied(b)).map(|(x, y)| (x - y).abs()).fold(0.0f32, f32::max);
+            sum += f64::from(d);
+            off += usize::from(d > 0.25);
+        }
+        let n = shown.px.len();
+        assert!(n > 4000, "{mode}/{depth}: {n}");
+        // The commit resamples bicubic and the preview bilinear, so soft edges differ a little
+        // (a mean of 0.002 here); a stroke of another width or a shadow falling elsewhere would
+        // differ over whole bands.
+        assert!(sum / n as f64 <= 0.006, "{mode}/{depth}: mean difference {}", sum / n as f64);
+        assert!(off * 500 <= n, "{mode}/{depth}: {off} of {n} pixels differ");
+        // Something is there to compare: fill, stroke and shadow.
+        assert!(committed.px.iter().filter(|p| p[3] > 0.5).count() > 2000, "{mode}/{depth}");
+    }
+}
+
+/// Groups (like type, shapes and smart objects) preview from a flattened render of the layer,
+/// which is read without the layer's own style and opacity: the box applies them itself.
+#[test]
+fn a_styled_group_previews_with_its_style_once() {
+    let mut app = app("rgb", 8);
+    app.session
+        .edit("group", |doc, active| {
+            let id = active.unwrap();
+            let at = doc.layers.iter().position(|l| l.id == id).unwrap();
+            let mut child = doc.layers.remove(at);
+            let style = std::mem::take(&mut child.effects.items);
+            let mut group = Layer::group("group", vec![child]);
+            group.effects.items = style;
+            group.opacity = 0.5;
+            *active = Some(group.id);
+            doc.layers.insert(at, group);
+            Ok(())
+        })
+        .unwrap();
+    begin(&mut app);
+    let pv = app.transform_preview.as_ref().unwrap();
+    // The texels are the bare pixels over their own bounds: no stroke, no opacity yet.
+    assert_eq!(pv.texture.size(), [40, 20]);
+    let (texels, _) = pv.texture.level_image(0).unwrap();
+    assert!(texels.pixels.iter().all(|p| *p == egui::Color32::from_rgb(0, 0, 255)), "{:?}", texels.pixels.first());
+    // The composite has the stroke round them, all of it at the group's 50 %.
+    let c = composite(&app, 1.0).unwrap();
+    let (fill, stroke) = (at(&c, 80.0, 70.0), at(&c, 57.0, 70.0));
+    assert!((fill[3] - 0.5).abs() < 0.01 && fill[2] > 0.9, "{fill:?}");
+    assert!((stroke[3] - 0.5).abs() < 0.01 && stroke[0] > 0.9, "{stroke:?}");
+    assert_eq!(at(&c, 53.0, 70.0)[3], 0.0);
+}
+
+#[test]
+fn edits_made_while_the_box_is_open_show_in_the_styled_preview() {
+    let mut app = app("rgb", 8);
+    begin(&mut app);
+    assert!(composite(&app, 1.0).is_some());
+    // Opacity.
+    edit_layer(&mut app, |l| l.opacity = 0.3);
+    let c = composite(&app, 1.0).unwrap();
+    assert!((at(&c, 57.0, 70.0)[3] - 0.3).abs() < 0.01 && (at(&c, 80.0, 70.0)[3] - 0.3).abs() < 0.01);
+    // Fill 0 %: the pixels go and the stroke stays (the outline-only look).
+    edit_layer(&mut app, |l| {
+        l.opacity = 1.0;
+        l.fill_opacity = 0.0;
+    });
+    let c = composite(&app, 1.0).unwrap();
+    assert_eq!(at(&c, 80.0, 70.0)[3], 0.0);
+    assert!(at(&c, 57.0, 70.0)[3] > 0.99);
+    // A wider stroke.
+    app.run("layer.layerStyle.stroke", json!({"size": 10, "color": "#ff0000", "position": "outside"})).unwrap();
+    assert!(at(&composite(&app, 1.0).unwrap(), 52.0, 70.0)[3] > 0.99);
+    // The style switched off, then the layer hidden: the box draws the bare pixels (or nothing).
+    edit_layer(&mut app, |l| l.effects.enabled = false);
+    assert!(composite(&app, 1.0).is_none());
+    edit_layer(&mut app, |l| l.effects.enabled = true);
+    assert!(composite(&app, 1.0).is_some());
+    edit_layer(&mut app, |l| l.visible = false);
+    assert!(composite(&app, 1.0).is_none());
+}
+
+#[test]
+fn layers_without_a_style_and_other_boxes_keep_the_plain_preview() {
+    // No style: nothing to composite, also if one is added once the box is open (its texels
+    // were not read for it).
+    let mut plain = app("rgb", 8);
+    edit_layer(&mut plain, |l| l.effects.items.clear());
+    begin(&mut plain);
+    assert!(composite(&plain, 1.0).is_none());
+    plain.run("layer.layerStyle.stroke", json!({"size": 4, "color": "#ff0000"})).unwrap();
+    assert!(composite(&plain, 1.0).is_none());
+    // The selected part of a styled layer: its style belongs to that part and the rest together.
+    let mut part = app("rgb", 8);
+    part.run("select.rect", json!({"x": 60, "y": 60, "width": 20, "height": 20})).unwrap();
+    begin(&mut part);
+    assert_eq!(part.ui.transform.as_ref().unwrap().rect, [60.0, 60.0, 80.0, 80.0]);
+    assert!(composite(&part, 1.0).is_none());
+    // Transform Selection moves an outline, not the layer.
+    let mut outline = app("rgb", 8);
+    outline.run("select.rect", json!({"x": 60, "y": 60, "width": 20, "height": 20})).unwrap();
+    crate::transform_tool::begin_selection(&mut outline, &egui::Context::default()).unwrap();
+    assert!(composite(&outline, 1.0).is_none());
+    // Warp mode draws its own mesh.
+    let mut warp = app("rgb", 8);
+    crate::transform_tool::begin_warp(&mut warp, &egui::Context::default()).unwrap();
+    assert!(composite(&warp, 1.0).is_none());
+}
+
+#[test]
+fn the_work_follows_the_zoom_and_never_the_document_size() {
+    let mut app = app("rgb", 8);
+    begin(&mut app);
+    // Zoomed out to 25 %: a sixteenth of the pixels.
+    let (full, half) = (composite(&app, 1.0).unwrap(), composite(&app, 0.25).unwrap());
+    assert_eq!(full.1.scale, 1.0);
+    assert_eq!(half.1.scale, 0.25);
+    assert!(half.0.px.len() * 8 < full.0.px.len(), "{} vs {}", half.0.px.len(), full.0.px.len());
+    assert!(at(&half, 80.0, 70.0)[3] > 0.99 && at(&half, 57.0, 70.0)[3] > 0.99 && at(&half, 50.0, 70.0)[3] == 0.0);
+    // Zoomed in: the document's own pixels, no finer.
+    assert_eq!(composite(&app, 16.0).unwrap().1.scale, 1.0);
+    // A box dragged out to an absurd size stays within the budget.
+    set_quad(&mut app, [[-4.0e6, -4.0e6], [4.0e6, -4.0e6], [4.0e6, 4.0e6], [-4.0e6, 4.0e6]]);
+    if let Some((buf, _)) = composite(&app, 1.0) {
+        assert!(buf.px.len() as f64 <= crate::transform_fx::MAX_PIXELS);
+    }
+    // A box that isn't a box: the bare pixels, no panic.
+    set_quad(&mut app, [[f64::NAN; 2]; 4]);
+    assert!(composite(&app, 1.0).is_none());
+    set_quad(&mut app, [[70.0, 70.0]; 4]);
+    assert!(composite(&app, 1.0).is_none());
+}
+
+/// Through the real canvas: the composite is made once per change, not once per frame, the box
+/// still drags, undoes and commits as before, and the committed layer keeps its style.
+#[test]
+fn the_canvas_draws_the_styled_preview_and_reuses_it_between_frames() {
+    let mut h = crate::transform_undo_tests::harness();
+    h.state_mut().run("layer.layerStyle.stroke", json!({"size": 4, "color": "#00ff00", "position": "outside"})).unwrap();
+    h.run_steps(2);
+    let steps = h.state().session.active().unwrap().history.entries().len();
+    crate::transform_undo_tests::begin(&mut h);
+    let builds = |h: &egui_kittest::Harness<'static, PhotocraftApp>| crate::transform_tool::styled_frame(h.state(), 1.0, false).unwrap().0.builds();
+    assert_eq!(builds(&h), 1, "composited when the box opened");
+    h.run_steps(5);
+    assert_eq!(builds(&h), 1, "and kept while nothing changes");
+    // Drag the bottom-right corner out: the composite follows the box.
+    crate::transform_undo_tests::drag(&mut h, [200.0, 160.0], [260.0, 196.0]);
+    let after_drag = builds(&h);
+    assert!(after_drag > 1, "{after_drag}");
+    let quad = h.state().ui.transform.as_ref().unwrap().quad;
+    assert!(quad[2][0] > 250.0, "{quad:?}");
+    h.run_steps(5);
+    assert_eq!(builds(&h), after_drag, "at rest again");
+    // Zooming rebuilds it for the new scale.
+    h.state_mut().ui.views[0].zoom = 0.5;
+    h.run_steps(2);
+    assert_eq!(builds(&h), after_drag + 1);
+    // Undo steps the box back (not the document), and the composite follows.
+    h.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::Z);
+    h.run_steps(2);
+    assert_eq!(h.state().ui.transform.as_ref().unwrap().quad[2], [200.0, 160.0]);
+    assert_eq!(h.state().session.active().unwrap().history.entries().len(), steps);
+    assert_eq!(builds(&h), after_drag + 2);
+    // Enter commits: one history step, the style still on the layer.
+    h.key_press(egui::Key::Enter);
+    h.run_steps(3);
+    let app = h.state();
+    assert!(app.ui.transform.is_none() && app.transform_preview.is_none());
+    let st = app.session.active().unwrap();
+    assert!(photocraft_compose::effects::has_effects(st.doc.layer(st.active_layer.unwrap()).unwrap()));
+}
diff --git a/crates/ui-egui/src/transform_tex.rs b/crates/ui-egui/src/transform_tex.rs
index 2811a6b586..bd84704542 100644
--- a/crates/ui-egui/src/transform_tex.rs
+++ b/crates/ui-egui/src/transform_tex.rs
@@ -58,11 +58,16 @@ impl PreviewTextures {
         if !s.is_finite() || s <= 0.0 {
             return (0, false);
         }
+        // Nearest Neighbor is point sampling: downsampled mip levels have already averaged
+        // neighbouring texels, so using one would blur a pixel-art transform preview.
+        if nearest_interpolation {
+            return (0, true);
+        }
         if s < 0.5 {
             // log2(1/s) levels down, at most 12 (4096× smaller).
-            return ((1.0 / s).log2().floor().clamp(0.0, 12.0) as u32, nearest_interpolation);
+            return ((1.0 / s).log2().floor().clamp(0.0, 12.0) as u32, false);
         }
-        let crisp = nearest_interpolation || (zoom >= CRISP_ZOOM && scale <= 1.05);
+        let crisp = zoom >= CRISP_ZOOM && scale <= 1.05;
         (0, crisp)
     }
 
@@ -85,7 +90,7 @@ impl PreviewTextures {
     }
 
     /// Level `n` of the mip chain (built on demand by 2×2 box filtering) and its uv extent.
-    fn level_image(&self, n: u32) -> Option<(Arc<ColorImage>, [f32; 2])> {
+    pub(crate) fn level_image(&self, n: u32) -> Option<(Arc<ColorImage>, [f32; 2])> {
         let mut imgs = self.images.lock().unwrap_or_else(PoisonError::into_inner);
         while imgs.len() <= n as usize {
             let prev = imgs.last()?;
@@ -203,6 +208,10 @@ mod tests {
         assert_eq!(PreviewTextures::choose(1.0, 1.0, true), (0, true));
         assert_eq!(PreviewTextures::choose(0.25, 1.0, false), (2, false));
         assert_eq!(PreviewTextures::choose(0.3, 1.0, false), (1, false));
+        // Nearest Neighbor must use the full-resolution texels, even when zoomed far out.
+        // A mipmap would average adjacent opaque/transparent pixels before sampling.
+        assert_eq!(PreviewTextures::choose(0.25, 1.0, true), (0, true));
+        assert_eq!(PreviewTextures::choose(1.0 / 4096.0, 1.0, true), (0, true));
         assert_eq!(PreviewTextures::choose(f32::NAN, 1.0, false), (0, false));
         assert_eq!(PreviewTextures::choose(1e-9, 1.0, false).0, 12);
     }
diff --git a/crates/ui-egui/src/transform_tool.rs b/crates/ui-egui/src/transform_tool.rs
index 062cdbdcce..81fc0fadcf 100644
--- a/crates/ui-egui/src/transform_tool.rs
+++ b/crates/ui-egui/src/transform_tool.rs
@@ -14,6 +14,7 @@ use std::sync::Arc;
 use egui::{Color32, CursorIcon, Pos2, Stroke, pos2, vec2};
 use photocraft_algo::transform::Homography;
 use photocraft_doc::{DocId, Document, LayerContent, LayerId};
+use photocraft_engine::jobs::{JobEvent, JobId, JobOutcome};
 use photocraft_geom::warp::{BezierMesh, Warp, WarpStyle};
 use serde_json::json;
 
@@ -64,6 +65,9 @@ pub struct TransformPreview {
     pub opacity: f32,
     /// The layers stacked over the moving one, drawn over its pixels ([`Above`]).
     above: Option<Above>,
+    /// A layer with a style: its pixels composited with the style as the box has them now,
+    /// drawn instead of the bare pixels (transform_fx.rs, #3653).
+    styled: Option<crate::transform_fx::StyledPreview>,
     gesture: Option<Gesture>,
     /// Warp-mode drag in progress.
     warp_drag: Option<WarpDrag>,
@@ -82,6 +86,9 @@ pub struct TransformPreview {
     /// A layer's session keeps `doc` and `opacity` up to date with edits made while the box is
     /// open ([`follow_edits`]); `None` for a lone mask or channel and Transform Selection.
     follow: Option<Follow>,
+    /// The commit running as a background job (#1015): the moving pixels stay on screen, without
+    /// the box, until it lands; Esc cancels it. The session ends with the job.
+    committing: Option<JobId>,
     /// Content-Aware Scale's live preview (cas_transform.rs).
     pub(crate) content_aware: Option<crate::cas_transform::Live>,
 }
@@ -213,7 +220,10 @@ pub fn begin(app: &mut PhotocraftApp, ctx: &egui::Context) -> Result<(), String>
     // The layers covering the moving pixels draw over them instead of under them.
     let above = Above::new(ctx, format!("transform-{session}-above"), &doc, id, max_side);
     above.hide_in(&mut pd.layers);
-    let (image, uv) = preview_image(&doc, id, lifted.as_ref(), b, max_side);
+    // A style is drawn again from the pixels as the box moves them, so they are read without it.
+    // Not for the selected part of a layer: its style belongs to that part and the rest together.
+    let styled = lifted.is_none() && photocraft_compose::effects::has_effects(layer);
+    let (image, uv) = preview_image(&doc, id, lifted.as_ref(), b, max_side, styled);
     let texture = crate::transform_tex::PreviewTextures::new(ctx, format!("transform-{session}"), image, uv);
     app.transform_preview = Some(TransformPreview {
         session,
@@ -221,7 +231,9 @@ pub fn begin(app: &mut PhotocraftApp, ctx: &egui::Context) -> Result<(), String>
         texture,
         opacity: layer.opacity * layer.fill_opacity,
         above: Some(above),
+        styled: styled.then(|| crate::transform_fx::StyledPreview::new(format!("transform-{session}-styled"))),
         follow: Some(Follow { revision, hidden: lifted.is_none() }),
+        committing: None,
         gesture: None,
         warp_drag: None,
         split_tool: None,
@@ -247,6 +259,7 @@ pub fn begin(app: &mut PhotocraftApp, ctx: &egui::Context) -> Result<(), String>
         made: None,
         mode: Default::default(),
         content_aware: None,
+        skew_v: 0.0,
     });
     start_steps(app);
     Ok(())
@@ -320,6 +333,7 @@ pub(crate) fn begin_content_aware(
         opacity: layer.opacity * layer.fill_opacity,
         above: Some(above),
         follow: Some(Follow { revision, hidden: false }),
+        committing: None,
         gesture: None,
         warp_drag: None,
         split_tool: None,
@@ -330,6 +344,7 @@ pub(crate) fn begin_content_aware(
         tool: app.ui.tool,
         path: None,
         content_aware: Some(live),
+        styled: None,
     });
     app.ui.transform = Some(TransformSession {
         session,
@@ -345,6 +360,7 @@ pub(crate) fn begin_content_aware(
         made: None,
         mode: Default::default(),
         content_aware: Some(Default::default()),
+        skew_v: 0.0,
     });
     start_steps(app);
     Ok(())
@@ -377,13 +393,20 @@ fn take_back_made(app: &mut PhotocraftApp, document: DocId, layer: LayerId) {
 
 /// After the transform: the step that made the layer and the transform become one history step,
 /// the transform's for a copy and Place Embedded for a placed file.
-fn fold_made(app: &mut PhotocraftApp, made: MadeLayer) {
+fn fold_made(app: &mut PhotocraftApp, document: DocId, made: MadeLayer) {
+    // A background commit lands in its own document, which need not be the active one by then.
+    let Some(index) = app.session.documents().iter().position(|st| st.doc.id == document) else { return };
+    let active = app.session.active_index();
+    app.session.set_active(index);
     if let Some(st) = app.session.active_mut() {
         st.history.purge_last();
         if made == MadeLayer::Place {
             st.history.set_current_label(photocraft_engine::file_cmds::PLACE_EMBEDDED);
         }
     }
+    if let Some(active) = active {
+        app.session.set_active(active);
+    }
 }
 
 /// Free Transform of a targeted unlinked layer mask, alpha channel or Quick Mask by itself: the
@@ -430,7 +453,9 @@ fn begin_lone(
         texture,
         opacity: 0.6,
         above: None,
+        styled: None,
         follow: None,
+        committing: None,
         gesture: None,
         warp_drag: None,
         split_tool: None,
@@ -456,6 +481,7 @@ fn begin_lone(
         made: None,
         mode: Default::default(),
         content_aware: None,
+        skew_v: 0.0,
     });
     start_steps(app);
     Ok(())
@@ -479,6 +505,7 @@ fn begin_path(app: &mut PhotocraftApp, ctx: &egui::Context, params: serde_json::
         doc,
         texture,
         opacity: 1.0,
+        styled: None,
         gesture: None,
         warp_drag: None,
         split_tool: None,
@@ -491,6 +518,7 @@ fn begin_path(app: &mut PhotocraftApp, ctx: &egui::Context, params: serde_json::
         content_aware: None,
         above: None,
         follow: None,
+        committing: None,
     });
     app.ui.transform = Some(TransformSession {
         session,
@@ -506,6 +534,7 @@ fn begin_path(app: &mut PhotocraftApp, ctx: &egui::Context, params: serde_json::
         made: None,
         mode: Default::default(),
         content_aware: None,
+        skew_v: 0.0,
     });
     start_steps(app);
     Ok(())
@@ -562,7 +591,9 @@ pub fn begin_selection(app: &mut PhotocraftApp, ctx: &egui::Context) -> Result<(
         texture,
         opacity: 1.0,
         above: None,
+        styled: None,
         follow: None,
+        committing: None,
         gesture: None,
         warp_drag: None,
         split_tool: None,
@@ -588,6 +619,7 @@ pub fn begin_selection(app: &mut PhotocraftApp, ctx: &egui::Context) -> Result<(
         made: None,
         mode: Default::default(),
         content_aware: None,
+        skew_v: 0.0,
     });
     start_steps(app);
     Ok(())
@@ -658,6 +690,9 @@ pub fn warps_type(app: &PhotocraftApp) -> bool {
 fn enter_type_warp(app: &mut PhotocraftApp, ctx: &egui::Context) {
     if app.ui.transform.as_ref().is_some_and(|t| t.quad != corners(t.rect)) {
         commit(app);
+        if app.ui.transform.is_some() {
+            return; // refused: the box stays as it was
+        }
         if let Err(e) = begin(app, ctx) {
             app.ui.status = e;
             return;
@@ -681,7 +716,8 @@ fn enter_type_warp(app: &mut PhotocraftApp, ctx: &egui::Context) {
         && let Some(pv) = app.transform_preview.as_mut()
     {
         let max_side = ctx.input(|i| i.max_texture_side).max(app.gpu.as_ref().map_or(1, |g| g.max_texture_side()));
-        let (image, uv) = preview_image(&plain, id, None, b, max_side);
+        // Read as the session's texels were: without the style when the box draws it itself.
+        let (image, uv) = preview_image(&plain, id, None, b, max_side, pv.styled.is_some());
         pv.texture = crate::transform_tex::PreviewTextures::new(ctx, format!("transform-{session}"), image, uv);
     }
     let warp =
@@ -717,13 +753,15 @@ pub fn leave_warp(app: &mut PhotocraftApp) {
 
 /// Texels of the moving pixels over `b`: full resolution unless the long side exceeds the GPU's
 /// `max_side` (#91: this used to be capped at 2048 px, so big layers previewed blurry), plus the
-/// uv extent covering `b`.
+/// uv extent covering `b`. `bare` leaves the layer's own style, opacity and fill out of a
+/// flattened render: the styled preview applies them to the moved pixels itself.
 fn preview_image(
     doc: &Document,
     id: LayerId,
     lifted: Option<&photocraft_raster::Surface>,
     b: photocraft_geom::Rect,
     max_side: usize,
+    bare: bool,
 ) -> (egui::ColorImage, [f32; 2]) {
     let layer = doc.layer(id);
     // Linked masks move with the pixels, so the moving texels carry them (#205).
@@ -740,6 +778,11 @@ fn preview_image(
                     l.visible = false;
                 }
             }
+            if let Some(l) = solo.layer_mut(id).filter(|_| bare) {
+                l.effects.enabled = false;
+                l.opacity = 1.0;
+                l.fill_opacity = 1.0;
+            }
             let buf = photocraft_compose::render(&solo, b);
             let mut s = photocraft_raster::Surface::new(photocraft_color::PixelFormat::RGBA8);
             let flat: Vec<f32> = buf.px.iter().flat_map(|p| *p).collect();
@@ -763,7 +806,7 @@ fn preview_mask(l: &photocraft_doc::Layer, b: photocraft_geom::Rect) -> Option<c
     let vector = l.vector_mask.as_ref().filter(|v| v.enabled);
     let linked_pixel = pixel.filter(|m| m.linked);
     if pixel.is_none_or(|m| m.linked)
-        && vector.is_some_and(|v| v.linked)
+        && vector.is_none_or(|v| v.linked)
         && let Some(surface) = photocraft_compose::masks::combined_mask(l, b)
     {
         return Some(PreviewMask { surface, density: 1.0 });
@@ -927,7 +970,13 @@ fn contains(l: &photocraft_doc::Layer, id: LayerId) -> bool {
     l.id == id || matches!(&l.content, LayerContent::Group(g) if g.children.iter().any(|c| contains(c, id)))
 }
 
+/// Undo and Redo while the commit runs in the background.
+const STILL_APPLYING: &str = "Free Transform is still being applied";
+
 pub fn commit(app: &mut PhotocraftApp) {
+    if committing(app).is_some() {
+        return;
+    }
     let document = app.transform_preview.as_ref().map(|pv| pv.doc.id);
     if document.is_some_and(|id| app.session.active().is_none_or(|st| st.doc.id != id)) {
         cancel(app);
@@ -935,7 +984,7 @@ pub fn commit(app: &mut PhotocraftApp) {
     }
     let type_layer = warps_type(app);
     let Some(t) = app.ui.transform.take() else { return };
-    app.transform_preview = None;
+    let mut preview = app.transform_preview.take();
     if let Some(options) = &t.content_aware {
         crate::cas_transform::commit(app, &t, options);
         return;
@@ -949,12 +998,12 @@ pub fn commit(app: &mut PhotocraftApp) {
             None => p["quad"] = json!(t.quad),
         }
         if let Err(e) = app.run("select.transformSelection", p) {
-            app.ui.status = e;
+            keep_open(app, t, preview, e);
         }
         return;
     }
-    if let Some(target) = t.path {
-        let mut p = target;
+    if let Some(target) = &t.path {
+        let mut p = target.clone();
         match &t.warp {
             Some(w) if w.is_identity() => return,
             Some(w) => p["warp"] = json!(w),
@@ -969,7 +1018,7 @@ pub fn commit(app: &mut PhotocraftApp) {
             },
         }
         if let Err(e) = app.run("path.transform", p) {
-            app.ui.status = e;
+            keep_open(app, t, preview, e);
         }
         return;
     }
@@ -985,26 +1034,66 @@ pub fn commit(app: &mut PhotocraftApp) {
             return; // untouched: nothing to do and no history step; a ⌥⌘T copy or a place stays
         }
         let mut p = json!({"layer": t.layer, "rect": t.rect, "quad": t.quad, "interpolation": t.interpolation});
-        if let Some(target) = t.target {
-            p["target"] = target;
+        if let Some(target) = &t.target {
+            p["target"] = target.clone();
         }
         app.run("edit.transform", p)
     };
-    match r {
-        Ok(_) => {
-            if let Some(made) = made {
-                fold_made(app, made);
-            }
-        }
-        Err(e) => {
-            if made.is_some()
-                && let Some(document) = document
-            {
-                take_back_made(app, document, LayerId(t.layer));
-            }
-            app.ui.status = e;
-        }
+    // A large layer's warp runs in the background: the session stays until the job ends.
+    if let Ok(v) = &r
+        && let Some(job) = v.get("pending").and_then(serde_json::Value::as_bool).filter(|p| *p).and(v.get("job")).and_then(serde_json::Value::as_u64)
+        && let Some(pv) = preview.as_mut()
+    {
+        pv.committing = Some(JobId(job));
+        app.ui.transform = Some(t);
+        app.transform_preview = preview;
+        return;
     }
+    match r {
+        Ok(_) => finish(app, document, LayerId(t.layer), made, true),
+        Err(e) => keep_open(app, t, preview, e),
+    }
+}
+
+/// After the transform landed or not: fold the layer the session made into its step, or take it
+/// back.
+fn finish(app: &mut PhotocraftApp, document: Option<DocId>, layer: LayerId, made: Option<MadeLayer>, landed: bool) {
+    let (Some(made), Some(document)) = (made, document) else { return };
+    if landed {
+        fold_made(app, document, made);
+    } else {
+        take_back_made(app, document, layer);
+    }
+}
+
+/// The job applying the transform, while it runs.
+pub(crate) fn committing(app: &PhotocraftApp) -> Option<JobId> {
+    app.transform_preview.as_ref().and_then(|pv| pv.committing)
+}
+
+/// A job ended (see [`crate::jobs_ui`]): when it was the commit, the session ends with it. Its
+/// status and errors are reported like any job's.
+pub fn on_job_event(app: &mut PhotocraftApp, e: &JobEvent) {
+    if committing(app) != Some(e.id) {
+        return;
+    }
+    let (Some(t), Some(mut pv)) = (app.ui.transform.take(), app.transform_preview.take()) else { return };
+    // A refused commit (a result over the pixel budget, #3773) keeps the box open, as inline.
+    if let JobOutcome::Failed(msg) = &e.outcome {
+        pv.committing = None;
+        keep_open(app, t, Some(pv), msg.clone());
+        return;
+    }
+    finish(app, Some(pv.doc.id), LayerId(t.layer), t.made, matches!(e.outcome, JobOutcome::Done(_)));
+}
+
+/// A commit the engine refused (a result over the pixel budget, #3773): the box stays open as it
+/// was, with the reason in the status bar, so the transform can be changed or cancelled. A copy or
+/// a placed layer it made goes only when it is cancelled.
+fn keep_open(app: &mut PhotocraftApp, t: TransformSession, preview: Option<TransformPreview>, e: String) {
+    app.ui.transform = Some(t);
+    app.transform_preview = preview;
+    app.ui.status = e;
 }
 
 /// A transform whose layer or document went away (undo, close) ends silently; picking another tool
@@ -1014,6 +1103,9 @@ pub fn commit(app: &mut PhotocraftApp) {
 /// that tool.
 pub fn end_if_left(app: &mut PhotocraftApp) {
     let Some(t) = &app.ui.transform else { return };
+    if committing(app).is_some() {
+        return;
+    }
     let Some(st) = app.session.active() else { return cancel(app) };
 
     let layer = LayerId(t.layer);
@@ -1036,6 +1128,10 @@ pub fn end_if_left(app: &mut PhotocraftApp) {
         || (!selection && st.active_layer.is_some_and(|active| active.0 != layer.0))
     {
         commit(app);
+        // Picking another tool or layer can't leave a refused transform open: it ends, as Esc would.
+        if app.ui.transform.is_some() {
+            cancel(app);
+        }
     }
 }
 
@@ -1065,6 +1161,11 @@ pub fn follow_edits(app: &mut PhotocraftApp) {
 }
 
 pub fn cancel(app: &mut PhotocraftApp) {
+    // Esc while the commit runs cancels the job; the session ends when it does.
+    if let Some(job) = committing(app) {
+        crate::jobs_ui::cancel(app, job);
+        return;
+    }
     let transform = app.ui.transform.take();
     let preview = app.transform_preview.take();
     if let (Some(t), Some(pv)) = (transform, preview)
@@ -1095,6 +1196,9 @@ pub fn track_steps(app: &mut PhotocraftApp, ctx: &egui::Context) {
 /// Toggle Last State, which would change the document under the box), `None` for the rest.
 pub fn is_enabled(app: &PhotocraftApp, id: &str) -> Option<bool> {
     let t = app.ui.transform.as_ref()?;
+    if committing(app).is_some() {
+        return box_command(id).then_some(false);
+    }
     let steps = app.transform_preview.as_ref().map(|pv| &pv.steps);
     match id {
         // Content-Aware Scale's box only scales: no switching it to another transform or Warp.
@@ -1102,8 +1206,8 @@ pub fn is_enabled(app: &PhotocraftApp, id: &str) -> Option<bool> {
         i if i.starts_with("edit.transform.") && t.content_aware.is_some() => Some(false),
         "edit.undo" => Some(steps.is_some_and(|s| s.can_undo(&Step::of(t)))),
         "edit.redo" => Some(steps.is_some_and(|s| !s.redo.is_empty())),
-        // No Toggle Last State under the box, and one box at a time.
-        "edit.toggleLastState" | "edit.contentAwareScale" | "edit.puppetWarp" => Some(false),
+        // No Toggle Last State or history jump under the box, and one box at a time.
+        "edit.toggleLastState" | "history.selectState" | "edit.contentAwareScale" | "edit.puppetWarp" => Some(false),
         // Rotate and Flip turn the box (not while warping, where the mesh is the box).
         _ if box_preset(id).is_some() => Some(t.warp.is_none()),
         // Editable type can't be distorted (#2630, as #2701 rules for the menus outside a box).
@@ -1136,16 +1240,27 @@ fn box_preset(id: &str) -> Option<(f64, f64, f64)> {
 }
 
 /// While transforming, the box owns the history for every caller (menus, shortcuts, the control
-/// channel, MCP): Undo and Redo step through it, and Toggle Last State, which would change the
-/// document under the box, is refused. Edit › Transform's Rotate and Flip turn the box itself, as
-/// in Photoshop, instead of the layer under it; committing stays with ↩ and the options bar.
+/// channel, MCP): Undo and Redo step through it, and Toggle Last State and History state jumps,
+/// which would change the document under the box, are refused. Edit › Transform's Rotate and
+/// Flip turn the box itself, as in Photoshop, instead of the layer under it; committing stays
+/// with ↩ and the options bar.
 /// `None` for other commands or when not transforming.
+/// The commands the open box answers itself ([`is_enabled`], [`intercept`]).
+fn box_command(id: &str) -> bool {
+    matches!(id, "edit.undo" | "edit.redo" | "edit.toggleLastState" | "edit.contentAwareScale" | "edit.puppetWarp") || box_preset(id).is_some()
+}
+
 pub fn intercept(app: &mut PhotocraftApp, id: &str) -> Option<Result<serde_json::Value, String>> {
     let warping = app.ui.transform.as_ref()?.warp.is_some();
+    if committing(app).is_some() {
+        return box_command(id).then(|| Err(STILL_APPLYING.into()));
+    }
     match id {
         "edit.undo" => Some(Ok(step(app, false))),
         "edit.redo" => Some(Ok(step(app, true))),
-        "edit.toggleLastState" | "edit.contentAwareScale" | "edit.puppetWarp" => Some(Err("Commit or cancel the transform first".into())),
+        "edit.toggleLastState" | "history.selectState" | "edit.contentAwareScale" | "edit.puppetWarp" => {
+            Some(Err("Commit or cancel the transform first".into()))
+        }
         _ => {
             let (kx, ky, angle) = box_preset(id)?;
             if warping {
@@ -1231,6 +1346,9 @@ fn accepts_outside_click(g: Gesture, end: [f64; 2], tol: f64) -> bool {
 /// Pointer input while transforming. Returns false when no transform is active.
 pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers) -> bool {
     let Some(t) = app.ui.transform.clone() else { return false };
+    if committing(app).is_some() {
+        return true;
+    }
     let tol = handle_tolerance(app);
     if t.warp.is_some() {
         warp_pointer(app, ev, tol, mods);
@@ -1251,9 +1369,9 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers) ->
             }
             // Distort only moves corners (and the whole box from inside): no rotating, no edges.
             // Even in Distort mode, remember an outside press so a plain click can
-            // accept the transform. A drag outside remains inert in that mode, and in
+            // accept the transform. A drag outside remains inert in that mode, in Skew, and in
             // Content-Aware Scale, which only scales and moves.
-            pv.gesture = (distort_allows(t.mode, h) || h == Hit::Outside).then_some(Gesture { hit: h, start: [x, y], quad0: t.quad, pivot0: t.pivot });
+            pv.gesture = (mode_allows(t.mode, h) || h == Hit::Outside).then_some(Gesture { hit: h, start: [x, y], quad0: t.quad, pivot0: t.pivot });
         }
         ToolEvent::Move { x, y, .. } | ToolEvent::Up { x, y } => {
             let g = pv.gesture;
@@ -1268,15 +1386,21 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, mods: egui::Modifiers) ->
                 return true;
             }
             let legacy = app.session.prefs().general.use_legacy_free_transform;
+            let unlinked = app.ui.transform_unlinked;
+            let type_layer = moves_type(app, &t);
             if let (Some(g), Some(s)) = (g, app.ui.transform.as_mut())
-                && distort_allows(t.mode, g.hit)
+                && mode_allows(t.mode, g.hit)
                 && (t.content_aware.is_none() || g.hit != Hit::Outside)
             {
                 let (mode, mods) = if no_distort { scale_not_distort(t.mode, g.hit, mods) } else { (t.mode, mods) };
-                let mut mods = mode_mods(mode, g.hit, legacy_mods(legacy, g.hit, mods));
-                // Content-Aware Scale: ⌘ neither skews nor distorts.
-                mods.command &= t.content_aware.is_none();
-                apply_drag(s, g, [x, y], mods);
+                if t.content_aware.is_some() {
+                    let mut mods = mode_mods(mode, g.hit, legacy_mods(legacy, g.hit, unlinked_mods(unlinked, legacy, g.hit, mods)));
+                    // Content-Aware Scale: ⌘ neither skews nor distorts.
+                    mods.command = false;
+                    apply_drag(s, g, [x, y], mods);
+                } else {
+                    apply_mode_drag(s, g, [x, y], mode, type_layer, legacy_mods(legacy, g.hit, unlinked_mods(unlinked, legacy, g.hit, mods)));
+                }
             }
         }
     }
@@ -1318,11 +1442,21 @@ pub(crate) fn legacy_mods(legacy: bool, hit: Hit, mut mods: egui::Modifiers) ->
     mods
 }
 
-/// Skew / Distort / Perspective modes: a handle drag acts as if that gesture's keys were held
-/// (⌘-drag an edge skews, ⌘-drag a corner distorts, ⌘⌥⇧-drag a corner adds perspective).
+/// The options bar's Maintain Aspect Ratio link turned off: corner and edge drags stretch freely
+/// and ⇧ keeps the proportions, as in Photoshop CC 2019 and later (#4174). The legacy preference
+/// already works that way, so it is left alone there.
+pub(crate) fn unlinked_mods(unlinked: bool, legacy: bool, hit: Hit, mut mods: egui::Modifiers) -> egui::Modifiers {
+    if unlinked && !legacy && !mods.command && matches!(hit, Hit::Corner(_) | Hit::Edge(_)) {
+        mods.shift = !mods.shift;
+    }
+    mods
+}
+
+/// Distort / Perspective modes: a corner drag acts as if that gesture's keys were held (⌘-drag a
+/// corner distorts, ⌘⌥⇧-drag a corner adds perspective). Skew has its own ([`apply_mode_drag`]).
 fn mode_mods(mode: TransformMode, hit: Hit, mut mods: egui::Modifiers) -> egui::Modifiers {
     match (mode, hit) {
-        (TransformMode::Skew, Hit::Edge(_)) | (TransformMode::Distort, Hit::Corner(_)) => mods.command = true,
+        (TransformMode::Distort, Hit::Corner(_)) => mods.command = true,
         (TransformMode::Perspective, Hit::Corner(_)) => {
             mods.command = true;
             mods.alt = true;
@@ -1333,9 +1467,74 @@ fn mode_mods(mode: TransformMode, hit: Hit, mut mods: egui::Modifiers) -> egui::
     mods
 }
 
-/// In Distort mode only corner drags (and moving the box from inside) do anything.
-fn distort_allows(mode: TransformMode, h: Hit) -> bool {
-    mode != TransformMode::Distort || !matches!(h, Hit::Outside | Hit::Edge(_))
+/// A handle drag in Edit › Transform `mode` (`Free` for Free Transform). `type_layer`: the box
+/// moves editable type, which only takes affine transforms.
+pub(crate) fn apply_mode_drag(s: &mut TransformSession, g: Gesture, p: [f64; 2], mode: TransformMode, type_layer: bool, mut mods: egui::Modifiers) {
+    if !mode_allows(mode, g.hit) {
+        return;
+    }
+    match (mode, g.hit) {
+        // Skew, as in Photoshop (#3437): a corner moves alone along one of its two edges,
+        // whichever the drag mostly follows; ⌥ moves the opposite corner the other way.
+        (TransformMode::Skew, Hit::Corner(i)) if i < 4 => {
+            let (d, q0) = ([p[0] - g.start[0], p[1] - g.start[1]], g.quad0);
+            // Corners 0..3 = TL, TR, BR, BL: the neighbour along the top/bottom edge, and along
+            // the left/right one.
+            let along = |j: usize| {
+                let e = [q0[i][0] - q0[j][0], q0[i][1] - q0[j][1]];
+                let l = e[0].hypot(e[1]);
+                let u = if l > 0.0 { [e[0] / l, e[1] / l] } else { [0.0, 0.0] };
+                let t = d[0] * u[0] + d[1] * u[1];
+                [t * u[0], t * u[1]]
+            };
+            let (hn, vn) = ([1, 0, 3, 2][i], [3, 2, 1, 0][i]);
+            let (h, v) = (along(hn), along(vn));
+            let (m, partner) = if h[0].hypot(h[1]) >= v[0].hypot(v[1]) { (h, hn) } else { (v, vn) };
+            // Editable type stays a parallelogram: the corner's whole edge slides with it.
+            let moved: &[usize] = if type_layer { &[i, partner] } else { &[i] };
+            let mut q = q0;
+            for k in 0..4 {
+                let sign = if moved.contains(&k) {
+                    1.0
+                } else if mods.alt && (if type_layer { true } else { k == (i + 2) % 4 }) {
+                    // ⌥: the opposite corner (on type, the opposite edge) the other way.
+                    -1.0
+                } else {
+                    continue;
+                };
+                if let (Some(dst), Some(src)) = (q.get_mut(k), q0.get(k)) {
+                    *dst = [src[0] + sign * m[0], src[1] + sign * m[1]];
+                }
+            }
+            s.quad = keep_convex(q0, q);
+            s.pivot = carry_pivot(q0, s.quad, g.pivot0);
+        }
+        // Rotate (#3941): a corner or edge turns about the reference point, the same drag as the
+        // zone just outside the box. Free Transform still scales from those handles.
+        (TransformMode::Rotate, Hit::Corner(_) | Hit::Edge(_)) => {
+            let mut g = g;
+            g.hit = Hit::Outside;
+            apply_drag(s, g, p, mods);
+        }
+        // Skew: an edge slides only along itself (⌘⇧ in Free Transform).
+        (TransformMode::Skew, Hit::Edge(_)) => {
+            mods.command = true;
+            mods.shift = true;
+            apply_drag(s, g, p, mods);
+        }
+        _ => apply_drag(s, g, p, mode_mods(mode, g.hit, mods)),
+    }
+}
+
+/// What a drag can do in each Edit › Transform mode: in Distort only the corners (and moving the
+/// box from inside); in Skew everything but rotating from outside the box (#3437). A click
+/// outside still commits.
+fn mode_allows(mode: TransformMode, h: Hit) -> bool {
+    match mode {
+        TransformMode::Distort => !matches!(h, Hit::Outside | Hit::Edge(_)),
+        TransformMode::Skew => h != Hit::Outside,
+        _ => true,
+    }
 }
 
 /// The turn at each corner of a quad (cross products of consecutive edges): all the same sign
@@ -1751,7 +1950,10 @@ pub fn split(app: &mut PhotocraftApp, id: &str, at: Option<[f64; 2]>) -> Result<
 fn near_rotate_corner(t: &TransformSession, p: [f64; 2], tol: f64) -> bool {
     t.warp.is_none()
         && t.mode != TransformMode::Distort
-        && hit(t, p, tol) == Hit::Outside
+        && {
+            let h = hit(t, p, tol);
+            h == Hit::Outside || (t.mode == TransformMode::Rotate && matches!(h, Hit::Corner(_) | Hit::Edge(_)))
+        }
         && t.quad.iter().any(|q| (p[0] - q[0]).hypot(p[1] - q[1]) <= tol * 3.0)
 }
 
@@ -1770,8 +1972,12 @@ pub(crate) fn rotate_cursor_dir(app: &PhotocraftApp, p: [f64; 2]) -> Option<[f64
 }
 
 fn rotate_dir(t: &TransformSession, pv: Option<&TransformPreview>, p: [f64; 2], tol: f64) -> Option<[f64; 2]> {
-    // Content-Aware Scale's box only scales: no rotate arrow.
-    if !(p[0].is_finite() && p[1].is_finite()) || t.warp.is_some() || t.content_aware.is_some() || t.mode == TransformMode::Distort {
+    // Content-Aware Scale's box only scales, and Skew doesn't rotate: no rotate arrow.
+    if !(p[0].is_finite() && p[1].is_finite())
+        || t.warp.is_some()
+        || t.content_aware.is_some()
+        || matches!(t.mode, TransformMode::Distort | TransformMode::Skew)
+    {
         return None;
     }
     let rotating = pv.is_some_and(|pv| pv.gesture.is_some_and(|g| g.hit == Hit::Outside));
@@ -1812,7 +2018,7 @@ pub fn cursor(app: &PhotocraftApp, p: [f64; 2], quick_split: bool) -> Option<Cur
         return Some(if w.mesh.as_ref().and_then(|m| surface_at(m, p)).is_some() { CursorIcon::Grab } else { CursorIcon::Default });
     }
     let h = hit(t, p, tol);
-    if !distort_allows(t.mode, h) || (t.content_aware.is_some() && h == Hit::Outside) {
+    if !mode_allows(t.mode, h) || (t.content_aware.is_some() && h == Hit::Outside) {
         return Some(CursorIcon::Default);
     }
     if rotate_cursor_dir(app, p).is_some() {
@@ -1830,6 +2036,15 @@ pub fn cursor(app: &PhotocraftApp, p: [f64; 2], quick_split: bool) -> Option<Cur
     })
 }
 
+/// For each vertex of the preview's `n` × `n` grid over the unit square (row by row), whether it
+/// maps to the front side of `h`'s horizon. A Distort dragged past the horizon sends the rest of
+/// the image to the far side, where its cells would wrap round infinity; the preview leaves them
+/// out, as the committed warp does (#4863).
+fn front_vertices(h: &Homography, n: usize) -> Vec<bool> {
+    let front = h.front_side([0.0, 0.0, 1.0, 1.0]);
+    (0..=n).flat_map(|j| (0..=n).map(move |i| (i as f64 / n as f64, j as f64 / n as f64))).map(|(u, v)| front * h.w(u, v) > 1e-9).collect()
+}
+
 /// Warped preview of the moving pixels plus the box, handles and reference point.
 pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform) {
     let (Some(t), Some(pv)) = (&app.ui.transform, &app.transform_preview) else { return };
@@ -1845,7 +2060,17 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
         draw_warp(painter, xf, t, w, pv, guide);
         return;
     }
-    if let Some(h) = Homography::rect_to_quad([0.0, 0.0, 1.0, 1.0], t.quad) {
+    let ctx = painter.ctx();
+    let styled = styled_frame(app, xf.zoom * ctx.pixels_per_point(), ctx.input(|i| i.pointer.any_down())).and_then(|(s, frame)| s.texture(ctx, &frame));
+    if let Some((tex, r)) = styled {
+        let mut mesh = egui::Mesh::with_texture(tex);
+        for (x, y, u, v) in [(r[0], r[1], 0.0, 0.0), (r[2], r[1], 1.0, 0.0), (r[2], r[3], 1.0, 1.0), (r[0], r[3], 0.0, 1.0)] {
+            mesh.vertices.push(egui::epaint::Vertex { pos: pos2(x, y), uv: pos2(u, v), color: Color32::WHITE });
+        }
+        mesh.add_triangle(0, 1, 2);
+        mesh.add_triangle(0, 2, 3);
+        painter.add(clip_to_canvas(mesh, canvas_size(pv), |p| xf.to_screen(p.x, p.y)));
+    } else if let Some(h) = Homography::rect_to_quad([0.0, 0.0, 1.0, 1.0], t.quad) {
         // A 24×24 grid keeps perspective previews straight.
         let n = 24;
         let zoom = xf.zoom * painter.ctx().pixels_per_point();
@@ -1856,6 +2081,7 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
         };
         let mut mesh = egui::Mesh::with_texture(tex);
         let tint = Color32::from_white_alpha((pv.opacity.clamp(0.0, 1.0) * 255.0) as u8);
+        let ahead = front_vertices(&h, n);
         for j in 0..=n {
             for i in 0..=n {
                 let (u, v) = (i as f64 / n as f64, j as f64 / n as f64);
@@ -1866,8 +2092,12 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
         for j in 0..n {
             for i in 0..n {
                 let a = (j * (n + 1) + i) as u32;
-                mesh.add_triangle(a, a + 1, a + n as u32 + 2);
-                mesh.add_triangle(a, a + n as u32 + 2, a + n as u32 + 1);
+                for tri in [[a, a + 1, a + n as u32 + 2], [a, a + n as u32 + 2, a + n as u32 + 1]] {
+                    // A cell with a corner past the horizon would stretch across the canvas (#4863).
+                    if tri.iter().all(|&k| ahead[k as usize]) {
+                        mesh.add_triangle(tri[0], tri[1], tri[2]);
+                    }
+                }
             }
         }
         painter.add(clip_to_canvas(mesh, canvas_size(pv), |p| xf.to_screen(p.x, p.y)));
@@ -1875,6 +2105,9 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
     if let Some(a) = &pv.above {
         a.draw(painter, xf);
     }
+    if pv.committing.is_some() {
+        return;
+    }
     let accent = crate::theme::Tokens::get(painter.ctx()).accent;
     if let (Some(path), Some(h)) = (&pv.path, Homography::rect_to_quad(t.rect, t.quad)) {
         crate::vector_ui::draw_outline(
@@ -1917,6 +2150,29 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
     }
 }
 
+/// What the styled preview of the moving layer is drawn from (transform_fx.rs), at `zoom` screen
+/// pixels per document pixel. `None` for a layer without a style (also once it is switched off
+/// while the box is open) or a hidden one: the bare pixels are drawn instead. The style, opacity
+/// and fill are the layer's as they are now, so edits made while the box is open show.
+pub(crate) fn styled_frame(app: &PhotocraftApp, zoom: f32, dragging: bool) -> Option<(&crate::transform_fx::StyledPreview, crate::transform_fx::Frame<'_>)> {
+    let (t, pv) = (app.ui.transform.as_ref()?, app.transform_preview.as_ref()?);
+    let styled = pv.styled.as_ref().filter(|_| t.warp.is_none())?;
+    let st = app.session.active().filter(|st| st.doc.id == pv.doc.id)?;
+    let layer = st.doc.layer(LayerId(t.layer)).filter(|l| l.visible && photocraft_compose::effects::has_effects(l))?;
+    let frame = crate::transform_fx::Frame {
+        doc: &st.doc,
+        layer,
+        revision: st.revision,
+        texels: &pv.texture,
+        quad: t.quad,
+        quad_scale: quad_scale(t),
+        nearest: t.interpolation == "nearest",
+        zoom,
+        dragging,
+    };
+    Some((styled, frame))
+}
+
 /// The value shown beside the pointer while the box is dragged, like Photoshop's Show
 /// Transformation Values: the box's angle while rotating, its scale while resizing, the offset
 /// while moving.
@@ -2180,14 +2436,102 @@ fn quad_scale(t: &TransformSession) -> f32 {
     if s.is_finite() { s as f32 } else { 1.0 }
 }
 
-/// Scale (%), angle (°) and translation implied by the current quad (affine readout).
+/// W and H (%), the angle (°) and the horizontal skew (°) the options bar shows for the box.
 fn readout(t: &TransformSession) -> (f64, f64, f64, f64) {
-    let (w0, h0) = (t.rect[2] - t.rect[0], t.rect[3] - t.rect[1]);
-    let e = [t.quad[1][0] - t.quad[0][0], t.quad[1][1] - t.quad[0][1]];
-    let f = [t.quad[3][0] - t.quad[0][0], t.quad[3][1] - t.quad[0][1]];
-    let sx = (e[0].hypot(e[1]) / w0.max(1e-9)) * 100.0;
-    let sy = (f[0].hypot(f[1]) / h0.max(1e-9)) * 100.0;
-    (sx, sy, e[1].atan2(e[0]).to_degrees(), 0.0)
+    let p = Parts::of(t);
+    (p.sx * 100.0, p.sy.abs() * 100.0, p.angle.to_degrees(), p.skew_h.to_degrees())
+}
+
+/// The box's affine part read as Photoshop's options bar does: the frame scaled (W, H), skewed
+/// (H, V) and then rotated about the reference point. Angles are radians; positive turns
+/// clockwise on screen, so a positive H skew leans the box's sides like the angle field would
+/// turn them, and a positive V skew its top and bottom.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Parts {
+    sx: f64,
+    /// Negative when the box is flipped vertically relative to its rotation.
+    sy: f64,
+    angle: f64,
+    skew_h: f64,
+    skew_v: f64,
+}
+
+/// The skew fields' reach: a skew of ±90° would flatten the box.
+const SKEW_LIMIT_DEG: f32 = 89.0;
+
+impl Parts {
+    /// The box's columns: where the frame's unit X and Y edges went (from the top-left corner).
+    fn columns(t: &TransformSession) -> Option<[[f64; 2]; 2]> {
+        let (w0, h0) = (t.rect[2] - t.rect[0], t.rect[3] - t.rect[1]);
+        if w0.abs() < 1e-9 || h0.abs() < 1e-9 {
+            return None;
+        }
+        let q = &t.quad;
+        let m = [[(q[1][0] - q[0][0]) / w0, (q[1][1] - q[0][1]) / w0], [(q[3][0] - q[0][0]) / h0, (q[3][1] - q[0][1]) / h0]];
+        m.iter().flatten().all(|v| v.is_finite()).then_some(m)
+    }
+
+    /// The box as scale, skew and rotation, keeping the session's typed V skew (any box can be
+    /// written with any V skew short of ±90°).
+    fn of(t: &TransformSession) -> Parts {
+        let skew_v = t.skew_v.to_radians();
+        let none = Parts { sx: 1.0, sy: 1.0, angle: 0.0, skew_h: 0.0, skew_v };
+        Parts::columns(t).map_or(none, |m| Parts::from_columns(m, skew_v))
+    }
+
+    fn from_columns([c0, c1]: [[f64; 2]; 2], skew_v: f64) -> Parts {
+        // X edge = sx · R(angle) · (1, tan v): its direction is the angle plus v.
+        let angle = c0[1].atan2(c0[0]) - skew_v;
+        let sx = c0[0].hypot(c0[1]) * skew_v.cos();
+        // Y edge = sy · R(angle) · (−tan h, 1).
+        let (gx, gy) = unturn(c1, angle);
+        let skew_h = if gy.abs() < 1e-12 { 0.0 } else { (-gx / gy).atan() };
+        Parts { sx, sy: gy, angle, skew_h, skew_v }
+    }
+
+    fn columns_of(self) -> [[f64; 2]; 2] {
+        let (sn, cs) = self.angle.sin_cos();
+        let rot = |x: f64, y: f64| [x * cs - y * sn, x * sn + y * cs];
+        let c0 = rot(self.sx, self.sx * self.skew_v.tan());
+        let c1 = rot(-self.sy * self.skew_h.tan(), self.sy);
+        [c0, c1]
+    }
+}
+
+/// `c` turned back by `angle` (radians).
+fn unturn(c: [f64; 2], angle: f64) -> (f64, f64) {
+    let (sn, cs) = angle.sin_cos();
+    (c[0] * cs + c[1] * sn, -c[0] * sn + c[1] * cs)
+}
+
+/// Sets the box's H and V skew (degrees), keeping its scale, angle and reference point: the
+/// options bar's skew fields.
+fn skew_about_pivot(app: &mut PhotocraftApp, skew_h: f64, skew_v: f64) {
+    let Some(s) = app.ui.transform.as_mut() else { return };
+    let Some(m) = Parts::columns(s) else { return };
+    let limit = f64::from(SKEW_LIMIT_DEG);
+    let (skew_h, skew_v) = (skew_h.clamp(-limit, limit), skew_v.clamp(-limit, limit));
+    let from = Parts::from_columns(m, s.skew_v.to_radians());
+    let to = Parts { skew_h: skew_h.to_radians(), skew_v: skew_v.to_radians(), ..from }.columns_of();
+    // The map from the old box to the new one: to · m⁻¹.
+    let det = m[0][0] * m[1][1] - m[1][0] * m[0][1];
+    if det.abs() < 1e-12 {
+        return;
+    }
+    let inv = [[m[1][1] / det, -m[0][1] / det], [-m[1][0] / det, m[0][0] / det]];
+    let l = |x: f64, y: f64| {
+        let (u, v) = (inv[0][0] * x + inv[1][0] * y, inv[0][1] * x + inv[1][1] * y);
+        [to[0][0] * u + to[1][0] * v, to[0][1] * u + to[1][1] * v]
+    };
+    let c = s.pivot;
+    let quad = s.quad.map(|q| {
+        let d = l(q[0] - c[0], q[1] - c[1]);
+        [c[0] + d[0], c[1] + d[1]]
+    });
+    if quad.iter().flatten().all(|v| v.is_finite()) {
+        s.quad = quad;
+        s.skew_v = skew_v;
+    }
 }
 
 /// Width of the mode, cancel and commit cluster kept on the right of the options bar.
@@ -2273,7 +2617,7 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
 
 fn transform_fields(app: &mut PhotocraftApp, ui: &mut egui::Ui, t: &TransformSession) {
     let tk = crate::theme::Tokens::get(ui.ctx());
-    let (_, _, angle, _) = readout(t);
+    let (_, _, angle, skew_h) = readout(t);
     let lbl = |ui: &mut egui::Ui, s: &str| {
         ui.label(egui::RichText::new(s).color(tk.text_dim).size(12.0));
     };
@@ -2286,6 +2630,16 @@ fn transform_fields(app: &mut PhotocraftApp, ui: &mut egui::Ui, t: &TransformSes
     if crate::widgets::value_field(ui, &mut a, -180.0..=180.0, "°", 60.0).changed() {
         rotate_about_pivot(app, (a as f64 - angle).to_radians());
     }
+    // Photoshop's H and V skew fields: the box's sides lean by H, its top and bottom by V.
+    let (mut h, mut v) = (skew_h as f32, t.skew_v as f32);
+    let lim = -SKEW_LIMIT_DEG..=SKEW_LIMIT_DEG;
+    lbl(ui, "H:");
+    let rh = crate::widgets::value_field(ui, &mut h, lim.clone(), "°", 56.0).on_hover_text(tl!("Set horizontal skew"));
+    lbl(ui, "V:");
+    let rv = crate::widgets::value_field(ui, &mut v, lim, "°", 56.0).on_hover_text(tl!("Set vertical skew"));
+    if rh.changed() || rv.changed() {
+        skew_about_pivot(app, f64::from(h), f64::from(v));
+    }
     crate::widgets::vline(ui, 22.0);
     lbl(ui, tl!("Interpolation:"));
     let mut interp = t.interpolation.clone();
@@ -2330,11 +2684,9 @@ pub(crate) fn position_size_fields(app: &mut PhotocraftApp, ui: &mut egui::Ui, t
     let size_w = if u.unit == photocraft_engine::prefs::Unit::Percent { 66.0 } else { 84.0 };
     lbl(ui, "W:");
     let rw = crate::widgets::value_field_prec(ui, &mut w, -wlim_u..=wlim_u, suffix, size_w, places);
-    let link_id = egui::Id::new("transform-link");
-    let mut link: bool = ui.data(|d| d.get_temp(link_id)).unwrap_or(true);
+    let link = !app.ui.transform_unlinked;
     if crate::icons::button(ui, if link { "link" } else { "unlink" }, 22.0, link, tl!("Maintain aspect ratio")).clicked() {
-        link = !link;
-        ui.data_mut(|d| d.insert_temp(link_id, link));
+        app.ui.transform_unlinked = link;
     }
     lbl(ui, "H:");
     let rh = crate::widgets::value_field_prec(ui, &mut h, -hlim_u..=hlim_u, suffix, size_w, places);
@@ -2618,6 +2970,7 @@ mod tests {
             made: None,
             mode: Default::default(),
             content_aware: None,
+            skew_v: 0.0,
         }
     }
 
@@ -2783,6 +3136,58 @@ mod tests {
         assert!(h.state().ui.transform.as_ref().unwrap().warp.as_ref().unwrap().is_identity());
     }
 
+    fn eq6(a: f64, b: f64) -> bool {
+        (a - b).abs() < 1e-6
+    }
+
+    /// Scale, skew and rotation read back exactly from the box they make, flips included.
+    #[test]
+    fn parts_round_trip() {
+        for (sx, sy, angle, h, v) in [(1.0, 1.0, 0.0, 0.0, 0.0), (1.5, 0.5, 30.0, 20.0, 0.0), (0.8, -1.2, -120.0, -35.0, 15.0), (2.0, 1.0, 179.0, 0.0, -60.0)] {
+            let p = Parts { sx, sy, angle: f64::to_radians(angle), skew_h: f64::to_radians(h), skew_v: f64::to_radians(v) };
+            let back = Parts::from_columns(p.columns_of(), p.skew_v);
+            for (a, b) in [(back.sx, p.sx), (back.sy, p.sy), (back.angle, p.angle), (back.skew_h, p.skew_h)] {
+                assert!(eq6(a, b), "{p:?} read back as {back:?}");
+            }
+        }
+    }
+
+    /// A box sheared sideways keeps W, H and the angle; only H skew moves (it used to read as a
+    /// taller box).
+    #[test]
+    fn a_sheared_box_reads_as_horizontal_skew() {
+        let mut t = session();
+        // The 100×50 frame with its bottom slid 50·tan 20° to the left: a positive H skew.
+        let d = 50.0 * 20f64.to_radians().tan();
+        t.quad = [[0.0, 0.0], [100.0, 0.0], [100.0 - d, 50.0], [-d, 50.0]];
+        let (w, h, angle, skew) = readout(&t);
+        assert!(eq6(w, 100.0) && eq6(h, 100.0) && eq6(angle, 0.0), "{w} {h} {angle}");
+        assert!(eq6(skew, 20.0), "{skew}");
+    }
+
+    /// Typing H and V skews leans the box about the reference point; the angle, W and H fields keep
+    /// their values, and V stays as typed.
+    #[test]
+    fn skew_fields_lean_the_box_about_the_reference_point() {
+        let t = type_into_bar_field(5, "20");
+        let (w, h, angle, skew) = readout(&t);
+        assert!(eq6(skew, 20.0) && eq6(angle, 0.0) && eq6(w, 100.0) && eq6(h, 100.0), "{w} {h} {angle} {skew}");
+        // The pivot (50, 25) stays put: the top edge slid right, the bottom left, by the same amount.
+        let d = 25.0 * 20f64.to_radians().tan();
+        assert!(eq6(t.quad[0][0], d) && eq6(t.quad[0][1], 0.0) && eq6(t.quad[3][0], -d) && eq6(t.quad[3][1], 50.0), "{:?}", t.quad);
+
+        let t = type_into_bar_field(6, "-10");
+        assert!(eq6(t.skew_v, -10.0));
+        let (w, h, angle, skew) = readout(&t);
+        assert!(eq6(skew, 0.0) && eq6(angle, 0.0) && eq6(w, 100.0) && eq6(h, 100.0), "{w} {h} {angle} {skew}");
+        // The right side rose: tan(−10°) per pixel across, about the pivot.
+        let d = 50.0 * (-10f64).to_radians().tan();
+        assert!(eq6(t.quad[1][1], d) && eq6(t.quad[0][1], -d), "{:?}", t.quad);
+        // A skew past ±90° would flatten the box: the field stops at the limit.
+        let t = type_into_bar_field(5, "120");
+        assert!(eq6(readout(&t).3, f64::from(SKEW_LIMIT_DEG)), "{}", readout(&t).3);
+    }
+
     /// Types `text` + Enter into the `n`th numeric field of the transform bar (X, Y, W, H, angle…).
     fn type_into_bar_field(n: usize, text: &str) -> TransformSession {
         type_into_bar_field_with(|_| {}, n, text)
@@ -2964,6 +3369,60 @@ mod tests {
         apply_drag(s, g, to, mods);
     }
 
+    /// A handle drag in Edit › Transform `mode`, as the canvas applies it (on a pixel layer).
+    fn drag_in(mode: TransformMode, from: [f64; 2], to: [f64; 2], mods: egui::Modifiers) -> [[f64; 2]; 4] {
+        drag_on(mode, false, from, to, mods)
+    }
+
+    fn drag_on(mode: TransformMode, type_layer: bool, from: [f64; 2], to: [f64; 2], mods: egui::Modifiers) -> [[f64; 2]; 4] {
+        let mut s = session();
+        let g = Gesture { hit: hit(&s, from, 8.0), start: from, quad0: s.quad, pivot0: s.pivot };
+        apply_mode_drag(&mut s, g, to, mode, type_layer, mods);
+        s.quad
+    }
+
+    /// Skew on editable type, checked in Photoshop: a corner can't move alone (type stays a
+    /// parallelogram), so it slides its whole edge: the top or bottom edge for a mostly
+    /// horizontal drag, the left or right one for a mostly vertical drag. ⌥ moves the opposite
+    /// edge the other way. Side handles are as on any layer.
+    #[test]
+    fn skew_mode_on_type_slides_the_corners_edge() {
+        let (skew, none) = (TransformMode::Skew, egui::Modifiers::NONE);
+        assert_eq!(drag_on(skew, true, [100.0, 0.0], [110.0, 3.0], none), [[10.0, 0.0], [110.0, 0.0], [100.0, 50.0], [0.0, 50.0]]);
+        assert_eq!(drag_on(skew, true, [100.0, 0.0], [102.0, -9.0], none), [[0.0, 0.0], [100.0, -9.0], [100.0, 41.0], [0.0, 50.0]]);
+        assert_eq!(drag_on(skew, true, [100.0, 0.0], [110.0, 3.0], egui::Modifiers::ALT), [[10.0, 0.0], [110.0, 0.0], [90.0, 50.0], [-10.0, 50.0]]);
+        assert_eq!(drag_on(skew, true, [50.0, 0.0], [62.0, 7.0], none), [[12.0, 0.0], [112.0, 0.0], [100.0, 50.0], [0.0, 50.0]]);
+    }
+
+    /// Edit › Transform › Skew, checked in Photoshop (#3437): a corner moves alone, horizontally or
+    /// vertically (whichever way the drag mostly goes); the top and bottom handles slide only
+    /// horizontally, the left and right ones only vertically; ⌥ moves the opposite corner or edge
+    /// the other way. Nothing scales.
+    #[test]
+    fn skew_mode_moves_a_corner_or_an_edge_along_one_axis() {
+        let skew = TransformMode::Skew;
+        let none = egui::Modifiers::NONE;
+        // Corner (top right), mostly horizontal, then mostly vertical: only that corner moves.
+        assert_eq!(drag_in(skew, [100.0, 0.0], [110.0, 3.0], none), [[0.0, 0.0], [110.0, 0.0], [100.0, 50.0], [0.0, 50.0]]);
+        assert_eq!(drag_in(skew, [100.0, 0.0], [102.0, -9.0], none), [[0.0, 0.0], [100.0, -9.0], [100.0, 50.0], [0.0, 50.0]]);
+        // Top edge: horizontal only, both its corners.
+        assert_eq!(drag_in(skew, [50.0, 0.0], [62.0, 7.0], none), [[12.0, 0.0], [112.0, 0.0], [100.0, 50.0], [0.0, 50.0]]);
+        // Left edge: vertical only.
+        assert_eq!(drag_in(skew, [0.0, 25.0], [6.0, 33.0], none), [[0.0, 8.0], [100.0, 0.0], [100.0, 50.0], [0.0, 58.0]]);
+        // ⌥: the opposite corner, and the opposite edge, go the other way.
+        let alt = egui::Modifiers::ALT;
+        assert_eq!(drag_in(skew, [100.0, 0.0], [110.0, 3.0], alt), [[0.0, 0.0], [110.0, 0.0], [100.0, 50.0], [-10.0, 50.0]]);
+        assert_eq!(drag_in(skew, [50.0, 0.0], [62.0, 7.0], alt), [[12.0, 0.0], [112.0, 0.0], [88.0, 50.0], [-12.0, 50.0]]);
+        // ⇧ changes nothing in Skew mode.
+        let shift = egui::Modifiers::SHIFT;
+        assert_eq!(drag_in(skew, [100.0, 0.0], [110.0, 3.0], shift), drag_in(skew, [100.0, 0.0], [110.0, 3.0], none));
+        assert_eq!(drag_in(skew, [50.0, 0.0], [62.0, 7.0], shift), drag_in(skew, [50.0, 0.0], [62.0, 7.0], none));
+        // A drag outside the box doesn't rotate it in Skew mode.
+        assert_eq!(drag_in(skew, [130.0, 25.0], [120.0, 60.0], none), corners([0.0, 0.0, 100.0, 50.0]));
+        // Free Transform is unchanged: a corner scales.
+        assert_ne!(drag_in(TransformMode::Free, [100.0, 0.0], [110.0, 3.0], none)[2], [100.0, 50.0]);
+    }
+
     fn close(a: [[f64; 2]; 4], b: [[f64; 2]; 4]) -> bool {
         a.iter().flatten().zip(b.iter().flatten()).all(|(x, y)| (x - y).abs() < 1e-6)
     }
@@ -3231,6 +3690,30 @@ mod tests {
         assert!(app.ui.transform.is_none() && app.transform_preview.is_none());
     }
 
+    /// A commit the engine refuses (here a collapsed box; a result over the pixel budget, #3773, is
+    /// refused the same way) shows the reason and keeps the box open, unchanged; picking another
+    /// tool then ends it.
+    #[test]
+    fn a_refused_commit_keeps_the_box_open() {
+        let ctx = egui::Context::default();
+        let mut app = app_with_square(64, photocraft_geom::Rect::new(8, 8, 24, 24));
+        let (revision, steps) = (app.session.active().unwrap().revision, app.session.active().unwrap().history.past_len());
+        begin(&mut app, &ctx).unwrap();
+        if let Some(t) = app.ui.transform.as_mut() {
+            t.quad = [[16.0, 16.0]; 4];
+        }
+        commit(&mut app);
+        let t = app.ui.transform.as_ref().expect("the box stays open");
+        assert_eq!(t.quad, [[16.0, 16.0]; 4], "as the user left it");
+        assert!(app.transform_preview.is_some(), "with its preview");
+        assert!(app.ui.status.contains("collapses"), "{}", app.ui.status);
+        let st = app.session.active().unwrap();
+        assert_eq!((st.revision, st.history.past_len()), (revision, steps), "the document was not changed");
+        app.ui.tool = if app.ui.tool == Tool::Brush { Tool::Move } else { Tool::Brush };
+        end_if_left(&mut app);
+        assert!(app.ui.transform.is_none() && app.transform_preview.is_none(), "another tool ends it");
+    }
+
     /// #352: ⌥⌘T transforms a copy. OK leaves the original and a moved copy as one history step;
     /// Cancel leaves no copy and nothing to redo; with a selection the copy holds the selected
     /// pixels only.
@@ -3554,12 +4037,45 @@ mod tests {
         assert_eq!(app.ui.transform.as_ref().unwrap().mode, TransformMode::Free);
     }
 
+    /// #3941: Edit › Transform › Rotate must rotate from a corner handle, not scale.
+    #[test]
+    fn rotate_mode_turns_the_box_from_a_corner_handle() {
+        let mut app = app_with_square(64, photocraft_geom::Rect::new(8, 8, 24, 24));
+        app.ui.extras.snap = false;
+        let ctx = egui::Context::default();
+        crate::menus::invoke(&mut app, &ctx, "edit.transform.rotate", json!({})).unwrap();
+        assert_eq!(app.ui.transform.as_ref().unwrap().mode, TransformMode::Rotate);
+        let q0 = app.ui.transform.as_ref().unwrap().quad;
+        press_drag(&mut app, q0[1], [q0[1][0], q0[1][1] + 16.0], egui::Modifiers::NONE);
+        let q = app.ui.transform.as_ref().unwrap().quad;
+        let w0 = (q0[1][0] - q0[0][0]).hypot(q0[1][1] - q0[0][1]);
+        let w = (q[1][0] - q[0][0]).hypot(q[1][1] - q[0][1]);
+        assert!((w - w0).abs() < 1e-6, "side length stays {w0}, got {w}: {q:?}");
+        assert!((q[0][1] - q[1][1]).abs() > 1.0, "the box rotated, not scaled: {q:?}");
+        crate::menus::invoke(&mut app, &ctx, "edit.transform.scale", json!({})).unwrap();
+        assert_eq!(app.ui.transform.as_ref().unwrap().mode, TransformMode::Free);
+    }
+
     fn near2(a: Option<[f64; 2]>, b: [f64; 2]) -> bool {
         a.is_some_and(|a| (a[0] - b[0]).abs() < 1e-9 && (a[1] - b[1]).abs() < 1e-9)
     }
 
     /// #1767: just outside a corner is the rotate zone: the OS pointer hides for the drawn curved
     /// arrow, which bends round that corner.
+    #[test]
+    fn the_preview_leaves_out_cells_past_the_horizon() {
+        // #4863: the bottom corners pulled in and one dragged far out: a concave quad whose
+        // source straddles the horizon. Its cells there are left out; an ordinary quad keeps all.
+        let past = Homography::rect_to_quad([0.0, 0.0, 1.0, 1.0], [[0.0, 0.0], [300.0, 0.0], [60.0, 60.0], [0.0, 300.0]]).unwrap();
+        let ahead = front_vertices(&past, 24);
+        assert!(ahead.iter().any(|a| *a) && ahead.iter().any(|a| !*a), "some of the grid is past the horizon");
+        // Three corners are on one side (drawn); the top-left one is past the horizon.
+        assert!(ahead[24 * 25 + 24] && ahead[24] && ahead[24 * 25], "the three corners in front are drawn");
+        assert!(!ahead[0], "the corner past the horizon is left out");
+        let plain = Homography::rect_to_quad([0.0, 0.0, 1.0, 1.0], [[0.0, 0.0], [300.0, 0.0], [280.0, 260.0], [0.0, 300.0]]).unwrap();
+        assert!(front_vertices(&plain, 24).iter().all(|a| *a));
+    }
+
     #[test]
     fn hovering_just_outside_a_corner_asks_for_the_rotate_cursor() {
         let mut app = app_with_square(256, photocraft_geom::Rect::new(32, 32, 160, 160));
@@ -3670,6 +4186,41 @@ mod tests {
         }
     }
 
+    /// #4174: turning off the options bar's Maintain Aspect Ratio link frees the handles too, as in
+    /// Photoshop: a plain corner or edge drag stretches one way, ⇧ keeps the proportions. Linked
+    /// (the default) is unchanged, and so is the legacy preference.
+    #[test]
+    fn the_aspect_link_decides_whether_handle_drags_keep_proportions() {
+        let (none, shift) = (egui::Modifiers::NONE, egui::Modifiers::SHIFT);
+        for (unlinked, legacy, mods, proportional) in
+            [(false, false, none, true), (true, false, none, false), (true, false, shift, true), (true, true, none, false)]
+        {
+            for at_edge in [false, true] {
+                let mut app = app_with_square(64, photocraft_geom::Rect::new(8, 8, 24, 24));
+                app.ui.extras.snap = false;
+                app.ui.transform_unlinked = unlinked;
+                app.session.prefs.edit(|p| p.general.use_legacy_free_transform = legacy);
+                begin(&mut app, &egui::Context::default()).unwrap();
+                let q0 = app.ui.transform.as_ref().unwrap().quad;
+                let from = if at_edge { [q0[1][0], (q0[1][1] + q0[2][1]) / 2.0] } else { q0[2] };
+                press_drag(&mut app, from, [from[0] + 16.0, from[1]], mods);
+                let q = app.ui.transform.as_ref().unwrap().quad;
+                let (w, h) = (q[2][0] - q[0][0], q[2][1] - q[0][1]);
+                let case = format!("unlinked {unlinked}, legacy {legacy}, shift {}, edge {at_edge}: {w} × {h}", mods.shift);
+                if legacy && at_edge {
+                    // Legacy edges always stretch their one axis.
+                    assert!((w - 32.0).abs() < 1e-6 && (h - 16.0).abs() < 1e-6, "{case}");
+                } else {
+                    assert_eq!((w - h).abs() < 1e-6, proportional, "{case}");
+                    assert!((w - 32.0).abs() < 1e-6, "{case}");
+                }
+            }
+        }
+        // ⌘ gestures (skew, distort) are left alone.
+        assert!(!unlinked_mods(true, false, Hit::Corner(0), egui::Modifiers::COMMAND).shift);
+        assert!(!unlinked_mods(true, false, Hit::Inside, none).shift);
+    }
+
     #[test]
     fn right_click_while_transforming_switches_the_mode() {
         let mut app = app_with_square(64, photocraft_geom::Rect::new(8, 8, 24, 24));
@@ -4197,7 +4748,7 @@ mod tests {
             let st = app.session.active().unwrap();
             let id = st.active_layer.unwrap();
             let b = photocraft_geom::Rect::new(8, 8, 24, 24);
-            let (img, _) = preview_image(&st.doc, id, None, b, 4096);
+            let (img, _) = preview_image(&st.doc, id, None, b, 4096, false);
             // Texel x = doc x − 8: x 10 is hidden by the mask, x 20 shows.
             assert_eq!(texel_alpha(&img, 12, 4), 255);
             assert_eq!(texel_alpha(&img, 2, 4), if linked { 0 } else { 255 }, "linked={linked}");
@@ -4212,11 +4763,37 @@ mod tests {
         let id = st.active_layer.unwrap();
         let (lifted, _) = photocraft_engine::transform_cmds::split_selected(st.doc.layer(id).unwrap().surface().unwrap(), &sel).unwrap();
         let b = photocraft_geom::Rect::new(8, 8, 20, 24);
-        let (img, _) = preview_image(&st.doc, id, Some(&lifted), b, 4096);
+        let (img, _) = preview_image(&st.doc, id, Some(&lifted), b, 4096, false);
         assert_eq!(texel_alpha(&img, 2, 4), 0, "masked");
         assert_eq!(texel_alpha(&img, 10, 4), 255, "revealed");
     }
 
+    #[test]
+    fn preview_feathers_the_linked_mask() {
+        // A feathered pixel mask without a vector mask: the compositor softens the edge at x 16,
+        // so the moving texels must be soft there too, not hard until the commit (#4560).
+        let mut app = masked_app(true);
+        app.session
+            .edit("feather", |doc, a| {
+                doc.layer_mut(a.unwrap()).unwrap().mask.as_mut().unwrap().feather = 4.0;
+                Ok(())
+            })
+            .unwrap();
+        let st = app.session.active().unwrap();
+        let id = st.active_layer.unwrap();
+        let b = photocraft_geom::Rect::new(8, 8, 24, 24);
+        let (img, _) = preview_image(&st.doc, id, None, b, 4096, false);
+        // Texel x 7 = doc x 15, just inside the hidden half; texel x 8 = doc x 16, just revealed.
+        assert!(texel_alpha(&img, 7, 4) > 0, "the feather reaches into the hidden side");
+        assert!(texel_alpha(&img, 8, 4) < 255, "the feather reaches into the revealed side");
+        // The same values the compositor masks the committed layer with.
+        let m = photocraft_compose::masks::combined_mask(st.doc.layer(id).unwrap(), b).unwrap();
+        for x in [6usize, 7, 8, 9, 15] {
+            let want = (m.sample_channel(8 + x as i32, 12, 0) * 255.0).round() as i32;
+            assert!((i32::from(texel_alpha(&img, x, 4)) - want).abs() <= 1, "texel {x}");
+        }
+    }
+
     #[test]
     fn targeted_unlinked_mask_transforms_alone_through_the_box() {
         let mut app = masked_app(false);
diff --git a/crates/ui-egui/src/transform_type_tests.rs b/crates/ui-egui/src/transform_type_tests.rs
index ea3c128a18..dcbbb70b3c 100644
--- a/crates/ui-egui/src/transform_type_tests.rs
+++ b/crates/ui-egui/src/transform_type_tests.rs
@@ -52,6 +52,7 @@ fn type_layers_offer_free_transform_but_not_distort_or_perspective() {
         pasteboard: false,
         anchor: None,
         text: false,
+        spelling: None,
     };
     assert!(crate::canvas_tool_menu::available(&app, &menu, "edit.freeTransform"));
     assert!(!crate::canvas_tool_menu::available(&app, &menu, "edit.transform.distort"));
diff --git a/crates/ui-egui/src/transform_undo_tests.rs b/crates/ui-egui/src/transform_undo_tests.rs
index d9ffdf9c66..832b221900 100644
--- a/crates/ui-egui/src/transform_undo_tests.rs
+++ b/crates/ui-egui/src/transform_undo_tests.rs
@@ -12,7 +12,7 @@ use crate::state::Tool;
 
 /// A 400 × 300 document with a 100 × 60 red rectangle on its own layer at (100, 100), the Move
 /// tool active, at 100 %.
-fn harness() -> Harness<'static, PhotocraftApp> {
+pub(crate) fn harness() -> Harness<'static, PhotocraftApp> {
     harness_tool(Tool::Move)
 }
 
@@ -63,7 +63,7 @@ fn screen(h: &Harness<'static, PhotocraftApp>, p: [f64; 2]) -> Pos2 {
 }
 
 /// Press at document point `from`, drag to `to` in a few steps and release.
-fn drag(h: &mut Harness<'static, PhotocraftApp>, from: [f64; 2], to: [f64; 2]) {
+pub(crate) fn drag(h: &mut Harness<'static, PhotocraftApp>, from: [f64; 2], to: [f64; 2]) {
     let (a, b) = (screen(h, from), screen(h, to));
     h.event(egui::Event::PointerMoved(a));
     h.run_steps(1);
@@ -77,7 +77,7 @@ fn drag(h: &mut Harness<'static, PhotocraftApp>, from: [f64; 2], to: [f64; 2]) {
     h.run_steps(3);
 }
 
-fn begin(h: &mut Harness<'static, PhotocraftApp>) {
+pub(crate) fn begin(h: &mut Harness<'static, PhotocraftApp>) {
     let ctx = h.ctx.clone();
     crate::menus::invoke(h.state_mut(), &ctx, "edit.freeTransform", json!({})).unwrap();
     h.run_steps(2);
@@ -241,6 +241,33 @@ fn the_hand_tool_does_not_steal_a_free_transform_drag() {
     assert!(width(&h) > 150, "the committed resize applied: {}", width(&h));
 }
 
+/// With the Zoom tool selected, a Free Transform drag resizes the box rather than zooming the view:
+/// the open box owns the pointer, as it does for the Hand (#4799).
+#[test]
+fn the_zoom_tool_does_not_steal_a_free_transform_drag() {
+    let mut h = harness_tool(Tool::Zoom);
+    begin(&mut h);
+    let q0 = quad(&h);
+    let (zoom0, center0) = (h.state().ui.views[0].zoom, h.state().ui.views[0].center);
+    let inside = screen(&h, [150.0, 130.0]);
+    h.event(egui::Event::PointerMoved(inside));
+    h.run_steps(1);
+    for pressed in [true, false] {
+        h.event(egui::Event::PointerButton { pos: inside, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+        h.run_steps(1);
+    }
+    h.run_steps(2);
+    assert_eq!(h.state().ui.views[0].zoom, zoom0, "a click inside the box did not zoom");
+    drag(&mut h, q0[2], [300.0, 220.0]);
+    let q1 = quad(&h);
+    assert!(!close(q1, q0), "the drag scaled the box, not the view: {q1:?}");
+    assert_eq!(h.state().ui.views[0].zoom, zoom0, "the Zoom tool did not zoom");
+    assert_eq!(h.state().ui.views[0].center, center0, "the Zoom tool did not move the view");
+    key(&mut h, Modifiers::NONE, Key::Enter);
+    assert!(h.state().ui.transform.is_none(), "the transform committed");
+    assert!(width(&h) > 150, "the committed resize applied: {}", width(&h));
+}
+
 /// With the (freehand) Lasso selected, a Free Transform of a lasso selection follows the drag: the
 /// Lasso reads its own pointer events, and dropped the moves and release of a drag it hadn't
 /// started, so the box never changed (#2153).
@@ -279,6 +306,32 @@ fn holding_space_still_pans_while_transforming() {
     assert_ne!(h.state().ui.views[0].center, center0, "the view panned instead");
 }
 
+#[test]
+fn transform_preview_stays_visible_while_panning() {
+    let mut h = harness();
+    begin(&mut h);
+    let texture = h.state().transform_preview.as_ref().unwrap().texture.pick(&h.ctx, 1.0, 1.0, false).0;
+    let has_preview = |h: &Harness<'static, PhotocraftApp>| {
+        h.output().shapes.iter().any(|clipped| matches!(&clipped.shape, egui::epaint::Shape::Mesh(mesh) if mesh.texture_id == texture))
+    };
+    assert!(has_preview(&h), "the transformed pixels are visible before panning");
+
+    let center0 = h.state().ui.views[0].center;
+    let from = screen(&h, [200.0, 160.0]);
+    let to = from + vec2(50.0, 40.0);
+    h.event(egui::Event::Key { key: Key::Space, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
+    h.run_steps(1);
+    h.event(egui::Event::PointerMoved(from));
+    h.run_steps(1);
+    h.event(egui::Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+    h.run_steps(1);
+    h.event(egui::Event::PointerMoved(to));
+    h.run_steps(1);
+
+    assert_ne!(h.state().ui.views[0].center, center0, "the held Hand panned the view");
+    assert!(has_preview(&h), "the transformed layer stays visible during the pan");
+}
+
 /// A transform started by dragging a Move-tool control: that first drag is undoable too.
 #[test]
 fn the_first_drag_from_the_move_tools_controls_undoes() {
diff --git a/crates/ui-egui/src/type_font_picker_tests.rs b/crates/ui-egui/src/type_font_picker_tests.rs
index 2fc600511f..f17032523d 100644
--- a/crates/ui-egui/src/type_font_picker_tests.rs
+++ b/crates/ui-egui/src/type_font_picker_tests.rs
@@ -463,3 +463,30 @@ fn font_menu_rows_search_both_names_and_sort_by_label() {
     assert_eq!(rows(Some(&labels), "雅黑"), [("Microsoft YaHei".to_string(), "微软雅黑".to_string())]);
     assert!(rows(Some(&labels), "nothing").is_empty());
 }
+
+#[test]
+fn wheel_over_the_closed_font_button_steps_through_the_families() {
+    let mut h = harness();
+    let button = h.query_all_by_role(Role::ComboBox).next().unwrap().rect().center();
+    h.hover_at(button);
+    h.run();
+    let wheel = |h: &mut Harness<'static, State>, y: f32| {
+        h.event(egui::Event::MouseWheel { unit: egui::MouseWheelUnit::Line, delta: vec2(0.0, y), phase: egui::TouchPhase::Move, modifiers: Modifiers::NONE });
+        h.run();
+    };
+    wheel(&mut h, -2.0);
+    assert_eq!(h.state().current, "Family 02", "two notches down pick the second next family");
+    assert!(popup_rect(&h).is_none(), "the list stays closed");
+    wheel(&mut h, 1.0);
+    assert_eq!(h.state().current, "Family 01");
+    wheel(&mut h, 5.0);
+    assert_eq!(h.state().current, "Family 00", "stops at the first family");
+}
+
+#[test]
+fn wheel_family_index_clamps_to_the_ends() {
+    assert_eq!(super::wheel_family_index(0, 3, -5.0), Some(2));
+    assert_eq!(super::wheel_family_index(1, 3, 1.0), Some(0));
+    assert_eq!(super::wheel_family_index(1, 3, 0.0), None);
+    assert_eq!(super::wheel_family_index(0, 0, -1.0), None);
+}
diff --git a/crates/ui-egui/src/type_tool.rs b/crates/ui-egui/src/type_tool.rs
index d7015a37a3..f00fb57157 100644
--- a/crates/ui-egui/src/type_tool.rs
+++ b/crates/ui-egui/src/type_tool.rs
@@ -52,7 +52,8 @@ fn to_text(aff: &Affine, x: f64, y: f64) -> (f32, f32) {
     (p.x as f32, p.y as f32)
 }
 
-/// Topmost visible type layer whose laid-out text contains the document point.
+/// Topmost shown type layer (it and every group around it visible, #4320) whose laid-out text
+/// contains the document point.
 fn hit_layer(app: &mut PhotocraftApp, x: f64, y: f64) -> Option<LayerId> {
     let doc = app.session.active()?.doc.clone();
     let slop = 6.0 / app.point_zoom().max(0.01);
@@ -61,7 +62,7 @@ fn hit_layer(app: &mut PhotocraftApp, x: f64, y: f64) -> Option<LayerId> {
     let mut ids: Vec<LayerId> = doc
         .walk()
         .into_iter()
-        .filter(|(_, _, l)| (l.visible || editing == Some(l.id)) && matches!(l.content, LayerContent::Text(_)))
+        .filter(|(path, _, l)| matches!(l.content, LayerContent::Text(_)) && (editing == Some(l.id) || doc.shown_at(path)))
         .map(|(_, _, l)| l.id)
         .collect();
     ids.reverse(); // walk() is bottom-up; hit the topmost first
@@ -150,6 +151,11 @@ pub fn edit_at(app: &mut PhotocraftApp, x: f64, y: f64) -> bool {
 }
 
 fn hit_offset(app: &mut PhotocraftApp, id: LayerId, x: f64, y: f64) -> usize {
+    offset_at(app, id, x, y)
+}
+
+/// The character offset of the caret position nearest document point (`x`, `y`) in layer `id`.
+pub(crate) fn offset_at(app: &mut PhotocraftApp, id: LayerId, x: f64, y: f64) -> usize {
     let Some((l, aff, text)) = layout(app, id) else { return 0 };
     let (tx, ty) = to_text(&aff, x, y);
     photocraft_text::hit_char(&l, &text, tx, ty).0
@@ -178,7 +184,7 @@ fn handle_sides(i: u8) -> (bool, bool, bool, bool) {
 }
 
 pub(crate) fn box_shape(app: &PhotocraftApp, id: LayerId) -> Option<(f32, f32, f32, f32)> {
-    match app.session.active().and_then(|s| text_layer(&s.doc, id).map(|t| t.shape))? {
+    match app.session.active().and_then(|s| text_layer(&s.doc, id).map(|t| t.shape.clone()))? {
         photocraft_doc::text::TextShape::Box { x, y, width, height } => Some((x, y, width, height)),
         _ => None,
     }
@@ -251,8 +257,9 @@ pub fn pointer_down(app: &mut PhotocraftApp, x: f64, y: f64, mods: egui::Modifie
         commit_with(app, mods);
         return true; // Photoshop: a click outside commits without starting new text
     }
-    // The Type Mask tools always start new text: existing type layers are just pixels to them.
-    if app.ui.tool.is_type_mask() {
+    // The Type Mask tools always start new text: existing type layers are just pixels to them;
+    // so does a ⇧-click with the Type tool, as in Photoshop, to start new text over old.
+    if app.ui.tool.is_type_mask() || mods.shift {
         return false;
     }
     if let Some(id) = hit_layer(app, x, y) {
@@ -458,6 +465,135 @@ fn kern_pair(app: &mut PhotocraftApp, id: LayerId, caret: usize, by: f32) {
     let _ = app.run("type.edit", json!({"layer": id.0, "kernPair": {"at": caret, "by": by}}));
 }
 
+/// A character style the type editor's ⇧⌘ keys toggle (Photoshop: ⇧⌘K All Caps, ⇧⌘U
+/// Underline, ⇧⌘B Faux Bold, ⇧⌘I Faux Italic, ⇧⌘/ Strikethrough).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum CharToggle {
+    AllCaps,
+    Underline,
+    FauxBold,
+    FauxItalic,
+    Strikethrough,
+}
+
+impl CharToggle {
+    fn is_on(self, st: &photocraft_doc::text::CharStyle) -> bool {
+        match self {
+            Self::AllCaps => st.caps == photocraft_doc::text::Caps::AllCaps,
+            Self::Underline => st.underline,
+            Self::FauxBold => st.faux_bold,
+            Self::FauxItalic => st.faux_italic,
+            Self::Strikethrough => st.strikethrough,
+        }
+    }
+
+    fn param(self, on: bool) -> (&'static str, serde_json::Value) {
+        match self {
+            Self::AllCaps => ("caps", json!(if on { "all" } else { "normal" })),
+            Self::Underline => ("underline", json!(on)),
+            Self::FauxBold => ("fauxBold", json!(on)),
+            Self::FauxItalic => ("fauxItalic", json!(on)),
+            Self::Strikethrough => ("strikethrough", json!(on)),
+        }
+    }
+}
+
+/// The byte range of characters `a..b` of `text`.
+fn byte_range(text: &str, a: usize, b: usize) -> (usize, usize) {
+    let at = |c: usize| text.char_indices().nth(c).map_or(text.len(), |(i, _)| i);
+    (at(a.min(b)), at(a.max(b)))
+}
+
+/// The character styles of the selection, or of the typing style when the text is empty. Empty
+/// when nothing is selected in non-empty text.
+fn selected_styles(t: &TextLayer, a: usize, b: usize) -> Vec<photocraft_doc::text::CharStyle> {
+    let runs = t.char_runs();
+    if t.text.is_empty() {
+        return runs.into_iter().take(1).map(|r| r.style).collect();
+    }
+    let (ba, bb) = byte_range(&t.text, a, b);
+    let mut at = 0usize;
+    let mut out = Vec::new();
+    for r in runs {
+        let (rs, re) = (at, at.saturating_add(r.len));
+        at = re;
+        if rs < bb && re > ba {
+            out.push(r.style);
+        }
+    }
+    out
+}
+
+/// The character range the type editor's formatting keys act on: the selection, or the empty
+/// text's typing style. `None` for a collapsed caret in non-empty text: Photoshop would style the
+/// next characters typed, which the document model can't hold apart from the text, so the keys
+/// do nothing there (rather than restyle a word the user didn't select).
+fn format_range(app: &PhotocraftApp, ed: &TextEdit) -> Option<(usize, usize)> {
+    let t = text_layer(&app.session.active()?.doc, LayerId(ed.layer))?;
+    let n = t.text.chars().count();
+    let (a, b) = (ed.caret.min(ed.anchor).min(n), ed.caret.max(ed.anchor).min(n));
+    (a < b || n == 0).then_some((a, b))
+}
+
+/// One `type.setStyle` step on the edited layer's `range`, kept apart from the typing session's
+/// coalesced edit so Undo takes back one key press at a time (as with kerning).
+fn set_style(app: &mut PhotocraftApp, ed: &TextEdit, range: (usize, usize), mut p: serde_json::Value) {
+    crate::type_transform::finish(app);
+    p["layer"] = json!(ed.layer);
+    p["range"] = json!([range.0, range.1]);
+    if let Err(e) = app.run("type.setStyle", p) {
+        app.ui.status = e;
+        app.ui.status_error = true;
+    }
+}
+
+/// ⇧⌘K/U/B/I/: flips a character style over the selection: off when every selected character
+/// already has it, else on.
+pub(crate) fn toggle_char_style(app: &mut PhotocraftApp, which: CharToggle) {
+    let Some(ed) = app.ui.text_edit.clone() else { return };
+    let Some(range) = format_range(app, &ed) else { return };
+    let Some(styles) = app.session.active().and_then(|s| text_layer(&s.doc, LayerId(ed.layer))).map(|t| selected_styles(t, range.0, range.1)) else {
+        return;
+    };
+    let on = !styles.iter().all(|st| which.is_on(st));
+    let (key, value) = which.param(on);
+    set_style(app, &ed, range, json!({ key: value }));
+}
+
+/// ⌥↑/↓ leading, ⇧⌥↑/↓ baseline shift and ⌥←/→ tracking: steps every selected character from its
+/// own value (`key` is `leadingBy`, `baselineShiftBy` or `trackingBy`).
+pub(crate) fn step_char_metric(app: &mut PhotocraftApp, key: &str, by: f32) {
+    let Some(ed) = app.ui.text_edit.clone() else { return };
+    let Some(range) = format_range(app, &ed) else { return };
+    // Leading steps in the points the Character panel shows for a scaled layer.
+    set_style(app, &ed, range, json!({ key: by, "metricsAsShown": key == "leadingBy" }));
+}
+
+/// ⌥⇧⌘H: flips Hyphenate for the paragraphs the selection (or the caret) is in: off when all of
+/// them hyphenate, else on.
+pub(crate) fn toggle_hyphenate(app: &mut PhotocraftApp) {
+    let Some(ed) = app.ui.text_edit.clone() else { return };
+    let Some(t) = app.session.active().and_then(|s| text_layer(&s.doc, LayerId(ed.layer))) else { return };
+    let n = t.text.chars().count();
+    let (a, b) = (ed.caret.min(ed.anchor).min(n), ed.caret.max(ed.anchor).min(n));
+    let (ba, bb) = byte_range(&t.text, a, b);
+    let len = t.text.len();
+    let mut at = 0usize;
+    let mut all = true;
+    let mut any = false;
+    for r in t.paragraph_runs() {
+        let (ps, pe) = (at, at.saturating_add(r.len));
+        at = pe;
+        let touches = if ba == bb { ps <= ba && (ba < pe || pe >= len) } else { ps < bb && pe > ba };
+        if touches {
+            any = true;
+            all &= r.style.hyphenate;
+        }
+    }
+    let on = !(any && all);
+    set_style(app, &ed, (a, b), json!({ "hyphenate": on }));
+}
+
 /// IME composition. The preedit text is written into the layer (so it lays out and reflows like
 /// typed text) and replaced by every update; `commit` makes the result final.
 fn ime_update(app: &mut PhotocraftApp, s: &str, commit: bool) {
@@ -630,6 +766,10 @@ pub fn handle_keys(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
         crate::type_transform::cancel_drag(app);
     }
     let Some(ed) = app.ui.text_edit.clone() else { return false };
+    // The font picker (and other focused fields) owns keyboard input while it is open.
+    if ctx.text_edit_focused() || ctx.egui_wants_keyboard_input() {
+        return true;
+    }
     let id = LayerId(ed.layer);
     let Some(text) = current_text(app, id) else {
         app.ui.text_edit = None;
@@ -675,6 +815,35 @@ pub fn handle_keys(app: &mut PhotocraftApp, ctx: &egui::Context) -> bool {
                 use egui::Key;
                 let key = &flow_key(*key, vertical_flow);
                 match key {
+                    // Photoshop's type formatting keys act on the selected characters and win
+                    // over the global ⇧⌘K/U/B/I (Color Settings, Desaturate, Auto Color, Inverse)
+                    // while typing. Each press is one history step.
+                    Key::K | Key::U | Key::B | Key::I | Key::Slash | Key::Questionmark if m.command && m.shift && !m.alt => {
+                        let which = match key {
+                            Key::K => CharToggle::AllCaps,
+                            Key::U => CharToggle::Underline,
+                            Key::B => CharToggle::FauxBold,
+                            Key::I => CharToggle::FauxItalic,
+                            _ => CharToggle::Strikethrough,
+                        };
+                        toggle_char_style(app, which);
+                    }
+                    Key::H if m.command && m.shift && m.alt => toggle_hyphenate(app),
+                    // ⌥↑/↓ leading -/+2 pt, ⇧⌥↑/↓ baseline shift +/-2 pt (10 with ⌘/Ctrl).
+                    Key::ArrowUp | Key::ArrowDown if m.alt => {
+                        let step = if m.command { 10.0 } else { 2.0 };
+                        let up = *key == Key::ArrowUp;
+                        if m.shift {
+                            step_char_metric(app, "baselineShiftBy", if up { step } else { -step });
+                        } else {
+                            step_char_metric(app, "leadingBy", if up { -step } else { step });
+                        }
+                    }
+                    // ⌥←/→ over a selection tracks it by -/+20 (100 with ⌘/Ctrl).
+                    Key::ArrowLeft | Key::ArrowRight if m.alt && !m.shift && a != b => {
+                        let step = if m.command { 100.0 } else { 20.0 };
+                        step_char_metric(app, "trackingBy", if *key == Key::ArrowRight { step } else { -step });
+                    }
                     Key::Backspace | Key::Delete => {
                         if a == b {
                             let fwd = *key == Key::Delete;
@@ -848,7 +1017,7 @@ pub fn draw_overlay(app: &mut PhotocraftApp, painter: &egui::Painter, xf: &ViewX
     if crate::type_transform::draw(app, painter, xf, mods) {
         return;
     }
-    let shape = app.session.active().and_then(|s| text_layer(&s.doc, id).map(|t| t.shape));
+    let shape = app.session.active().and_then(|s| text_layer(&s.doc, id).map(|t| t.shape.clone()));
     let frame = Stroke::new(1.0, t.accent);
     match shape {
         Some(photocraft_doc::text::TextShape::Box { x, y, width, height }) => {
@@ -984,11 +1153,11 @@ fn draw_mask_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXfor
 }
 
 /// Font families: bundled, system, and those the host serves (`photocraft_text::served`, fetched
-/// when picked). Cached until fonts are registered or the served catalog changes.
+/// when picked). Cached until the shared engine registers fonts or the served catalog changes.
 pub fn families() -> Arc<Vec<String>> {
     type Cached = Option<((u64, u64), Arc<Vec<String>>)>;
     static FAMILIES: std::sync::Mutex<Cached> = std::sync::Mutex::new(None);
-    let key = (photocraft_text::fonts::generation(), photocraft_text::served::generation());
+    let key = (photocraft_text::fonts::shared_generation(), photocraft_text::served::generation());
     let mut cached = FAMILIES.lock().unwrap_or_else(PoisonError::into_inner);
     if let Some((k, v)) = cached.as_ref()
         && *k == key
@@ -1026,11 +1195,11 @@ pub fn sync_font_names(ctx: &egui::Context, show_in_english: bool) {
     });
 }
 
-/// The fonts' localized family names, keyed by family. Cached until fonts are registered.
+/// The fonts' localized family names, keyed by family. Cached until the shared engine registers fonts.
 fn localized_families() -> Arc<HashMap<String, String>> {
     type Cached = Option<(u64, Arc<HashMap<String, String>>)>;
     static LOCALIZED: std::sync::Mutex<Cached> = std::sync::Mutex::new(None);
-    let key = photocraft_text::fonts::generation();
+    let key = photocraft_text::fonts::shared_generation();
     let mut cached = LOCALIZED.lock().unwrap_or_else(PoisonError::into_inner);
     if let Some((k, v)) = cached.as_ref()
         && *k == key
@@ -1360,6 +1529,26 @@ pub(crate) fn family_picker_in(
     press.after(&response.response);
     let hovered_font = response.inner.unwrap_or_default();
 
+    // The wheel over the closed button steps through the families, a notch each, like Photoshop's
+    // options-bar font menu: no need to open the list (#3350).
+    if !egui::ComboBox::is_open(ui.ctx(), response.response.id) && ui.is_enabled() {
+        let hovered = response.response.hovered();
+        if hovered {
+            ui.input_mut(|i| i.smooth_scroll_delta = egui::Vec2::ZERO);
+        }
+        let notches = crate::widgets::wheel_notches_of(ui, response.response.id.with("family-wheel"), hovered, 1.0);
+        let rows = font_menu_rows(families, labels, "");
+        if let Some(i) = rows.iter().position(|(f, _)| *f == current)
+            && let Some(n) = wheel_family_index(i, rows.len(), notches)
+            && let Some((f, _)) = rows.get(n)
+            && **f != *current
+        {
+            current.clone_from(f);
+            photocraft_text::served::request(f);
+            changed = true;
+        }
+    }
+
     if salt == "type-font" {
         let hover_id = egui::Id::new("type-font-hover");
         if let Some(f) = hovered_font {
@@ -1372,6 +1561,17 @@ pub(crate) fn family_picker_in(
     changed
 }
 
+/// The row `notches` wheel notches from row `index` of `len` (down, negative, is the next one),
+/// stopping at the ends; none when the wheel did not move.
+fn wheel_family_index(index: usize, len: usize, notches: f32) -> Option<usize> {
+    let steps = notches.abs().min(len as f32) as usize;
+    if steps == 0 || len == 0 {
+        return None;
+    }
+    let last = len - 1;
+    Some(if notches < 0.0 { index.saturating_add(steps).min(last) } else { index.saturating_sub(steps) })
+}
+
 /// Representative for the displayed properties: the edit layer, else a selected type layer.
 pub(crate) fn target(app: &PhotocraftApp) -> Option<(u64, Option<[usize; 2]>)> {
     if let Some(ed) = &app.ui.text_edit {
@@ -1732,8 +1932,14 @@ fn num_field(ui: &mut egui::Ui, label: &str, tip: &str, v: f32, range: std::ops:
         ui.spacing_mut().item_spacing.x = 4.0;
         let (r, resp) = ui.allocate_exact_size(egui::vec2(22.0, 22.0), egui::Sense::hover());
         ui.painter().text(r.center(), egui::Align2::CENTER_CENTER, label, crate::theme::semibold(10.0), t.text_dim);
-        crate::widgets::scrub_label(ui, &resp.on_hover_text(tip));
-        if crate::widgets::value_field(ui, &mut v, range, unit, width).changed() {
+        crate::widgets::scrub_label(ui, &resp.on_hover_text(tl!(tip)));
+        let response = crate::widgets::value_field(ui, &mut v, range, unit, width);
+        response.widget_info(|| {
+            let mut info = egui::WidgetInfo::drag_value(ui.is_enabled(), f64::from(v));
+            info.label = Some(tl!(tip).to_owned());
+            info
+        });
+        if response.changed() {
             out = Some(v);
         }
     });
@@ -1783,6 +1989,102 @@ fn toggle_cell(ui: &mut egui::Ui, w: f32, on: bool, tip: &str, paint: impl FnOnc
     resp.on_hover_text(tl!(&tip)).clicked()
 }
 
+/// The Character panel's OpenType buttons, in Photoshop's order: (feature tag, command id,
+/// tooltip). The tooltips are the Type › OpenType menu labels.
+pub(crate) const OPENTYPE_BUTTONS: [(&str, &str, &str); 8] = [
+    ("liga", "type.openType.standardLigatures", "Standard Ligatures"),
+    ("calt", "type.openType.contextualAlternates", "Contextual Alternates"),
+    ("dlig", "type.openType.discretionaryLigatures", "Discretionary Ligatures"),
+    ("swsh", "type.openType.swash", "Swash"),
+    ("salt", "type.openType.stylisticAlternates", "Stylistic Alternates"),
+    ("titl", "type.openType.titlingAlternates", "Titling Alternates"),
+    ("ordn", "type.openType.ordinals", "Ordinals"),
+    ("frac", "type.openType.fractions", "Fractions"),
+];
+
+/// Photoshop's OpenType button row: each shows pressed while its feature is on at the type
+/// target (the selection start, else the layer) and toggles it through the Type › OpenType
+/// command, on the same scope as the other Character controls.
+fn opentype_row(app: &mut PhotocraftApp, ui: &mut egui::Ui, c: &photocraft_doc::text::CharStyle, full: f32) {
+    let cw = cell_width(full, OPENTYPE_BUTTONS.len());
+    let mut clicked = None;
+    ui.horizontal(|ui| {
+        ui.spacing_mut().item_spacing.x = 2.0;
+        for (tag, id, tip) in OPENTYPE_BUTTONS {
+            let on = photocraft_engine::type_extra_cmds::feature_on(c, tag);
+            if toggle_cell(ui, cw, on, tip, |ui, r, col| opentype_glyph(ui.painter(), r, tag, col)) {
+                clicked = Some((id, on));
+            }
+        }
+    });
+    if let Some((id, on)) = clicked {
+        toggle_opentype(app, id, on);
+    }
+}
+
+/// Runs an OpenType toggle command on the Character panel's scope: the edited layer's selected
+/// characters (or its whole text) while typing, else every selected type layer. The new state
+/// is explicit, so it follows the button the user saw rather than the layer's first run.
+pub(crate) fn toggle_opentype(app: &mut PhotocraftApp, id: &str, shown_on: bool) {
+    let Some(mut p) = formatting_params(app) else { return };
+    p["on"] = json!(!shown_on);
+    let _ = app.run(id, p);
+}
+
+/// Small glyph labels for the OpenType buttons (drawn here, no Adobe artwork): fi, st, ct with
+/// a ligature arc, a swash A, aa, T, 1st and ½.
+fn opentype_glyph(p: &egui::Painter, r: egui::Rect, tag: &str, col: Color32) {
+    let font = egui::FontId::proportional(13.0);
+    let centred = |s: &str, font: egui::FontId| {
+        let g = p.layout_no_wrap(s.to_string(), font, col);
+        let pos = r.center() - g.size() / 2.0;
+        let gr = egui::Rect::from_min_size(pos, g.size());
+        p.galley(pos, g, col);
+        gr
+    };
+    match tag {
+        "liga" => {
+            centred("fi", font);
+        }
+        "calt" => {
+            centred("st", font);
+        }
+        "dlig" => {
+            let gr = centred("ct", font);
+            // The ligature's connecting arc from the c over to the t.
+            let a = egui::pos2(gr.left() + gr.width() * 0.3, gr.top() + gr.height() * 0.42);
+            let b = egui::pos2(gr.right() - gr.width() * 0.2, gr.top() + 4.0);
+            let mid = egui::pos2((a.x + b.x) / 2.0, gr.top() + 1.5);
+            p.line_segment([a, mid], Stroke::new(1.0, col));
+            p.line_segment([mid, b], Stroke::new(1.0, col));
+        }
+        "swsh" => {
+            let gr = centred("A", crate::theme::semibold(13.0));
+            // A swash tail sweeping out under the letter.
+            let y = gr.bottom() - 3.0;
+            p.line_segment([egui::pos2(gr.left() - 3.0, y + 1.5), egui::pos2(gr.right() + 2.0, y - 0.5)], Stroke::new(1.0, col));
+        }
+        "salt" => {
+            centred("aa", font);
+        }
+        "titl" => {
+            centred("T", crate::theme::semibold(13.0));
+        }
+        "ordn" => {
+            let one = p.layout_no_wrap("1".into(), font, col);
+            let st = p.layout_no_wrap("st".into(), egui::FontId::proportional(9.0), col);
+            let left = r.center().x - (one.size().x + st.size().x) / 2.0;
+            let top = r.center().y - one.size().y / 2.0;
+            let st_x = left + one.size().x;
+            p.galley(egui::pos2(left, top), one, col);
+            p.galley(egui::pos2(st_x, top - 1.0), st, col);
+        }
+        _ => {
+            centred("½", font);
+        }
+    }
+}
+
 /// Width of each of `n` equal cells filling `avail` with 2 pt gaps.
 fn cell_width(avail: f32, n: usize) -> f32 {
     let n = n.max(1) as f32;
@@ -1957,6 +2259,8 @@ fn type_sections(app: &mut PhotocraftApp, ui: &mut egui::Ui, character: bool, pa
             }
         });
         ui.add_space(ROW_GAP);
+        opentype_row(app, ui, &c, full);
+        ui.add_space(ROW_GAP);
     }
     if paragraph && section(ui, "paragraph", tl!("Paragraph")) {
         use photocraft_doc::text::TextAlign as A;
@@ -2122,6 +2426,102 @@ mod tests {
         current_text(app, LayerId(ed.layer)).unwrap()
     }
 
+    /// A committed type layer reading `s` at the same spot as the others (stacked variants, #4320).
+    fn stacked_variant(app: &mut PhotocraftApp, s: &str) -> LayerId {
+        app.ui.text_edit = None;
+        pointer_up(app, [50.0, 100.0], [50.0, 100.0]);
+        insert(app, s);
+        commit(app);
+        app.session.active().unwrap().active_layer.unwrap()
+    }
+
+    fn hide(app: &mut PhotocraftApp, id: LayerId) {
+        app.run("layer.setProps", json!({"layer": id.0, "visible": false})).unwrap();
+    }
+
+    /// Wraps `id` in a new group and returns the group.
+    fn group_of(app: &mut PhotocraftApp, id: LayerId) -> LayerId {
+        app.run("layer.select", json!({"layer": id.0, "mode": "replace"})).unwrap();
+        app.run("layer.groupLayers", json!({})).unwrap();
+        let doc = &app.session.active().unwrap().doc;
+        let path = doc.path_of(id).unwrap();
+        doc.layer_at(&path[..path.len() - 1]).unwrap().id
+    }
+
+    /// Three type variants at one spot, bottom to top: A, B, C.
+    fn variants() -> (PhotocraftApp, [LayerId; 3]) {
+        let mut app = app();
+        let ids = ["Variant A", "Variant B", "Variant C"].map(|s| stacked_variant(&mut app, s));
+        (app, ids)
+    }
+
+    const ON_TEXT: (f64, f64) = (60.0, 95.0);
+
+    /// #4320: variants hidden through their groups above the shown one are not picked.
+    #[test]
+    fn type_click_skips_text_in_hidden_groups_above_the_shown_variant() {
+        let (mut app, [a, b, c]) = variants();
+        for id in [b, c] {
+            let g = group_of(&mut app, id);
+            hide(&mut app, g);
+        }
+        assert_eq!(hit_layer(&mut app, ON_TEXT.0, ON_TEXT.1), Some(a));
+        assert!(pointer_down(&mut app, ON_TEXT.0, ON_TEXT.1, egui::Modifiers::NONE));
+        assert_eq!(app.ui.text_edit.as_ref().map(|e| e.layer), Some(a.0), "the click edits the shown variant");
+    }
+
+    #[test]
+    fn type_click_skips_text_in_a_nested_hidden_group() {
+        let (mut app, [a, b, c]) = variants();
+        hide(&mut app, b);
+        let inner = group_of(&mut app, c);
+        let outer = group_of(&mut app, inner);
+        hide(&mut app, outer);
+        assert!(app.session.active().unwrap().doc.layer(c).unwrap().visible, "only the outer group is hidden");
+        assert_eq!(hit_layer(&mut app, ON_TEXT.0, ON_TEXT.1), Some(a));
+    }
+
+    #[test]
+    fn type_click_skips_own_hidden_variants_above_and_below() {
+        let (mut app, [a, b, c]) = variants();
+        hide(&mut app, b);
+        hide(&mut app, c);
+        assert_eq!(hit_layer(&mut app, ON_TEXT.0, ON_TEXT.1), Some(a), "hidden variants above");
+        let (mut app, [a, b, c]) = variants();
+        hide(&mut app, a);
+        hide(&mut app, b);
+        assert_eq!(hit_layer(&mut app, ON_TEXT.0, ON_TEXT.1), Some(c), "hidden variants below");
+    }
+
+    /// The Move tool's double-click on type (#1132) shares the pick.
+    #[test]
+    fn move_double_click_edits_the_shown_variant_not_one_in_a_hidden_group() {
+        let (mut app, [a, b, c]) = variants();
+        for id in [b, c] {
+            let g = group_of(&mut app, id);
+            hide(&mut app, g);
+        }
+        app.ui.tool = crate::state::Tool::Move;
+        assert!(edit_at(&mut app, ON_TEXT.0, ON_TEXT.1));
+        assert_eq!(app.ui.text_edit.as_ref().map(|e| e.layer), Some(a.0));
+    }
+
+    /// Photoshop: a click on existing type edits it; a ⇧-click there starts a new type layer.
+    #[test]
+    fn shift_click_on_existing_type_starts_new_text() {
+        let mut app = app();
+        pointer_up(&mut app, [50.0, 100.0], [50.0, 100.0]);
+        insert(&mut app, "Existing words");
+        commit(&mut app);
+        let existing = app.session.active().unwrap().doc.layers.last().unwrap().id;
+        let (x, y) = (60.0, 95.0);
+        assert_eq!(hit_layer(&mut app, x, y), Some(existing), "the click lands on the existing text");
+        assert!(!pointer_down(&mut app, x, y, egui::Modifiers::SHIFT), "⇧: not consumed, so a new type layer starts");
+        assert!(app.ui.text_edit.is_none());
+        assert!(pointer_down(&mut app, x, y, egui::Modifiers::NONE), "a plain click edits the existing text");
+        assert_eq!(app.ui.text_edit.as_ref().map(|e| e.layer), Some(existing.0));
+    }
+
     #[test]
     fn click_creates_placeholder_selected_and_typing_replaces_it() {
         let mut app = app();
diff --git a/crates/ui-egui/src/type_tool_tests.rs b/crates/ui-egui/src/type_tool_tests.rs
index 46d763e5b9..0f5be9e2fa 100644
--- a/crates/ui-egui/src/type_tool_tests.rs
+++ b/crates/ui-egui/src/type_tool_tests.rs
@@ -14,6 +14,65 @@ use super::{layout, text_layer};
 use crate::PhotocraftApp;
 use crate::canvas::ViewXform;
 
+#[test]
+fn focused_font_search_does_not_type_into_the_canvas_layer() {
+    let mut app = new_app();
+    let id = app.run("type.create", json!({"text": "Sample", "size": 24})).unwrap()["layer"].as_u64().unwrap();
+    app.ui.text_edit = Some(crate::state::TextEdit {
+        layer: id,
+        caret: 6,
+        anchor: 6,
+        session: "s".into(),
+        created: false,
+        mask: false,
+        dragging: false,
+        resize: None,
+        preedit: None,
+    });
+    let mut h = Harness::builder().build_ui_state(
+        |ui, app: &mut PhotocraftApp| {
+            let search_id = egui::Id::new("font-search-regression");
+            let mut query = ui.data(|d| d.get_temp::<String>(search_id)).unwrap_or_default();
+            ui.add(egui::TextEdit::singleline(&mut query).id(search_id)).request_focus();
+            ui.data_mut(|d| d.insert_temp(search_id, query));
+            super::handle_keys(app, ui.ctx());
+        },
+        app,
+    );
+    h.run_steps(2);
+    h.event(egui::Event::Text("Ins".into()));
+    h.run();
+    assert_eq!(h.ctx.data(|d| d.get_temp::<String>(egui::Id::new("font-search-regression"))).as_deref(), Some("Ins"));
+    assert_eq!(super::current_text(h.state_mut(), LayerId(id)).as_deref(), Some("Sample"));
+}
+
+#[test]
+fn numeric_type_fields_have_localized_accessible_names() {
+    let pt = crate::i18n::Lang::from_code("pt-br").unwrap();
+    let mut h = Harness::builder().build_ui_state(
+        move |ui, value: &mut f32| {
+            if !ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                return;
+            }
+            crate::i18n::with_language(pt, || {
+                if let Some(next) = super::num_field(ui, "tT", "Font size", *value, 1.0..=999.0, "pt", 80.0) {
+                    *value = next;
+                }
+            });
+        },
+        24.0,
+    );
+    PhotocraftApp::setup_context(&h.ctx, Default::default());
+    h.run_steps(4);
+    h.get_by_role_and_label(egui::accesskit::Role::SpinButton, "Tamanho da fonte").click();
+    h.run();
+    h.key_press_modifiers(Modifiers::COMMAND, egui::Key::A);
+    h.event(egui::Event::Text("36".into()));
+    h.key_press(egui::Key::Enter);
+    h.run();
+    assert_eq!(*h.state(), 36.0);
+}
+
 fn harness(ppp: f32, app: PhotocraftApp) -> Harness<'static, PhotocraftApp> {
     make_harness(ppp, app, false)
 }
@@ -1333,8 +1392,10 @@ mod multi_layer_formatting {
         h
     }
 
-    fn number(h: &mut Harness<'static, PhotocraftApp>, index: usize, value: &str) {
-        h.get_all_by_role(Role::SpinButton).nth(index).expect("numeric field").click();
+    fn number(h: &mut Harness<'static, PhotocraftApp>, label: &str, value: &str) {
+        // Variable-font axes add numeric fields before size/leading. Select the setting by
+        // its accessible name, so a font scan cannot shift this action onto another control.
+        h.get_by_role_and_label(Role::SpinButton, label).click();
         h.run();
         h.key_press_modifiers(Modifiers::COMMAND, egui::Key::A);
         h.event(egui::Event::Text(value.into()));
@@ -1371,7 +1432,16 @@ mod multi_layer_formatting {
         for i in 0..2 {
             let mut expected = before[i].clone();
             expected.font_family = "JetBrains Mono".into();
-            expected.postscript_name = None;
+            // #3556: the new family's installed face at the peer's weight and italic is named (no
+            // name without such a face), so a PSD names a real font.
+            expected.postscript_name = photocraft_text::shared()
+                .lock()
+                .unwrap()
+                .fonts
+                .faces("JetBrains Mono")
+                .into_iter()
+                .find(|f| f.italic == expected.italic && f.weight.round() as u16 == expected.weight)
+                .and_then(|f| f.postscript_name);
             assert_eq!(style(h.state(), ids[i], 0), expected, "family changes preserve each peer's face and metrics");
         }
         assert_eq!(style(h.state(), ids[2], 0), before[2]);
@@ -1390,6 +1460,33 @@ mod multi_layer_formatting {
         assert_ne!(text(h.state(), ids[2]).antialias, AntiAlias::Sharp);
     }
 
+    /// Other engines registering fonts and the served catalog growing (tests running in parallel)
+    /// used to move the key of the font menu's preview cache, so its samples re-rendered and asked
+    /// for a repaint every pass and `Harness::run` never settled (a flaky `exceeded max_steps`).
+    /// Here both happen on every pass.
+    #[test]
+    fn the_font_menu_settles_while_other_engines_register_fonts() {
+        let (app, _) = fixture();
+        let mut pass = 0u32;
+        let mut h = Harness::builder().with_size(vec2(1100.0, 800.0)).build_ui_state(
+            move |ui, app| {
+                photocraft_text::TextEngine::new();
+                // The served catalog is process-wide: names that sort last.
+                photocraft_text::served::add_families([format!("zz Churn Test {pass:03}")]);
+                pass = pass.saturating_add(1);
+                if ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                    ui.horizontal(|ui| super::super::options_bar(app, ui));
+                }
+            },
+            app,
+        );
+        PhotocraftApp::setup_context(&h.ctx, Default::default());
+        h.run_steps(4);
+        h.get_all_by_role(Role::ComboBox).next().unwrap().click();
+        h.run();
+        h.run();
+    }
+
     #[test]
     fn properties_edit_shown_metrics_and_paragraphs_with_a_non_type_primary() {
         let (mut app, ids) = fixture();
@@ -1400,16 +1497,16 @@ mod multi_layer_formatting {
         let raster = LayerId(app.run("layer.new.layer", json!({"name": "Selected raster"})).unwrap()["layer"].as_u64().unwrap());
         selected(&mut app, &[ids[0], ids[1], raster]);
         let mut h = controls(app, true);
-        number(&mut h, 0, "60");
+        number(&mut h, "Font size", "60");
         // Differ from the automatic 72 pt leading so this is an actual property change.
-        number(&mut h, 1, "84");
+        number(&mut h, "Leading (set to the font size × auto-leading when Auto)", "84");
         h.get_by_label("Faux Bold").click();
         h.run();
         h.get_by_label("Center text").click();
         h.run();
         h.get_by_label("Hyphenate").click();
         h.run();
-        number(&mut h, 6, "9");
+        number(&mut h, "Indent left margin", "9");
         for (id, scale) in [(ids[0], 2.0), (ids[1], 4.0)] {
             let c = style(h.state(), id, 0);
             assert_eq!(c.size_pt * scale, 60.0);
@@ -1426,7 +1523,7 @@ mod multi_layer_formatting {
         let peer = text(h.state(), ids[1]).char_runs();
         editing(h.state_mut(), ids[0]);
         h.run();
-        number(&mut h, 0, "40");
+        number(&mut h, "Font size", "40");
         assert_eq!((size_at(h.state(), ids[0], 0), size_at(h.state(), ids[0], 1), size_at(h.state(), ids[0], 3)), (30.0, 20.0, 30.0));
         assert_eq!(text(h.state(), ids[1]).char_runs(), peer);
     }
@@ -1455,6 +1552,51 @@ mod multi_layer_formatting {
         assert_eq!(text(&app, ids[0]).antialias, AntiAlias::Sharp);
     }
 
+    /// The Character panel's OpenType buttons (TYPE-218-5, #3752): Photoshop's eight, in its
+    /// order; each shows pressed while its feature is on and toggles it on the selected type
+    /// layers, or on the selected characters while typing.
+    #[test]
+    fn character_panel_opentype_buttons_toggle_and_show_the_feature() {
+        use egui::accesskit::Toggled;
+        use egui_kittest::kittest::NodeT;
+        use photocraft_engine::type_extra_cmds::feature_on;
+        let (app, ids) = fixture();
+        let untouched = style(&app, ids[2], 0);
+        let mut h = controls(app, true);
+        let shown = |h: &Harness<'static, PhotocraftApp>, label: &str| h.get_by_label(label).accesskit_node().toggled();
+        let order: Vec<String> = h
+            .get_all_by_role(Role::Button)
+            .filter_map(|n| n.accesskit_node().label())
+            .filter(|l| super::super::OPENTYPE_BUTTONS.iter().any(|(_, _, tip)| tip == l))
+            .collect();
+        let expected: Vec<&str> = super::super::OPENTYPE_BUTTONS.iter().map(|(_, _, tip)| *tip).collect();
+        assert_eq!(order, expected, "every OpenType button, in Photoshop's order");
+        assert_eq!(shown(&h, "Standard Ligatures"), Some(Toggled::True), "ligatures are on by default");
+        assert_eq!(shown(&h, "Fractions"), Some(Toggled::False));
+        h.get_by_label("Fractions").click();
+        h.run();
+        for id in &ids[..2] {
+            assert!(feature_on(&style(h.state(), *id, 0), "frac"), "selected layers get the feature");
+        }
+        assert_eq!(style(h.state(), ids[2], 0), untouched, "an unselected layer is untouched");
+        h.run();
+        assert_eq!(shown(&h, "Fractions"), Some(Toggled::True), "the button shows the feature on");
+        h.get_by_label("Standard Ligatures").click();
+        h.run();
+        h.run();
+        assert!(!style(h.state(), ids[0], 0).ligatures && !style(h.state(), ids[1], 0).ligatures);
+        assert_eq!(shown(&h, "Standard Ligatures"), Some(Toggled::False));
+        // While typing, only the selected characters (1..3) change.
+        editing(h.state_mut(), ids[0]);
+        h.run();
+        h.get_by_label("Swash").click();
+        h.run();
+        let swash = |h: &Harness<'static, PhotocraftApp>, ci| feature_on(&style(h.state(), ids[0], ci), "swsh");
+        assert!(!swash(&h, 0) && swash(&h, 1) && swash(&h, 2) && !swash(&h, 3));
+        h.run();
+        assert_eq!(shown(&h, "Swash"), Some(Toggled::True), "shown at the selection start");
+    }
+
     /// Type › Anti-Alias and Type › Orientation check the edited (else selected) layer's value.
     #[test]
     fn type_menu_checks_the_current_anti_alias_and_orientation() {
diff --git a/crates/ui-egui/src/type_transform.rs b/crates/ui-egui/src/type_transform.rs
index d99334cba9..2a68366d6e 100644
--- a/crates/ui-egui/src/type_transform.rs
+++ b/crates/ui-egui/src/type_transform.rs
@@ -85,7 +85,7 @@ pub(crate) fn frame(app: &mut PhotocraftApp) -> Option<TransformSession> {
         return None;
     }
     let LayerContent::Text(text) = &layer.content else { return None };
-    let shape = text.shape;
+    let shape = text.shape.clone();
     let size = text.size_pt;
     let (layout, aff, _) = crate::type_tool::layout(app, id)?;
     if !aff.m.iter().all(|v| v.is_finite()) || aff.inverse().is_none() {
@@ -126,6 +126,7 @@ pub(crate) fn frame(app: &mut PhotocraftApp) -> Option<TransformSession> {
         made: None,
         mode: Default::default(),
         content_aware: None,
+        skew_v: 0.0,
     })
 }
 
diff --git a/crates/ui-egui/src/variables_ui.rs b/crates/ui-egui/src/variables_ui.rs
index fc10df402f..a4700cddad 100644
--- a/crates/ui-egui/src/variables_ui.rs
+++ b/crates/ui-egui/src/variables_ui.rs
@@ -17,6 +17,16 @@ pub fn owns(fields: &Map<String, Value>) -> bool {
     fields.contains_key("__variables")
 }
 
+/// Alt+Cancel (Reset): restore `__variables` from the open-time snapshot.
+pub fn reset(fields: &mut Map<String, Value>) {
+    if !owns(fields) {
+        return;
+    }
+    if let Some(orig) = fields.get("__variablesOrig").cloned() {
+        fields.insert("__variables".into(), orig);
+    }
+}
+
 /// Layers available to bind, top to bottom: (id, display name, is-text).
 fn layer_options(app: &PhotocraftApp) -> Vec<(u64, String, bool)> {
     let Some(st) = app.session.active() else { return Vec::new() };
@@ -31,6 +41,8 @@ pub fn menu(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<
             let page = if id.ends_with("dataSets") { "dataSets" } else { "define" };
             let mut f = Map::new();
             let state = app.session.active().map(|st| crate::variables_ui::to_state(&st.doc.variables)).unwrap_or_else(|| json!({"defs": [], "dataSets": []}));
+            // Snapshot at open so Alt+Reset restores the document's variables.
+            f.insert("__variablesOrig".into(), state.clone());
             f.insert("__variables".into(), state);
             f.insert("__page".into(), json!(page));
             f.insert("__label".into(), json!("Variables"));
@@ -40,6 +52,7 @@ pub fn menu(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<
             // No data set named: open the dialog on the Data Sets page to pick one.
             let mut f = Map::new();
             let state = app.session.active().map(|st| crate::variables_ui::to_state(&st.doc.variables)).unwrap_or_else(|| json!({"defs": [], "dataSets": []}));
+            f.insert("__variablesOrig".into(), state.clone());
             f.insert("__variables".into(), state);
             f.insert("__page".into(), json!("dataSets"));
             f.insert("__label".into(), json!("Variables"));
@@ -378,6 +391,16 @@ mod tests {
         }
     }
 
+    #[test]
+    fn alt_reset_restores_open_snapshot() {
+        let mut f = Map::new();
+        let orig = json!({"defs": [{"name": "a"}], "dataSets": []});
+        f.insert("__variables".into(), json!({"defs": [{"name": "edited"}], "dataSets": []}));
+        f.insert("__variablesOrig".into(), orig.clone());
+        reset(&mut f);
+        assert_eq!(f["__variables"], orig);
+    }
+
     #[test]
     fn owns_detects_the_field() {
         let mut f = Map::new();
diff --git a/crates/ui-egui/src/vector_paint_tests.rs b/crates/ui-egui/src/vector_paint_tests.rs
index 15a0c3f92c..c62277fb1e 100644
--- a/crates/ui-egui/src/vector_paint_tests.rs
+++ b/crates/ui-egui/src/vector_paint_tests.rs
@@ -285,3 +285,34 @@ fn selected_shape_colour_drags_apply_live_coalesce_per_gesture_and_keep_tool_def
     h.state_mut().run("edit.redo", json!({})).unwrap();
     assert_eq!(shape(h.state()).fill, first.fill);
 }
+
+/// #3997, #3999: after drawing a shape, the options bar's Fill swatch recolours it, as Stroke
+/// does (in v0.7.0 the Fill swatch was only a preview of the foreground colour).
+#[test]
+fn options_bar_fill_swatch_recolours_the_shape_just_drawn() {
+    let mut app = app("rgb", 8);
+    app.run("tools.setColors", json!({"foreground": "#ff0000", "background": "#0000ff"})).unwrap();
+    app.ui.tool_options.stroke_width = 3.0;
+    finish_shape(&mut app, Tool::Rectangle, [20.0, 20.0], [100.0, 80.0], Modifiers::NONE);
+    let original = shape(&app).clone();
+    let history = app.session.active().unwrap().history.past_len();
+    let mut h = harness(app, false);
+    h.get_by_label("Fill color").click();
+    h.run_steps(4);
+    let rect = popup_rect(&h);
+    let start = rect.min + vec2(55.0, rect.height() * 0.5);
+    h.hover_at(start);
+    h.step();
+    pointer(&mut h, start, true);
+    h.event(Event::PointerMoved(start + vec2(30.0, 6.0)));
+    h.step();
+    pointer(&mut h, start + vec2(30.0, 6.0), false);
+    h.run_steps(2);
+    let edited = shape(h.state()).clone();
+    assert_ne!(edited.fill, original.fill, "the Fill swatch recoloured the shape");
+    assert_eq!(edited.fill.as_ref().and_then(color_of), Some(h.state().session.tools.foreground), "and the next shape's fill");
+    assert_eq!(edited.stroke, original.stroke, "the stroke is untouched");
+    assert_eq!(h.state().session.active().unwrap().history.past_len(), history + 1);
+    h.state_mut().run("edit.undo", json!({})).unwrap();
+    assert_eq!(shape(h.state()).fill, original.fill);
+}
diff --git a/crates/ui-egui/src/vector_ui.rs b/crates/ui-egui/src/vector_ui.rs
index c9b3873c9a..e9d998b046 100644
--- a/crates/ui-egui/src/vector_ui.rs
+++ b/crates/ui-egui/src/vector_ui.rs
@@ -187,14 +187,31 @@ fn pen_to_json(pen: &PenPath, closed: bool) -> Value {
     json!({"subpaths": [{"closed": closed, "knots": pen.knots.iter().enumerate().map(|(i, k)| json!({"anchor": k[0], "in": k[1], "out": k[2], "smooth": !pen.unlinked.contains(&i) && (k[1] != k[0] || k[2] != k[0])})).collect::<Vec<_>>()}]})
 }
 
+/// Is `(x, y)` on the first anchor of a Pen path that a click there would close (two anchors or
+/// more)? `tol` is the anchors' hit radius in document pixels.
+fn on_closing_anchor(pen: &PenPath, x: f64, y: f64, tol: f64) -> bool {
+    pen.knots.len() >= 2 && pen.knots.first().is_some_and(|k| (k[0][0] - x).hypot(k[0][1] - y) < tol)
+}
+
+/// Would a click at `(x, y)` with `tool` close the path being drawn: the Pen over the first
+/// anchor, or the Curvature Pen over the first of three anchors or more? The canvas shows the
+/// close-path pointer there, as Photoshop does (#4596).
+pub fn closes_path_at(app: &PhotocraftApp, tool: Tool, x: f64, y: f64) -> bool {
+    let Some(pen) = app.ui.pen.as_ref().filter(|p| !p.dragging && p.moving.is_none()) else { return false };
+    match tool {
+        Tool::Pen => !pen.curvature && on_closing_anchor(pen, x, y, 6.0 / app.point_zoom().max(0.01) as f64),
+        Tool::CurvaturePen => pen.curvature && pen.knots.len() >= 3 && curvature_hit(app, x, y) == Some(0),
+        _ => false,
+    }
+}
+
 /// Pen press: close on the first anchor, reshape the last anchor's outgoing handle,
 /// or add a new anchor (dragging a new anchor pulls symmetrical handles).
 pub fn pen_down(app: &mut PhotocraftApp, x: f64, y: f64) {
     let tol = 6.0 / app.point_zoom().max(0.01) as f64;
     let pen = app.ui.pen.get_or_insert_with(PenPath::default);
     if let Some(first) = pen.knots.first().map(|k| k[0])
-        && pen.knots.len() >= 2
-        && (first[0] - x).hypot(first[1] - y) < tol
+        && on_closing_anchor(pen, x, y, tol)
     {
         // Pressing the first anchor closes the path on release. Until then a stand-in for it
         // takes the drag, which pulls out that anchor's handles (close-drag, #3306).
@@ -246,6 +263,13 @@ pub fn pen_undo_last_point(app: &mut PhotocraftApp) -> bool {
     if pen.knots.pop().is_none() {
         return false;
     }
+    let n = pen.knots.len();
+    let ds = &mut app.ui.direct_selection;
+    if ds.target == Some(crate::direct_select::PathRef::Pen) {
+        // A ⌘/Ctrl selection on the path being drawn loses the removed anchor.
+        ds.anchors.retain(|a| a[1] < n);
+        ds.segment = ds.segment.filter(|s| s[1] + 1 < n);
+    }
     pen.unlinked.retain(|&i| i < pen.knots.len());
     if pen.curvature {
         pen.moving = None;
@@ -304,6 +328,12 @@ pub fn pen_grab_handle(app: &mut PhotocraftApp, x: f64, y: f64) -> bool {
     true
 }
 
+/// Would a press at `at` close the Pen path: is the pointer on the first anchor of a path that
+/// already has a segment, and no drag is under way? The canvas then shows the close cue (#4193).
+pub(crate) fn over_first_anchor(pen: &PenPath, at: [f64; 2], tol: f64) -> bool {
+    !pen.dragging && pen.moving.is_none() && pen.knots.len() >= 2 && pen.knots.first().is_some_and(|k| (k[0][0] - at[0]).hypot(k[0][1] - at[1]) < tol)
+}
+
 /// Is a close-drag in progress: does the path end in the stand-in for its first anchor?
 fn closing(pen: &PenPath) -> bool {
     pen.knots.len() >= 3 && pen.knots.first().map(|k| k[0]) == pen.knots.last().map(|k| k[0])
@@ -331,9 +361,49 @@ fn fold_close(pen: &PenPath) -> Option<PenPath> {
     Some(p)
 }
 
+/// The Pen path being drawn as a document path (one open subpath), so ⌘/Ctrl (Direct Selection)
+/// can edit it in place while drawing (#4022).
+pub(crate) fn pen_path(pen: &PenPath) -> Path {
+    let pt = |q: [f64; 2]| photocraft_geom::Point::new(q[0], q[1]);
+    let knots = pen
+        .knots
+        .iter()
+        .enumerate()
+        .map(|(i, k)| photocraft_doc::Knot {
+            anchor: pt(k[0]),
+            in_ctrl: pt(k[1]),
+            out_ctrl: pt(k[2]),
+            smooth: !pen.unlinked.contains(&i) && (k[1] != k[0] || k[2] != k[0]),
+        })
+        .collect();
+    Path::new(vec![photocraft_doc::vector::Subpath { closed: false, knots, op: Default::default() }])
+}
+
+/// The Pen path being drawn becomes `path`'s first subpath, edited with ⌘/Ctrl (Direct Selection);
+/// drawing carries on from its last anchor. A Curvature Pen path keeps following its anchors.
+pub(crate) fn pen_replace(app: &mut PhotocraftApp, path: &Path) {
+    let Some(pen) = app.ui.pen.as_mut() else { return };
+    let knots = path.subpaths.first().map(|s| s.knots.as_slice()).unwrap_or_default();
+    pen.knots = knots.iter().map(knot_points).collect();
+    pen.unlinked = knots.iter().enumerate().filter(|(_, k)| !k.smooth).map(|(i, _)| i).collect();
+    pen.dragging = false;
+    pen.adjusting_last = false;
+    pen.moving = None;
+    if pen.curvature {
+        curvature_refresh(pen, false);
+    }
+    if pen.knots.is_empty() {
+        app.ui.pen = None;
+    }
+}
+
 /// Finish the pen path: a work path (Path mode) or a new shape layer (Shape mode).
 pub fn pen_commit(app: &mut PhotocraftApp, closed: bool) {
     let Some(mut pen) = app.ui.pen.take() else { return };
+    if app.ui.direct_selection.target == Some(crate::direct_select::PathRef::Pen) {
+        // Its anchors are no longer the Pen's: the committed path is another path.
+        app.ui.direct_selection = Default::default();
+    }
     if pen.curvature {
         curvature_refresh(&mut pen, closed);
     }
@@ -366,8 +436,16 @@ fn commit_path(app: &mut PhotocraftApp, pen: &PenPath, closed: bool) {
         }
         app.run("layer.vectorMask.edit", json!({"layer": id, "path": p}))
     } else {
-        // The drawn work path is selected in the Paths panel, as in Photoshop.
-        app.run("path.set", json!({"name": "work", "path": path})).inspect(|_| app.ui.selected_path = Some("work".into()))
+        // Photoshop adds the new subpath to the path selected in the Paths panel, which is the
+        // Work Path right after drawing one, so path after path builds up there (#4721). With no
+        // path selected, a new Work Path replaces the old one. The drawn path ends up selected.
+        let target = app.ui.selected_path.clone().filter(|n| app.session.active().is_some_and(|st| path_exists(&st.doc, n)));
+        let name = target.clone().unwrap_or_else(|| "work".into());
+        let mut params = json!({"name": name, "path": path});
+        if target.is_some() {
+            params["op"] = json!("combine");
+        }
+        app.run("path.set", params).inspect(|_| app.ui.selected_path = Some(name))
     };
     if let Err(e) = r {
         app.ui.status = e;
@@ -375,6 +453,11 @@ fn commit_path(app: &mut PhotocraftApp, pen: &PenPath, closed: bool) {
     }
 }
 
+/// Does `doc` have the path the Paths panel calls `name`: "work", or a saved path's name?
+fn path_exists(doc: &Document, name: &str) -> bool {
+    if name == "work" { doc.work_path.is_some() } else { doc.paths.iter().any(|p| p.name == name) }
+}
+
 // ---------------------------------------------------------------------------------------------
 // Freeform Pen and Curvature Pen
 
@@ -541,6 +624,18 @@ pub fn takes_path_mask(id: &str) -> bool {
     id.starts_with("layer.newFillLayer.") || id.starts_with("layer.newAdjustmentLayer.")
 }
 
+/// The work or saved path explicitly selected in the Paths panel (not a layer's own path).
+pub fn selected_document_path(app: &PhotocraftApp) -> Option<String> {
+    let st = app.session.active()?;
+    let sel = app.ui.selected_path.as_deref()?;
+    let listed = path_rows(&st.doc, st.active_layer).iter().any(|r| match r.kind {
+        PathRow::Work => sel == "work",
+        PathRow::Saved => r.name == sel,
+        PathRow::Layer => false,
+    });
+    listed.then(|| sel.to_string())
+}
+
 /// New fill and adjustment layers take the path selected in the Paths panel as their vector mask,
 /// as in Photoshop (#1419): the command gets it as `"path"` unless the caller set one (`null`
 /// opts out). Only an explicitly selected work or saved path counts; deselect it by clicking the
@@ -549,16 +644,7 @@ pub fn with_active_path(app: &PhotocraftApp, id: &str, params: Value) -> Value {
     if !takes_path_mask(id) || params.get("path").is_some() {
         return params;
     }
-    let Some(st) = app.session.active() else { return params };
-    let Some(sel) = app.ui.selected_path.as_deref() else { return params };
-    let listed = path_rows(&st.doc, st.active_layer).iter().any(|r| match r.kind {
-        PathRow::Work => sel == "work",
-        PathRow::Saved => r.name == sel,
-        PathRow::Layer => false,
-    });
-    if !listed {
-        return params;
-    }
+    let Some(sel) = selected_document_path(app) else { return params };
     match params {
         Value::Object(mut m) => {
             m.insert("path".into(), json!(sel));
@@ -642,11 +728,98 @@ pub(crate) fn free_transform_path(app: &PhotocraftApp) -> Option<(Value, Path)>
     Some((params, path))
 }
 
+fn point_in_subpath(sp: &photocraft_doc::vector::Subpath, pt: [f64; 2]) -> bool {
+    if !sp.closed || sp.knots.len() < 3 {
+        return false;
+    }
+    let mut inside = false;
+    let n = sp.knots.len();
+    for i in 0..n {
+        let j = (i + 1) % n;
+        let xi = sp.knots[i].anchor.x;
+        let yi = sp.knots[i].anchor.y;
+        let xj = sp.knots[j].anchor.x;
+        let yj = sp.knots[j].anchor.y;
+        let intersect = ((yi > pt[1]) != (yj > pt[1])) && (pt[0] < (xj - xi) * (pt[1] - yi) / (yj - yi) + xi);
+        if intersect {
+            inside = !inside;
+        }
+    }
+    inside
+}
+
+/// The topmost visible shape layer under `at` (document coordinates):
+/// hits the shape path or anchor within `tol`, or any non-transparent pixel of the shape's raster surface,
+/// or point inside the shape's filled geometry.
+pub fn pick_shape_at(doc: &Document, at: [f64; 2], tol: f64) -> Option<photocraft_doc::LayerId> {
+    let (x, y) = (at[0].floor() as i32, at[1].floor() as i32);
+    for (path, _, l) in doc.walk().iter().rev() {
+        if !l.visible || !(1..=path.len()).all(|n| doc.layer_at(&path[..n]).is_some_and(|a| a.visible)) {
+            continue;
+        }
+        let board = path.first().and_then(|i| doc.layers.get(*i)).and_then(|t| t.artboard());
+        if board.is_some_and(|a| !a.rect.contains(x, y)) {
+            continue;
+        }
+        if let LayerContent::Shape(sh) = &l.content {
+            if photocraft_vector::edit::hit(&sh.path, photocraft_geom::Point::new(at[0], at[1]), tol, &[]).is_some() {
+                return Some(l.id);
+            }
+            if sh.fill.is_some() {
+                if let Some(surf) = l.surface() {
+                    let mut px = [[0.0f32; 4]; 1];
+                    surf.read_rgba_into(photocraft_doc::Rect::from_xywh(x, y, 1, 1), &mut px);
+                    if px[0][3] > 0.0 {
+                        return Some(l.id);
+                    }
+                }
+                if let Some(photocraft_doc::LiveShape::Rect { rect, .. }) = &sh.live {
+                    let x0 = rect[0].min(rect[0] + rect[2]);
+                    let x1 = rect[0].max(rect[0] + rect[2]);
+                    let y0 = rect[1].min(rect[1] + rect[3]);
+                    let y1 = rect[1].max(rect[1] + rect[3]);
+                    if at[0] >= x0 && at[0] <= x1 && at[1] >= y0 && at[1] <= y1 {
+                        return Some(l.id);
+                    }
+                }
+                if let Some(photocraft_doc::LiveShape::Ellipse { rect }) = &sh.live {
+                    let rx = rect[2].abs() / 2.0;
+                    let ry = rect[3].abs() / 2.0;
+                    if rx > 1e-6 && ry > 1e-6 {
+                        let cx = rect[0] + rect[2] / 2.0;
+                        let cy = rect[1] + rect[3] / 2.0;
+                        let dx = (at[0] - cx) / rx;
+                        let dy = (at[1] - cy) / ry;
+                        if dx * dx + dy * dy <= 1.0 {
+                            return Some(l.id);
+                        }
+                    }
+                }
+                if sh.path.subpaths.iter().any(|sp| point_in_subpath(sp, at)) {
+                    return Some(l.id);
+                }
+            }
+        }
+    }
+    None
+}
+
 pub fn path_selection_finish(app: &mut PhotocraftApp, start: [f64; 2], end: [f64; 2]) {
     let (dx, dy) = (end[0] - start[0], end[1] - start[1]);
+    let tol = 6.0 / f64::from(app.point_zoom().max(0.01));
     if dx.abs() + dy.abs() < 0.5 {
+        let Some(st) = app.session.active() else { return };
+        if let Some(id) = pick_shape_at(&st.doc, start, tol) {
+            let _ = app.run("layer.select", json!({"layer": id.0}));
+        }
         return;
     }
+    if target_path(app).is_none() {
+        let Some(st) = app.session.active() else { return };
+        if let Some(id) = pick_shape_at(&st.doc, start, tol) {
+            let _ = app.run("layer.select", json!({"layer": id.0}));
+        }
+    }
     let Some((target, path)) = target_path(app) else { return };
     let _ = match target {
         PathTarget::Shape(id) => app.run("shape.edit", json!({"layer": id, "move": [dx.round(), dy.round()]})),
@@ -670,6 +843,45 @@ fn bezier(p0: [f64; 2], c0: [f64; 2], c1: [f64; 2], p1: [f64; 2], t: f64) -> [f6
     [f(p0[0], c0[0], c1[0], p1[0]), f(p0[1], c0[1], c1[1], p1[1])]
 }
 
+/// `q` lies on the chord from `a` to `d` (within a thousandth of a pixel).
+fn on_chord(a: [f64; 2], q: [f64; 2], d: [f64; 2]) -> bool {
+    let (dx, dy, vx, vy) = (d[0] - a[0], d[1] - a[1], q[0] - a[0], q[1] - a[1]);
+    let len = dx.hypot(dy);
+    if len < 1e-9 {
+        return vx.hypot(vy) < 1e-3;
+    }
+    let t = (vx * dx + vy * dy) / (len * len);
+    (vx * dy - vy * dx).abs() / len < 1e-3 && (-1e-9..=1.0 + 1e-9).contains(&t)
+}
+
+/// How far (in screen pixels) a drawn chord may stray from the true curve.
+const CURVE_TOLERANCE: f64 = 0.3;
+/// Pieces per segment at most: 0.3 px holds for curves bending up to about 1.4 million px on screen.
+const MAX_CURVE_PIECES: usize = 1024;
+
+/// Screen points along one cubic segment (both ends included). The control points are mapped to
+/// the screen first (`xf` is affine, so the curve maps exactly), and the number of chords follows
+/// how much the curve bends there: a straight segment is one chord, and a curve zoomed in stays
+/// smooth instead of showing a fixed 16 chords (#4084). Uses the bound
+/// `max|B''| / 8n² <= tol` with `max|B''| <= 6·max(|p0−2c0+c1|, |c0−2c1+p1|)`.
+pub(crate) fn curve_points(p0: [f64; 2], c0: [f64; 2], c1: [f64; 2], p1: [f64; 2], xf: &dyn Fn([f64; 2]) -> Pos2) -> Vec<Pos2> {
+    let [a, b, c, d] = [p0, c0, c1, p1].map(|q| {
+        let s = xf(q);
+        [f64::from(s.x), f64::from(s.y)]
+    });
+    let second = |p: [f64; 2], q: [f64; 2], r: [f64; 2]| (p[0] - 2.0 * q[0] + r[0]).hypot(p[1] - 2.0 * q[1] + r[1]);
+    let n = (0.75 * second(a, b, c).max(second(b, c, d)) / CURVE_TOLERANCE).sqrt().ceil();
+    // A straight segment (controls on the chord, like the Pen's retracted handles) is one chord;
+    // NaN (a non-finite point) falls back to one too.
+    let n = if n.is_finite() && !(on_chord(a, b, d) && on_chord(a, c, d)) { (n as usize).clamp(1, MAX_CURVE_PIECES) } else { 1 };
+    (0..=n)
+        .map(|k| {
+            let q = bezier(a, b, c, d, k as f64 / n as f64);
+            pos2(q[0] as f32, q[1] as f32)
+        })
+        .collect()
+}
+
 /// Screen polylines for a path (one per subpath).
 pub(crate) fn path_lines(path: &Path, xf: &dyn Fn([f64; 2]) -> Pos2) -> Vec<(Vec<Pos2>, bool)> {
     path.subpaths
@@ -680,11 +892,7 @@ pub(crate) fn path_lines(path: &Path, xf: &dyn Fn([f64; 2]) -> Pos2) -> Vec<(Vec
             let segs = if s.closed { n } else { n.saturating_sub(1) };
             for i in 0..segs {
                 let (a, b) = (&s.knots[i], &s.knots[(i + 1) % n]);
-                for k in 0..=16 {
-                    let q =
-                        bezier([a.anchor.x, a.anchor.y], [a.out_ctrl.x, a.out_ctrl.y], [b.in_ctrl.x, b.in_ctrl.y], [b.anchor.x, b.anchor.y], k as f64 / 16.0);
-                    pts.push(xf(q));
-                }
+                pts.extend(curve_points([a.anchor.x, a.anchor.y], [a.out_ctrl.x, a.out_ctrl.y], [b.in_ctrl.x, b.in_ctrl.y], [b.anchor.x, b.anchor.y], xf));
             }
             if pts.is_empty()
                 && let Some(k) = s.knots.first()
@@ -759,9 +967,13 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
         if let Some((_, p)) = targeted_vector_mask(app) {
             draw_path(&p, tool == Tool::PathSelection);
         }
+        // The segment the Pen's Auto Add/Delete would add an anchor to, or the anchor it would delete.
+        crate::anchor_tools::draw_pen_hover(app, painter, &to_scr, accent, painter.ctx().input(|i| i.modifiers));
     }
-    // Pen path in progress, with handles of the last knot and a rubber band to the pointer.
-    if let Some(pen) = &app.ui.pen {
+    // Pen path in progress, with handles of the last knot and a rubber band to the pointer. While
+    // ⌘/Ctrl drags it, Direct Selection draws its preview instead.
+    let edited = matches!(&app.ui.direct_selection.drag, Some(crate::direct_select::Drag::Edit { target: crate::direct_select::PathRef::Pen, .. }));
+    if let Some(pen) = app.ui.pen.as_ref().filter(|_| !edited) {
         let mut pts = Vec::new();
         // A close-drag shows the first segment bending with the handle being pulled out.
         let mut knots = pen.knots.clone();
@@ -773,9 +985,7 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
             first[2] = out;
         }
         for w in knots.windows(2) {
-            for k in 0..=16 {
-                pts.push(to_scr(bezier(w[0][0], w[0][2], w[1][1], w[1][0], k as f64 / 16.0)));
-            }
+            pts.extend(curve_points(w[0][0], w[0][2], w[1][1], w[1][0], &to_scr));
         }
         painter.add(egui::Shape::line(pts, Stroke::new(1.5, accent)));
         if let (Some(last), Some(h)) = (pen.knots.last(), app.hover_doc)
@@ -788,7 +998,7 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
                 next.knots.push([h; 3]);
                 curvature_refresh(&mut next, false);
                 if let [.., a, b] = next.knots.as_slice() {
-                    let pts: Vec<Pos2> = (0..=24).map(|k| to_scr(bezier(a[0], a[2], b[1], b[0], k as f64 / 24.0))).collect();
+                    let pts = curve_points(a[0], a[2], b[1], b[0], &to_scr);
                     painter.add(egui::Shape::dashed_line(&pts, Stroke::new(1.0, accent), 4.0, 3.0));
                 }
             } else {
@@ -805,6 +1015,16 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
             }
             draw_anchor(painter, c, last, accent);
         }
+        // Hovering the first anchor: Photoshop's close cue, a small ring beside the pointer.
+        let tol = 6.0 / f64::from(app.point_zoom().max(0.01));
+        if let Some(h) = app.hover_doc
+            && over_first_anchor(pen, h, tol)
+            && let Some(first) = pen.knots.first()
+        {
+            let c = to_scr(first[0]);
+            painter.rect_filled(Rect::from_center_size(c, vec2(8.0, 8.0)), 0.0, accent);
+            painter.circle_stroke(c + vec2(11.0, 11.0), 3.5, Stroke::new(1.5, accent));
+        }
     }
 }
 
@@ -826,11 +1046,12 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
         ui.label(egui::RichText::new(s).color(t.text_dim).size(12.0));
     };
     let o = &mut app.ui.tool_options;
-    if tool == Tool::PathSelection {
+    let target = selected_shape(&app.session);
+    if tool == Tool::PathSelection && target.is_none() {
         lbl(ui, if app.ui.vector_mask_target { "Drag to move the targeted vector mask" } else { tl!("Drag to move the active shape's path or the Work Path") });
         return true;
     }
-    if tool == Tool::DirectSelection {
+    if tool == Tool::DirectSelection && target.is_none() {
         let (shift, alt) = (crate::shortcuts::pretty("Shift"), crate::shortcuts::pretty("Alt"));
         lbl(
             ui,
@@ -863,6 +1084,10 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
                 o.stroke_width = enabled_stroke_width(o.stroke_width);
             }
         }
+        if tool == Tool::Pen {
+            crate::widgets::vline(ui, 22.0);
+            crate::widgets::checkbox(ui, &mut o.pen_auto_add_delete, tl!("Auto Add/Delete"));
+        }
         let enter = crate::shortcuts::pretty("Enter");
         match tool {
             Tool::FreeformPen => {
@@ -893,7 +1118,6 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
     crate::widgets::dropdown(ui, "shape-mode", &mut mode, &[("shape".to_string(), tl!("Shape"))], 80.0);
     crate::widgets::vline(ui, 22.0);
     // Fill and Stroke edit the selected shape layer too (#3347), and still set the next shape's.
-    let target = selected_shape(&app.session);
     let (fg, bg) = (app.session.tools.foreground, app.session.tools.background);
     let (mut has_fill, fill, stroke) = match &target {
         Some(s) => (s.fill.is_some(), s.fill.clone(), s.stroke.clone()),
@@ -936,7 +1160,15 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
         Tool::Rectangle => {
             crate::widgets::vline(ui, 22.0);
             lbl(ui, tl!("Radius:"));
-            crate::widgets::value_field(ui, &mut o.corner_radius, 0.0..=10000.0, "px", 62.0);
+            let mut r = match target.as_ref().and_then(|s| s.live.as_ref()) {
+                Some(photocraft_doc::LiveShape::Rect { radii, .. }) => radii[0] as f32,
+                _ => o.corner_radius,
+            };
+            if crate::widgets::value_field(ui, &mut r, 0.0..=10000.0, "px", 62.0).changed() {
+                o.corner_radius = r;
+                let rf = r as f64;
+                edit = Some(json!({"radii": [rf, rf, rf, rf], "coalesce": key("radius")}));
+            }
         }
         Tool::Polygon => {
             crate::widgets::vline(ui, 22.0);
@@ -955,6 +1187,18 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui, tool: Tool) -> bo
             crate::widgets::vline(ui, 22.0);
             crate::preset_panels::shape_picker(app, ui);
         }
+        _ if matches!(tool, Tool::PathSelection | Tool::DirectSelection) => {
+            if let Some(photocraft_doc::LiveShape::Rect { radii, .. }) = target.as_ref().and_then(|s| s.live.as_ref()) {
+                crate::widgets::vline(ui, 22.0);
+                lbl(ui, tl!("Radius:"));
+                let mut r = radii[0] as f32;
+                if crate::widgets::value_field(ui, &mut r, 0.0..=10000.0, "px", 62.0).changed() {
+                    o.corner_radius = r;
+                    let rf = r as f64;
+                    edit = Some(json!({"radii": [rf, rf, rf, rf], "coalesce": key("radius")}));
+                }
+            }
+        }
         _ => {}
     }
     for (is_stroke, change) in [(false, fill_color), (true, stroke_color)] {
@@ -986,13 +1230,14 @@ struct SelectedShape {
     layer: photocraft_doc::LayerId,
     fill: Option<photocraft_doc::Fill>,
     stroke: Option<photocraft_doc::ShapeStroke>,
+    live: Option<photocraft_doc::LiveShape>,
 }
 
 fn selected_shape(session: &photocraft_engine::Session) -> Option<SelectedShape> {
     let st = session.active()?;
     let layer = st.active_layer?;
     match &st.doc.layer(layer)?.content {
-        LayerContent::Shape(sh) => Some(SelectedShape { doc: st.doc.id, layer, fill: sh.fill.clone(), stroke: sh.stroke.clone() }),
+        LayerContent::Shape(sh) => Some(SelectedShape { doc: st.doc.id, layer, fill: sh.fill.clone(), stroke: sh.stroke.clone(), live: sh.live.clone() }),
         _ => None,
     }
 }
@@ -1583,6 +1828,60 @@ pub fn paths_panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
 mod tests {
     use super::*;
 
+    /// #4084: zoomed in, a curve's chords stay within a fraction of a pixel of the true curve
+    /// (16 fixed chords showed corners), and a straight segment stays one chord.
+    #[test]
+    fn path_curves_stay_smooth_at_any_zoom() {
+        let (p0, c0, c1, p1) = ([0.0, 100.0], [20.0, -60.0], [80.0, -60.0], [100.0, 100.0]);
+        for zoom in [0.25, 1.0, 8.0, 64.0, 320.0] {
+            let xf = move |q: [f64; 2]| pos2((q[0] * zoom) as f32 + 10.0, (q[1] * zoom) as f32 - 5.0);
+            let pts = curve_points(p0, c0, c1, p1, &xf);
+            let n = pts.len() - 1;
+            assert_eq!((pts[0], pts[n]), (xf(p0), xf(p1)), "the ends are the anchors");
+            for (k, w) in pts.windows(2).enumerate() {
+                let curve = xf(bezier(p0, c0, c1, p1, (k as f64 + 0.5) / n as f64));
+                let chord = w[0] + (w[1] - w[0]) * 0.5;
+                assert!((chord - curve).length() <= 0.35, "zoom {zoom}: chord {k} of {n} is {} px off", (chord - curve).length());
+            }
+            // Zoomed out it stays cheap.
+            if zoom <= 1.0 {
+                assert!(n <= 32, "zoom {zoom}: {n} chords");
+            }
+        }
+        let xf = |q: [f64; 2]| pos2((q[0] * 320.0) as f32, (q[1] * 320.0) as f32);
+        // Retracted handles, and handles along the line: one chord.
+        assert_eq!(curve_points([0.0, 0.0], [0.0, 0.0], [50.0, 50.0], [50.0, 50.0], &xf).len(), 2);
+        assert_eq!(curve_points([0.0, 0.0], [10.0, 10.0], [40.0, 40.0], [50.0, 50.0], &xf).len(), 2);
+        // A handle past the end is a curve that doubles back, not a line.
+        assert!(curve_points([0.0, 0.0], [0.0, 0.0], [80.0, 80.0], [50.0, 50.0], &xf).len() > 2);
+        // Hostile coordinates: no panic, a bounded number of points.
+        for bad in [f64::NAN, f64::INFINITY, 1e300] {
+            assert!(curve_points([0.0, 0.0], [bad, 0.0], [0.0, bad], [1.0, 1.0], &xf).len() <= MAX_CURVE_PIECES + 1);
+        }
+        // Through path_lines too: a closed subpath of two curved segments.
+        let mut path = Path::default();
+        path.subpaths.push(photocraft_doc::vector::Subpath {
+            knots: vec![
+                photocraft_doc::vector::Knot {
+                    anchor: photocraft_geom::Point::new(0.0, 0.0),
+                    in_ctrl: photocraft_geom::Point::new(0.0, 40.0),
+                    out_ctrl: photocraft_geom::Point::new(0.0, -40.0),
+                    smooth: true,
+                },
+                photocraft_doc::vector::Knot {
+                    anchor: photocraft_geom::Point::new(60.0, 0.0),
+                    in_ctrl: photocraft_geom::Point::new(60.0, -40.0),
+                    out_ctrl: photocraft_geom::Point::new(60.0, 40.0),
+                    smooth: true,
+                },
+            ],
+            closed: true,
+            ..Default::default()
+        });
+        let lines = path_lines(&path, &xf);
+        assert!(lines[0].1 && lines[0].0.len() > 2 * 17, "zoomed in, more than the old 16 chords per segment: {}", lines[0].0.len());
+    }
+
     #[test]
     fn all_shape_tools_and_open_pen_use_the_complete_stroke_defaults() {
         for tool in [Tool::Rectangle, Tool::EllipseShape, Tool::Triangle, Tool::Polygon, Tool::Line, Tool::CustomShape] {
@@ -1773,6 +2072,21 @@ mod tests {
         assert!(photocraft_engine::vector_cmds::shape_path(&json!({"kind": "rect"})).is_err());
     }
 
+    #[test]
+    fn pen_shows_the_close_cue_only_over_the_first_anchor_of_a_real_segment() {
+        let mut app = app();
+        app.ui.tool = Tool::Pen;
+        pen_down(&mut app, 20.0, 20.0);
+        pen_up(&mut app);
+        let one = app.ui.pen.clone().unwrap();
+        assert!(!over_first_anchor(&one, [20.0, 20.0], 6.0), "a single anchor has nothing to close");
+        pen_down(&mut app, 120.0, 20.0);
+        pen_up(&mut app);
+        let two = app.ui.pen.clone().unwrap();
+        assert!(over_first_anchor(&two, [22.0, 21.0], 6.0));
+        assert!(!over_first_anchor(&two, [60.0, 60.0], 6.0));
+    }
+
     #[test]
     fn pen_builds_and_closes_a_work_path() {
         let mut app = app();
@@ -1796,6 +2110,84 @@ mod tests {
         assert_eq!((wp.subpaths[0].knots[0].anchor.x, wp.subpaths[0].knots[0].anchor.y), (30.0, 25.0));
     }
 
+    /// #4721: a second Pen path joins the Work Path it was drawn after (still selected), as a new
+    /// subpath, instead of replacing it; a saved path that is selected takes it instead; with no
+    /// path selected, the new path replaces the Work Path, as in Photoshop.
+    #[test]
+    fn a_new_pen_path_joins_the_selected_path() {
+        let mut app = app();
+        app.ui.tool = Tool::Pen;
+        let draw = |app: &mut PhotocraftApp, x: f64| {
+            for (dx, dy) in [(0.0, 0.0), (40.0, 0.0), (40.0, 40.0)] {
+                pen_down(app, x + dx, 20.0 + dy);
+                pen_up(app);
+            }
+            pen_down(app, x + 0.5, 20.5); // close
+            pen_up(app);
+        };
+        let work = |app: &PhotocraftApp| app.session.active().unwrap().doc.work_path.clone().unwrap();
+        draw(&mut app, 20.0);
+        assert_eq!(app.ui.selected_path.as_deref(), Some("work"));
+        draw(&mut app, 120.0);
+        let wp = work(&app);
+        assert_eq!(wp.subpaths.len(), 2, "the first path stays");
+        assert!(wp.subpaths.iter().all(|s| s.closed && s.knots.len() == 3));
+        assert_eq!(wp.subpaths[0].knots[0].anchor.x, 20.0);
+        assert_eq!(wp.subpaths[1].knots[0].anchor.x, 120.0);
+        // One History step per path.
+        app.session.undo();
+        assert_eq!(work(&app).subpaths.len(), 1, "undo takes back only the second path");
+        app.session.redo();
+        // A selected saved path takes the next one.
+        app.run("path.set", json!({"name": "Saved", "path": {"subpaths": [{"knots": [[2, 2], [12, 2], [12, 8]]}]}})).unwrap();
+        app.ui.selected_path = Some("Saved".into());
+        draw(&mut app, 220.0);
+        let saved = app.session.active().unwrap().doc.paths.iter().find(|p| p.name == "Saved").unwrap().path.clone();
+        assert_eq!(saved.subpaths.len(), 2);
+        assert_eq!(work(&app).subpaths.len(), 2, "the Work Path is left alone");
+        assert_eq!(app.ui.selected_path.as_deref(), Some("Saved"));
+        // No path selected: a new Work Path replaces the old one.
+        app.ui.selected_path = None;
+        draw(&mut app, 320.0);
+        let wp = work(&app);
+        assert_eq!(wp.subpaths.len(), 1);
+        assert_eq!(wp.subpaths[0].knots[0].anchor.x, 320.0);
+        assert_eq!(app.ui.selected_path.as_deref(), Some("work"));
+    }
+
+    /// #4596: the close-path pointer shows where a click would close the path, and only there:
+    /// over the first anchor once the Pen has two anchors (the Curvature Pen three), not while an
+    /// anchor is being dragged.
+    #[test]
+    fn close_path_pointer_shows_where_a_click_closes() {
+        let mut app = app();
+        app.ui.tool = Tool::Pen;
+        assert!(!closes_path_at(&app, Tool::Pen, 20.0, 20.0), "no path yet");
+        pen_down(&mut app, 20.0, 20.0);
+        pen_up(&mut app);
+        assert!(!closes_path_at(&app, Tool::Pen, 20.0, 20.0), "one anchor: a click there doesn't close");
+        pen_down(&mut app, 120.0, 20.0);
+        assert!(!closes_path_at(&app, Tool::Pen, 20.0, 20.0), "not while dragging the new anchor");
+        pen_up(&mut app);
+        assert!(closes_path_at(&app, Tool::Pen, 21.0, 22.0), "over the first anchor");
+        assert!(!closes_path_at(&app, Tool::Pen, 120.0, 20.0) && !closes_path_at(&app, Tool::Pen, 60.0, 60.0), "the last anchor and empty canvas");
+        assert!(!closes_path_at(&app, Tool::CurvaturePen, 20.0, 20.0), "a Pen path isn't the Curvature Pen's");
+        pen_down(&mut app, 21.0, 22.0);
+        pen_up(&mut app);
+        assert!(app.ui.pen.is_none() && !closes_path_at(&app, Tool::Pen, 20.0, 20.0), "the click closed it");
+
+        app.ui.tool = Tool::CurvaturePen;
+        for (x, y) in [(20.0, 20.0), (120.0, 20.0)] {
+            curvature_down(&mut app, x, y);
+            curvature_up(&mut app);
+        }
+        assert!(!closes_path_at(&app, Tool::CurvaturePen, 20.0, 20.0), "two anchors: the Curvature Pen moves the first");
+        curvature_down(&mut app, 120.0, 120.0);
+        curvature_up(&mut app);
+        assert!(closes_path_at(&app, Tool::CurvaturePen, 20.0, 20.0));
+        assert!(!closes_path_at(&app, Tool::CurvaturePen, 120.0, 120.0));
+    }
+
     #[test]
     fn pen_point_undo_preserves_earlier_knots_and_document_history() {
         let mut app = app();
@@ -2136,6 +2528,65 @@ mod tests {
         click_fill(&mut h);
         assert_eq!(h.state().session.active().unwrap().history.past_len(), history);
     }
+
+    /// #3915: Path Selection and Direct Selection options bars show Fill, Stroke, and Radius
+    /// controls when a shape is selected, and editing them edits the selected shape.
+    #[test]
+    fn path_selection_options_bar_edits_the_selected_shape() {
+        use egui::accesskit::Role;
+        use egui_kittest::kittest::Queryable;
+        let mut app = app();
+        app.run("tools.setColors", json!({"foreground": "#ff0000", "background": "#0000ff"})).unwrap();
+        finish_shape(&mut app, Tool::Rectangle, [20.0, 20.0], [120.0, 100.0], Default::default());
+        let shape = |app: &PhotocraftApp| {
+            let st = app.session.active().unwrap();
+            match &st.doc.layer(st.active_layer.unwrap()).unwrap().content {
+                LayerContent::Shape(sh) => (sh.fill.clone(), sh.stroke.clone()),
+                _ => panic!("not a shape layer"),
+            }
+        };
+        assert!(shape(&app).0.is_some() && shape(&app).1.is_none());
+        let mut h = egui_kittest::Harness::builder().with_size(vec2(1100.0, 48.0)).build_ui_state(
+            |ui, app: &mut PhotocraftApp| {
+                if ui.ctx().fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) {
+                    ui.horizontal_centered(|ui| options_bar(app, ui, Tool::PathSelection));
+                }
+            },
+            app,
+        );
+        PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::Studio);
+        h.run_steps(4);
+        let click_fill = |h: &mut egui_kittest::Harness<'_, PhotocraftApp>| {
+            let label = h.query_all(egui_kittest::kittest::by().label("Fill:").include_labels()).next().expect("the Fill label").rect();
+            let at = egui::pos2(label.right() + h.ctx.global_style().spacing.item_spacing.x + 7.0, label.center().y);
+            h.hover_at(at);
+            h.step();
+            for pressed in [true, false] {
+                h.event(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
+                h.step();
+            }
+            h.run_steps(2);
+        };
+        // Stroke width field is available on Path Selection bar too.
+        h.get_all_by_role(Role::SpinButton).next().expect("the stroke width").click();
+        h.run();
+        for c in "6".chars() {
+            h.event(egui::Event::Text(c.to_string()));
+            h.run();
+        }
+        h.key_press(egui::Key::Enter);
+        h.run_steps(2);
+        let stroke = shape(h.state()).1.expect("the width field stroked the shape");
+        assert_eq!(stroke.width, 6.0);
+        assert_eq!(stroke.paint, photocraft_doc::Fill::Solid(photocraft_doc::Color::rgba(0.0, 0.0, 1.0, 1.0)));
+        // Fill toggle.
+        click_fill(&mut h);
+        assert_eq!(shape(h.state()).0, None, "unchecking Fill removed the shape's fill");
+        // No shape selected: renders hint text instead.
+        h.state_mut().run("layer.new.layer", json!({})).unwrap();
+        h.run_steps(2);
+        assert!(h.query_all(egui_kittest::kittest::by().label("Fill:").include_labels()).next().is_none());
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/view_cmds.rs b/crates/ui-egui/src/view_cmds.rs
index abedae867a..793257be8b 100644
--- a/crates/ui-egui/src/view_cmds.rs
+++ b/crates/ui-egui/src/view_cmds.rs
@@ -96,9 +96,13 @@ pub struct ViewOptions {
     pub middle_eastern_composer: bool,
     /// Parameters from the last successfully applied New Guide Layout dialog.
     pub guide_layout: Value,
+    /// Developer overlay of the active layer's storage tiles (tile_overlay.rs), set with the
+    /// control channel's `ui.set {"tileGrid": true}`.
+    pub tile_grid: bool,
 }
 
-fn default_guide_layout() -> Value {
+/// Factory New Guide Layout values (Alt+Reset and a fresh ViewOptions).
+pub(crate) fn default_guide_layout() -> Value {
     json!({"columns": 8, "gutter": 20, "rows": 0, "rowGutter": 0, "margin": 0, "centerColumns": false, "clearExisting": false})
 }
 
@@ -120,6 +124,7 @@ impl Default for ViewOptions {
             language_features: "defaultFeatures".into(),
             middle_eastern_composer: false,
             guide_layout: default_guide_layout(),
+            tile_grid: false,
         }
     }
 }
@@ -166,6 +171,41 @@ const LAYOUTS: [&str; 10] = [
     "tile",
 ];
 
+/// Whether the window was maximized when a screen mode took it full screen (egui temp data).
+fn was_maximized_id() -> egui::Id {
+    egui::Id::new("pc-full-screen-was-maximized")
+}
+
+/// The window commands for switching to screen mode `next`, and whether the window should be
+/// maximized again when it leaves full screen. With `keep_apart` (Windows), full screen and
+/// maximized never overlap: a maximized window is un-maximized before it goes full screen and
+/// maximized again after it leaves. Why: winit on Windows keeps the maximized style on a window
+/// that goes full screen from maximized, and the shell then draws the taskbar black instead of
+/// hiding it; on the way out the window stays maximized at the monitor's full size, over the
+/// taskbar (#3550, #4018, #4230). [OBSERVED 2026-10-12, Windows 11, eframe 0.36.2, winit 0.30.13,
+/// a minimal eframe window; un-maximizing first gave a clean full screen and a work-area maximize.]
+///
+/// WORKAROUND(winit#4756): remove `keep_apart` once the winit in Cargo.lock (0.30.13 today) has
+/// the fix; check first with https://gist.github.com/aweussom/3f80ffb82df7f0102341858afbbffd9b
+/// (`--max`, no `--fix`: full screen must have no WS_MAXIMIZE and hide the taskbar).
+fn screen_mode_commands(keep_apart: bool, full_screen: bool, maximized: bool, was_maximized: bool, next: &str) -> (Vec<egui::ViewportCommand>, bool) {
+    let want = next != "standard";
+    let mut commands = Vec::new();
+    let mut remember = was_maximized;
+    if keep_apart && want && !full_screen && maximized {
+        commands.push(egui::ViewportCommand::Maximized(false));
+        remember = true;
+    }
+    commands.push(egui::ViewportCommand::Fullscreen(want));
+    if !want {
+        if keep_apart && full_screen && remember {
+            commands.push(egui::ViewportCommand::Maximized(true));
+        }
+        remember = false;
+    }
+    (commands, remember)
+}
+
 /// Pixel aspect ratio (width / height of a pixel) of a preset id.
 pub fn pixel_aspect_ratio(id: &str) -> f32 {
     // View › Pixel Aspect Ratio › Custom: `custom:<ratio>:<name>` (see `workspace_ui`).
@@ -214,6 +254,106 @@ fn snap_slot<'a>(s: &'a mut SnapTo, key: &str) -> Option<&'a mut bool> {
     })
 }
 
+/// Every [`show_slot`] key.
+const SHOW_KEYS: [&str; 13] = [
+    "layerEdges",
+    "selectionEdges",
+    "targetPath",
+    "pixelGrid",
+    "smartGuides",
+    "brushPreview",
+    "slices",
+    "notes",
+    "mesh",
+    "editPins",
+    "count",
+    "canvasGuides",
+    "artboardGuides",
+];
+/// Every [`snap_slot`] key.
+const SNAP_KEYS: [&str; 5] = ["guides", "grid", "layers", "slices", "documentBounds"];
+
+/// The flags of `now` that differ from `def`, by key (`None` when none do).
+fn changed_flags<T: Copy>(now: T, def: T, keys: &[&str], slot: impl for<'a> Fn(&'a mut T, &str) -> Option<&'a mut bool>) -> Option<Value> {
+    let (mut now, mut def) = (now, def);
+    let diff: Map<String, Value> = keys
+        .iter()
+        .filter_map(|k| {
+            let v = *slot(&mut now, k)?;
+            (Some(v) != slot(&mut def, k).copied()).then(|| ((*k).to_string(), Value::Bool(v)))
+        })
+        .collect();
+    (!diff.is_empty()).then_some(Value::Object(diff))
+}
+
+/// View › Extras, Show and Snap To as remembered across restarts (`Preferences::view_extras`):
+/// only what differs from the defaults, so a default changed in a later release still reaches
+/// users who never touched that item. `Null` when nothing differs.
+fn remembered(app: &PhotocraftApp) -> Value {
+    let (v, e, def) = (&app.ui.view, &app.ui.extras, crate::state::Extras::default());
+    let mut m = Map::new();
+    if v.extras != ViewOptions::default().extras {
+        m.insert("extras".into(), Value::Bool(v.extras));
+    }
+    // View › Show › Grid and Guides live in `UiState::extras` beside the rulers and snapping.
+    if e.grid != def.grid {
+        m.insert("grid".into(), Value::Bool(e.grid));
+    }
+    if e.guides != def.guides {
+        m.insert("guides".into(), Value::Bool(e.guides));
+    }
+    if let Some(show) = changed_flags(v.show, Show::default(), &SHOW_KEYS, show_slot) {
+        m.insert("show".into(), show);
+    }
+    if let Some(snap) = changed_flags(v.snap_to, SnapTo::default(), &SNAP_KEYS, snap_slot) {
+        m.insert("snapTo".into(), snap);
+    }
+    if m.is_empty() { Value::Null } else { Value::Object(m) }
+}
+
+/// Remember View › Extras, Show and Snap To in the preferences once the user lets go of the
+/// pointer (#3762). Cheap: a small JSON compare per frame. Run every frame, so items set by the
+/// control channel or the Show Extras Options dialog are remembered too.
+pub fn persist(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    if ctx.input(|i| i.pointer.any_down()) {
+        return;
+    }
+    let now = remembered(app);
+    if app.session.prefs().view_extras != now {
+        app.session.prefs.edit(|p| p.view_extras = now);
+    }
+}
+
+/// Restore the remembered View › Extras, Show and Snap To items at launch. A hand-edited file
+/// can't break them: an unknown key or a value that isn't a boolean keeps its default.
+pub fn restore(app: &mut PhotocraftApp) {
+    let saved = app.session.prefs().view_extras.clone();
+    if !saved.is_null() && !saved.is_object() {
+        log::warn!("Preferences: the remembered View › Show items are not an object; using the defaults");
+        return;
+    }
+    let flag = |k: &str| saved.get(k).and_then(Value::as_bool);
+    if let Some(on) = flag("extras") {
+        app.ui.view.extras = on;
+    }
+    if let Some(on) = flag("grid") {
+        app.ui.extras.grid = on;
+    }
+    if let Some(on) = flag("guides") {
+        app.ui.extras.guides = on;
+    }
+    for (k, v) in saved.get("show").and_then(Value::as_object).into_iter().flatten() {
+        if let (Some(slot), Some(on)) = (show_slot(&mut app.ui.view.show, k), v.as_bool()) {
+            *slot = on;
+        }
+    }
+    for (k, v) in saved.get("snapTo").and_then(Value::as_object).into_iter().flatten() {
+        if let (Some(slot), Some(on)) = (snap_slot(&mut app.ui.view.snap_to, k), v.as_bool()) {
+            *slot = on;
+        }
+    }
+}
+
 /// Window › <panel>: (panel, dock tab) for panels that live as tabs of a dock card.
 fn panel_tab(app: &PhotocraftApp, id: &str) -> Option<(&'static str, usize)> {
     let pro = app.ui.theme.is_pro();
@@ -459,6 +599,8 @@ fn wraps(id: &str) -> bool {
             | "type.pasteLoremIpsum"
             | "image.applyImage"
             | "image.calculations"
+            | "select.saveSelection"
+            | "select.loadSelection"
     )
 }
 
@@ -555,7 +697,13 @@ fn run(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, p: &Value) -> Res
         };
         o.screen_mode = next.to_string();
         // Both full-screen modes take the whole display; the menu bar stays in the first.
-        ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(next != "standard"));
+        let (full_screen, maximized) = ctx.input(|i| (i.viewport().fullscreen.unwrap_or(false), i.viewport().maximized.unwrap_or(false)));
+        let was_maximized = ctx.data(|d| d.get_temp::<bool>(was_maximized_id())).unwrap_or(false);
+        let (commands, was_maximized) = screen_mode_commands(cfg!(target_os = "windows"), full_screen, maximized, was_maximized, next);
+        ctx.data_mut(|d| d.insert_temp(was_maximized_id(), was_maximized));
+        for command in commands {
+            ctx.send_viewport_cmd(command);
+        }
         return Ok(json!({"screenMode": next}));
     }
     if let Some(k) = id.strip_prefix("view.pixelAspectRatio.") {
@@ -575,7 +723,7 @@ fn run(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, p: &Value) -> Res
         return Ok(json!(k));
     }
     if let Some(k) = id.strip_prefix("window.arrange.") {
-        return arrange(app, k);
+        return arrange(app, k, p);
     }
     match id {
         "view.extras" => {
@@ -641,15 +789,23 @@ fn fit_layers(app: &mut PhotocraftApp) -> Result<Value, String> {
     Ok(json!({"zoom": v.zoom, "bounds": [b.x0, b.y0, b.x1, b.y1]}))
 }
 
+/// A finite `[x, y]` screen position within a sane range (window systems reject wild values).
+fn screen_position(v: &Value) -> Option<[f32; 2]> {
+    const LIMIT: f64 = 1.0e6;
+    let a = v.as_array().filter(|a| a.len() == 2)?;
+    let n = |i: usize| a.get(i).and_then(Value::as_f64).filter(|x| x.is_finite() && x.abs() <= LIMIT).map(|x| x as f32);
+    Some([n(0)?, n(1)?])
+}
+
 pub(crate) fn float_window(app: &mut PhotocraftApp, doc: usize, offset: usize) -> u64 {
     let wid = app.ui.alloc_id();
     let mut view = app.ui.views.get(doc).cloned().unwrap_or_default();
     view.fit_pending = offset > 0 || view.fit_pending;
-    app.ui.windows.push(crate::state::DocWindow { id: wid, document: doc, view, open: true });
+    app.ui.windows.push(crate::state::DocWindow { id: wid, document: doc, view, open: true, position: None });
     wid
 }
 
-fn arrange(app: &mut PhotocraftApp, k: &str) -> Result<Value, String> {
+fn arrange(app: &mut PhotocraftApp, k: &str, p: &Value) -> Result<Value, String> {
     if LAYOUTS.contains(&k) {
         app.ui.view.arrange = k.to_string();
         // Each document fits its new cell.
@@ -662,10 +818,31 @@ fn arrange(app: &mut PhotocraftApp, k: &str) -> Result<Value, String> {
             app.ui.windows.clear();
             Ok(json!({"arrange": "tabs"}))
         }
-        "newWindowForDocument" | "floatInWindow" => {
+        "newWindowForDocument" => {
             let doc = app.session.active_index().ok_or("no document")?;
             Ok(json!({"window": float_window(app, doc, 0)}))
         }
+        // Optional `document` (index; default the active one) and `position` (`[x, y]`, the
+        // window's screen position in points): dragging a tab off the tab strip uses both (#3733).
+        "floatInWindow" => {
+            let doc = match p.get("document") {
+                None | Some(Value::Null) => app.session.active_index().ok_or("no document")?,
+                Some(v) => {
+                    let i = v.as_u64().ok_or("document must be a document index")?;
+                    usize::try_from(i).ok().filter(|&i| i < app.session.documents().len()).ok_or(format!("no document {i}"))?
+                }
+            };
+            let position = match p.get("position") {
+                None | Some(Value::Null) => None,
+                Some(v) => Some(screen_position(v).ok_or("position must be [x, y] in points")?),
+            };
+            let wid = float_window(app, doc, 0);
+            if let Some(w) = app.ui.windows.iter_mut().find(|w| w.id == wid) {
+                w.position = position;
+            }
+            app.session.set_active(doc);
+            Ok(json!({"window": wid}))
+        }
         "floatAllInWindows" | "cascade" => {
             let n = app.session.documents().len();
             let ids: Vec<u64> = (0..n).map(|d| float_window(app, d, d)).collect();
@@ -802,10 +979,27 @@ fn form(app: &mut PhotocraftApp, command: &str, label: &str, fields: Value, choi
     if let Value::Object(m) = fields {
         f.extend(m);
     }
+    // Snapshot user-facing params at open so Alt+Reset can restore them.
+    let orig: Map<String, Value> = f.iter().filter(|(k, _)| !k.starts_with("__")).map(|(k, v)| (k.clone(), v.clone())).collect();
+    f.insert("__formOrig".into(), Value::Object(orig));
     app.ui.open_dialog(DialogKind::Command, f)
 }
 
+/// Alt+Cancel (Reset): restore the `__form` params captured at open.
+pub fn reset_form(f: &mut Map<String, Value>) {
+    if !f.contains_key("__form") {
+        return;
+    }
+    let Some(Value::Object(orig)) = f.get("__formOrig").cloned() else { return };
+    f.retain(|k, _| k.starts_with("__"));
+    f.extend(orig);
+}
+
 fn label_of(key: &str) -> String {
+    // A name that already reads as text ("iPhone 14 Pro Max", "Web 1920") is not camelCase.
+    if key.contains(' ') {
+        return tl!(key).to_owned();
+    }
     let mut out = String::new();
     for (i, c) in key.chars().enumerate() {
         if i == 0 {
@@ -836,10 +1030,30 @@ mod label_tests {
         crate::i18n::with_language(crate::i18n::Lang::EN, || {
             assert_eq!(label_of("useAntialias"), "Use antialias");
             assert_eq!(label_of("radius"), "Radius");
+            assert_eq!(label_of("iPhone 14 Pro Max"), "iPhone 14 Pro Max");
         });
     }
 }
 
+#[cfg(test)]
+mod form_reset_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn alt_reset_restores_form_orig() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
+        let id = form(&mut app, "test.form", "Test", json!({"radius": 5.0, "on": true}), json!({}));
+        let f = &mut app.ui.dialog_mut(id).unwrap().fields;
+        f.insert("radius".into(), json!(99.0));
+        f.insert("on".into(), json!(false));
+        reset_form(f);
+        assert_eq!(f["radius"], json!(5.0));
+        assert_eq!(f["on"], json!(true));
+        assert!(f.contains_key("__formOrig"));
+    }
+}
+
 /// Body of a `__form` dialog: text fields, number fields, checkboxes and `__choices` dropdowns.
 pub fn form_body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
     let choices = f.get("__choices").cloned().unwrap_or(Value::Null);
@@ -851,6 +1065,31 @@ pub fn form_body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
     egui::Grid::new("form-dialog").num_columns(2).spacing([12.0, 6.0]).show(ui, |ui| {
         for k in keys {
             let v = f.get(&k).cloned().unwrap_or(Value::Null);
+            if k == "naming" && f.get("__command").and_then(Value::as_str) == Some("file.automate.batch") {
+                let label = ui.label(tl!("File Naming"));
+                let mut naming = v.as_str().unwrap_or_default().to_owned();
+                ui.add(egui::TextEdit::singleline(&mut naming).desired_width(260.0).hint_text("{name}"))
+                    .labelled_by(label.id)
+                    .on_hover_text("{name} · {serial} · {date} (UTC)");
+                f.insert(k, json!(naming));
+                ui.end_row();
+                continue;
+            }
+            if k == "quality" && f.get("__command").and_then(Value::as_str) == Some("file.automate.batch") {
+                ui.label(label(&k));
+                let mut custom = v.as_f64().is_some();
+                let mut quality = v.as_f64().or_else(|| f.get("__batchQuality").and_then(Value::as_f64)).unwrap_or(8.0).clamp(0.0, 12.0) as f32;
+                ui.horizontal(|ui| {
+                    crate::widgets::checkbox(ui, &mut custom, tl!("Custom"));
+                    ui.add_enabled_ui(custom, |ui| crate::widgets::value_field(ui, &mut quality, 0.0..=12.0, "", 74.0));
+                });
+                // None preserves the command's existing JPEG and lossless WebP defaults.
+                // The inactive custom value is shell state, never a command parameter.
+                f.insert("__batchQuality".into(), json!(quality));
+                f.insert(k, if custom { json!(quality) } else { Value::Null });
+                ui.end_row();
+                continue;
+            }
             let new = match &v {
                 Value::Array(_) | Value::Object(_) | Value::Null => continue,
                 Value::Bool(b) => {
@@ -864,7 +1103,7 @@ pub fn form_body(ui: &mut egui::Ui, f: &mut Map<String, Value>) {
                     let mut s = s.clone();
                     match choices.get(&k).and_then(Value::as_array) {
                         Some(opts) => {
-                            let opts: Vec<(String, String)> = opts.iter().filter_map(Value::as_str).map(|o| (o.to_string(), label_of(o))).collect();
+                            let opts: Vec<(String, String)> = opts.iter().filter_map(Value::as_str).map(|o| (o.to_string(), label(o))).collect();
                             let refs: Vec<(String, &str)> = opts.iter().map(|(a, b)| (a.clone(), b.as_str())).collect();
                             crate::widgets::dropdown(ui, &format!("form-{k}"), &mut s, &refs, 200.0);
                         }
@@ -998,7 +1237,7 @@ fn front(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<Val
         }
         "file.automate.fitImage" => {
             let (w, h, _) = doc?;
-            dialog(app, json!({"width": w, "height": h, "dontEnlarge": false}), json!({}))
+            dialog(app, json!({"width": w, "height": h, "dontEnlarge": false, "__compact": true}), json!({}))
         }
         "file.automate.conditionalModeChange" => dialog(
             app,
@@ -1055,7 +1294,7 @@ fn front(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<Val
             let scope = if selected_adjustments { "selected" } else { "all" };
             dialog(app, json!({"path": format!("{dir}/{stem}.cube"), "size": 33, "title": stem, "scope": scope}), json!({"scope": ["all", "selected"]}))
         }
-        "file.scripts.loadFilesIntoStack" => dialog(app, json!({"paths": dir}), json!({})),
+        "file.scripts.loadFilesIntoStack" => Some(Ok(json!({"dialog": crate::stack_dialog::open(app)}))),
         // Photography automation (photo_cmds / lens_cmds): a folder (or the open documents).
         "file.automate.photomerge" => dialog(
             app,
@@ -1075,7 +1314,7 @@ fn front(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<Val
         "file.scripts.imageProcessor" => dialog(
             app,
             json!({"input": dir, "output": format!("{dir}/processed"), "format": "jpg", "quality": 8, "width": 0, "height": 0, "convertToSrgb": true}),
-            json!({"format": ["jpg", "png", "psd", "tiff"]}),
+            json!({"format": ["jpg", "png", "psd", "tiff", "webp"]}),
         ),
         "file.automate.batch" => {
             let Some(action) = crate::actions::selected_action(app) else {
@@ -1085,8 +1324,8 @@ fn front(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<Val
             let name = action.name.clone();
             dialog(
                 app,
-                json!({"action": name, "steps": steps, "input": dir, "output": format!("{dir}/batch"), "format": "same"}),
-                json!({"format": ["same", "png", "jpg", "psd", "tiff"]}),
+                json!({"action": name, "steps": steps, "input": dir, "output": format!("{dir}/batch"), "format": "same", "quality": null, "__batchQuality": 8, "naming": "", "startingSerial": 1}),
+                json!({"format": ["same", "png", "jpg", "psd", "tiff", "webp"]}),
             )
         }
         // Channel workflow dialogs (see channels_panel.rs for the channel references).
@@ -1118,8 +1357,16 @@ fn front(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<Val
                 "add",
                 "subtract",
             ];
+            // The active layer's transparency, and its mask only when it has one.
+            let layer = st.active_layer.and_then(|l| d.layer(l));
             let mut load = chans.clone();
-            load.extend(["transparency", "mask", "selection"].map(String::from));
+            if layer.is_some() {
+                load.push("transparency".into());
+            }
+            if layer.is_some_and(|l| l.mask.is_some()) {
+                load.push("mask".into());
+            }
+            load.push("selection".into());
             match id {
                 "select.saveSelection" => dialog(
                     app,
@@ -1137,10 +1384,20 @@ fn front(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<Val
                 "image.applyImage" => {
                     let mut masks = vec!["none".to_string()];
                     masks.extend(load.iter().cloned());
+                    // Source layer: Merged, then the pixel layers top to bottom (the engine takes
+                    // the topmost layer of a name), shown by their own names.
+                    let mut layers = vec!["merged".to_string()];
+                    for (_, _, l) in d.walk().into_iter().rev() {
+                        if l.surface().is_some() && !layers.contains(&l.name) {
+                            layers.push(l.name.clone());
+                        }
+                    }
+                    let names: Map<String, Value> = layers.iter().skip(1).map(|n| (n.clone(), json!(n))).collect();
+                    // Scale and Offset only affect Add and Subtract.
                     dialog(
                         app,
-                        json!({"sourceChannel": chans[0], "sourceInvert": false, "blending": "multiply", "opacity": 100.0, "preserveTransparency": false, "maskChannel": "none"}),
-                        json!({"sourceChannel": load, "blending": blends, "maskChannel": masks}),
+                        json!({"sourceLayer": "merged", "sourceChannel": chans[0], "sourceInvert": false, "blending": "multiply", "opacity": 100.0, "scale": 1.0, "offset": 0, "preserveTransparency": false, "maskChannel": "none", "__labels": names}),
+                        json!({"sourceLayer": layers, "sourceChannel": load, "blending": blends, "maskChannel": masks}),
                     )
                 }
                 _ => dialog(
@@ -1155,7 +1412,8 @@ fn front(app: &mut PhotocraftApp, id: &str, params: &Value) -> Option<Result<Val
 }
 
 /// File › Save a Copy: pick a name, encode with the export service, write; the document's path
-/// and saved state are untouched.
+/// and saved state are untouched. An action being recorded keeps it as a `file.saveACopy` step
+/// with its path (#4373).
 fn save_a_copy(app: &mut PhotocraftApp) -> Result<Value, String> {
     let doc = app.session.active().ok_or("no document")?.doc.clone();
     let stem = doc.name.rsplit_once('.').map_or(doc.name.as_str(), |(a, _)| a);
@@ -1166,27 +1424,40 @@ fn save_a_copy(app: &mut PhotocraftApp) -> Result<Value, String> {
         let parked = app.with_document(doc.id, |app| {
             let ask = crate::targa_options_ui::wants_prompt(app, &path);
             if ask {
-                crate::targa_options_ui::park(app, path.clone(), true, false)?;
+                crate::targa_options_ui::park(app, path.clone(), true, "file.saveACopy")?;
             }
             Ok(ask)
         })?;
         if parked {
             return Ok(json!({"path": path, "warnings": []}));
         }
-        let settings = app.save_settings();
-        let export = app.services.export.as_ref().ok_or("no exporter configured")?;
-        let (bytes, warnings) = export(&doc, &path, &settings)?;
-        let write = app.services.write.as_mut().ok_or("no writer configured")?;
-        write(&path, &bytes)?;
-        let template = "Saved a copy as {path}";
-        app.ui.status = crate::i18n::fmt(tl!(template), &[("path", &path)]);
-        app.ui.status_error = false;
-        let what = crate::i18n::fmt(tl!(template), &[("path", &crate::file_open::display_name(&path))]);
-        crate::notices::io_warnings(app, &what, &warnings);
-        Ok(json!({"path": path, "warnings": warnings}))
+        let r = write_copy(app, &doc, &path, None)?;
+        app.session.journal.push(("file.saveACopy".into(), json!({"path": path})));
+        Ok(r)
     })
 }
 
+/// Writes `doc` to `path` as a copy (Save a Copy, and its replayed action step): the document's
+/// path and saved state are untouched. `tga_bits` is the Targa answer, when there is one.
+pub(crate) fn write_copy(
+    app: &mut PhotocraftApp,
+    doc: &photocraft_doc::Document,
+    path: &str,
+    tga_bits: Option<photocraft_io::TgaBits>,
+) -> Result<Value, String> {
+    let settings = crate::ExportSettings { tga_bits, ..app.save_settings() };
+    let export = app.services.export.as_ref().ok_or("no exporter configured")?;
+    let (bytes, warnings) = export(doc, path, &settings)?;
+    let write = app.services.write.as_mut().ok_or("no writer configured")?;
+    write(path, &bytes)?;
+    let template = "Saved a copy as {path}";
+    app.ui.status = crate::i18n::fmt(tl!(template), &[("path", path)]);
+    app.ui.status_error = false;
+    let what = crate::i18n::fmt(tl!(template), &[("path", &crate::file_open::display_name(path))]);
+    crate::notices::io_warnings(app, &what, &warnings);
+    Ok(json!({"path": path, "warnings": warnings}))
+}
+
 /// Layer › Smart Objects › Export Contents: saves the contents file under its own name by default.
 fn export_contents(app: &mut PhotocraftApp) -> Result<Value, String> {
     let st = app.session.active().ok_or("no document")?;
diff --git a/crates/ui-egui/src/view_cmds/tests.rs b/crates/ui-egui/src/view_cmds/tests.rs
index bd91465706..7ef3100d9e 100644
--- a/crates/ui-egui/src/view_cmds/tests.rs
+++ b/crates/ui-egui/src/view_cmds/tests.rs
@@ -59,6 +59,34 @@ fn show_snap_extras_and_screen_modes_are_state() {
     assert_eq!(v["view"]["show"]["layer_edges"], true);
 }
 
+#[test]
+fn full_screen_and_maximized_never_overlap_on_windows() {
+    use egui::ViewportCommand::{Fullscreen, Maximized};
+    // Maximized → full screen: un-maximize first, and remember it.
+    let (cmds, remember) = screen_mode_commands(true, false, true, false, "fullScreenWithMenuBar");
+    assert_eq!(cmds, vec![Maximized(false), Fullscreen(true)]);
+    assert!(remember);
+    // Full screen → the other full-screen mode: nothing about maximized changes.
+    let (cmds, remember) = screen_mode_commands(true, true, false, true, "fullScreen");
+    assert_eq!(cmds, vec![Fullscreen(true)]);
+    assert!(remember);
+    // Full screen → Standard: maximize again after leaving, then forget.
+    let (cmds, remember) = screen_mode_commands(true, true, false, true, "standard");
+    assert_eq!(cmds, vec![Fullscreen(false), Maximized(true)]);
+    assert!(!remember);
+    // A window that was not maximized goes in and out untouched.
+    let (cmds, remember) = screen_mode_commands(true, false, false, false, "fullScreen");
+    assert_eq!((cmds, remember), (vec![Fullscreen(true)], false));
+    let (cmds, remember) = screen_mode_commands(true, true, false, false, "standard");
+    assert_eq!((cmds, remember), (vec![Fullscreen(false)], false));
+    // Standard while already standard never maximizes.
+    let (cmds, _) = screen_mode_commands(true, false, false, true, "standard");
+    assert_eq!(cmds, vec![Fullscreen(false)]);
+    // Elsewhere the commands are as before.
+    let (cmds, remember) = screen_mode_commands(false, false, true, false, "fullScreen");
+    assert_eq!((cmds, remember), (vec![Fullscreen(true)], false));
+}
+
 #[test]
 fn zoom_presets_and_fit_layers() {
     let (mut app, ctx) = app_with(1);
@@ -227,6 +255,45 @@ fn apply_image_and_calculations_open_dialogs_without_editing() {
     }
 }
 
+#[test]
+fn apply_image_dialog_offers_source_layer_scale_and_offset() {
+    let (mut app, ctx) = app_with(0);
+    app.run("file.new", json!({"width": 8, "height": 8})).unwrap();
+    app.run("edit.fill", json!({"color": "#c08040"})).unwrap();
+    app.run("layer.new.layer", json!({"name": "Skin High"})).unwrap();
+    app.run("edit.fill", json!({"color": "#406080"})).unwrap();
+    app.sync_views();
+    let background = app.session.active().unwrap().doc.walk()[0].2.name.clone();
+    let open = |app: &mut PhotocraftApp| menu(app, &ctx, "image.applyImage", json!({})).unwrap()["dialog"].as_u64().unwrap();
+    let d = open(&mut app);
+    let fields = &app.ui.dialog_mut(d).unwrap().fields;
+    assert_eq!(fields["sourceLayer"], "merged");
+    assert_eq!(fields["scale"], 1.0);
+    assert_eq!(fields["offset"], 0);
+    // Merged first, then the layers top to bottom, shown by their own names.
+    assert_eq!(fields["__choices"]["sourceLayer"], json!(["merged", "Skin High", background]));
+    assert_eq!(fields["__labels"]["Skin High"], "Skin High");
+    // The frequency separation recipe: a layer subtracted from itself at Scale 2, Offset 128 is mid grey.
+    for (k, v) in [("sourceLayer", json!("Skin High")), ("blending", json!("subtract")), ("scale", json!(2.0)), ("offset", json!(128))] {
+        app.ui.dialog_mut(d).unwrap().fields.insert(k.into(), v);
+    }
+    crate::dialogs::confirm(&mut app, d).unwrap();
+    let st = app.session.active().unwrap();
+    let p = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().pixel(3, 3);
+    assert!(p[..3].iter().all(|v| (v - 128.0 / 255.0).abs() < 0.003), "{p:?}");
+    app.run("edit.undo", json!({})).unwrap();
+    // The chosen layer is the source, not the merged image.
+    let d = open(&mut app);
+    for (k, v) in [("sourceLayer", json!(background)), ("blending", json!("subtract")), ("scale", json!(2.0)), ("offset", json!(128))] {
+        app.ui.dialog_mut(d).unwrap().fields.insert(k.into(), v);
+    }
+    crate::dialogs::confirm(&mut app, d).unwrap();
+    let st = app.session.active().unwrap();
+    let p = st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().pixel(3, 3);
+    let want = (64.0 - 192.0) / 255.0 / 2.0 + 128.0 / 255.0;
+    assert!((p[0] - want).abs() < 0.003, "{p:?} vs {want}");
+}
+
 #[test]
 fn new_guide_layout_remembers_successful_values_not_cancelled_edits() {
     let (mut app, ctx) = app_with(1);
@@ -291,3 +358,125 @@ fn lookup_export_dialog_uses_the_current_adjustment_selection() {
     assert_eq!(direct["layerCount"], 1);
     assert!(direct["cube"].as_str().unwrap().contains("LUT_3D_SIZE 3"));
 }
+
+/// Float in Window takes the document and the screen position a dragged-off tab was dropped at
+/// (#3733); bad params are errors, not panics.
+#[test]
+fn float_in_window_takes_a_document_and_position() {
+    let (mut app, ctx) = app_with(3);
+    let r = menu(&mut app, &ctx, "window.arrange.floatInWindow", json!({"document": 1, "position": [1950.0, 40.5]})).unwrap();
+    let w = app.ui.windows.last().unwrap();
+    assert_eq!(r, json!({"window": w.id}));
+    assert_eq!((w.document, w.position), (1, Some([1950.0, 40.5])));
+    assert_eq!(app.session.active_index(), Some(1));
+    menu(&mut app, &ctx, "window.arrange.floatInWindow", json!({})).unwrap();
+    assert_eq!(app.ui.windows.last().map(|w| (w.document, w.position)), Some((1, None)), "defaults: the active document, placed by the OS");
+    for bad in [
+        json!({"document": 3}),
+        json!({"document": -1}),
+        json!({"document": "b"}),
+        json!({"position": [1.0]}),
+        json!({"position": [1.0, "x"]}),
+        json!({"position": [1.0e30, 0.0]}),
+        json!({"position": 5}),
+    ] {
+        assert!(menu(&mut app, &ctx, "window.arrange.floatInWindow", bad.clone()).is_err(), "{bad}");
+    }
+    assert_eq!(app.ui.windows.len(), 2, "rejected params open no window");
+}
+
+#[test]
+fn save_selection_opens_its_dialog_and_saves_on_confirm() {
+    // #3713: Select › Save Selection… asks for the channel, name and operation first.
+    let (mut app, ctx) = app_with(1);
+    app.run("select.all", json!({})).unwrap();
+    let revision = app.session.active().unwrap().revision;
+    let dialog = menu(&mut app, &ctx, "select.saveSelection", json!({})).unwrap()["dialog"].as_u64().expect("Save Selection opens a dialog");
+    assert_eq!(app.session.active().unwrap().revision, revision, "saved before confirmation");
+    assert!(app.session.active().unwrap().doc.channels.is_empty());
+    let fields = &mut app.ui.dialog_mut(dialog).unwrap().fields;
+    assert_eq!(fields["__command"], "select.saveSelection");
+    assert_eq!(fields["channel"], "new");
+    assert_eq!(fields["__choices"]["operation"], json!(["new", "replace", "add", "subtract", "intersect"]));
+    fields.insert("name".into(), json!("Keep"));
+    crate::dialogs::confirm(&mut app, dialog).unwrap();
+    let names: Vec<_> = app.session.active().unwrap().doc.channels.iter().map(|c| c.name.clone()).collect();
+    assert_eq!(names, ["Keep"]);
+    // A second save lists the new channel as a destination.
+    let dialog = menu(&mut app, &ctx, "select.saveSelection", json!({})).unwrap()["dialog"].as_u64().unwrap();
+    assert_eq!(app.ui.dialog_mut(dialog).unwrap().fields["__choices"]["channel"], json!(["new", "Keep"]));
+}
+
+#[test]
+fn load_selection_opens_its_dialog_and_loads_on_confirm() {
+    // #3713: Select › Load Selection… used to fail with "missing `channel`".
+    let (mut app, ctx) = app_with(1);
+    app.run("select.all", json!({})).unwrap();
+    app.run("select.saveSelection", json!({"name": "Keep"})).unwrap();
+    app.run("select.deselect", json!({})).unwrap();
+    let dialog = menu(&mut app, &ctx, "select.loadSelection", json!({})).unwrap()["dialog"].as_u64().expect("Load Selection opens a dialog");
+    assert!(app.session.active().unwrap().doc.selection.is_none(), "loaded before confirmation");
+    let fields = &app.ui.dialog_mut(dialog).unwrap().fields;
+    assert_eq!(fields["__command"], "select.loadSelection");
+    assert_eq!(fields["channel"], "Keep");
+    assert_eq!(fields["invert"], false);
+    assert_eq!(fields["operation"], "new");
+    let channels = fields["__choices"]["channel"].as_array().unwrap();
+    assert!(channels.contains(&json!("Keep")) && channels.contains(&json!("transparency")));
+    // The layer has no mask, so its mask is not offered.
+    assert!(!channels.contains(&json!("mask")), "{channels:?}");
+    crate::dialogs::confirm(&mut app, dialog).unwrap();
+    assert!(app.session.active().unwrap().doc.selection.is_some());
+}
+
+#[test]
+fn load_selection_without_alpha_channels_offers_the_composite() {
+    let (mut app, ctx) = app_with(1);
+    let dialog = menu(&mut app, &ctx, "select.loadSelection", json!({})).unwrap()["dialog"].as_u64().unwrap();
+    assert_eq!(app.ui.dialog_mut(dialog).unwrap().fields["channel"], "RGB");
+    crate::dialogs::confirm(&mut app, dialog).unwrap();
+}
+
+/// One frame of the shortcut handler with a plain Esc press.
+fn press_esc(app: &mut PhotocraftApp, ctx: &egui::Context) {
+    let key = egui::Key::Escape;
+    let input = egui::RawInput {
+        focused: true,
+        events: vec![egui::Event::Key { key, physical_key: Some(key), pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }],
+        ..Default::default()
+    };
+    ctx.run_ui(input, |ui| crate::shortcuts::handle(app, ui.ctx())).textures_delta.clear();
+}
+
+#[test]
+fn esc_leaves_full_screen_modes_unless_something_else_owns_it() {
+    let (mut app, ctx) = app_with(1);
+    // Both full screen modes return to Standard, and the menu check follows (#4116).
+    for mode in ["fullScreen", "fullScreenWithMenuBar"] {
+        menu(&mut app, &ctx, &format!("view.screenMode.{mode}"), json!({})).unwrap();
+        press_esc(&mut app, &ctx);
+        assert_eq!(app.ui.view.screen_mode, "standard", "{mode}");
+        assert_eq!(checked(&app, "view.screenMode.standard"), Some(true));
+    }
+    // In Standard, Esc leaves the mode alone.
+    press_esc(&mut app, &ctx);
+    assert_eq!(app.ui.view.screen_mode, "standard");
+    // An open dialog takes Esc first.
+    menu(&mut app, &ctx, "view.screenMode.fullScreen", json!({})).unwrap();
+    menu(&mut app, &ctx, "image.canvasSize", json!({})).unwrap();
+    assert_eq!(app.ui.dialogs.len(), 1);
+    press_esc(&mut app, &ctx);
+    assert_eq!(app.ui.view.screen_mode, "fullScreen");
+    app.ui.dialogs.clear();
+    // So does Free Transform: Esc cancels it and the mode stays.
+    app.run("select.all", json!({})).unwrap();
+    crate::transform_tool::begin(&mut app, &ctx).unwrap();
+    assert!(app.ui.transform.is_some());
+    press_esc(&mut app, &ctx);
+    assert!(app.ui.transform.is_none());
+    assert_eq!(app.ui.view.screen_mode, "fullScreen");
+    // A selection stays while Esc leaves full screen; the next Esc deselects.
+    press_esc(&mut app, &ctx);
+    assert_eq!(app.ui.view.screen_mode, "standard");
+    assert!(app.session.active().unwrap().doc.selection.is_some());
+}
diff --git a/crates/ui-egui/src/vp_ui.rs b/crates/ui-egui/src/vp_ui.rs
index bdaad601c6..bd0353d678 100644
--- a/crates/ui-egui/src/vp_ui.rs
+++ b/crates/ui-egui/src/vp_ui.rs
@@ -19,6 +19,7 @@ use serde_json::{Value, json};
 
 use crate::PhotocraftApp;
 use crate::canvas::{ToolEvent, ViewXform};
+use crate::edit_history::{EditHistory, Step};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -63,8 +64,12 @@ pub struct VpSession {
     pub new_layer: bool,
     clip: Option<Clip>,
     drag: Option<Drag>,
+    history: EditHistory<VpEdit>,
 }
 
+/// What ⌘Z steps through: the planes and where the paste sits on them.
+type VpEdit = (Vec<VpPlane>, [f64; 2], f64);
+
 /// Most planes a session holds (the control channel can't make it allocate without bound).
 const MAX_PLANES: usize = 64;
 /// Most grid lines drawn per direction.
@@ -152,6 +157,24 @@ impl VpSession {
         }
     }
 
+    fn edit(&self) -> VpEdit {
+        (self.planes.clone(), self.paste_at, self.paste_width)
+    }
+
+    fn settle(&mut self, busy: bool) {
+        let now = self.edit();
+        self.history.settle(&now, busy || self.drag.is_some());
+    }
+
+    pub(crate) fn step(&mut self, step: Step) {
+        let mut now = self.edit();
+        if self.history.step(&mut now, step) {
+            (self.planes, self.paste_at, self.paste_width) = now;
+            self.drag = None;
+            self.selected = self.selected.filter(|i| *i < self.planes.len());
+        }
+    }
+
     fn delete_selected(&mut self) {
         if let Some(i) = self.selected.take().filter(|i| *i < self.planes.len()) {
             self.planes.remove(i);
@@ -300,6 +323,7 @@ pub fn begin(app: &mut PhotocraftApp, ctx: &egui::Context) -> Result<(), String>
         new_layer: false,
         clip,
         drag: None,
+        history: EditHistory::new(&(Vec::new(), [0.25, 0.25], 0.5)),
     });
     app.ui.status = tl!("Vanishing Point: click four corners to create a plane").into();
     Ok(())
@@ -369,6 +393,7 @@ pub fn control(app: &mut PhotocraftApp, ui: &Value) -> Result<Value, String> {
     if let Some(b) = ui.get("newLayer").and_then(Value::as_bool) {
         s.new_layer = b;
     }
+    s.settle(false);
     Ok(s.describe())
 }
 
@@ -383,6 +408,7 @@ pub fn pointer(app: &mut PhotocraftApp, ev: ToolEvent, _mods: egui::Modifiers) {
             s.drag = None;
         }
     }
+    s.settle(false);
 }
 
 /// Keys while the mode is active (↩ and Esc are handled by `distort_ui::keys`).
@@ -400,6 +426,7 @@ pub fn keys(app: &mut PhotocraftApp, ctx: &egui::Context) {
         s.tool = VpTool::CreatePlane;
     } else if key(Key::Delete) || key(Key::Backspace) {
         s.delete_selected();
+        s.settle(false);
     }
 }
 
@@ -551,6 +578,9 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
             app.distort.vanishing = None;
         }
     });
+    if let Some(s) = app.distort.vanishing.as_mut() {
+        s.settle(ui.input(|i| i.pointer.any_down()));
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/wheel_nav.rs b/crates/ui-egui/src/wheel_nav.rs
index 4d07537df1..c65ad1fe2c 100644
--- a/crates/ui-egui/src/wheel_nav.rs
+++ b/crates/ui-egui/src/wheel_nav.rs
@@ -11,7 +11,8 @@
 //! [`configure`] makes egui fold ⌘/Ctrl + wheel into a sideways scroll as it does ⇧ + wheel, so
 //! only a real pinch (egui's `Event::Zoom`, or a touch screen) reaches `zoom_delta`. macOS and
 //! browsers deliver a pinch as its own event, but Windows hands a precision touchpad pinch to apps
-//! as Ctrl + wheel in fractions of a notch: [`fold_legacy_pinch`] turns those back into a pinch
+//! as Ctrl + wheel in fractions of a notch (also on some Linux Wayland systems):
+//! [`fold_legacy_pinch`] turns those back into a pinch
 //! before egui sees them, so Ctrl + a notched mouse wheel scrolls sideways and the pinch still
 //! zooms.
 //!
@@ -89,24 +90,28 @@ pub fn configure(ctx: &Context) {
     });
 }
 
-/// Turn a Windows touchpad pinch, which arrives as Ctrl + wheel in fractions of a notch, into
+/// Turn a Windows or Linux touchpad pinch, which arrives as Ctrl + wheel in fractions of a notch or points, into
 /// pinch events (`Event::Zoom`) at egui's Ctrl-scroll zoom speed (`notch` points per line,
 /// `speed` per point). Ctrl + wheel in whole notches (a mouse wheel) is left to scroll sideways,
 /// unless it comes within [`PINCH_GAP`] of a pinch step. `last` is the time of the previous pinch
 /// step; returns the time of the latest one.
 pub fn legacy_pinch_to_zoom(events: &mut [Event], now: f64, last: Option<f64>, notch: f32, speed: f32) -> Option<f64> {
     let ctrl_wheel = |e: &Event| match e {
-        Event::MouseWheel { unit: MouseWheelUnit::Line, delta, modifiers, .. } if modifiers.ctrl => Some(*delta),
+        Event::MouseWheel { unit: MouseWheelUnit::Line, delta, modifiers, .. } if modifiers.ctrl => Some((*delta, false)),
+        // Wayland precision touchpads can use point units. These are already actual
+        // screen points, not line notches; normalize before the exponential below.
+        Event::MouseWheel { unit: MouseWheelUnit::Point, delta, modifiers, .. } if modifiers.ctrl => Some((*delta / notch.max(1.0), true)),
         _ => None,
     };
     let fraction = |d: Vec2| d.x.fract() != 0.0 || d.y.fract() != 0.0;
-    let pinching = last.is_some_and(|t| (0.0..PINCH_GAP).contains(&(now - t))) || events.iter().filter_map(ctrl_wheel).any(fraction);
+    let pinching =
+        last.is_some_and(|t| (0.0..PINCH_GAP).contains(&(now - t))) || events.iter().filter_map(ctrl_wheel).any(|(d, high_res)| high_res || fraction(d));
     if !pinching {
         return last;
     }
     let mut latest = last;
     for e in events.iter_mut() {
-        if let Some(d) = ctrl_wheel(e) {
+        if let Some((d, _)) = ctrl_wheel(e) {
             let f = (speed * notch * (d.x + d.y)).exp();
             *e = Event::Zoom(if f.is_finite() && f > 0.0 { f } else { 1.0 });
             latest = Some(now);
@@ -119,8 +124,16 @@ fn pinch_id() -> Id {
     Id::new("pc-wheel-legacy-pinch")
 }
 
-/// [`legacy_pinch_to_zoom`] for one frame's raw input (`raw_input_hook`, on Windows).
+/// [`legacy_pinch_to_zoom`] for one frame's raw input (`raw_input_hook`, Windows and Linux).
 pub fn fold_legacy_pinch(ctx: &Context, raw: &mut RawInput) {
+    // Native gesture events already carry their own magnification. Some backends
+    // also emit a Ctrl-wheel event in the same frame: folding that wheel event
+    // would apply the same pinch twice. End any legacy continuation as well,
+    // so a later real Ctrl+wheel notch isn't treated as part of that pinch.
+    if raw.events.iter().any(|event| matches!(event, Event::Zoom(_))) {
+        ctx.data_mut(|d| d.remove::<f64>(pinch_id()));
+        return;
+    }
     let (notch, speed) = ctx.options(|o| (o.input_options.line_scroll_speed, o.input_options.scroll_zoom_speed));
     let now = raw.time.unwrap_or_else(|| ctx.input(|i| i.time));
     let last = ctx.data(|d| d.get_temp::<f64>(pinch_id()));
@@ -342,6 +355,43 @@ mod tests {
         assert!(near(pan, Vec2::new(40.0, 0.0)) && zoom == 1.0, "Ctrl + mouse wheel scrolls sideways: {pan:?} {zoom}");
     }
 
+    #[test]
+    fn linux_wayland_point_unit_pinch_keeps_mouse_notches_for_sideways_scroll() {
+        // Some Wayland compositors report fractional Ctrl-wheel pinch steps in points
+        // rather than line units. The delta must not be multiplied by notch twice.
+        let mut point = [Event::MouseWheel { unit: MouseWheelUnit::Point, delta: Vec2::new(0.0, 8.0), phase: TouchPhase::Move, modifiers: CTRL }];
+        assert_eq!(legacy_pinch_to_zoom(&mut point, 1.0, None, 40.0, 0.005), Some(1.0));
+        assert!(matches!(point[0], Event::Zoom(f) if (f - (8.0f32 * 0.005).exp()).abs() < 1e-5));
+        let mut wheel_only = [wheel(Vec2::new(0.0, 1.0), CTRL)];
+        assert_eq!(legacy_pinch_to_zoom(&mut wheel_only, 2.0, Some(1.0), 40.0, 0.005), Some(1.0));
+        assert!(matches!(wheel_only[0], Event::MouseWheel { .. }), "whole mouse notch is not a pinch");
+    }
+
+    #[test]
+    fn native_pinch_is_not_zoomed_twice_when_ctrl_wheel_arrives_in_the_same_frame() {
+        let (_, zoom) = gesture(vec![vec![Event::Zoom(1.2), wheel(Vec2::new(0.0, 0.25), CTRL)]], false, true);
+        assert!((zoom - 1.2).abs() < 1e-4, "native zoom must win over fallback: {zoom}");
+    }
+
+    #[test]
+    fn native_pinch_resets_legacy_gesture_continuation() {
+        let ctx = Context::default();
+        let mut legacy = RawInput { time: Some(1.0), events: vec![wheel(Vec2::new(0.0, 0.25), CTRL)], ..Default::default() };
+        fold_legacy_pinch(&ctx, &mut legacy);
+        assert!(matches!(legacy.events[0], Event::Zoom(_)));
+
+        // Native magnification takes over before the synthetic gesture times out.
+        let mut native = RawInput { time: Some(1.1), events: vec![Event::Zoom(1.1), wheel(Vec2::new(0.0, 0.25), CTRL)], ..Default::default() };
+        fold_legacy_pinch(&ctx, &mut native);
+        assert!(matches!(native.events[0], Event::Zoom(f) if (f - 1.1).abs() < 1e-5));
+        assert!(matches!(native.events[1], Event::MouseWheel { .. }));
+
+        // A notched mouse scroll must no longer inherit the previous pinch.
+        let mut notch = RawInput { time: Some(1.12), events: vec![wheel(Vec2::new(0.0, 1.0), CTRL)], ..Default::default() };
+        fold_legacy_pinch(&ctx, &mut notch);
+        assert!(matches!(notch.events[0], Event::MouseWheel { .. }));
+    }
+
     #[test]
     fn a_whole_notch_inside_a_pinch_stays_a_pinch() {
         let mut ev = [wheel(Vec2::new(0.0, 0.5), CTRL)];
diff --git a/crates/ui-egui/src/wide_angle_ui.rs b/crates/ui-egui/src/wide_angle_ui.rs
index cd8bf0332c..35b996deea 100644
--- a/crates/ui-egui/src/wide_angle_ui.rs
+++ b/crates/ui-egui/src/wide_angle_ui.rs
@@ -18,6 +18,7 @@ use photocraft_raster::Surface;
 use serde_json::{Value, json};
 
 use crate::PhotocraftApp;
+use crate::edit_history::{EditHistory, Step};
 use crate::theme::Tokens;
 use crate::widgets;
 
@@ -41,6 +42,7 @@ pub struct WideAngleDialog {
     drag: Option<([f64; 2], [f64; 2])>,
     pub residual: f64,
     pub render_ms: f64,
+    history: EditHistory<WideAngle>,
 }
 
 fn tex_image(s: &Surface, w: usize, h: usize) -> egui::ColorImage {
@@ -85,6 +87,13 @@ impl WideAngleDialog {
         self.dirty = false;
     }
 
+    pub(crate) fn step(&mut self, step: Step) {
+        if self.history.step(&mut self.params, step) {
+            self.drag = None;
+            self.dirty = true;
+        }
+    }
+
     fn command_params(&self) -> Value {
         let mut v = serde_json::to_value(&self.params).unwrap_or(json!({}));
         v["layer"] = json!(self.layer.0);
@@ -122,6 +131,7 @@ pub fn open(app: &mut PhotocraftApp, ctx: &egui::Context) -> Result<(), String>
     let mut d = WideAngleDialog {
         layer,
         layer_name: name,
+        history: EditHistory::new(&params),
         params,
         frame,
         scale: 1.0 / k as f64,
@@ -188,6 +198,7 @@ pub fn menu(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, params: &Val
         d.params.constraints.remove(i as usize);
         d.dirty = true;
     }
+    d.history.settle(&d.params, false);
     if d.dirty {
         d.render(ctx);
     }
@@ -216,6 +227,7 @@ pub fn show(app: &mut PhotocraftApp, ctx: &egui::Context) {
     let shift = ctx.input(|i| i.modifiers.shift);
     egui::Area::new(egui::Id::new("awa-dialog")).order(egui::Order::Foreground).fixed_pos(screen.min).show(ctx, |ui| {
         let Some(d) = app.wide_angle.as_mut() else { return };
+        d.history.settle(&d.params, ctx.input(|i| i.pointer.any_down()));
         if d.dirty {
             d.render(ctx);
         }
@@ -445,4 +457,23 @@ mod tests {
         menu(&mut app, &ctx, "filter.adaptiveWideAngle", &json!({"ui": {"cancel": true}})).unwrap().unwrap();
         assert!(app.wide_angle.is_none());
     }
+
+    #[test]
+    fn command_z_steps_the_dialog_not_the_document() {
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        let ctx = egui::Context::default();
+        app.run("file.new", json!({"width": 160, "height": 100})).unwrap();
+        app.run("layer.new.layer", json!({})).unwrap();
+        app.run("edit.fill", json!({"color": "#808080"})).unwrap();
+        let steps = app.session.active().unwrap().history.past_len();
+        menu(&mut app, &ctx, "filter.adaptiveWideAngle", &json!({})).unwrap().unwrap();
+        for y in [20, 60] {
+            menu(&mut app, &ctx, "filter.adaptiveWideAngle", &json!({"ui": {"add": {"a": [20, y], "b": [140, y]}}})).unwrap().unwrap();
+        }
+        crate::edit_history::tests::press_z(&mut app, &ctx, egui::Modifiers::COMMAND);
+        assert_eq!(app.wide_angle.as_ref().unwrap().params.constraints.len(), 1, "⌘Z removes the last constraint");
+        assert_eq!(app.session.active().unwrap().history.past_len(), steps, "the document beneath is untouched");
+        crate::edit_history::tests::press_z(&mut app, &ctx, egui::Modifiers::COMMAND | egui::Modifiers::SHIFT);
+        assert_eq!(app.wide_angle.as_ref().unwrap().params.constraints.len(), 2, "⇧⌘Z puts it back");
+    }
 }
diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs
index 378678459b..9e56022cef 100644
--- a/crates/ui-egui/src/widgets.rs
+++ b/crates/ui-egui/src/widgets.rs
@@ -17,6 +17,9 @@ pub use type_ahead::list_open as dropdown_list_open;
 /// The setting is local to this popup's Ui and leaves other themes unchanged.
 pub fn style_spectrum_popup_menu(ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
+    // The 6 pt gap between rows was outside both buttons, so a drag across a menu
+    // dropped the highlight (#4602). Padding stays inside the row, which is the hit target.
+    ui.spacing_mut().item_spacing.y = 0.0;
     if !t.pro {
         return;
     }
@@ -26,7 +29,9 @@ pub fn style_spectrum_popup_menu(ui: &mut Ui) {
     v.widgets.hovered.bg_fill = t.accent;
     v.widgets.hovered.fg_stroke = Stroke::new(1.0, Color32::WHITE);
     v.widgets.hovered.bg_stroke = Stroke::NONE;
-    v.widgets.hovered.corner_radius = CornerRadius::same(3);
+    v.widgets.inactive.corner_radius = CornerRadius::ZERO;
+    v.widgets.hovered.corner_radius = CornerRadius::ZERO;
+    v.widgets.active.corner_radius = CornerRadius::ZERO;
 }
 
 /// An accent insertion line on one edge of `r` while a drag hovers it (vertical: on its left or,
@@ -220,6 +225,25 @@ fn pro_panel(
     CardResponse::new(strip_resp, mresp, tabs_out)
 }
 
+/// The panel menu button (hamburger in Pro, ellipsis in Studio), matching the dock and cards.
+pub fn panel_menu_button(ui: &mut Ui) -> Response {
+    let t = Tokens::get(ui.ctx());
+    let size = vec2(20.0, 20.0);
+    let (rect, resp) = ui.allocate_exact_size(size, Sense::click());
+    let tint = crate::icons::button_chrome(ui, rect, false, resp.hovered());
+    if t.pro {
+        for k in 0..3 {
+            let y = rect.center().y - 3.5 + k as f32 * 3.5;
+            ui.painter().line_segment([pos2(rect.center().x - 5.0, y), pos2(rect.center().x + 5.0, y)], Stroke::new(1.0, tint));
+        }
+    } else {
+        crate::icons::paint(ui, rect, "ellipsis", 14.0, tint);
+    }
+    let tip = tl!("Panel menu");
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, tip));
+    resp.on_hover_text(tip)
+}
+
 pub fn pill_tab(ui: &mut Ui, label: &str, selected: bool) -> Response {
     let t = Tokens::get(ui.ctx());
     let font = theme::medium(12.5);
@@ -246,6 +270,27 @@ pub fn value_field(ui: &mut Ui, value: &mut f32, range: std::ops::RangeInclusive
     value_field_in(ui, value, range, suffix, width, 0.0, FieldOpts::default()).0
 }
 
+/// A single-line label for a row that also holds fixed-width controls: laid out no wider than
+/// `max_w`, cut with '…' when the text (often a longer translation) does not fit, with the full
+/// string on hover. Fixed chrome must never let a label overrun its row (#3580), so an *essential*
+/// label beside a fixed control should use this rather than a show/hide fit check; a *redundant*
+/// label (one whose control already carries the meaning, e.g. an icon row's caption) may be dropped.
+pub fn elided_label_sensed(ui: &mut Ui, text: &str, max_w: f32, sense: Sense) -> Response {
+    let t = Tokens::get(ui.ctx());
+    let font = egui::TextStyle::Body.resolve(ui.style());
+    let galley = crate::tab_strip::elided(ui, text, font, t.text_dim, max_w);
+    let elided = galley.elided;
+    let (rect, resp) = ui.allocate_exact_size(galley.size(), sense);
+    ui.painter().galley(rect.min, galley, t.text_dim);
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Label, ui.is_enabled(), text));
+    if elided { resp.on_hover_text(text) } else { resp }
+}
+
+/// [`elided_label_sensed`] with hover only (a plain, non-interactive label).
+pub fn elided_label(ui: &mut Ui, text: &str, max_w: f32) -> Response {
+    elided_label_sensed(ui, text, max_w, Sense::hover())
+}
+
 /// Height of a [`value_field`]'s box.
 pub const VALUE_FIELD_H: f32 = 24.0;
 
@@ -255,6 +300,11 @@ pub fn compact_value_field(ui: &mut Ui, value: &mut f32, range: std::ops::RangeI
     value_field_box(ui, value, range, suffix, vec2(width, height), 0.0, FieldOpts::default()).0
 }
 
+/// A compact field whose mouse scrub wraps at the native fullscreen viewport's horizontal edges.
+pub(crate) fn compact_wrapping_value_field(ui: &mut Ui, value: &mut f32, range: std::ops::RangeInclusive<f32>, suffix: &str, size: Vec2) -> Response {
+    value_field_box(ui, value, range, suffix, size, 0.0, FieldOpts { wrap_drag: true, ..Default::default() }).0
+}
+
 /// A size dialog's unit key (`px`, `in`, `cm`, `mm`, `pt`, `pica`, `percent`) as a unit.
 pub fn unit_of_key(key: &str) -> photocraft_engine::prefs::Unit {
     use photocraft_engine::prefs::Unit;
@@ -279,7 +329,7 @@ pub fn unit_decimals(key: &str) -> u32 {
 /// A [`value_field`] showing `decimals` decimal places instead of the one (or two, for a small
 /// range) it picks itself: the ruler units need their own precision (#2434).
 pub fn value_field_prec(ui: &mut Ui, value: &mut f32, range: std::ops::RangeInclusive<f32>, suffix: &str, width: f32, decimals: u32) -> Response {
-    value_field_in(ui, value, range, suffix, width, 0.0, FieldOpts { decimals: Some(decimals), units: None }).0
+    value_field_in(ui, value, range, suffix, width, 0.0, FieldOpts { decimals: Some(decimals), ..Default::default() }).0
 }
 
 /// A field's unit and the resolution a typed unit converts at (`1in` in a px field).
@@ -295,7 +345,7 @@ pub struct FieldUnits {
 /// A [`value_field_prec`] without a suffix, whose unit is chosen beside it (Image Size and New
 /// Document's unit menus) and converts typed units at that dialog's own resolution.
 pub fn value_field_units(ui: &mut Ui, value: &mut f32, range: std::ops::RangeInclusive<f32>, width: f32, decimals: u32, units: FieldUnits) -> Response {
-    value_field_in(ui, value, range, "", width, 0.0, FieldOpts { decimals: Some(decimals), units: Some(units) }).0
+    value_field_in(ui, value, range, "", width, 0.0, FieldOpts { decimals: Some(decimals), units: Some(units), ..Default::default() }).0
 }
 
 fn field_resolution_id() -> egui::Id {
@@ -423,6 +473,7 @@ struct FieldOpts {
     decimals: Option<u32>,
     /// The unit typed units convert into (default: the suffix's, at [`set_field_resolution`]).
     units: Option<FieldUnits>,
+    wrap_drag: bool,
 }
 
 /// A [`value_field`] that leaves `trailing` points free inside its box, right of the suffix, and
@@ -449,7 +500,7 @@ fn value_field_box(
     trailing: f32,
     opts: FieldOpts,
 ) -> (Response, Rect) {
-    let FieldOpts { decimals, units } = opts;
+    let FieldOpts { decimals, units, wrap_drag } = opts;
     let t = Tokens::get(ui.ctx());
     let (rect, slot) = ui.allocate_exact_size(size, Sense::hover());
     let scrub = take_label_scrub(ui, rect);
@@ -497,7 +548,7 @@ fn value_field_box(
             ui.spacing_mut().button_padding = Vec2::ZERO;
             ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                 let layout = egui::Layout::centered_and_justified(ui.layout().main_dir());
-                ui.allocate_ui_with_layout(field.size(), layout, |ui| number_edit(ui, value, range, fine, decimals, units)).inner
+                ui.allocate_ui_with_layout(field.size(), layout, |ui| number_edit(ui, value, range, fine, decimals, units, wrap_drag)).inner
             })
             .inner
         }
@@ -640,6 +691,45 @@ pub fn popup_value_field(ui: &mut Ui, name: &str, value: &mut f32, range: std::o
     out
 }
 
+/// Height of a [`text_field`]'s box, matching a [`value_field`].
+pub const TEXT_FIELD_H: f32 = 24.0;
+
+/// Inner padding of a [`text_field`]'s box: 6 pt either side, 2 pt above and below.
+const TEXT_FIELD_PAD: Vec2 = vec2(6.0, 2.0);
+
+/// A single-line text field in PhotoCraft's shared field style (#3789): the same box as a
+/// [`value_field`] -- the theme's field fill and `field_border`, rounded by `radius_sm` -- with a
+/// consistent inner padding and no focus outline. egui's default white focus ring (its
+/// `selection.stroke`) is what made the Preferences search field look different from the Color
+/// Picker's hex field, so every plain, non-numeric input (search, hex, name, filter) is drawn
+/// through here to look and behave the same. `id` carries the field's text and focus across
+/// frames; `hint` shows while it is empty; `mono` picks the monospaced face for hex and other
+/// code-like values.
+pub fn text_field(ui: &mut Ui, id: egui::Id, text: &mut String, hint: &str, width: f32, mono: bool) -> Response {
+    text_field_ex(ui, id, text, hint, width, mono, None)
+}
+
+/// [`text_field`] limited to `char_limit` characters (a hex field's six digits, say).
+pub fn text_field_ex(ui: &mut Ui, id: egui::Id, text: &mut String, hint: &str, width: f32, mono: bool, char_limit: Option<usize>) -> Response {
+    let t = Tokens::get(ui.ctx());
+    let (rect, _) = ui.allocate_exact_size(vec2(width.max(16.0), TEXT_FIELD_H), Sense::hover());
+    surface(ui, rect, t.field, false);
+    if !t.bevel {
+        ui.painter().rect_stroke(rect, t.radius_sm, Stroke::new(1.0, t.field_border), StrokeKind::Inside);
+    }
+    let font = if mono { theme::mono(12.0) } else { egui::FontId::proportional(12.5) };
+    let mut edit = egui::TextEdit::singleline(text).id(id).hint_text(hint).frame(egui::Frame::NONE).font(font);
+    if let Some(limit) = char_limit {
+        edit = edit.char_limit(limit);
+    }
+    // A child Ui keeps the field's selection colour local: `Visuals::selection` also fills selected
+    // list rows and slider trails, which must keep the theme's.
+    let layout = egui::Layout::centered_and_justified(egui::Direction::TopDown);
+    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(rect.shrink2(TEXT_FIELD_PAD)).layout(layout));
+    child.style_mut().visuals.selection.bg_fill = t.field_selection();
+    child.add(edit)
+}
+
 fn first_field_id() -> egui::Id {
     egui::Id::new("pc-focus-first-field")
 }
@@ -666,6 +756,7 @@ fn number_edit(
     fine: bool,
     decimals: Option<u32>,
     units: crate::numeric_expression::Units,
+    wrap_drag: bool,
 ) -> Response {
     let (id, ctx) = (ui.next_auto_id(), ui.ctx().clone());
     // Focused before the DragValue is drawn, so it gains focus this frame and selects its text.
@@ -680,10 +771,14 @@ fn number_edit(
     let math = ui.memory(|m| m.has_focus(id)) && ui.data(|d| d.get_temp(held)).unwrap_or(false);
     ui.data_mut(|d| d.insert_temp(held, math));
     let before = *value;
+    let speed = if fine { 0.01 } else { 0.5 };
+    let wrapping = wrap_drag && crate::scrub_wrap::active(ui);
+    let wrapped_drag = wrapping && ui.input(|i| i.pointer.primary_down());
     let mut resp = ui.add(
         egui::DragValue::new(value)
-            .range(range)
-            .speed(if fine { 0.01 } else { 0.5 })
+            .range(range.clone())
+            // A warp is an absolute-position jump. The scoped scrub below removes that jump.
+            .speed(if wrapped_drag { 0.0 } else { speed })
             .custom_formatter(move |v, _| match decimals {
                 Some(d) => fmt_num_prec(v, d),
                 None if fine => fmt_num2(v),
@@ -701,6 +796,9 @@ fn number_edit(
                 v
             }),
     );
+    if wrap_drag {
+        crate::scrub_wrap::update(ui, &resp, value, before, range, speed, wrapping);
+    }
     resp.flags.set(egui::response::Flags::CHANGED, *value != before);
     resp
 }
@@ -758,7 +856,7 @@ fn wheel_notches(ui: &Ui, resp: &Response) -> f32 {
 }
 
 /// [`wheel_notches`] of widget `id` while `hovered`, a notch with Shift counting `shift_notches`.
-fn wheel_notches_of(ui: &Ui, id: egui::Id, hovered: bool, shift_notches: f32) -> f32 {
+pub(crate) fn wheel_notches_of(ui: &Ui, id: egui::Id, hovered: bool, shift_notches: f32) -> f32 {
     if !hovered {
         return 0.0;
     }
@@ -913,6 +1011,22 @@ pub fn slider_row_with(
     suffix: &str,
     gradient: Option<&[Color32]>,
     g: RowGestures,
+) -> Response {
+    slider_row_prec(ui, label, value, range, suffix, gradient, g, None)
+}
+
+/// [`slider_row_with`] whose field shows `decimals` places instead of the one (or two, for a
+/// small range) it picks itself: Exposure's ±20 stops show two, its Offset four (#4164).
+#[allow(clippy::too_many_arguments)]
+pub fn slider_row_prec(
+    ui: &mut Ui,
+    label: &str,
+    value: &mut f32,
+    range: std::ops::RangeInclusive<f32>,
+    suffix: &str,
+    gradient: Option<&[Color32]>,
+    g: RowGestures,
+    decimals: Option<u32>,
 ) -> Response {
     let t = Tokens::get(ui.ctx());
     let mut changed_resp = None;
@@ -921,7 +1035,7 @@ pub fn slider_row_with(
         let l = ui.label(egui::RichText::new(tl!(label)).color(t.text_dim));
         scrub_label_within(ui, &l, f32::INFINITY);
         ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-            changed_resp = Some(value_field(ui, value, range.clone(), suffix, 74.0));
+            changed_resp = Some(value_field_in(ui, value, range.clone(), suffix, 74.0, 0.0, FieldOpts { decimals, ..Default::default() }).0);
         });
     });
     let s = slider_with(ui, value, range, gradient, g);
@@ -1488,19 +1602,13 @@ pub fn checkbox(ui: &mut Ui, on: &mut bool, label: &str) -> Response {
         .horizontal(|ui| {
             ui.spacing_mut().item_spacing.x = 6.0;
             let (rect, resp) = ui.allocate_exact_size(vec2(14.0, 14.0), Sense::click());
-            let p = ui.painter();
-            if *on {
-                p.rect_filled(rect, 2.0, t.accent);
-                let a = rect.left_center() + vec2(3.0, 0.5);
-                let b = rect.center_bottom() + vec2(-1.0, -3.5);
-                let c = rect.right_top() + vec2(-3.0, 3.5);
-                p.line_segment([a, b], Stroke::new(1.8, Color32::WHITE));
-                p.line_segment([b, c], Stroke::new(1.8, Color32::WHITE));
-            } else {
-                p.rect_filled(rect, 2.0, t.field);
-                p.rect_stroke(rect, 2.0, Stroke::new(1.5, if resp.hovered() { t.text_dim } else { t.text_faint }), StrokeKind::Inside);
-            }
-            let l = ui.add(egui::Label::new(egui::RichText::new(tl!(label)).color(t.text_dim)).sense(Sense::click()));
+            let resp = resp.on_hover_cursor(egui::CursorIcon::PointingHand);
+            let l = ui
+                .add(egui::Label::new(egui::RichText::new(tl!(label)).color(t.text_dim)).selectable(false).sense(Sense::click()))
+                .on_hover_cursor(egui::CursorIcon::PointingHand);
+            // Pressing the label presses the box (#4476).
+            let pressed = resp.is_pointer_button_down_on() || l.is_pointer_button_down_on();
+            check_box(ui.painter(), rect, *on, resp.hovered() || l.hovered(), pressed, &t);
             resp.union(l)
         })
         .inner;
@@ -1511,6 +1619,34 @@ pub fn checkbox(ui: &mut Ui, on: &mut bool, label: &str) -> Response {
     resp
 }
 
+/// The fill of a check box: the accent when `on`, else the field colour. While it's pressed
+/// (the mouse is down on it or on its label) Photoshop shows that a release will act: an
+/// unchecked box darkens a little and a checked one turns a little less opaque (#4476).
+pub fn check_box_fill(on: bool, pressed: bool, t: &Tokens) -> Color32 {
+    match (on, pressed) {
+        (true, false) => t.accent,
+        (true, true) => t.accent.gamma_multiply(0.75),
+        (false, false) => t.field,
+        (false, true) => t.field.lerp_to_gamma(Color32::BLACK, 0.18),
+    }
+}
+
+/// Paint a check box in `rect`: [`check_box_fill`] with a white tick when `on`, else an
+/// outline that brightens while `hovered` or `pressed`.
+pub fn check_box(p: &egui::Painter, rect: Rect, on: bool, hovered: bool, pressed: bool, t: &Tokens) {
+    p.rect_filled(rect, 2.0, check_box_fill(on, pressed, t));
+    if on {
+        let a = rect.left_center() + vec2(3.0, 0.5);
+        let b = rect.center_bottom() + vec2(-1.0, -3.5);
+        let c = rect.right_top() + vec2(-3.0, 3.5);
+        let tick = Stroke::new(rect.width() * 0.125, Color32::WHITE);
+        p.line_segment([a, b], tick);
+        p.line_segment([b, c], tick);
+    } else {
+        p.rect_stroke(rect, 2.0, Stroke::new(1.5, if hovered || pressed { t.text_dim } else { t.text_faint }), StrokeKind::Inside);
+    }
+}
+
 /// Small chevron for dropdowns (replaces egui's filled triangle).
 pub fn chevron_icon(ui: &Ui, rect: Rect, visuals: &egui::style::WidgetVisuals, _open: bool) {
     let c = rect.center();
@@ -1568,6 +1704,27 @@ fn clean(text: &str) -> String {
 mod tests {
     use egui::{Key, Modifiers};
 
+    #[test]
+    fn checkbox_label_is_a_button_target_not_selectable_text() {
+        use egui::CursorIcon;
+        use egui_kittest::{Harness, kittest::Queryable};
+
+        let mut h = Harness::builder().with_size(egui::vec2(300.0, 80.0)).build_ui_state(
+            |ui, on: &mut bool| {
+                super::checkbox(ui, on, "Show Transform Controls");
+            },
+            false,
+        );
+        h.run_steps(2);
+        let label = h.get_by_label("Show Transform Controls").rect();
+        h.hover_at(label.center());
+        h.run_steps(2);
+        assert_eq!(h.output().platform_output.cursor_icon, CursorIcon::PointingHand);
+        h.get_by_label("Show Transform Controls").click();
+        h.run_steps(2);
+        assert!(*h.state());
+    }
+
     /// #3208: a rounded swatch's checker is one shared, repeating, unblurred two-by-two tile on
     /// the rounded rect, scaled so a cell stays `cell` points, so nothing shows past the corners.
     #[test]
@@ -1594,6 +1751,20 @@ mod tests {
         );
     }
 
+    /// #3580: the shared eliding label never lays out wider than the room it is given, so a longer
+    /// translation shrinks with '…' instead of overrunning its row; a short label is untouched.
+    #[test]
+    fn elided_label_never_exceeds_its_room() {
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(240.0, 60.0)).build_ui(|ui| {
+            let long = super::elided_label(ui, "Preenchimento:", 24.0); // pt-br Fill:, the longest catalog
+            assert!(long.rect.width() <= 25.0, "elided to the room, got {}", long.rect.width());
+            let short = super::elided_label(ui, "Fill", 200.0);
+            assert!(short.rect.width() < 60.0, "a short label is not padded: {}", short.rect.width());
+        });
+        crate::PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::Studio);
+        h.run_steps(2);
+    }
+
     #[test]
     fn spectrum_popup_style_matches_main_menu_and_preserves_studio() {
         for kind in [crate::theme::ThemeKind::Pro, crate::theme::ThemeKind::ProMedium, crate::theme::ThemeKind::Studio, crate::theme::ThemeKind::StudioLight] {
@@ -1604,6 +1775,7 @@ mod tests {
                 let original_padding = ui.spacing().button_padding;
                 let original_hover = ui.visuals().widgets.hovered.fg_stroke;
                 super::style_spectrum_popup_menu(ui);
+                assert_eq!(ui.spacing().item_spacing.y, 0.0, "{kind:?}: menu rows meet so the gap is selectable");
                 if tokens.pro {
                     assert_eq!(ui.spacing().button_padding, egui::vec2(10.0, 4.0));
                     assert_eq!(ui.visuals().widgets.hovered.bg_fill, tokens.accent);
@@ -1618,6 +1790,31 @@ mod tests {
     }
     use egui_kittest::{Harness, kittest::Queryable};
 
+    /// #3789: a plain text field is one boxed, outline-free input whose text-selection colour stays
+    /// local, so it isn't recoloured for the rest of the frame (selected rows, slider trails).
+    #[test]
+    fn text_field_is_a_boxed_input_whose_selection_colour_stays_local() {
+        use egui::accesskit::Role;
+        let mut h = Harness::new_ui_state(
+            |ui, s: &mut (String, egui::Color32, egui::Color32)| {
+                s.1 = ui.visuals().selection.bg_fill;
+                super::text_field(ui, egui::Id::new("tf"), &mut s.0, "hint", 140.0, false);
+                s.2 = ui.visuals().selection.bg_fill;
+            },
+            (String::new(), egui::Color32::WHITE, egui::Color32::BLACK),
+        );
+        crate::PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::Studio);
+        h.run();
+        assert_eq!(h.state().1, h.state().2, "the field's selection colour does not leak into its parent");
+        h.get_by_role(Role::TextInput).click();
+        h.run_steps(1);
+        for ch in "abc".chars() {
+            h.event(egui::Event::Text(ch.to_string()));
+            h.run_steps(1);
+        }
+        assert_eq!(h.state().0, "abc", "typing reaches the bound string");
+    }
+
     /// Sets up a test with one value field. Its state is its value and how many times it changed.
     fn field(value: f32, range: std::ops::RangeInclusive<f32>) -> Harness<'static, (f32, u32)> {
         let mut h = Harness::new_ui_state(
diff --git a/crates/ui-egui/src/work_area.rs b/crates/ui-egui/src/work_area.rs
index 5b4411140a..df4bc7a77e 100644
--- a/crates/ui-egui/src/work_area.rs
+++ b/crates/ui-egui/src/work_area.rs
@@ -10,7 +10,7 @@
 //! [`fit_window`] also fixes the cause at startup: a window that doesn't fit its monitor is
 //! maximized, which puts it in the work area (Photoshop opens maximized on small displays).
 
-use egui::{Rect, Vec2, pos2};
+use egui::{Rect, Vec2, pos2, vec2};
 
 /// Room kept free at the monitor's bottom edge for a taskbar or Dock egui can't see (the Windows
 /// taskbar is 40–48 pt tall; a bottom Dock about as much).
@@ -19,12 +19,30 @@ pub const TASKBAR: f32 = 48.0;
 const MIN_VISIBLE: f32 = 160.0;
 
 /// Where the window's content can be seen, in egui points. `monitor` is the monitor's size,
-/// `inner` the content's rect on the desktop (both from [`egui::ViewportInfo`]); `fills_screen`
-/// is true for a maximized or full-screen window (already inside the work area).
-pub fn visible_part(content: Rect, monitor: Option<Vec2>, inner: Option<Rect>, fills_screen: bool) -> Rect {
-    let (Some(m), Some(inner)) = (monitor, inner) else { return content };
-    let finite = m.x.is_finite() && m.y.is_finite() && inner.min.is_finite() && inner.max.is_finite();
-    if fills_screen || !finite || m.x < 1.0 || m.y < 1.0 {
+/// `inner` the content's rect on the desktop (both from [`egui::ViewportInfo`]). `state` says
+/// whether the window is maximized or full screen.
+pub fn visible_part(content: Rect, monitor: Option<Vec2>, inner: Option<Rect>, state: WindowState) -> Rect {
+    let Some(m) = monitor else { return content };
+    if state == WindowState::FullScreen || !m.x.is_finite() || !m.y.is_finite() || m.x < 1.0 || m.y < 1.0 {
+        return content;
+    }
+    // A maximized window is usually inside the work area already, but not always (#3737): on X11
+    // a window manager that doesn't reserve a panel's space (Cinnamon's Muffin with PhotoCraft's
+    // own title bar, a panel without a strut) maximizes it to the whole monitor, and the panel then
+    // covers its bottom. Where the window is known, it is checked like any other; only a maximized
+    // window with no position (Wayland) is taken to fit.
+    if state == WindowState::Maximized && inner.is_none() {
+        return content;
+    }
+    // #3737: Wayland never tells a window where it is (winit's `inner_position` fails), so egui has
+    // no `inner_rect` there, only the monitor's size. A window bigger than the monitor less the
+    // taskbar still runs under it wherever it is: at best its content starts at the monitor's top,
+    // so at most that much of it can be seen.
+    let Some(inner) = inner else {
+        let room = vec2(m.x, m.y - TASKBAR);
+        return trusted(content, Rect::from_min_size(content.min, room));
+    };
+    if !inner.min.is_finite() || !inner.max.is_finite() {
         return content;
     }
     // Only the monitor's size is known, not where it is on the desktop: assume monitors tile the
@@ -36,7 +54,33 @@ pub fn visible_part(content: Rect, monitor: Option<Vec2>, inner: Option<Rect>, f
     // Desktop → window coordinates.
     let shift = content.min - inner.min;
     let local = usable.translate(shift);
-    let visible = content.intersect(local);
+    trusted(content, local)
+}
+
+/// How the window sits on its monitor.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum WindowState {
+    Normal,
+    Maximized,
+    /// Full screen covers the taskbar on purpose: all of it can be seen.
+    FullScreen,
+}
+
+impl WindowState {
+    fn of(v: &egui::ViewportInfo) -> Self {
+        if v.fullscreen == Some(true) {
+            Self::FullScreen
+        } else if v.maximized == Some(true) {
+            Self::Maximized
+        } else {
+            Self::Normal
+        }
+    }
+}
+
+/// `content` cut to `usable`, unless that leaves too little to be a sensible guess.
+fn trusted(content: Rect, usable: Rect) -> Rect {
+    let visible = content.intersect(usable);
     if !visible.is_positive() || visible.height() < MIN_VISIBLE.min(content.height()) || visible.width() < MIN_VISIBLE.min(content.width()) {
         return content;
     }
@@ -48,8 +92,7 @@ pub fn visible_rect(ctx: &egui::Context) -> Rect {
     let content = ctx.content_rect();
     ctx.input(|i| {
         let v = i.viewport();
-        let fills = v.maximized == Some(true) || v.fullscreen == Some(true);
-        visible_part(content, v.monitor_size, v.inner_rect, fills)
+        visible_part(content, v.monitor_size, v.inner_rect, WindowState::of(v))
     })
 }
 
@@ -68,11 +111,15 @@ pub fn fit_window(ctx: &egui::Context) -> bool {
     if ctx.data(|d| d.get_temp::<bool>(fitted_id())).is_some() {
         return false;
     }
+    let content = ctx.content_rect();
     let (monitor, outer, maximized, fullscreen) = ctx.input(|i| {
         let v = i.viewport();
         (v.monitor_size, v.outer_rect, v.maximized, v.fullscreen)
     });
-    let (Some(m), Some(outer)) = (monitor, outer) else { return false };
+    // On Wayland the window's position, and so its outer rect, is never known (#3737): its content
+    // size is the least the window takes up.
+    let outer = outer.unwrap_or(content);
+    let Some(m) = monitor else { return false };
     // macOS keeps new windows inside the screen's visible frame itself.
     if cfg!(target_os = "macos") {
         return false;
@@ -88,6 +135,7 @@ pub fn fit_window(ctx: &egui::Context) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use WindowState::{FullScreen, Maximized, Normal};
     use egui::{Rect, pos2, vec2};
 
     const MONITOR: Vec2 = vec2(1366.0, 768.0);
@@ -100,30 +148,61 @@ mod tests {
     fn a_window_taller_than_its_display_is_cut_at_the_taskbar() {
         // 1440 × 900 at the desktop origin on 1366 × 768: right and bottom are off-screen.
         let (content, inner) = window(0.0, 0.0, 1440.0, 900.0);
-        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), false), Rect::from_min_max(pos2(0.0, 0.0), pos2(1366.0, 768.0 - TASKBAR)));
+        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), Normal), Rect::from_min_max(pos2(0.0, 0.0), pos2(1366.0, 768.0 - TASKBAR)));
         // Below a 31 pt title bar, a full-height window reaches under the taskbar.
         let (content, inner) = window(0.0, 31.0, 1366.0, 737.0);
-        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), false).bottom(), 768.0 - TASKBAR - 31.0);
+        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), Normal).bottom(), 768.0 - TASKBAR - 31.0);
         // A small window clear of the taskbar is all visible.
         let (content, inner) = window(100.0, 80.0, 800.0, 500.0);
-        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), false), content);
+        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), Normal), content);
         // On a second monitor to the right, the same.
         let (content, inner) = window(1366.0 + 100.0, 0.0, 1440.0, 900.0);
-        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), false).bottom(), 768.0 - TASKBAR);
+        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), Normal).bottom(), 768.0 - TASKBAR);
     }
 
     #[test]
     fn maximized_unknown_or_nonsense_input_keeps_the_window() {
         let (content, inner) = window(0.0, 0.0, 1440.0, 900.0);
-        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), true), content, "maximized: already in the work area");
-        assert_eq!(visible_part(content, None, Some(inner), false), content);
-        assert_eq!(visible_part(content, Some(MONITOR), None, false), content);
-        assert_eq!(visible_part(content, Some(vec2(f32::NAN, 768.0)), Some(inner), false), content);
-        assert_eq!(visible_part(content, Some(vec2(0.0, 0.0)), Some(inner), false), content);
-        assert_eq!(visible_part(content, Some(MONITOR), Some(Rect::from_min_size(pos2(f32::INFINITY, 0.0), vec2(10.0, 10.0))), false), content);
+        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), FullScreen), content, "full screen covers the taskbar on purpose");
+        assert_eq!(visible_part(content, None, Some(inner), Normal), content);
+        assert_eq!(visible_part(content, Some(vec2(f32::NAN, 768.0)), Some(inner), Normal), content);
+        assert_eq!(visible_part(content, Some(vec2(0.0, 0.0)), Some(inner), Normal), content);
+        assert_eq!(visible_part(content, Some(MONITOR), Some(Rect::from_min_size(pos2(f32::INFINITY, 0.0), vec2(10.0, 10.0))), Normal), content);
         // A guess that would leave almost nothing visible is not trusted.
         let (content, inner) = window(0.0, 600.0, 1000.0, 300.0);
-        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), false), content);
+        assert_eq!(visible_part(content, Some(MONITOR), Some(inner), Normal), content);
+    }
+
+    #[test]
+    fn a_maximized_window_under_a_panel_is_still_cut_at_the_taskbar() {
+        // #3737, X11 (Linux Mint): the window manager maximized the window to the whole 1920 × 1080
+        // monitor without reserving the bottom panel's space, so the panel covers it.
+        for scale in [1.0_f32, 1.5] {
+            let monitor = vec2(1920.0, 1080.0) / scale;
+            let content = Rect::from_min_size(pos2(0.0, 0.0), monitor);
+            let bottom = monitor.y - TASKBAR;
+            assert_eq!(visible_part(content, Some(monitor), Some(content), Maximized).bottom(), bottom, "at {scale}×");
+            // A window manager that reserves the panel: the maximized window already ends above it.
+            let fitted = Rect::from_min_size(pos2(0.0, 0.0), vec2(monitor.x, bottom));
+            assert_eq!(visible_part(fitted, Some(monitor), Some(fitted), Maximized), fitted, "at {scale}×");
+            // Full screen is meant to cover the panel.
+            assert_eq!(visible_part(content, Some(monitor), Some(content), FullScreen), content, "at {scale}×");
+        }
+    }
+
+    #[test]
+    fn an_unknown_window_position_still_keeps_clear_of_the_taskbar() {
+        // #3737, Wayland: only the monitor's size is known. A window taller than the monitor less
+        // the taskbar can be seen at most down to there, wherever it is.
+        let content = Rect::from_min_size(pos2(0.0, 0.0), vec2(1366.0, 740.0));
+        assert_eq!(visible_part(content, Some(MONITOR), None, Normal), Rect::from_min_max(pos2(0.0, 0.0), pos2(1366.0, 768.0 - TASKBAR)));
+        let big = Rect::from_min_size(pos2(0.0, 0.0), vec2(1440.0, 900.0));
+        assert_eq!(visible_part(big, Some(MONITOR), None, Normal), Rect::from_min_max(pos2(0.0, 0.0), pos2(1366.0, 768.0 - TASKBAR)));
+        // One that fits, or a maximized one, is all visible.
+        let small = Rect::from_min_size(pos2(0.0, 0.0), vec2(1000.0, 600.0));
+        assert_eq!(visible_part(small, Some(MONITOR), None, Normal), small);
+        assert_eq!(visible_part(content, Some(MONITOR), None, Maximized), content);
+        assert_eq!(visible_part(content, Some(MONITOR), None, FullScreen), content);
     }
 
     fn frame(ctx: &egui::Context, monitor: Option<Vec2>, outer: Option<Rect>, maximized: Option<bool>) -> Vec<egui::ViewportCommand> {
@@ -158,6 +237,19 @@ mod tests {
         );
         let ctx = egui::Context::default();
         assert!(!frame(&ctx, Some(MONITOR), big, Some(true)).contains(&egui::ViewportCommand::Maximized(true)));
+        // Wayland: no outer rect, but a content area bigger than the monitor is maximized too (#3737).
+        let ctx = egui::Context::default();
+        let mut input = egui::RawInput { screen_rect: Some(Rect::from_min_size(pos2(0.0, 0.0), vec2(1440.0, 900.0))), ..Default::default() };
+        if let Some(v) = input.viewports.get_mut(&egui::ViewportId::ROOT) {
+            v.monitor_size = Some(MONITOR);
+            v.maximized = Some(false);
+        }
+        let mut out = ctx.run_ui(input, |ui| {
+            fit_window(ui.ctx());
+        });
+        out.textures_delta.clear();
+        let cmds = out.viewport_output.get(&egui::ViewportId::ROOT).map(|v| v.commands.clone()).unwrap_or_default();
+        assert_eq!(cmds.contains(&egui::ViewportCommand::Maximized(true)), !cfg!(target_os = "macos"));
         assert!(fits(vec2(1366.0, 720.0), MONITOR) && !fits(vec2(1366.0, 740.0), MONITOR) && !fits(vec2(1440.0, 700.0), MONITOR));
     }
 }
diff --git a/crates/ui-egui/tests/batch_export_options.rs b/crates/ui-egui/tests/batch_export_options.rs
new file mode 100644
index 0000000000..5bf87909bf
--- /dev/null
+++ b/crates/ui-egui/tests/batch_export_options.rs
@@ -0,0 +1,384 @@
+//! #2399: batch conversion exposes the formats and quality its engine already supports.
+//! The menu controls are exercised separately from the existing engine's decoded outputs.
+
+use egui_kittest::kittest::Queryable;
+use photocraft_codecs::{ChannelLayout, EncodeOptions, Format, Image};
+use photocraft_ui_egui::{PhotocraftApp, menus};
+use serde_json::{Value, json};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+type Harness = egui_kittest::Harness<'static, PhotocraftApp>;
+
+fn harness() -> Harness {
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1100.0, 760.0)).with_max_steps(64).wgpu().build_eframe(|cc| {
+        PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+        let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+        app.session.prefs.edit(|p| p.interface.language = "en".into());
+        if let Some(rs) = cc.wgpu_render_state.as_ref() {
+            app.set_wgpu(rs.clone());
+        }
+        app.run("file.new", json!({"width": 8, "height": 8, "background": "white"})).unwrap();
+        app.run("actions.record", json!({"name": "Invert"})).unwrap();
+        app.run("image.adjustments.invert", json!({})).unwrap();
+        app.run("actions.stop", json!({})).unwrap();
+        app
+    });
+    h.run_steps(4);
+    h
+}
+
+fn open(h: &mut Harness, command: &str) {
+    let ctx = h.ctx.clone();
+    menus::invoke(h.state_mut(), &ctx, command, json!({})).expect("open the real menu dialog");
+    h.run_steps(5);
+}
+
+fn evidence(h: &mut Harness, name: &str) {
+    if let Some(dir) = std::env::var_os("PHOTOCRAFT_BATCH_EVIDENCE_DIR") {
+        std::fs::create_dir_all(&dir).unwrap();
+        h.render().expect("offscreen UI render").save(Path::new(&dir).join(format!("{name}.png"))).unwrap();
+    }
+}
+
+fn open_format_choices(h: &mut Harness) {
+    let label = h.get_by_label("Format").rect();
+    // The full app also draws the workspace and layer-blend dropdowns behind this modal.
+    // Target the actual form field beside Format, like the existing numeric-field harnesses.
+    h.query_all_by_role(egui::accesskit::Role::ComboBox)
+        .find(|n| {
+            let r = n.rect();
+            r.left() >= label.right() && (r.center().y - label.center().y).abs() < 3.0
+        })
+        .expect("format dropdown beside its label")
+        .click();
+    h.run_steps(3);
+}
+
+fn choose_webp(h: &mut Harness) {
+    open_format_choices(h);
+    h.query_by_label("WebP").or_else(|| h.query_by_label("Webp")).expect("WebP output choice").click();
+    h.run_steps(3);
+}
+
+fn replace_text(h: &mut Harness, value: &str) {
+    h.event(egui::Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::COMMAND });
+    h.event(egui::Event::Key { key: egui::Key::A, physical_key: None, pressed: false, repeat: false, modifiers: egui::Modifiers::COMMAND });
+    h.event(egui::Event::Text(value.into()));
+    h.run_steps(3);
+}
+
+fn edit_path(h: &mut Harness, name: &str, value: &Path) {
+    let label = h.get_by_label(name).rect();
+    h.query_all_by_role(egui::accesskit::Role::TextInput)
+        .find(|n| {
+            let r = n.rect();
+            r.left() >= label.right() && (r.center().y - label.center().y).abs() < 3.0
+        })
+        .expect("path text field beside its label")
+        .click();
+    h.run_steps(2);
+    replace_text(h, &value.to_string_lossy());
+    h.get_by_label(name).click();
+    h.run_steps(2);
+}
+
+fn edit_quality(h: &mut Harness, value: &str) {
+    let label = h.get_by_label("Quality").rect();
+    h.query_all_by_role(egui::accesskit::Role::SpinButton)
+        .find(|n| {
+            let r = n.rect();
+            r.left() >= label.right() && (r.center().y - label.center().y).abs() < 3.0
+        })
+        .expect("quality numeric field beside its label")
+        .click();
+    h.run_steps(2);
+    replace_text(h, value);
+    h.get_by_label("Quality").click();
+    h.run_steps(3);
+}
+
+#[test]
+fn batch_menu_offers_webp() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let mut h = harness();
+    open(&mut h, "file.automate.batch");
+    open_format_choices(&mut h);
+    evidence(&mut h, "batch-formats");
+    assert!(h.query_by_label("WebP").or_else(|| h.query_by_label("Webp")).is_some(), "Batch must offer the supported WebP output format");
+}
+
+#[test]
+fn batch_menu_offers_quality() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let mut h = harness();
+    open(&mut h, "file.automate.batch");
+    evidence(&mut h, "batch-quality");
+    assert!(h.query_by_label("Quality").is_some(), "Batch must expose its supported output quality");
+}
+
+#[test]
+fn image_processor_menu_offers_webp() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let mut h = harness();
+    open(&mut h, "file.scripts.imageProcessor");
+    open_format_choices(&mut h);
+    evidence(&mut h, "image-processor-formats");
+    assert!(h.query_by_label("WebP").or_else(|| h.query_by_label("Webp")).is_some(), "Image Processor must offer the supported WebP output format");
+}
+
+struct Scratch(PathBuf);
+
+impl Scratch {
+    fn new() -> Self {
+        let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+        let path = std::env::temp_dir().join(format!("photocraft-batch-options-{}-{now}", std::process::id()));
+        std::fs::create_dir_all(&path).unwrap();
+        Self(path)
+    }
+}
+
+impl Drop for Scratch {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+
+fn pattern() -> Image {
+    let mut data = Vec::new();
+    for y in 0..48u32 {
+        for x in 0..64u32 {
+            data.extend([(x * 13 + y * 3) as u8, (y * 17 + x * 5) as u8, ((x ^ y) * 11) as u8]);
+        }
+    }
+    Image::from_u8(64, 48, ChannelLayout::Rgb, data).unwrap()
+}
+
+#[test]
+fn existing_engine_batch_and_image_processor_support_webp_quality() {
+    let dir = Scratch::new();
+    let input = dir.0.join("owned-pattern.png");
+    let source = pattern();
+    std::fs::write(&input, photocraft_codecs::encode(&source, Format::Png, &EncodeOptions::default()).unwrap()).unwrap();
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+    app.run("file.new", json!({"width": 8, "height": 8})).unwrap();
+    let doc = app.session.active().unwrap().doc.clone();
+    let revision = app.session.active().unwrap().revision;
+    let history = app.session.active().unwrap().history.entries();
+    let prefs = serde_json::to_value(app.session.prefs()).unwrap();
+
+    for (command, prefix) in [("file.automate.batch", "batch"), ("file.scripts.imageProcessor", "processor")] {
+        let expected: Vec<u8> = source.data().iter().map(|v| if prefix == "batch" { 255 - v } else { *v }).collect();
+        let mut outputs = Vec::new();
+        for quality in [Value::Null, json!(0), json!(12)] {
+            let out = dir.0.join(format!("{prefix}-{quality}"));
+            std::fs::create_dir(&out).unwrap();
+            let result = app
+                .run(command, json!({"input": [input], "output": out, "steps": [["image.adjustments.invert", {}]], "format": "webp", "quality": quality}))
+                .unwrap();
+            assert_eq!(result["errors"], json!([]), "{command}: {result}");
+            let path = result["files"][0].as_str().unwrap();
+            assert!(path.ends_with(".webp"));
+            let bytes = std::fs::read(path).unwrap();
+            let decoded = photocraft_codecs::decode_as(Format::WebP, &bytes).unwrap();
+            assert_eq!(decoded.dimensions(), (64, 48));
+            assert_eq!(decoded.layout(), ChannelLayout::Rgb);
+            if quality.is_null() && prefix == "batch" {
+                assert_eq!(decoded.data(), expected, "default Batch WebP is lossless, and the action was applied");
+            }
+            outputs.push(bytes);
+        }
+        assert_ne!(outputs[1], outputs[2], "{command}: low and high quality must affect the encoder");
+        assert!(outputs[1].len() < outputs[2].len(), "{command}: this synthetic pattern grows at higher quality");
+    }
+    let active = app.session.active().unwrap();
+    assert!(Arc::ptr_eq(&active.doc, &doc), "batch commands leave the active document untouched");
+    assert_eq!(active.revision, revision);
+    assert_eq!(active.history.entries(), history);
+    assert_eq!(serde_json::to_value(app.session.prefs()).unwrap(), prefs);
+}
+
+#[test]
+fn batch_custom_quality_is_bounded_dialog_local_and_reversible() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let mut h = harness();
+    open(&mut h, "file.automate.batch");
+    assert!(h.state().ui.dialogs.last().unwrap().fields["quality"].is_null(), "default command quality remains unset");
+    h.get_by_label("Custom").click();
+    h.run_steps(3);
+    edit_quality(&mut h, "-5");
+    assert_eq!(h.state().ui.dialogs.last().unwrap().fields["quality"].as_f64(), Some(0.0));
+    edit_quality(&mut h, "99");
+    assert_eq!(h.state().ui.dialogs.last().unwrap().fields["quality"].as_f64(), Some(12.0));
+    edit_quality(&mut h, "5");
+    h.get_by_label("Custom").click();
+    h.run_steps(3);
+    assert!(h.state().ui.dialogs.last().unwrap().fields["quality"].is_null());
+    h.get_by_label("Custom").click();
+    h.run_steps(3);
+    assert_eq!(h.state().ui.dialogs.last().unwrap().fields["quality"].as_f64(), Some(5.0), "switching defaults does not lose the dialog's custom value");
+    h.get_by_label("Cancel").click();
+    h.run_steps(3);
+    open(&mut h, "file.automate.batch");
+    assert!(h.state().ui.dialogs.last().unwrap().fields["quality"].is_null(), "reopening returns to the existing default");
+}
+
+#[test]
+fn batch_and_processor_real_controls_write_the_chosen_webp_quality() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let dir = Scratch::new();
+    let input = dir.0.join("input");
+    std::fs::create_dir(&input).unwrap();
+    let original = pattern();
+    std::fs::write(input.join("owned-pattern.png"), photocraft_codecs::encode(&original, Format::Png, &EncodeOptions::default()).unwrap()).unwrap();
+    let mut h = harness();
+    let doc = h.state().session.active().unwrap().doc.clone();
+    let revision = h.state().session.active().unwrap().revision;
+    let history = h.state().session.active().unwrap().history.entries();
+    let prefs = serde_json::to_value(h.state().session.prefs()).unwrap();
+    let actions = serde_json::to_value(&h.state().session.actions.list).unwrap();
+    for (command, prefix) in [("file.automate.batch", "batch"), ("file.scripts.imageProcessor", "processor")] {
+        let mut outputs = Vec::new();
+        for quality in [0, 12] {
+            let output = dir.0.join(format!("{prefix}-{quality}"));
+            open(&mut h, command);
+            if prefix == "batch" {
+                assert!(h.state().ui.dialogs.last().unwrap().fields["quality"].is_null());
+                h.get_by_label("Custom").click();
+                h.run_steps(3);
+            } else {
+                let fields = &h.state().ui.dialogs.last().unwrap().fields;
+                assert_eq!(fields["quality"], json!(8));
+                assert_eq!(fields["width"], json!(0));
+                assert_eq!(fields["height"], json!(0));
+                assert_eq!(fields["convertToSrgb"], json!(true));
+            }
+            choose_webp(&mut h);
+            edit_path(&mut h, "Input", &input);
+            edit_path(&mut h, "Output", &output);
+            edit_quality(&mut h, &quality.to_string());
+            evidence(&mut h, &format!("{prefix}-webp-quality-{quality}"));
+            h.get_by_label("OK").click();
+            h.run_steps(5);
+            assert!(h.state().ui.dialogs.is_empty());
+            let bytes = std::fs::read(output.join("owned-pattern.webp")).expect("the actual dialog confirmation writes the selected WebP");
+            let decoded = photocraft_codecs::decode_as(Format::WebP, &bytes).unwrap();
+            assert_eq!(decoded.dimensions(), (64, 48));
+            assert_eq!(decoded.layout(), ChannelLayout::Rgb);
+            let (_, params) = h.state().session.journal.last().unwrap();
+            assert_eq!(params["format"], json!("webp"));
+            assert_eq!(params["quality"].as_f64(), Some(f64::from(quality)));
+            assert!(params.as_object().unwrap().keys().all(|k| !k.starts_with("__")), "private shell values never become command params");
+            outputs.push(bytes);
+        }
+        assert_ne!(outputs[0], outputs[1], "{command}: actual chosen quality reaches the encoder");
+        assert!(outputs[0].len() < outputs[1].len());
+    }
+    let active = h.state().session.active().unwrap();
+    assert!(Arc::ptr_eq(&active.doc, &doc));
+    assert_eq!((active.revision, active.history.entries()), (revision, history));
+    assert_eq!(serde_json::to_value(h.state().session.prefs()).unwrap(), prefs);
+    assert_eq!(serde_json::to_value(&h.state().session.actions.list).unwrap(), actions);
+}
+
+#[test]
+fn batch_naming_controls_export_the_requested_names_and_reset_on_cancel() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let dir = Scratch::new();
+    let input = dir.0.join("input");
+    let output = dir.0.join("output");
+    std::fs::create_dir(&input).unwrap();
+    let source = pattern();
+    let bytes = photocraft_codecs::encode(&source, Format::Png, &EncodeOptions::default()).unwrap();
+    for name in ["first.png", "second.png"] {
+        std::fs::write(input.join(name), &bytes).unwrap();
+    }
+    let mut h = harness();
+    open(&mut h, "file.automate.batch");
+    h.get_by_role_and_label(egui::accesskit::Role::TextInput, "File Naming").click();
+    h.run_steps(2);
+    replace_text(&mut h, "cancelled_{serial}");
+    h.get_by_label("Cancel").click();
+    h.run_steps(3);
+    assert!(!output.exists());
+    open(&mut h, "file.automate.batch");
+    let fields = &h.state().ui.dialogs.last().unwrap().fields;
+    assert_eq!(fields["naming"], "");
+    assert_eq!(fields["startingSerial"], 1);
+    edit_path(&mut h, "Input", &input);
+    edit_path(&mut h, "Output", &output);
+    h.get_by_role_and_label(egui::accesskit::Role::TextInput, "File Naming").click();
+    h.run_steps(2);
+    replace_text(&mut h, "{serial}_{name}");
+    let label = h.get_by_label("Starting serial").rect();
+    h.query_all_by_role(egui::accesskit::Role::SpinButton)
+        .find(|n| {
+            let r = n.rect();
+            r.left() >= label.right() && r.left() < label.right() + 100.0 && (r.center().y - label.center().y).abs() < 3.0
+        })
+        .expect("starting serial number control")
+        .click();
+    h.run_steps(2);
+    h.event(egui::Event::Text("7".into()));
+    h.run_steps(3);
+    h.get_by_label("Starting serial").click();
+    h.run_steps(3);
+    assert_eq!(h.state().ui.dialogs.last().unwrap().fields["startingSerial"], 7, "typing changes the starting serial");
+    evidence(&mut h, "batch-naming");
+    h.get_by_label("OK").click();
+    h.run_steps(5);
+    assert!(h.state().ui.dialogs.is_empty());
+    let expected: Vec<_> = source.data().iter().map(|v| 255 - v).collect();
+    for name in ["007_first.png", "008_second.png"] {
+        let bytes = std::fs::read(output.join(name)).expect("dialog naming reaches the exporter");
+        let decoded = photocraft_codecs::decode_as(Format::Png, &bytes).unwrap();
+        assert_eq!(decoded.data(), expected, "the recorded Invert action still runs");
+    }
+    assert!(!output.join("first.png").exists());
+    assert!(!output.join("second.png").exists());
+}
+
+#[test]
+fn batch_default_quality_keeps_lossless_webp_and_existing_jpeg_bytes() {
+    let _gpu = photocraft_testkit::gpu_lock();
+    let dir = Scratch::new();
+    let input = dir.0.join("input");
+    std::fs::create_dir(&input).unwrap();
+    let original = pattern();
+    std::fs::write(input.join("owned-pattern.png"), photocraft_codecs::encode(&original, Format::Png, &EncodeOptions::default()).unwrap()).unwrap();
+    let mut h = harness();
+    for format in ["webp", "jpg"] {
+        let output = dir.0.join(format!("ui-default-{format}"));
+        let reference = dir.0.join(format!("engine-existing-default-{format}"));
+        open(&mut h, "file.automate.batch");
+        if format == "webp" {
+            choose_webp(&mut h);
+        } else {
+            open_format_choices(&mut h);
+            h.get_by_label("Jpg").click();
+            h.run_steps(3);
+        }
+        edit_path(&mut h, "Input", &input);
+        edit_path(&mut h, "Output", &output);
+        assert!(h.state().ui.dialogs.last().unwrap().fields["quality"].is_null());
+        evidence(&mut h, &format!("batch-default-{format}"));
+        h.get_by_label("OK").click();
+        h.run_steps(5);
+        let result = std::fs::read(output.join(format!("owned-pattern.{format}"))).unwrap();
+        let mut session = photocraft_engine::Session::new();
+        let r = session
+            .execute("file.automate.batch", json!({"input": input, "output": reference, "steps": [["image.adjustments.invert", {}]], "format": format}))
+            .unwrap();
+        assert_eq!(r["errors"], json!([]));
+        assert_eq!(
+            result,
+            std::fs::read(reference.join(format!("owned-pattern.{format}"))).unwrap(),
+            "{format}: UI default equals the command's existing unset quality"
+        );
+        if format == "webp" {
+            let decoded = photocraft_codecs::decode_as(Format::WebP, &result).unwrap();
+            let expected: Vec<u8> = original.data().iter().map(|v| 255 - v).collect();
+            assert_eq!(decoded.data(), expected, "default WebP remains lossless after the recorded action");
+        }
+    }
+}
diff --git a/crates/ui-egui/tests/crop_default_mode.rs b/crates/ui-egui/tests/crop_default_mode.rs
index 19e885a967..7c426410db 100644
--- a/crates/ui-egui/tests/crop_default_mode.rs
+++ b/crates/ui-egui/tests/crop_default_mode.rs
@@ -24,6 +24,8 @@ fn harness() -> Option<Harness> {
         egui_kittest::Harness::builder().with_size(egui::vec2(900.0, 640.0)).with_max_steps(64).wgpu().build_eframe(|cc| {
             PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
             let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+            // The queries below use English labels; don't follow the system locale.
+            app.session.prefs.edit(|p| p.interface.language = "en".into());
             if let Some(rs) = cc.wgpu_render_state.as_ref() {
                 app.set_wgpu(rs.clone());
             }
@@ -104,6 +106,9 @@ fn setup() -> Option<Harness> {
 
 #[test]
 fn a_ratio_dropdown_updates_the_preview_and_enter_without_touching_a_handle() {
+    // Windows WARP can access-violate when GPU harnesses initialize or tear down concurrently:
+    // hold the GPU lock for the whole test, harness included.
+    let _gpu = photocraft_testkit::gpu_lock();
     let Some(mut h) = setup() else { return };
     h.get_by_value("Ratio").click();
     h.run_steps(3);
@@ -122,6 +127,9 @@ fn a_ratio_dropdown_updates_the_preview_and_enter_without_touching_a_handle() {
 
 #[test]
 fn the_swap_button_and_x_apply_the_same_inscribed_ratio() {
+    // Windows WARP can access-violate when GPU harnesses initialize or tear down concurrently:
+    // hold the GPU lock for the whole test, harness included.
+    let _gpu = photocraft_testkit::gpu_lock();
     let Some(mut h) = setup() else { return };
     let original = [30.0, 20.0, 270.0, 180.0];
     h.state_mut().ui.crop_rect = Some(original);
@@ -146,6 +154,9 @@ fn the_swap_button_and_x_apply_the_same_inscribed_ratio() {
 
 #[test]
 fn a_resize_renders_the_frame_and_image_with_the_same_camera() {
+    // Windows WARP can access-violate when GPU harnesses initialize or tear down concurrently:
+    // hold the GPU lock for the whole test, harness included.
+    let _gpu = photocraft_testkit::gpu_lock();
     let Some(mut h) = setup() else { return };
     let box0 = screen_box(&h);
     let c = mid(box0);
diff --git a/crates/ui-egui/tests/custom_print_paper.rs b/crates/ui-egui/tests/custom_print_paper.rs
new file mode 100644
index 0000000000..7361468bbc
--- /dev/null
+++ b/crates/ui-egui/tests/custom_print_paper.rs
@@ -0,0 +1,142 @@
+//! #3820: edit custom paper through the real Print dialog, preview it, and print safely to PDF.
+use egui::{Event, Key, Modifiers, PointerButton, vec2};
+use egui_kittest::{Harness, kittest::Queryable};
+use photocraft_ui_egui::{PhotocraftApp, file_ui::open_print};
+use serde_json::{Map, Value, json};
+
+fn app() -> (PhotocraftApp, u64) {
+    let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), photocraft_ui_egui::Services::default());
+    app.run("file.new", json!({"width": 120, "height": 80, "name": "Custom paper"})).unwrap();
+    let id = open_print(&mut app);
+    // Every UI path in these fixtures is safe even if an unexpected Enter confirms the dialog.
+    app.ui.dialog_mut(id).unwrap().fields.insert("dryRun".into(), json!(true));
+    (app, id)
+}
+
+fn show(ui: &mut egui::Ui, app: &mut PhotocraftApp) {
+    if ui.ctx().fonts(|fonts| fonts.families().contains(&egui::FontFamily::Name("medium".into()))) {
+        photocraft_ui_egui::dialogs::show(app, ui.ctx());
+    }
+}
+
+fn harness(app: PhotocraftApp) -> Harness<'static, PhotocraftApp> {
+    let mut h = Harness::builder().with_size(vec2(1000.0, 900.0)).with_max_steps(64).build_ui_state(show, app);
+    PhotocraftApp::setup_context(&h.ctx, Default::default());
+    h.run_steps(4);
+    h
+}
+
+fn click(h: &mut Harness<'_, PhotocraftApp>, label: &str) {
+    if let Some(node) = h.query_by_label(label) {
+        node.click();
+    } else {
+        h.get_by_value(label).click();
+    }
+    h.run_steps(3);
+}
+
+fn shown(h: &Harness<'_, PhotocraftApp>, text: &str) -> bool {
+    h.query_by_label(text).is_some() || h.query_by_value(text).is_some()
+}
+
+fn enter_length(h: &mut Harness<'_, PhotocraftApp>, label: &str, value: &str) {
+    // Anchor the pointer to the real label; the existing length widget immediately follows it.
+    let pos = h.get_by_label(label).rect().right_center() + vec2(35.0, 0.0);
+    h.event(Event::PointerMoved(pos));
+    h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+    h.run_steps(1);
+    h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+    h.run_steps(1);
+    h.key_press_modifiers(Modifiers::COMMAND, Key::A);
+    h.event(Event::Text(value.into()));
+    h.run_steps(1);
+    h.key_press(Key::Tab);
+    h.run_steps(3);
+}
+
+fn fields(h: &Harness<'_, PhotocraftApp>, id: u64) -> Map<String, Value> {
+    h.state().ui.dialogs.iter().find(|d| d.id == id).unwrap().fields.clone()
+}
+
+#[test]
+fn custom_paper_ui_edits_reach_preview_and_pdf_and_restore_when_reopened() {
+    let (mut app, id) = app();
+    let output = std::env::temp_dir().join(format!("pc-custom-paper-{}.pdf", std::process::id()));
+    let dialog = app.ui.dialog_mut(id).unwrap();
+    dialog.fields.insert("output".into(), json!(output.to_string_lossy()));
+    dialog.fields.insert("dryRun".into(), json!(true));
+    let mut h = harness(app);
+    click(&mut h, "letter");
+    assert!(shown(&h, "a4"), "the real preset menu must be open");
+    assert!(shown(&h, "Custom"), "the paper menu must offer editable custom dimensions");
+    click(&mut h, "Custom");
+    assert_eq!(fields(&h, id)["paper"], json!([612.0, 792.0]), "Custom starts at the current preset dimensions");
+    click(&mut h, "Centimeters");
+    click(&mut h, "Inches");
+    enter_length(&mut h, "Paper Width", "7.25");
+    enter_length(&mut h, "Paper Height", "9.25");
+    let edited = fields(&h, id);
+    assert_eq!(edited["paper"], json!([522.0, 666.0]), "the engine takes points, not the displayed units");
+    click(&mut h, "Custom");
+    click(&mut h, "a4");
+    assert_eq!(fields(&h, id)["paper"], "a4");
+    assert!(!shown(&h, "Paper Width"));
+    click(&mut h, "a4");
+    click(&mut h, "Custom");
+    assert_eq!(fields(&h, id)["paper"], edited["paper"], "returning from a preset restores the custom dimensions");
+    click(&mut h, "Inches");
+    click(&mut h, "Millimeters");
+    assert_eq!(fields(&h, id)["paper"], edited["paper"], "changing units must not change the physical paper");
+    click(&mut h, "Millimeters");
+    click(&mut h, "Inches");
+    assert_eq!(fields(&h, id)["paper"], edited["paper"]);
+    let preview = photocraft_engine::print_cmds::layout(&h.state().session.active().unwrap().doc, &Value::Object(edited.clone()), "file.print").unwrap();
+    assert_eq!(preview.paper, (522.0, 666.0));
+    click(&mut h, "Portrait");
+    click(&mut h, "Landscape");
+    let edited = fields(&h, id);
+    assert_eq!(edited["paper"], json!([522.0, 666.0]), "orientation must not rewrite the unrotated custom dimensions");
+    let preview = photocraft_engine::print_cmds::layout(&h.state().session.active().unwrap().doc, &Value::Object(edited), "file.print").unwrap();
+    assert_eq!(preview.paper, (666.0, 522.0));
+    click(&mut h, "Print");
+    let pdf = std::fs::read(&output).unwrap();
+    assert!(String::from_utf8_lossy(&pdf).contains("/MediaBox [0 0 666.00 522.00]"));
+    assert_eq!(h.state().session.file_menu.last_print.as_ref().unwrap()["paper"], json!([522.0, 666.0]));
+    let id = open_print(h.state_mut());
+    h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("dryRun".into(), json!(true));
+    h.run_steps(3);
+    assert!(shown(&h, "Custom"), "reopening array-valued settings must show Custom");
+    assert_eq!(fields(&h, id)["paper"], json!([522.0, 666.0]));
+    std::fs::remove_file(output).unwrap();
+}
+
+#[test]
+fn remembered_custom_paper_is_shown_without_becoming_a_preset() {
+    let (mut app, id) = app();
+    app.ui.dialog_mut(id).unwrap().fields.insert("paper".into(), json!([432.0, 576.0]));
+    let h = harness(app);
+    assert!(shown(&h, "Custom"), "an array paper size must not display as letter");
+    assert!(shown(&h, "Paper Width"));
+    assert!(shown(&h, "Paper Height"));
+    assert_eq!(fields(&h, id)["paper"], json!([432.0, 576.0]));
+}
+
+#[test]
+fn invalid_custom_paper_is_rejected_without_printing_or_changing_the_document() {
+    let (mut app, id) = app();
+    let output = std::env::temp_dir().join(format!("pc-invalid-custom-paper-{}.pdf", std::process::id()));
+    app.ui.dialog_mut(id).unwrap().fields.insert("output".into(), json!(output.to_string_lossy()));
+    let before = app.session.active().unwrap().doc.clone();
+    let mut h = harness(app);
+    click(&mut h, "letter");
+    click(&mut h, "Custom");
+    enter_length(&mut h, "Paper Width", "0");
+    let edited = fields(&h, id);
+    assert!(photocraft_engine::print_cmds::layout(&h.state().session.active().unwrap().doc, &Value::Object(edited), "file.print").is_err());
+    click(&mut h, "Print");
+    let error = &h.state().ui.status;
+    assert!(error.contains("paper is too small"), "{error}");
+    assert_eq!(h.state().session.active().unwrap().doc, before);
+    assert!(h.state().session.file_menu.last_print.is_none());
+    assert!(!output.exists());
+}
diff --git a/crates/ui-egui/tests/export_as_scaling.rs b/crates/ui-egui/tests/export_as_scaling.rs
index a05edbc6af..f1c9cba32c 100644
--- a/crates/ui-egui/tests/export_as_scaling.rs
+++ b/crates/ui-egui/tests/export_as_scaling.rs
@@ -24,6 +24,7 @@ fn harness() -> Option<(Harness, Writes)> {
                     file_dialog: Some(Box::new(|request, _parent, reply| {
                         reply.send(match request {
                             FileDialogRequest::Save { suggested } => Some(FileDialogAnswer::SaveTo(suggested)),
+                            FileDialogRequest::Folder { .. } => None,
                             FileDialogRequest::Open { .. } => None,
                         })
                     })),
diff --git a/crates/ui-egui/tests/layout_perf.rs b/crates/ui-egui/tests/layout_perf.rs
index 502390c979..fb17833e18 100644
--- a/crates/ui-egui/tests/layout_perf.rs
+++ b/crates/ui-egui/tests/layout_perf.rs
@@ -132,6 +132,9 @@ fn auto_select_moves_the_layer_under_the_pointer() {
     actual_pixels(&mut h);
     h.state_mut().ui.tool = Tool::Move;
     h.state_mut().ui.tool_options.move_auto_select = true;
+    // The default target is Group (#4056); these layers sit in groups, and the test is about the
+    // layer under the pointer.
+    h.state_mut().ui.tool_options.move_target = "layer".into();
     h.state_mut().run("layer.select", json!({"layer": k.pixel.0})).expect("select");
     h.run_steps(2);
     let (pixel_before, text_before) = (bounds(&h, k.pixel), bounds(&h, k.text));
@@ -150,6 +153,7 @@ fn a_move_tool_click_selects_without_moving() {
     let (mut h, k) = app();
     h.state_mut().ui.tool = Tool::Move;
     h.state_mut().ui.tool_options.move_auto_select = true;
+    h.state_mut().ui.tool_options.move_target = "layer".into();
     for id in [k.text, k.shape, k.pixel, k.text] {
         let before = (bounds(&h, id), h.state().session.active().expect("doc").history.entries().len());
         let p = screen(&h, point_on(&h, id));
diff --git a/crates/ui-egui/tests/marquee_autoscroll.rs b/crates/ui-egui/tests/marquee_autoscroll.rs
new file mode 100644
index 0000000000..2fc5772604
--- /dev/null
+++ b/crates/ui-egui/tests/marquee_autoscroll.rs
@@ -0,0 +1,183 @@
+//! #4183: dragging a Rectangular Marquee past the edge of a zoomed-in canvas scrolls the view, so
+//! the selection can be larger than what is on screen (as in Photoshop).
+//!
+//! Before the fix the view stayed put and the selection stopped at the visible edge. The real app
+//! runs offscreen on wgpu with real egui pointer events. Skips when no GPU adapter exists (like
+//! `drag_preview_canvas.rs`).
+
+use egui::{Modifiers, PointerButton, Pos2};
+use photocraft_ui_egui::PhotocraftApp;
+use photocraft_ui_egui::canvas::ViewXform;
+use photocraft_ui_egui::control::{ControlRequest, handle};
+use serde_json::{Value, json};
+
+type Harness = egui_kittest::Harness<'static, PhotocraftApp>;
+
+fn harness() -> Option<Harness> {
+    harness_with_size(egui::vec2(900.0, 640.0))
+}
+
+fn harness_with_size(size: egui::Vec2) -> Option<Harness> {
+    let built = std::panic::catch_unwind(|| {
+        egui_kittest::Harness::builder().with_size(size).with_max_steps(64).wgpu().build_eframe(|cc| {
+            PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
+            let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), Default::default());
+            if let Some(rs) = cc.wgpu_render_state.as_ref() {
+                app.set_wgpu(rs.clone());
+            }
+            app
+        })
+    });
+    match built {
+        Ok(h) => Some(h),
+        Err(_) => {
+            eprintln!("skipping: no GPU adapter");
+            None
+        }
+    }
+}
+
+fn control(h: &mut Harness, method: &str, params: Value) {
+    let ctx = h.ctx.clone();
+    let (req, _rx) = ControlRequest::new(method, params);
+    handle(h.state_mut(), &ctx, &req);
+    h.run_steps(3);
+}
+
+/// A 3000 × 2000 document at 100 %, centred, with `tool` active: far larger than the canvas.
+fn setup(h: &mut Harness, tool: &str) {
+    {
+        let app = h.state_mut();
+        while app.session.active().is_some() {
+            app.run("file.close", json!({"discard": true})).expect("close");
+        }
+        app.run("file.new", json!({"width": 3000, "height": 2000, "background": "white"})).expect("new");
+        app.sync_views();
+        app.ui.extras.rulers = false;
+    }
+    control(h, "ui.set", json!({"tool": tool, "zoom": 1.0, "center": [1500, 1000]}));
+    h.run_steps(3);
+}
+
+fn xf(h: &Harness) -> ViewXform {
+    ViewXform::active(h.state()).expect("an active document view")
+}
+
+fn pointer_at(h: &mut Harness, p: Pos2) {
+    h.event(egui::Event::PointerMoved(p));
+    h.step();
+}
+
+fn button_at(h: &mut Harness, p: Pos2, pressed: bool) {
+    h.event(egui::Event::PointerButton { pos: p, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+    h.step();
+}
+
+/// Selection bounds `[x0, y0, x1, y1]` in document pixels.
+fn selection(h: &Harness) -> Option<[i32; 4]> {
+    let st = h.state().session.active()?;
+    let b = st.doc.selection.as_ref()?.content_bounds();
+    (!b.is_empty()).then_some([b.x0, b.y0, b.x1, b.y1])
+}
+
+#[test]
+fn marquee_dragged_past_the_right_edge_scrolls_and_selects_beyond_the_view() {
+    let Some(mut h) = harness() else { return };
+    setup(&mut h, "rectMarquee");
+    let start = xf(&h);
+    let rect = start.rect;
+    // The document column at the canvas's right edge before the drag: the most a selection
+    // could reach without scrolling.
+    let visible_right = start.to_doc(egui::pos2(rect.right(), rect.center().y))[0];
+
+    let from = rect.center();
+    pointer_at(&mut h, from);
+    button_at(&mut h, from, true);
+    for i in 1..=6 {
+        let t = i as f32 / 6.0;
+        pointer_at(&mut h, from + egui::vec2((rect.right() - from.x - 10.0) * t, 60.0 * t));
+    }
+    // Past the edge, then held still for a while: the view keeps scrolling.
+    let outside = egui::pos2(rect.right() + 40.0, from.y + 60.0);
+    pointer_at(&mut h, outside);
+    for _ in 0..30 {
+        h.step();
+    }
+    let moved = xf(&h).center[0] - start.center[0];
+    assert!(moved > 50.0, "the view scrolls right while the drag is held past the edge (moved {moved})");
+    assert!((xf(&h).center[1] - start.center[1]).abs() < 1e-3, "and only horizontally");
+
+    button_at(&mut h, outside, false);
+    h.run_steps(3);
+    let sel = selection(&h).expect("a selection");
+    assert!(sel[2] as f64 > visible_right + 50.0, "the selection reaches past the column that was visible at the press: {sel:?} vs {visible_right}");
+
+    // Once released, the view no longer scrolls even with the pointer outside.
+    let after = xf(&h).center;
+    pointer_at(&mut h, outside);
+    h.run_steps(10);
+    assert_eq!(xf(&h).center, after);
+}
+
+#[test]
+fn a_drag_inside_the_canvas_does_not_scroll() {
+    let Some(mut h) = harness() else { return };
+    setup(&mut h, "rectMarquee");
+    let start = xf(&h);
+    let from = start.rect.center();
+    pointer_at(&mut h, from);
+    button_at(&mut h, from, true);
+    for i in 1..=6 {
+        pointer_at(&mut h, from + egui::vec2(15.0 * i as f32, 10.0 * i as f32));
+    }
+    for _ in 0..20 {
+        h.step();
+    }
+    assert_eq!(xf(&h).center, start.center);
+    button_at(&mut h, from + egui::vec2(90.0, 60.0), false);
+}
+
+#[test]
+fn rotated_marquee_scrolls_on_the_axis_that_is_visibly_clipped() {
+    let Some(mut h) = harness_with_size(egui::vec2(1200.0, 640.0)) else { return };
+    setup(&mut h, "rectMarquee");
+    let rect = xf(&h).rect;
+    assert!(rect.width() > rect.height());
+    // Fits horizontally before rotation, but at 90 degrees it overflows vertically.
+    let width = ((rect.width() + rect.height()) / 2.0) as u32;
+    let height = (rect.width() * 2.0) as u32;
+    for overscroll in [true, false] {
+        {
+            let app = h.state_mut();
+            app.run("file.close", json!({"discard": true})).expect("close");
+            app.run("file.new", json!({"width": width, "height": height, "background": "white"})).expect("new");
+            app.run("prefs.set", json!({"path": "tools.overscroll", "value": overscroll})).expect("overscroll");
+            app.sync_views();
+        }
+        control(&mut h, "ui.set", json!({"tool": "rectMarquee", "zoom": 1.0, "center": [width / 2, height / 2]}));
+        h.state_mut().ui.views[0].rotation = 90.0;
+        h.run_steps(3);
+        let start = xf(&h);
+        let from = start.rect.center();
+        let outside = egui::pos2(from.x + 30.0, start.rect.bottom() + 40.0);
+        pointer_at(&mut h, from);
+        button_at(&mut h, from, true);
+        pointer_at(&mut h, outside);
+        h.run_steps(30);
+        let moved = xf(&h).center[0] - start.center[0];
+        if let Some(dir) = std::env::var_os("CRAFT_UI_VISUAL_FIXTURES") {
+            let dir = std::path::PathBuf::from(dir);
+            std::fs::create_dir_all(&dir).expect("fixture directory");
+            h.render().expect("render").save(dir.join(format!("rotated-marquee-overscroll-{overscroll}.png"))).expect("save fixture");
+        }
+        assert!(moved > 10.0, "rotated vertical overflow must scroll document x, overscroll={overscroll}, moved={moved}");
+        let limit = width as f32 - start.rect.height() / (2.0 * start.zoom);
+        assert!((xf(&h).center[0] - limit).abs() < 0.01, "stops at the rotated image edge, overscroll={overscroll}");
+        assert!((xf(&h).center[1] - start.center[1]).abs() < 0.01);
+        button_at(&mut h, outside, false);
+        h.run_steps(3);
+        let after = xf(&h).center;
+        h.run_steps(10);
+        assert_eq!(xf(&h).center, after);
+    }
+}
diff --git a/crates/vector/src/edit.rs b/crates/vector/src/edit.rs
index b0846382e5..ea99cff25c 100644
--- a/crates/vector/src/edit.rs
+++ b/crates/vector/src/edit.rs
@@ -184,7 +184,9 @@ pub fn add_anchor(path: &mut Path, knot: [usize; 2], t: f64) -> Result<[usize; 2
     let a = *knot_mut(path, knot)?;
     let b = *knot_mut(path, end)?;
     let new = if retracted(&a, Handle::Out) && retracted(&b, Handle::In) {
-        let p = lerp(a.anchor, b.anchor, t);
+        // Hit testing and hover feedback use the cubic parameter, which is not linear even
+        // when both handles are retracted. Keep the inserted corner at that same point.
+        let p = eval(&[a.anchor, a.out_ctrl, b.in_ctrl, b.anchor], t);
         Knot::corner(p.x, p.y)
     } else {
         let (p01, p12, p23) = (lerp(a.anchor, a.out_ctrl, t), lerp(a.out_ctrl, b.in_ctrl, t), lerp(b.in_ctrl, b.anchor, t));
@@ -453,6 +455,28 @@ mod tests {
         }
     }
 
+    #[test]
+    fn adding_to_a_straight_segment_uses_the_hit_position() {
+        for (points, closed) in [
+            (vec![(0.0, 0.0), (100.0, 0.0)], false),
+            (vec![(0.0, 0.0), (0.0, 100.0)], false),
+            (vec![(0.0, 0.0), (100.0, 100.0)], false),
+            (vec![(0.0, 0.0), (100.0, 0.0), (100.0, 100.0)], true),
+        ] {
+            for t in [0.25, 0.75] {
+                let sp = if closed { Subpath::polygon(&points) } else { Subpath::polyline(&points) };
+                let mut p = Path::new(vec![sp]);
+                let segment = if closed { 2 } else { 0 };
+                let clicked = eval(&p.subpaths[0].segments()[segment], t);
+                let Some(Hit::Segment(knot, hit_t)) = hit(&p, clicked, 1.0, &[]) else { panic!("expected a segment hit at {clicked:?}") };
+                let added = add_anchor(&mut p, knot, hit_t).unwrap();
+                let inserted = at(&p, added[0], added[1]);
+                assert!(dist(inserted.anchor, clicked) < 1e-9, "t={t}: inserted {:?}, clicked {clicked:?}", inserted.anchor);
+                assert_eq!(inserted, Knot::corner(clicked.x, clicked.y), "straight segments retain retracted handles");
+            }
+        }
+    }
+
     #[test]
     fn adding_to_a_straight_segment_makes_a_corner_on_the_line() {
         let mut p = tri();
@@ -460,7 +484,7 @@ mod tests {
         assert_eq!(add_anchor(&mut p, [0, 2], 0.5).unwrap(), [0, 3]);
         assert_eq!(at(&p, 0, 3), Knot::corner(25.0, 40.0));
         assert_eq!(add_anchor(&mut p, [0, 0], 0.25).unwrap(), [0, 1]);
-        assert_eq!(at(&p, 0, 1), Knot::corner(25.0, 0.0));
+        assert_eq!(at(&p, 0, 1), Knot::corner(15.625, 0.0));
         assert_eq!(p.subpaths[0].knots.len(), 5);
         assert!(p.subpaths[0].closed);
     }
diff --git a/crates/vector/src/shapes.rs b/crates/vector/src/shapes.rs
index a459ba816e..b154a47325 100644
--- a/crates/vector/src/shapes.rs
+++ b/crates/vector/src/shapes.rs
@@ -29,9 +29,11 @@ pub fn clamp_radii(w: f64, h: f64, radii: [f64; 4]) -> [f64; 4] {
     r.map(|v| v * f)
 }
 
-/// Rectangle with corner radii `[top-left, top-right, bottom-right, bottom-left]`.
+/// Rectangle with corner radii `[top-left, top-right, bottom-right, bottom-left]`. A negative
+/// width or height extends from the origin to the left or up, like [`ellipse`] and [`polygon`].
 pub fn rounded_rect(x: f64, y: f64, w: f64, h: f64, radii: [f64; 4]) -> Path {
-    let (w, h) = (w.abs(), h.abs());
+    let (x, w) = if w < 0.0 { (x + w, -w) } else { (x, w) };
+    let (y, h) = if h < 0.0 { (y + h, -h) } else { (y, h) };
     let [tl, tr, br, bl] = clamp_radii(w, h, radii);
     if tl <= 0.0 && tr <= 0.0 && br <= 0.0 && bl <= 0.0 {
         return rect(x, y, w, h);
@@ -143,6 +145,20 @@ mod tests {
         assert_eq!(clamp_radii(10.0, 10.0, [10.0; 4]), [5.0; 4]);
     }
 
+    #[test]
+    fn negative_size_rect_extends_from_its_origin_like_the_ellipse() {
+        // Issue #4203: a negative width/height drew the rectangle on the far side of its origin.
+        let want = ellipse(50.0, 10.0, -20.0, 30.0).control_bounds().unwrap();
+        let want_neg_h = ellipse(50.0, 40.0, -20.0, -30.0).control_bounds().unwrap();
+        for radii in [[0.0; 4], [5.0; 4]] {
+            let b = rounded_rect(50.0, 10.0, -20.0, 30.0, radii).control_bounds().unwrap();
+            assert_eq!(b, want, "radii {radii:?}");
+            assert_eq!(b, (30.0, 10.0, 50.0, 40.0), "radii {radii:?}");
+            let b = rounded_rect(50.0, 40.0, -20.0, -30.0, radii).control_bounds().unwrap();
+            assert_eq!(b, want_neg_h, "radii {radii:?}");
+        }
+    }
+
     #[test]
     fn star_vertices() {
         assert_eq!(polygon(0.0, 0.0, 10.0, 10.0, 5, 0.5).subpaths[0].knots.len(), 10);
diff --git a/docs/batch-naming.md b/docs/batch-naming.md
new file mode 100644
index 0000000000..a922803f81
--- /dev/null
+++ b/docs/batch-naming.md
@@ -0,0 +1,41 @@
+# Batch output naming
+
+Select a recorded action, then open **File > Automate > Batch**. Set the input and output
+folders. **File Naming** accepts a filename stem template; the selected export format supplies
+the extension. Leave it blank to keep the existing source filenames and collision reporting.
+
+| Token | Value |
+| --- | --- |
+| `{name}` | Input filename without its last extension |
+| `{serial}` | Input position plus **Starting serial** (default 1), padded to at least three digits |
+| `{date}` | UTC date at the start of the batch, in `YYYY-MM-DD` form |
+
+For example, `{name}_{serial}` with starting serial 7 writes `photo_007.png` and
+`photo_008.png` for two PNG inputs named `photo.png`. A serial after 999 becomes 1000;
+it does not wrap. Folder inputs use the existing filename order, and an explicit input array
+keeps its order. Failed inputs consume their position, so later filenames do not shift.
+Braces in an input filename are literal text, not additional tokens.
+
+Unknown tokens, unmatched braces, invalid parameter types, path separators, reserved filename
+characters, excessive filename length (255 UTF-8 bytes), and serial overflow are rejected before
+export writes begin. Starting serial must be an integer from 1 to 4,294,967,295.
+A custom template that resolves to an existing input file is also rejected; choose a separate
+destination or another template. Ordinary per-file read, action and save failures still appear
+in the batch's `errors` result. When two results share a name, including a case-only difference,
+the first successful result is kept and the later collision is reported.
+
+The same options are available on `file.automate.batch` through the engine command interface:
+
+```json
+{
+  "input": ["first/photo.png", "second/photo.png"],
+  "output": "exports",
+  "steps": [["image.adjustments.invert", {}]],
+  "format": "png",
+  "naming": "{name}_{serial}",
+  "startingSerial": 7
+}
+```
+
+The CLI can invoke this command with `run --cmd file.automate.batch --params ...`.
+This option belongs to Batch; Image Processor and droplet options retain their existing behavior.
diff --git a/docs/brush-parity.md b/docs/brush-parity.md
index 119da10d66..7a5e499820 100644
--- a/docs/brush-parity.md
+++ b/docs/brush-parity.md
@@ -1,6 +1,6 @@
 # Brush and painting parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (`~` held with the Brush or Pencil erases with its brush; Clear painting mode) · **Target:** Adobe Photoshop 2026
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** minor (Hue Jitter amount track; Brush Settings minimum fields follow their Control; checkbox-only rows and non-destructive Smoothing switch; shaped-tip cursor follows the view) · **Target:** Adobe Photoshop 2026
 
 Painting is where Photoshop users notice differences first, so it gets its own checklist: the
 brush engine (`crates/paint/src/brush.rs`), the Brush Settings UI
@@ -24,11 +24,14 @@ tablets against Photoshop side by side.
 | Texture (pattern, scale, brightness, contrast, mode, depth, each tip) | done | |
 | Dual Brush | done | |
 | Color Dynamics (FG/BG, hue/sat/brightness jitter, purity, per tip) | done | |
+| Hue Jitter uses a standard percentage-amount track instead of a hue spectrum | done | #3825 (Hue Jitter appearance only); rendered track checked in all 14 themes; numeric and pointer edits retain percentage units and engine command routing. |
 | Transfer (opacity/flow/wetness/mix jitter and controls) | done | |
+| Shape Dynamics and Transfer minimum fields disabled when their Control is Off, retaining their values | done | #3825 (minimum-field interaction only); `brush_sections.rs` UI regressions cover all six fields, reactivation and disabled input |
 | Brush Pose (tilt, rotation, pressure overrides) | done | |
 | Noise, Wet Edges, Build-up, Protect Texture | done | |
 | Smoothing: amount, Pulled String, Stroke Catch-up, Catch-up on End, Adjust for Zoom | done | `brush.rs:428-438` |
 | Section locks | done | #174 |
+| Noise, Wet Edges, Build-up, Smoothing and Protect Texture: checkbox-only rows keep the selected controls open | done | `brush_panel_tests.rs`, #4283; Smoothing enable/disable preserves its amount and options, including imported ABR tool settings |
 | Brush tip from an image file | missing | TOOL-213-12 |
 | Erodible, Airbrush and Bristle tips (Photoshop's special tips) | partial | not audited in detail; "3D-based brushes don't work" (#1660) |
 | Anti-aliasing off for brushes | missing | #1666 (Pencil is the aliased path) |
@@ -54,7 +57,7 @@ tablets against Photoshop side by side.
 | Interpolation and smoothing match Photoshop | partial | #2138, #2057 |
 | Soft-edge falloff matches Photoshop's curve | partial | #2149, #1619 |
 | Brush preview and cursor crisp, not pixelated | partial | #1433 |
-| Cursor outline equals the painted footprint at every zoom | partial | #1761, #2364 |
+| Cursor outline equals the painted footprint at every zoom | partial | #1761, #2364; shaped tips trace their outline (#3467), turned and flipped with a rotated or flipped view |
 | Latency: dab to screen within a frame | partial | budgets P13/P16/P33 over (scorecard); big-brush lag #2619, #1994; cursor lag #2566, #1343 |
 | No hitch at mouse-up on a long stroke | not measurable | P32 needs a frame harness |
 | Live stroke for Brush and Eraser | done | |
@@ -114,3 +117,7 @@ tablets against Photoshop side by side.
 |---|---|---|
 | 2026-10-10 | major | First version, from a source audit and the open issues |
 | 2026-10-11 | minor | `~` held with the Brush or Pencil erases with that tool's brush, and Clear joins their Mode menus (#3439) |
+| 2026-10-12 | minor | Five Brush Settings switch rows toggle without selecting a properties pane; Smoothing has a default-on switch and retains its settings while disabled (#4283). No brush-feel estimate changed. |
+| 2026-10-12 | minor | A shaped tip's cursor outline turns and flips with a rotated or flipped view, and follows pixel aspect correction |
+| 2026-10-13 | minor | Shape Dynamics and Transfer minimum inputs follow their Control and retain their values while disabled (#3825, partial). No brush-feel estimate changed. |
+| 2026-10-13 | minor | Hue Jitter uses the same themed amount slider as other jitter controls (#3825, partial). No brush-feel estimate changed. |
diff --git a/docs/context-menu-parity.md b/docs/context-menu-parity.md
index 425c91f42f..76d6724b7e 100644
--- a/docs/context-menu-parity.md
+++ b/docs/context-menu-parity.md
@@ -1,6 +1,6 @@
 # Context-menu parity contract
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** trivial (status line and revision history added; linked from ui-parity.md) · **Target:** Adobe Photoshop 2026
+> **Last reviewed:** 2026-10-13 · **Last updated:** 2026-10-13 · **Change:** minor (layer-mask thumbnail menu, #4575) · **Target:** Adobe Photoshop 2026
 
 Status: implementation contract, updated 2026-10-09. Scope: canvas, document tabs, and panels. “Right-click” means a secondary pointer click; macOS Control-click should also open the same menu where the platform sends a context-menu gesture. Photoshop changes a context menu with the active tool, selection, and panel item. Adobe documents that principle but does not publish a complete current menu catalog. **Documented** means an Adobe source explicitly names the gesture or action. **Inferred** means a PhotoCraft design target or an item known from a main menu whose presence in a Photoshop context menu still needs a current-product capture. Do not present inferred rows as exact Photoshop menus. [Adobe: panels and menus](https://helpx.adobe.com/photoshop/using/panels-menus.html), [Adobe: shortcuts and context menus](https://helpx.adobe.com/sa_en/photoshop/using/customizing-keyboard-shortcuts.html).
 
@@ -27,7 +27,7 @@ The “PhotoCraft at branch point” column records behavior before this PR. Pic
 | Ruler, Note, Count | Unit / measurement, note edit/delete, count-group operations **(inferred)** | No tool menu | P2 |
 | Brush, Pencil, Eraser, Background Eraser, Spot Healing, Healing, Clone Stamp, History Brush, Blur, Sharpen, Smudge, Dodge, Burn, Sponge | Brush preset, size and hardness where applicable | Picker | P0; [Adobe Brush Settings](https://helpx.adobe.com/photoshop/desktop/apply-painting-techniques/brushes-presets/create-brush-set-painting-options.html). Alt+secondary-drag on Windows and Control+Option-drag on macOS adjust size/hardness ([Adobe cursor shortcuts](https://helpx.adobe.com/in/photoshop/desktop/get-started/settings-and-preferences/change-tool-pointers.html)) |
 | Gradient, Paint Bucket | Gradient preset/type/mode or fill source/tolerance **(inferred context placement)** | No tool menu | P1 |
-| Type | In text: cut/copy/paste, spelling suggestions, text formatting; outside text: type-layer action **(inferred context placement)** | While editing text (canvas_tool_menu.rs `TYPE_EDIT_MENU`): Undo, Cut, Copy, Paste, Select All (on the text), Check Spelling…, Find and Replace Text…, Faux Bold/Italic (checked), Rasterize Type, Create Work Path, Convert to Shape, Horizontal/Vertical and the anti-alias modes (checked), Convert to Paragraph/Point Text, Warp Text…; Esc closes only the menu. Spelling suggestions for the word under the pointer and the non-editing type-layer menu remain open | P1; separate editing and nonediting states; [Adobe type editing](https://helpx.adobe.com/photoshop/desktop/text-typography/get-started-with-text/edit-text.html) |
+| Type | In text: cut/copy/paste, spelling suggestions, text formatting; outside text: type-layer action **(inferred context placement)** | While editing text (canvas_tool_menu.rs `TYPE_EDIT_MENU`): Undo, Cut, Copy, Paste, Select All (on the text), Check Spelling…, Find and Replace Text…, Faux Bold/Italic (checked), Rasterize Type, Create Work Path, Convert to Shape, Horizontal/Vertical and the anti-alias modes (checked), Convert to Paragraph/Point Text, Warp Text…; Esc closes only the menu. Over a misspelled word the menu starts with up to 3 spelling suggestions (replace the word) and Add to Dictionary (#4370); Ignore / Ignore All and the non-editing type-layer menu remain open | P1; separate editing and nonediting states; [Adobe type editing](https://helpx.adobe.com/photoshop/desktop/text-typography/get-started-with-text/edit-text.html) |
 | Hand, Zoom | Fit on Screen, 100%, 200%, Print Size; zoom step choices **(inferred context placement)** | View menu (#3242): Zoom In, Zoom Out, Fit on Screen, Fill Screen, 100%, 200%, Print Size. Zoom In/Out step about the right-clicked point (Preferences › Tools › Zoom Clicked Point to Center centres it). Outside the image the pasteboard menu still wins. | P1; view actions stay out of document history; row order still needs a dated Photoshop capture |
 | Pen, Path Selection | Path/point actions, Make Selection, Fill/Stroke Path, Free Transform Path **(inferred context placement)** | Pen canvas right-click follows the user-provided 20-row Photoshop capture below. Paths rows offer Make Selection, Fill and Stroke. Path Selection's own canvas menu remains open. | P1; distinguish node, segment, path, and blank canvas |
 | Rectangle, Ellipse Shape, Triangle, Polygon, Line, Custom Shape | Shape/path operations, fill/stroke settings, transform **(inferred context placement)** | No tool menu | P2 |
@@ -77,13 +77,13 @@ Photoshop's Generative Fill and Delete and Fill Selection rows are left out: Pho
 | Surface / target | Desired options and state | PhotoCraft now | Source and confidence |
 |---|---|---|---|
 | Layers panel row | Blending Options, Duplicate/Delete, Group, export, convert/rasterize, mask, clipping, link, style copy/paste/clear, merge/flatten, Rename; filter by layer kind and selection | Implemented in layer_menu_ui.rs; item enablement uses menu commands | PhotoCraft inventory. Adobe documents layer rename/delete, color tagging, rasterization, and flattening [here](https://helpx.adobe.com/photoshop/using/layers.html); exact combined ordering **inferred** without a live capture |
-| Layers panel color label / thumbnail / mask thumbnail / effect row | Color label; context actions specific to hit icon | Generic row on some targets; inspect before extending | Adobe explicitly documents right-click on layer/group to assign a color ([layers](https://helpx.adobe.com/photoshop/using/layers.html)); other icon menus need capture |
+| Layers panel color label / thumbnail / mask thumbnail / effect row | Color label; context actions specific to hit icon | Layer-mask thumbnail: Disable/Delete/Apply Layer Mask, Add/Subtract/Intersect Mask with Selection, Select and Mask… (layer_menu_ui.rs `show_mask`, #4575; Mask Options… missing). Generic row on the other targets; inspect before extending | Adobe explicitly documents right-click on layer/group to assign a color ([layers](https://helpx.adobe.com/photoshop/using/layers.html)); other icon menus need capture |
 | Channels panel row | Duplicate/Delete/Rename, channel display and overlay color, spot conversion; new/split/merge | Implemented in channels_panel.rs | PhotoCraft inventory; exact Photoshop order **inferred** |
 | Brushes and preset panels | Rename/Delete brush or group, export selected brushes, view/reset preset choices | Rename/Delete, and preset group/item menus exist | Adobe explicitly documents Export Selected Brushes from brush/group right-click ([brushes](https://helpx.adobe.com/photoshop/desktop/apply-painting-techniques/brushes-presets/create-brush-set-painting-options.html)); Photoshop pop-up-panel rename/delete/reset/view options are [documented](https://helpx.adobe.com/photoshop/using/panels-menus.html), though some are panel-button menus |
 | Paths, History, Actions, Swatches, Gradients, Patterns, Styles, Libraries, Properties | Target-specific duplicate/delete/rename and panel operations where a panel exists | Paths row menu added in this PR; other panels need audit | **Inferred** catalog; record a Photoshop capture before claiming parity |
 | Document tab | Close, Close Others, Close All, Reveal in file manager, duplicate/move to window where supported | Close, Close Others, Close All, Reveal in Finder, and drag to reorder implemented; duplicate/move to window where supported remains open | **Inferred** exact list; P1 |
 | Empty pasteboard / workspace | Gray, Black, Custom canvas color choices; verify any additional entries in a current Photoshop capture | No menu | Adobe [documents right-clicking outside the image for canvas color](https://helpx.adobe.com/ph_en/photoshop/using/filling-stroking-selections-layers-paths.html); exact current layout still needs a capture |
-| Text field / selected text | Native edit menu and spelling suggestions without routing to active image tool | Edit menu implemented in text_field_menu.rs for every text field (Undo, Cut, Copy, Paste, Delete, Select All; a right-click inside the selection keeps it; never reaches the canvas or tool menu). Spelling suggestions missing: `edit.checkSpelling` (`suggest`) is not wired into the menu yet (UI-217-8) | P1; **inferred** exact spelling list |
+| Text field / selected text | Native edit menu and spelling suggestions without routing to active image tool | Edit menu implemented in text_field_menu.rs for every text field (Undo, Cut, Copy, Paste, Delete, Select All; a right-click inside the selection keeps it; never reaches the canvas or tool menu). Spelling suggestions live in the Type tool's edit menu (canvas_tool_menu.rs), not in generic fields, which hold no type layer text (UI-217-8) | P1; **inferred** exact spelling list |
 | Tool icon in Options bar | Reset Tool, Reset All Tools | Audit | Explicitly documented in [Adobe Photoshop reference](https://helpx.adobe.com/archive/en/photoshop/cc/2015/photoshop_reference.pdf); historical source, verify modern label |
 | Adaptive Wide Angle constraint line | Auto, Horizontal, Vertical orientation | Current right-click deletes constraint | P1 behavior mismatch: [Adobe documents orientation choice](https://helpx.adobe.com/photoshop/using/adaptive-wide-angle-filter.html) |
 
@@ -100,6 +100,7 @@ Each slice needs pure model tests (including every item dispatching a known comm
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-13 | minor | Layer-mask thumbnail menu (#4575) |
 | 2026-10-10 | trivial | Status line, revision history |
 | 2026-10-09 | minor | Selection canvas reference and tool matrix updates |
 | 2026-10-07 | minor | Pen canvas reference capture |
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index c73a0be6a6..771fec92e9 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -23,6 +23,8 @@ The first request on every TCP connection must authenticate. No other method is
 {"id": "auth", "method": "auth", "params": {"token": "<64 hexadecimal characters>"}}
 ```
 
+Authenticate once per connection. A later `auth` frame on the same connection gets `{"ok": false, "error": "already authenticated"}` and the connection keeps serving.
+
 After the successful authentication reply, each request is one JSON line:
 
 ```json
@@ -36,20 +38,21 @@ Each reply is one JSON line with the same `id`:
 {"id": 2, "ok": false, "error": "unknown tool `foo`"}
 ```
 
-The desktop server waits up to 60 seconds for a reply. A request still queued at that deadline is rejected before dispatch; a timeout does not cancel work that has already started. The timeout error names the likely causes: the command may still be running, or the request was queued while the window was not drawing frames — on Wayland the frame update (and with it the control drain) only runs on compositor frame callbacks, so a display that is asleep or a fully occluded window makes every request time out while the app itself is healthy.
+The desktop server waits up to 60 seconds for a reply. A request still queued at that deadline is rejected before dispatch; a timeout does not cancel work that has already started. The two timeouts read differently, both starting with `timeout`: a request that was never dispatched (still queued at the deadline) says `timeout: not run` and is safe to re-send, while `timeout: no reply in 60s` means the command was dispatched and may still be running and still apply, so check the document before re-sending it. The timeout error names the likely causes: the command may still be running, or the request was queued while the window was not drawing frames — on Wayland the frame update (and with it the control drain) only runs on compositor frame callbacks, so a display that is asleep or a fully occluded window makes every request time out while the app itself is healthy.
 
 The transport is `apps/photocraft/src/control_server.rs`, and the handlers are in `crates/ui-egui/src/control.rs`. The MCP server (`photocraft-cli mcp --bridge 127.0.0.1:<port>`, crate `photocraft-automation`) wraps this same protocol. See [MCP bridge](#mcp-bridge) below.
 
 ## Methods
 
 - `engine.execute {command, params}`: run any engine or UI command by id. Engine commands run directly with their default params and never open a dialog. Use `ui.menu.invoke` for menu-click behaviour, which opens a command's dialog when no params are given. `params` must be a JSON object (omit it or pass `null` for none); an array, string, number or boolean is an error naming the command, in every transport (control channel, `serve`, MCP and the CLI)
-- `engine.commands`: list commands with enablement
+- `engine.commands`: list commands with enablement; the `result` is a JSON array of command objects (see [Command list replies](#command-list-replies))
 - `ui.inspect`: full UI state (tool, panels, views, dialogs, windows, window size). The menu tree is not included; use `ui.menu.list`. `brushPicker` is `null` while closed and `{pos: [x, y], size: [w, h]?, list: {collapsed, filter, renaming, showName, showStroke, showTip, scale}}` while the Brush Preset picker is open (coordinates in screen points; `size` is the picker's content size once its corner grip was dragged, `null` before that, and the drag remembers both dimensions; the three `show*` flags pick the parts of each preset's card — at least one is always on; `scale` is the footer slider, 0.15–2 with 1 the standard, multiplying the cards' width and height — the heights stop at half size and the name and tip-size text hold their 1.0 size — and dropping the tips' size numbers at 0.40 and below; the parts and the scale are remembered across restarts, while the search, collapsed groups and a rename in progress are not). `view` holds the View/Window/Type preferences: `screen_mode`, `extras`, `show` and `snap_to` flags, `flip_horizontal`, `arrange` (Window › Arrange layout), pixel aspect, font preview size, language options. `perf.timings.gpuInfo` holds the graphics adapter, backend, driver, the backend chosen at launch and why, the canvas renderer (`gpu`/`cpu`) and, after a device loss, `lost` (`help.systemInfo` returns the same as `info`)
 - `ui.set {tool?, panels?, dockTabs?, dock?, dockWidth?, colorPanel?, maskTarget?, vectorMaskTarget?, selectionMode?, zoom?, center?, rotation?, fit?, theme?, brushSize?, brushSection?, brushTab?, brushesView?, brushPicker?, brushPickerName?, brushPickerStroke?, brushPickerTip?, brushPickerScale?, gradientBlendMode?, gradientClassic?, shapeStroke?}`: change UI state; any other field is an error, checked before anything changes (`zoom` is the canvas zoom where 1 = 100%, one document pixel per physical display pixel, so a scaled display doesn't magnify the image; `theme` is `pro`, `proMedium`, `studio`, `studioLight` or `classic`; `selectionMode` is the selection tools' options-bar mode, 0 New, 1 Add, 2 Subtract, 3 Intersect; `brushSection` indexes the Brush Settings sections, `brushTab` 0 = Brush Settings, 1 = Brushes; `brushesView` is `list` or `grid` for the Brushes panel; `brushPickerName`, `brushPickerStroke` and `brushPickerTip` are the Brush Preset picker's card parts (booleans, at least one on), and `brushPickerScale` its footer card-scale slider (0.15 to 2, 1 the standard); `brushPicker` is `[x, y]` in screen points to open the Brush Preset picker there (as a right-click with a painting tool does) or `null` to close it, and picking a preset in it is `tools.setBrush {"preset": name}`; `dock` is `{order: ["layers", …], heights: {"properties": 180}, collapsed: ["color"], tabOrder: {"layers": ["Paths", "Layers", "Channels"]}}`, the right-dock groups top to bottom, their heights in points, the groups collapsed to their tab strip and each group's tab order left to right by panel name (a group left out keeps its default order, unknown names are ignored and tabs not listed follow in their default order; `dockTabs` keeps indexing tabs in their default order); `dockWidth` sets the right dock width in points, clamped to 250..520; `colorPanel` is `{background}`, whether the Color panel edits the background colour; `maskTarget` targets the active layer's mask, which, like Photoshop, swaps in the foreground/background pair kept for masks (white/black until one is picked) and swaps the pixels' pair back when the pixels are targeted again)
   - `typeTransform` is `null` outside a temporary Ctrl/Cmd Type-tool drag. During a drag it reports its source document/revision, original affine, oriented `frame` (layer, local bounds, document-space corners and pivot), and captured `gesture`. Drive it with `ui.pointer` and `command: true` at `down`; `move`/`up` may release the modifier. The document/history remain unchanged during preview, and `up` applies one `type.edit` within `textEdit`'s session. Pressing Escape during the drag cancels only the preview. This pointer state is never restored from saved UI state.
 - `ui.menu.invoke {id, params?, wait?}` / `ui.menu.list`: activate a menu item by id; list the menu tree. A menu item that starts a background job (a filter without a dialog, such as Blur More) replies with the job's result once it has been applied; with `"wait": false` the reply is `{job, pending: true}` at once. Window ends with the open documents as `window.document.<index>` (tab order, the active one checked, #2991); invoking one brings that document to the front and replies `{document: index}`
 - `ui.set` also accepts `gradientBlendMode` (a layer blend mode name, such as `Difference`) and `gradientClassic` (boolean) for the Gradient tool options bar.
 - `ui.set` also accepts `camTransformOnDrop` (boolean), the Content-Aware Move tool's Transform On Drop checkbox: a drop then puts a scale/rotate box on the patch (`ui.inspect` › `camTransform`: its document/revision, drag `offset` and `frame`), driven with `ui.pointer` (handles as Free Transform's; outside the box rotates), committed with `ui.key Enter` (one `paint.contentAwareMove` with `scaleX`, `scaleY`, `rotate`) or dropped with `Escape`.
+- `ui.set` also accepts `tileGrid` (boolean), a developer overlay of the active layer's storage tiles: the tile grid over the document, every stored tile filled and labelled `tx,ty`, tiles with identical pixels in a shared colour and unique ones in blue. It has no menu item and View › Extras doesn't hide it. `ui.inspect` reports it as `view.tile_grid`.
 - Each painting tool keeps its own brush, as in Photoshop: `tools.setBrush` and `ui.set {brushSize}` change the active tool's brush, and switching tools swaps in that tool's own (size, hardness, mode, opacity, flow, dynamics, smoothing). A tool used for the first time starts from the brush in hand. The colours, the erase flag and the stroke seed stay shared. So `ui.set {tool: "eraser", brushSize: 12}` sets the Eraser's size, and `ui.set {tool: "brush"}` afterwards brings the Brush's own size back.
 - `ui.set` also accepts the Eyedropper options bar (#1649): `eyedropperSampleSize` (`"point"` or 1, 3, 5, 11, 31, 51, 101: the side of the averaged square, shared by the Eyedropper, a painting tool's Alt-click eyedropper, the Curves/Color Picker eyedroppers and the Info panel), `eyedropperSample` (`current`, `currentAndBelow`, `all`, `allNoAdjustments`, `currentAndBelowNoAdjustments`) and `eyedropperRing` (boolean, Show Sampling Ring). `ui.inspect` reports them under `toolOptions` (`eyedropper_size`, `eyedropper_sample`, `eyedropper_ring`). The engine command `document.sampleColor {x, y, size, sampleLayer}` returns the colour such a sample picks.
 - `ui.set` also accepts the Crop tool's overlay menu (#1919): `cropOverlay` (`thirds`, `grid`, `diagonal`, `triangle`, `goldenRatio`, `goldenSpiral`), `cropOverlayShow` (`auto`: only while the crop box is dragged, Photoshop's default; `always`; `never`) and `cropOverlayOrientation` (0..3; Triangle has two orientations and Golden Spiral four, the others ignore it). `ui.inspect` reports them under `toolOptions` (`crop_overlay`, `crop_overlay_show`, `crop_overlay_orientation`). In the app, O cycles the overlay and ⇧O its orientation while the Crop tool shows a box.
@@ -59,9 +62,11 @@ The transport is `apps/photocraft/src/control_server.rs`, and the handlers are i
   - A Layer Style color field opens the shared picker with `ui.dialog.open {"kind":"colorPicker","parent":12,"effect":"fx2","field":"color"}`. `parent` is the Layer Style dialog id; `effect` is its effect instance id. `field` must be one of that instance's color parameters (`color`, or `from`/`to` for Gradient Overlay). The picker previews over the pending style without changing the document. Picker OK changes only the parent parameter; Cancel discards the preview. Confirm the parent afterwards to apply the style. Parent confirmation is refused while its picker is open; parent cancellation closes both. The binding is exposed in `ui.inspect` as `__layerStyleColor`; changed/closed targets or a document switch invalidate it.
   - `ui.dialog.open {kind:"colorPicker", textStyle:{kind:"character"|"paragraph", id:u32}}` opens the shared Color Picker for an explicitly enabled Color attribute in Style Options. It opens the matching style panel/editor after validation; inherited colors must first be enabled through the existing style command. The picker reports its bound document/revision/style under `__textStyleColor` in `ui.inspect`. Changes preview in an isolated document; OK runs the existing style `set` command once, Cancel changes nothing. Document edits/switches or closed/changed Style Options discard the picker. `textStyle` cannot be combined with `parent`, `effect`, `field` or `target`.
   - The shell's own dialogs (Window › Workspace › New Workspace / Delete Workspace, View › Pixel Aspect Ratio › Custom Pixel Aspect Ratio…, View › Show › Show Extras Options…, View › 32-bit Preview Options…) are listed in `ui.inspect`'s `dialogs` with the id `"shell"` (at most one is open). `ui.dialog.set`, `ui.dialog.confirm` and `ui.dialog.cancel` take `{"dialog": "shell"}`; OK runs the dialog's command and keeps the dialog open if it fails
+  - The unsaved-changes prompt (closing a document, Revert, quitting with unsaved work) is listed in `ui.inspect`'s `dialogs` with the id `"discard"` while it is up: `fields` gives the waiting `command` (`file.close`, `file.exit`…), the `document` it asks about, how many are `remaining`, and its `choices`. `ui.dialog.confirm` takes `{"dialog": "discard", "choice": "save" | "dontSave" | "cancel"}` (default `save`; Revert takes `dontSave` or `cancel`) and answers it as the window's buttons do, one document at a time; `ui.dialog.cancel` with `{"dialog": "discard"}` cancels it. Save of an untitled document opens the save dialog first, so the reply's `fileDialog` is true and the prompt stays open until that is answered.
   - Layer Style (`layerStyle {effect?}` opens on that effect kind): the fields hold the dialog's whole state, so agents read and drive it like a user. `effects` lists every effect instance in the layer's order as `{id, kind, on, params, fx}` (`fx` is the effect snapshot the dialog loaded; OK edits that snapshot with `params`, so anything the dialog doesn't model survives). `selected` picks the page (`blendingOptions` or an instance id), `preview` (default on) gates the live canvas preview, `p:blendingOptions` edits blend mode/opacity/fill opacity, and `patternList` names the usable patterns. OK replaces the layer's effects in one step (`layer.layerStyle.replace`); Cancel discards. "New Style…" saves the pending state via `style.presets.new {effects}`, a swatch click applies a style preset, and Make/Reset Default use `layer.layerStyle.makeDefault` / `layer.layerStyle.defaultFor`
   - Preferences (`ui.menu.invoke {id: "edit.preferences.interface"}`) exposes the sections in its `values` field. Apply (`ui.dialog.apply`) and OK (`ui.dialog.confirm`) on Preferences are refused over control because automation denies whole-preferences updates and filesystem-bearing preference sections. A refused `ui.dialog.apply` returns an error and keeps the dialog open; a refused `ui.dialog.confirm` returns an error but closes and removes the dialog. `ui.dialog.cancel` closes the dialog without saving. Individual safe preferences can instead be changed with `engine.execute` using `prefs.set` (e.g. `{"command": "prefs.set", "params": {"path": "interface.showTooltips", "value": false}}`). Settings marked for the next launch still require a restart.
   - Edit › Fill… (`ui.menu.invoke {id: "edit.fill"}`, Shift+F5, Shift+Backspace) opens the Fill dialog; its fields are `edit.fill`'s params (`contents`, `color`, `pattern`, `colorAdaptation`, `mode`, `opacity`, `preserveTransparency`), and OK remembers them in the preferences (`dialogs["edit.fill"]`).
+  - Save for Web (`ui.menu.invoke {id: "file.export.saveForWebLegacy"}`) is resizable with independently scrolling settings. Dialog fields `__view` (`original|optimized|2up|4up`), `__zoom` (`null` = Fit, otherwise a factor; 1 = 100% in physical display pixels), and `__center: [u,v]` control the shared preview navigation. `__previewRects` reports pane rectangles in screen points. Drag a preview to pan, scroll/pinch to zoom at the pointer, or double-click to fit. GIF/PNG-8 expose `colorTable: ["#rrggbb", …]` (opaque source entries) and `colorTableEdits: {"0":"#rrggbb", …}` (zero-based replacements after quantization). A swatch opens a color picker; edits update the preview and saved file without remapping pixel indices or changing the document. Reset clears replacements. Changing palette/size/matte/transparency settings regenerates the table and clears index-based edits. Previews and generated tables use a bounded 2048-pixel proxy; full-size export uses that explicit table unchanged. `__paletteApproximate` reports proxy-derived palette generation, and enlarged proxy previews are labelled. The engine export command accepts the same table/edit parameters; its no-path estimate returns the source `colorTable` and `transparentIndex` as well as size statistics. Opening a new dialog does not carry a previous image's table across.
   - A pixel tool pressed on a type, shape, Smart Object or fill layer (e.g. through `ui.pointer`) opens the "Rasterize?" prompt instead of painting: a dialog with `__rasterize` (`type|shape|smartObject|fill`), `message`, `layer`, `tool` and `at`. `ui.dialog.confirm` runs the `layer.rasterize.*` command and then paints at `at` (two history states, `{"rasterized", "painted"}`); `ui.dialog.cancel` does nothing.
   - Edit › Transform › Warp on editable type (`ui.menu.invoke {"id":"edit.transform.warp"}`, or the warp toggle of an open transform box) opens Warp mode with no prompt, as in Photoshop: the mesh can't be dragged or split, only the options bar's warp style, Bend, H and V apply, and the commit sets the layer's Warp Text in one step, so the type stays editable. Directly: `engine.execute {"command":"edit.transform.warp","params":{"style":"flag","bend":40}}` on a type layer. Distort and Perspective stay greyed for type.
 - `ui.window.open {document?}` / `ui.window.close {window}`: extra document windows
@@ -71,6 +76,7 @@ The transport is `apps/photocraft/src/control_server.rs`, and the handlers are i
 - `ui.click {x, y, button?, count?}` / `ui.move {x, y}`: synthetic pointer input in screen points (`button`: `left` (default), `right` (or `secondary`) or `middle`). `count` (default 1, `2` for a double-click) is at most 256; a larger one is an error and queues nothing
 - `ui.key {key, command?, shift?, alt?, ctrl?}` (flags may also be grouped under `modifiers`): press and release a key, e.g. `{"key": "ArrowLeft", "shift": true}`
 - `ui.pointer`, `ui.click`, `ui.move`, `ui.key` and `ui.screenshot` validate every parameter before acting, as `ui.set` does: an unknown field (top-level, under `modifiers` or in an event), a value of the wrong JSON type (`"x": "abc"`, `"ctrl": "yes"`), a `button`, `kind`, `tool` or `key` outside the accepted set, or a number outside its range (`pressure`, tilt, `rotation`, `count`) is an error naming the parameter, and nothing is queued or applied. A `null` field counts as omitted and takes its default
+- Engine commands (`engine.execute`, `photocraft-cli run`, MCP `command_run`) reject a param key their `params` doc does not name for the commands listed in `STRICT` (`crates/engine/src/param_check.rs`, today `layer.hideLayers` and `layer.showLayers`): `{"ids":[4]}` is the error `unknown parameter \`ids\` (expected: layer)`, and nothing runs. Other commands still ignore unknown keys until their `params` doc is complete and they are added to that list (`coalesce` and `target` are always accepted).
 - `ui.type {text}`: type text (goes to the focused widget, or to the canvas while the Type tool is editing)
 - `ui.resize {width, height}`: resize the main window
 - `ui.gpu.simulateLoss {error?}`: act as if the wgpu device was lost (or reported an error with `error: true`). The app switches to the CPU image compositor for the rest of the session and shows the same recovery warning as on a real loss. `gpuFallbackNotice` in `ui.inspect` contains the reason while the warning is open. Keep Using CPU saves CPU compatibility for the next launch; Retry GPU saves GPU mode and asks the user to save and restart. The window renderer still requires a working graphics or software adapter. Returns `wasActive` and `gpuInfo`. For testing the fallback
@@ -88,7 +94,7 @@ Change the UI language without restarting with `prefs.set`:
 are documented in [UI localisation](localization.md). `prefs.get` and the existing preference
 store expose and persist the same setting; scripts keep using canonical command IDs.
 
-`engine.execute` runs any command by id. `engine.commands` (or the engine command `command.list`) lists them all, with labels, menu paths, shortcuts, a parameter description, and whether each is currently enabled. Examples:
+`engine.execute` runs any command by id. `engine.commands` (or the engine command `command.list`) lists them all, with labels, menu paths, shortcuts, a parameter description, and whether each is currently enabled (reply shape: [Command list replies](#command-list-replies)). Each row carries `enabled` (bool), `disabledReason` (`null` when enabled, otherwise the precondition that failed, such as `"no document open"`, `"no selection"` or `"the clipboard is empty"`) and `needsDocument` (true when the command is off because no document is open, so the first step is to create or open one; a command may still have its own precondition after that, such as an active text layer. False when enabled or off for another reason). With no document open, nearly every document command reports `enabled: false, needsDocument: true`; plan around `needsDocument` rather than reading `enabled` alone (#3664). Examples:
 
 | Command | Params |
 |---|---|
@@ -168,6 +174,35 @@ their usual file access. Source replacement, relinking and export commands remai
 double-clicking its thumbnail in Layers. Text input, Commit and Cancel use the existing Type tool
 editing session; non-type layers return an error without changing the tool or document.
 
+### Command list replies
+
+`engine.commands` (control channel and `serve`), the engine command `command.list` and the MCP
+tool `command_list` all reply with a bare JSON array, not an object: there is no
+`{"commands": [...]}` wrapper. On the control channel and `serve` the array is the reply's
+`result` (`{"id":1,"ok":true,"result":[…]}`); the MCP tool returns it as its JSON text.
+Each element describes one command, in registry order:
+
+```json
+{"id":"file.new","label":"New…","menu":["File"],"shortcut":"Cmd+N","params":"{\"width\":1..300000=1920,…}","enabled":true,"disabledReason":null,"needsDocument":false}
+```
+
+| Key | Type | Meaning |
+|---|---|---|
+| `id` | string | The id to pass to `engine.execute` / `command_run` |
+| `label` | string | Menu label |
+| `menu` | array of strings | Menu path above the item (`[]` for commands without a menu item) |
+| `shortcut` | string or `null` | Default shortcut, e.g. `"Cmd+Shift+X"` |
+| `params` | string | Human-readable parameter doc (not a JSON schema) |
+| `enabled` | boolean | Whether the command can run in the current state |
+| `disabledReason` | string or `null` | Why the command can't run now (`null` when `enabled`) |
+| `needsDocument` | boolean | `true` when it is off because no document is open (#3664) |
+
+Filtering narrows the same array without changing its elements: `serve`'s `engine.commands
+{filter}` and the MCP tool's `filter` keep commands whose id or label contains the text
+(case-insensitive), and the MCP tool's `enabled_only` keeps those with `enabled: true`. The
+desktop control channel's `engine.commands` takes no filter and always returns every command.
+The shape is pinned by a test in `crates/automation/src/rpc.rs` (#3684).
+
 ### Background jobs (#210)
 
 Long commands (every `filter.*`, `edit.contentAwareFill`, `edit.contentAwareScale`, `file.automate.photomerge`, `brush.presets.importAbr`), file opens and interactive saves (File › Save, Save As and the TIFF Options continuation, #2017) run as background jobs in the desktop app: the window keeps drawing, the status bar shows progress with a Cancel button, and jobs that lock the active document show a modal progress dialog (Esc cancels). `engine.execute`, `ui.menu.invoke`, `ui.dialog.confirm` and `app.save` still wait for the result by default; pass `"wait": false` to get `{job, pending: true}` at once, then poll `jobs.list` (`state`: running, done, failed, cancelled; `progress` 0–1; the result or error) and stop it with `jobs.cancel {job}`. A cancelled or failed job leaves the document unchanged. While a job runs, commands that would edit its document fail with "… is still running on this document". `ui.inspect` reports `jobs` (running jobs, opening files, saving files). Set `PHOTOCRAFT_INLINE_JOBS=1` to run everything inline.
@@ -261,7 +296,7 @@ How each MCP tool maps onto control methods in bridge mode:
 |---|---|
 | `command_run {id, params, wait?}` | `engine.execute {command: id, params, wait}` |
 | `jobs_list` / `jobs_cancel {job?}` | `jobs.list` / `jobs.cancel {job?}` |
-| `command_list {filter?, enabled_only?}` | `engine.commands` (filtered by the MCP server) |
+| `command_list {filter?, enabled_only?}` | `engine.commands` (filtered by the MCP server; replies with the same bare array, rows keep `disabledReason` and `needsDocument`, see [Command list replies](#command-list-replies)) |
 | `doc_new {…}` | `engine.execute {command: "file.new", params}` |
 | `doc_inspect` | `engine.execute {command: "document.inspect"}` |
 | `doc_open {path}` | `app.open {path}` |
@@ -319,7 +354,7 @@ no MCP framing, no app start-up per command. Configure its file access with the
 |---|---|
 | `engine.execute` | `{command, params?, wait?}`: any engine command (`wait: false` starts a long one as a background job: `{job, pending}`) |
 | `jobs.list` / `jobs.cancel` | `{}` / `{job?}`: background jobs; cancel one or all. Every request (and MCP tool call) first applies the jobs that finished, so `doc.save`, `doc.inspect`, `doc.render` and `session.list` include a finished job's result without polling `jobs.list` first |
-| `engine.commands` | `{filter?}`: registry with params docs and enablement |
+| `engine.commands` | `{filter?}`: registry with params docs and enablement (`enabled`, `disabledReason`, `needsDocument`); `result` is a bare array of command objects ([Command list replies](#command-list-replies)) |
 | `session.list` | open documents and the active index |
 | `doc.open` / `doc.new` | `{path}` / `file.new` params |
 | `doc.place` | `{path, scale? (percent), fit? (true), center? ([x, y]), index?}`: places a file as a Smart Object layer above the active one and returns `{layer, scale, bounds}`. `path` resolves beneath the read root, so this is the capability-scoped `file.placeEmbedded` — that command itself still refuses an ambient path |
@@ -427,8 +462,9 @@ keeps the dialog open for correction. Nothing else writes document history.
 command line) of a camera raw developed from its sensor data shows this dialog first, titled
 "Camera Raw (name)", with **Open** and **Cancel**, as Photoshop opens raws in Adobe Camera Raw.
 `ui.inspect.cameraRaw.openingRaw` is then `{name, path}`. Commit (Open) re-develops the raw when
-Temperature, Tint or Exposure changed (as-shot white-balance gains and develop exposure on the
-sensor data; without an as-shot white balance, or without the file's bytes, they stay RGB
+Temperature, Tint, Exposure, Shadows, Highlights, Clarity, Texture or Dehaze changed (as-shot
+white-balance gains, develop exposure, and the other five in linear light before the camera's
+tone curve, as Camera Raw does for raw files; without an as-shot white balance, or without the file's bytes, they stay RGB
 adjustments), applies the remaining settings as one `filter.cameraRaw` step and leaves the
 document unmodified; its result is `{document, redeveloped, filter?}`. Cancel closes the
 document. `app.open` and other automation opens never show the dialog. The preference
@@ -523,6 +559,20 @@ the parent before its next step. Every nested command retains the normal automat
 Existing recordings containing expanded commands remain unchanged; remove those steps and record
 the named call again if desired.
 
+Actions sit in **set folders** (`set` on `actions.list` / `actions.get`, filled by Load Actions,
+written by Save Actions, changed with `actions.assignSet`): the panel shows loose actions first,
+then each set as a collapsible folder (`ui.actions.collapsedSets`); dropping an action among
+another set's rows moves it into that set. Each step has Photoshop's two toggles: the check
+(`actions.toggle`, skipped when off) and the **dialog** toggle (`actions.dialog`). Playing a
+step with its dialog on opens that command's dialog seeded with the recorded values and pauses:
+the play result carries `paused: {step, id, dialog}`, OK runs the dialog's values and continues
+from the next step, Cancel stops the action. Agents (`automation_input`) play headlessly with the
+recorded values. The panel menu's **Insert Stop…** adds an `actions.stopMessage` step after the
+selected step (`actions.insert` takes any command id and params). `actions.conditional {if, then,
+else}` is Photoshop's Insert Conditional as a step: it tests the document or active layer
+(`always`, `landscape`, `modeIsRGB`, `hasLayers`, `isBackground`, `hasPixelMask`… see its params)
+and plays the matching action by name, failing the caller when that action fails.
+
 Layer-panel **Quick Export as PNG** exports every selected layer as a separate PNG. A single
 Save dialog chooses the first filename; remaining files are numbered siblings with sanitized
 layer names. Selection is captured before opening the dialog; an unselected layer is excluded.
diff --git a/docs/development.md b/docs/development.md
index 1236dd65c5..17c7e67dce 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -82,7 +82,7 @@ CRAFT_FONTS_DIR="$PWD/../craft-fonts" cargo test --workspace     # runs the Japa
 
 ## Graphics startup and device loss
 
-`--safe-gpu` starts with the CPU renderer for one launch (no GPU canvas; a software adapter for the window where the platform has one: WARP on Windows, llvmpipe over GL on Linux). Before creating the wgpu device the app writes and locks `gpu-starting.json` in the config directory; it clears it once the first frames have rendered. A launch that finds an unlocked marker knows the previous start died inside the graphics driver (#4) and uses the next safer backend (Windows: Vulkan → DX12 → CPU; Linux: Vulkan → GL → CPU; macOS: Metal → CPU), remembering it in `performance.gpuBackend` (Preferences › Performance › GPU Backend, with **Reset GPU Backend**). With `auto`, Intel adapters on Windows use DX12. Help › System Info shows the adapter, backend, driver and fallback state.
+`--safe-gpu` starts with the CPU renderer for one launch (no GPU canvas; a software adapter for the window where the platform has one: WARP on Windows, llvmpipe over GL on Linux). Before creating the wgpu device the app writes and locks `gpu-starting.json` in the config directory; it clears it once the first frames have rendered. A launch that finds an unlocked marker knows the previous start died inside the graphics driver (#4) and uses the next safer backend (Windows: Vulkan → DX12 → CPU; Linux: Vulkan → GL → CPU; macOS: Metal → CPU), remembering a working hardware backend in `performance.gpuBackend` (Preferences › Performance › GPU Backend, with **Reset GPU Backend**). CPU recovery is temporary until **Keep Using CPU** is chosen in the recovery dialog; dismissing the dialog or quitting without a choice preserves the previous GPU preference (#3483). With `auto`, Intel adapters on Windows use DX12. Help › System Info shows the adapter, backend, driver and fallback state.
 
 On DX12 the shader compiler is FXC (`d3dcompiler_47.dll`, part of Windows), or a `dxcompiler.dll` placed beside `photocraft.exe`, loaded by its full path. wgpu's default looks `dxcompiler.dll` up by name, which reaches the current directory and `PATH` and loaded other programs' incompatible builds (#712).
 
@@ -104,6 +104,7 @@ By default PhotoCraft's own crates log at `info` and everything else at `warn`.
 | Variable | Effect |
 |---|---|
 | `PHOTOCRAFT_CONTROL_PORT` | Same as `--control <port>` |
+| `PHOTOCRAFT_NO_PRINT` | Set to anything but `0`: `file.print` / `file.printOneCopy` refuse to spool (`dryRun` still works). CI sets it, with `LPDEST=photocraft-no-such-printer` as a second net; set both when running the panic hunt or fuzzers locally |
 | `RUST_LOG` | Log levels for standard error and the log file (see [Logs](#logs)) |
 | `PHOTOCRAFT_CONTROL_TOKEN` | 64-hex bearer token for control TCP (avoid on shared systems where environment inspection is possible) |
 | `PHOTOCRAFT_CONTROL_TOKEN_FILE` | Read, or create for a server, the control bearer-token file |
@@ -144,6 +145,7 @@ See `docs/control-protocol.md` for every method. Tips:
 - **macOS does not render occluded windows.** `ui.screenshot` raises the window first (`focus: true` by default). Use `ui.focus` before other visual checks.
 - **Capture only our own window.** For native captures (to see the real title bar and traffic lights), capture by window id (`screencapture -l <CGWindowID>`), never a screen region, which can grab other apps.
 - **Pointer gestures:** `ui.pointer` takes events in *document* coordinates and runs them through the same tool state machine as the mouse.
+- **Seeing tile storage:** `ui.set {"tileGrid": true}` overlays the active layer's stored tiles, which shows how sparse a layer is and which tiles share pixels (`ui-egui/src/tile_overlay.rs`).
 
 ## Headless CLI
 
@@ -352,7 +354,7 @@ trunk build --release              # writes ../../dist/web (index.html, .js glue
 trunk serve --release              # dev server on http://127.0.0.1:8765
 ```
 
-Any static file server works for `dist/web`, for example `python3 -m http.server 8765` run inside that directory. Trunk downloads the matching `wasm-bindgen` and `wasm-opt` itself. `trunk build --release` uses the `wasm-release` Cargo profile (`data-cargo-profile` in `index.html`: fat LTO, opt-level "z" for `photocraft-ui-egui`, "s" for other crates except pixel processing, which keeps level 3). The UI override reduces browser code size while retaining the speed-oriented settings for filters and compositing. Serve the `.wasm` with compression; its raw size varies with the source and compiler. Keep it under 24 MiB (`packaging/web/package.sh` enforces this; Cloudflare's per-file cap is 25 MiB). Pull-request CI also builds the actual browser app with the same pinned Trunk version as the release job and runs `packaging/web/package.sh`, including the relative-URL and 24 MiB checks. The `web build and wasm size gate` check runs on main and on PRs that change something the web build compiles or packages (`apps/photocraft-web`, `packaging/web`, crate sources and manifests, `Cargo.toml`/`Cargo.lock`, the CI workflow), and reports the resulting wasm size in the Actions job summary. The web build never embeds craft-fonts (see Fonts above). To see where the bytes go, run `twiggy top -n 40` on `target/wasm32-unknown-unknown/wasm-release/photocraft-web.wasm` (before wasm-opt strips the names).
+Any static file server works for `dist/web`, for example `python3 -m http.server 8765` run inside that directory. Trunk downloads the matching `wasm-bindgen` and `wasm-opt` itself. `trunk build --release` uses the `wasm-release` Cargo profile (`data-cargo-profile` in `index.html`: fat LTO, opt-level "z" for the UI, engine, I/O and web shells and for large crates off the hot paths (document model, file parsers, JSON, SVG parsing, shader translation), "s" for other crates except pixel processing, which keeps level 3). The UI override reduces browser code size while retaining the speed-oriented settings for filters and compositing. Serve the `.wasm` with compression; its raw size varies with the source and compiler. Keep it under 24 MiB (`packaging/web/package.sh` enforces this; Cloudflare's per-file cap is 25 MiB). Pull-request CI also builds the actual browser app with the same pinned Trunk version as the release job and runs `packaging/web/package.sh`, including the relative-URL and 24 MiB checks. The `web build and wasm size gate` check runs on main and on PRs that change something the web build compiles or packages (`apps/photocraft-web`, `packaging/web`, crate sources and manifests, `Cargo.toml`/`Cargo.lock`, the CI workflow), and reports the resulting wasm size in the Actions job summary. The web build never embeds craft-fonts (see Fonts above). To see where the bytes go, run `twiggy top -n 40` on `target/wasm32-unknown-unknown/wasm-release/photocraft-web.wasm` (before wasm-opt strips the names).
 
 URL flags: `?webgl` forces the WebGL2 backend, and `?cpu` forces the CPU canvas path.
 
@@ -415,6 +417,21 @@ Input calls (`ui.key`, `ui.type`, `ui.click`) now reply only after the app has p
 so a following `ui.inspect` observes their effect.
 
 
+## Photoshop Actions (.atn)
+
+`photocraft-psd` reads and writes Photoshop Actions files (`atn`, version 16: Photoshop 6 and
+later); `photocraft-engine`'s `atn_cmds` maps their events onto commands (`actions.load`,
+`actions.save`; the Actions panel menu's Load/Save Actions…; `photocraft-cli batch --actions
+set.atn`). To see what a set holds (event ids, panel names, the parameter keys Photoshop
+recorded) when adding an event to the table:
+
+```sh
+cargo run -p photocraft-psd --example atn_dump -- "Default Actions.atn"
+```
+
+Events outside the table load as `actions.photoshopStep` steps that keep the descriptor
+verbatim (so Save Actions writes them back) and fail at playback with the step's Photoshop name.
+
 ## Remove Tool quality
 
 `cargo run --release -p photocraft-engine --example remove_quality -- <dir> [out dir]` fills
@@ -527,3 +544,22 @@ stroke is drawn above its clipped layers; linked effect patterns tile from the l
 reference point; stroke distances follow a 5 × 5 chamfer metric (1, √2, √5) seeded at sub-pixel
 edge offsets; interior effects keep the layer's alpha; outside strokes blend onto the backdrop with
 their own modes, an upper stroke covering lower ones.
+
+## System printing
+
+`file.print` and `file.printOneCopy` keep PDF layout, scaling, marks and ICC conversion in
+PhotoCraft and submit the rendered bytes through `craft-print` at the Git revision pinned in
+`Cargo.toml`. CUPS streams the PDF on macOS/Linux; Windows uses the shared Windows PDF backend.
+The driver receives exact physical sheet size so it does not scale PhotoCraft's layout twice.
+Windows raster printing does not establish physical-printer colour fidelity; test critical
+photo output with the actual printer and its profile.
+
+Desktop commands run composition and submission on a background worker. The UI reports success
+only when the spooler accepts the job; remove submitted jobs in the system print queue. Headless
+`Session::execute` stays synchronous. The returned `pdf` is `null` for a spool-only job, and
+`command` is a diagnostic preview, not an executable command with a PDF path. Supplying `output`
+keeps a PDF at that path and defaults `send` to false. `dryRun` renders the PDF and reports the
+backend command without submitting; it writes a PDF only when `output` is explicit. `send: false`
+without an output requires `dryRun: true`. Remembered print settings omit `output`, `dryRun` and
+`send`, so Print One Copy derives submission from its own output choice. Shared spooler transport
+files are automatically removed on Windows; CUPS needs none.
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index c1da1665a9..cb2ca13acd 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -1,6 +1,6 @@
 # File-format parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (D5100 crop and Camera Raw tuning validation) · **Target:** Adobe Photoshop 2026
+> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-13 · **Change:** minor (palette PNGs open in Indexed Color mode, #4804; earlier: CMYK Invert, Posterize and Threshold on the inks; 16-bit Lab Invert; Photoshop-oracle floor 145/258; `.atn` import maps 112 events; DDS textures open, #1327; DPX read and write, #1049; #2465 fixed: CS2 placed layers with only a `PlLd` block open their contents; Photoshop Actions `.atn` read and write; `.shc` contour files read and write; earlier the same day: indexed BMP palette mode; Save keeps a JPEG's quality and a WebP's encoding) · **Target:** Adobe Photoshop 2026
 
 Every format Photoshop 2026 (27.11.0) reads or writes, with PhotoCraft's support, fidelity and
 tests. Photoshop's list comes from its `Info.plist` `CFBundleDocumentTypes`, the PiPL read/write
@@ -21,15 +21,15 @@ XL are missing (gap G10). Remaining: 300–500 h including PSD fidelity.
 
 | Format | Photoshop | PhotoCraft read | PhotoCraft write | Fidelity and tests |
 |---|---|---|---|---|
-| PSD | R/W | yes | yes | 1/8/16/32-bit; Bitmap, Gray, Indexed, RGB, CMYK, Multichannel, Lab, Duotone; layers, groups, masks, vector masks, adjustment and fill layers, effects, text, shapes, smart objects (SoLd/lnk2), smart filters (14 mapped, rest verbatim), slices, comps, Advanced Blending. Oracle floors: Photoshop-authored 133/256, io 146/170, psd-tools 236/309; round trip ≥ 169/170, 308/309, 258/256. Known failures: #1281, #2469, #2465 (#2374, text layers, closed 2026-10-10) |
+| PSD | R/W | yes | yes | 1/8/16/32-bit; Bitmap, Gray, Indexed, RGB, CMYK, Multichannel, Lab, Duotone; layers, groups, masks, vector masks, adjustment and fill layers, effects, text, shapes, smart objects (SoLd/lnk2; CS2 PlLd/lnkD read with their warp, kept as is or re-saved as SoLd once edited), smart filters (14 mapped, rest verbatim), slices, comps, Advanced Blending. Oracle floors: Photoshop-authored 145/258, io 146/170, psd-tools 236/309; round trip ≥ 169/170, 308/309, 258/256. Known failures: #1281, #2469 (#2374, text layers, closed 2026-10-10; #2465, CS2 `PlLd`-only smart objects, fixed 2026-10-12) |
 | PSB | R/W | yes | yes | Auto-switches above 2 GB (REL-212-2); 4–5 GB fixtures generated (FILE-216-2); > 4 GB fails on Windows (#375) |
 | Cloud PSD (.psdc) | R/W | no | no | Out of scope (Adobe cloud) |
 | TIFF | R/W | yes | yes | 8/16/32f, Gray/RGB/CMYK, BigTIFF, every IFD, banded parallel decode; layered TIFF both byte orders (FILE-215-7: extra alpha channels not written) |
-| JPEG | R/W | yes | yes | 8-bit Gray/RGB/CMYK, ICC/EXIF/XMP; no JPEG Options dialog (quality 0–12, baseline/progressive) (FILE-215-19) |
-| PNG | R/W | yes | yes | 8/16-bit, ICC/text; APNG first frame only; alpha channels on open (#2225) |
+| JPEG | R/W | yes | yes | 8-bit Gray/RGB/CMYK, ICC/EXIF/XMP; Save keeps the opened file's quality (estimated from its quantisation tables, #2399); no JPEG Options dialog (quality 0–12, baseline/progressive) (FILE-215-19) |
+| PNG | R/W | yes | yes | 8/16-bit, ICC/text; APNG first frame only; alpha channels on open (#2225); palette PNGs open in Indexed Color mode with their transparent entry (#4804) |
 | GIF | R/W | yes | yes | File › Open keeps the first frame; New Video Layer from File and Video Frames to Layers take every frame, with the timeline rate from the delays (#572). Per-frame delays and keeping the frames in `.pcraft` are not done |
-| BMP | R/W | yes | yes | 8-bit |
-| WebP | R/W | yes | yes | Lossless and our own lossy VP8 encoder; ICC/EXIF/XMP |
+| BMP | R/W | yes | yes | 8-bit; palette BMPs open in Indexed Color mode |
+| WebP | R/W | yes | yes | Lossless and our own lossy VP8 encoder; ICC/EXIF/XMP; Save keeps an opened file lossy (at its quality) or lossless (#2399) |
 | AVIF | R/W | no (#463) | optional feature, off by default | |
 | JPEG XL | R/W | inside DNG only | no | |
 | HEIF/HEIC | R/W(HEIF) | yes (pure-Rust heic-rs, `heif` feature, on in releases) | no | 8/16-bit |
@@ -43,7 +43,7 @@ XL are missing (gap G10). Remaining: 300–500 h including PSD fidelity.
 | Generic EPS / AI | R (rasterize) | no | no | |
 | SVG | R (rasterize) | yes, as editable shape layers or a vector smart object | no | Better than Photoshop for editing; gradients approximated (FILE-215-9) |
 | JPEG 2000 | R/W | no (#1047) | no | |
-| Cineon / DPX | R (DPX), R/W (CIN) | no (#1049) | no | |
+| Cineon / DPX | R (DPX), R/W (CIN) | DPX: luma, RGB, RGBA at 8/10/12/16 bits, both byte orders (#1049); Cineon no | DPX: 8/10/12/16 bits (`dpxBits`, `--dpx-bits`); Cineon no | Writes DPX, which Photoshop only reads; header fields (creator, project, copyright, transfer, frame rate, time code…) round-trip; no Cineon, no RLE |
 | DICOM | R/W | no | no | |
 | PCX | R/W | no | no | |
 | Pixar | R/W | no | no | |
@@ -90,6 +90,7 @@ D5100 colour profile. Counts and the G14 estimate are unchanged.
 | Paint.NET `.pdn` | yes | no | [pdn.md](pdn.md) |
 | OpenRaster `.ora` | yes | yes | [ora.md](ora.md) |
 | ICO, QOI | yes | yes | |
+| DirectDraw Surface `.dds` | yes | no | Top mip level of a 2D texture: uncompressed RGB, RGBA or luminance, BC1–BC3 (DXT1/3/5), legacy or DX10 header. Cubemaps, arrays, volumes and BC4–BC7 are refused (#1327). Photoshop needs a plug-in |
 | Krita `.kra`, GIMP `.xcf`, Procreate | no | no | Not in Photoshop either |
 
 ### Affinity import notes (moved from `roadmap.md`)
@@ -130,9 +131,10 @@ remaining gaps in #1606 stay tracked with per-sample corpus ceilings.
 | LUTs `.cube` / `.3dl` / `.look` | R/W (Export Color Lookup) | R/W / R / R | `cms/src/lutfile.rs` |
 | Keyboard shortcuts `.kys` | R/W | R | `engine/src/kys.rs` |
 | ICC profiles | R | R | Own CMS |
-| Actions `.atn` | R/W | no | AUTO-219-2 |
+| Actions `.atn` | R/W | R/W | `psd/src/atn.rs` (version 16 sets, exact round trip), `engine/src/atn_cmds.rs` (112 Photoshop events ↔ commands; other steps kept verbatim). Panel menu, CLI `batch --actions set.atn`, `actions.load`/`actions.save`. Photoshop 5-era version 12 files unsupported (AUTO-219-2) |
 | Styles `.asl` | R/W | no | #1693 |
-| Contours `.shc`, custom shapes `.csh`, tool presets `.tpl` | R/W | no | FILE-215-15 |
+| Contours `.shc` | R/W | R/W | `psd/src/shc.rs`; Contour Editor Load…/Save… (FILE-215-15). No user contour library; not yet checked against a Photoshop-written file |
+| Custom shapes `.csh`, tool presets `.tpl` | R/W | no | |
 | Curves `.acv`, Levels `.alv`, other adjustment presets | R/W | not audited | |
 | C2PA Content Credentials | R/W | no | #1050 |
 
@@ -140,5 +142,15 @@ remaining gaps in #1606 stay tracked with per-sample corpus ceilings.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-13 | minor | Palette PNGs open in Indexed Color mode (#4804) |
+| 2026-10-12 | minor | `.atn`: 112 events mapped (Select and Mask, Filter Gallery Spatter, Ripple, Crystallize, Pattern Fill layers, mask targeting, Step Backward, points, Bitmap) |
+| 2026-10-12 | minor | DDS textures open, read-only (#1327) |
+| 2026-10-12 | minor | #2465 fixed: Photoshop CS2 placed layers (`PlLd` only, file in `lnkD`) open as editable smart objects and save their edits |
+| 2026-10-12 | minor | CMYK Invert, Posterize and Threshold work on the inks and 16-bit Lab Invert mirrors a and b around neutral (oracle bad pixels: CMYK 71–77% → 9–10%, 37% → 1.6%; lab16 invert 52% → 1.2%); Photoshop-oracle floor 133 → 145 of 258 |
+| 2026-10-12 | minor | DPX read and write (#1049); Cineon still missing |
+| 2026-10-12 | minor | Photoshop Actions `.atn`: read and write, 90 events mapped, the rest kept verbatim (AUTO-219-2) |
+| 2026-10-12 | minor | Presets table: Contours `.shc` read and write through the Contour Editor (FILE-215-15); `.csh` and `.tpl` stay missing |
+| 2026-10-12 | minor | Palette BMPs open in Indexed Color mode (#3802) |
+| 2026-10-12 | minor | Save writes a JPEG at its own estimated quality and a WebP lossy or lossless as opened (#2399) |
 | 2026-10-11 | minor | D5100 image area and fitted-look preservation in Camera Raw tuning |
 | 2026-10-10 | major | First version: Photoshop 2026 27.11.0's formats from its bundle, against our codecs; Affinity notes moved from `roadmap.md` |
diff --git a/docs/font-resolution.md b/docs/font-resolution.md
new file mode 100644
index 0000000000..e1f1e273f7
--- /dev/null
+++ b/docs/font-resolution.md
@@ -0,0 +1,42 @@
+# PostScript font resolution
+
+PSD text may identify a face by its PostScript name as well as a family/style.
+The PostScript prefix need not match the family name, and the family stored with
+a run can be a guess made from that name.
+
+## Resolution
+
+`FontDb::resolve_postscript` first looks for an installed face with that exact
+PostScript name (families that share the guessed prefix are read first), then
+falls back to a heuristic split of the name. The heuristic splits at the last
+hyphen. A name without a hyphen loses a trailing capitalised style word
+(`GmarketSansBold` → Gmarket Sans, 700; `ExampleSansSemiBoldItalic` → Example
+Sans, 600, italic). A lowercase ending is not a style (`Daylight`), and a style
+word after the vendor tag `MT` stays in the family (`ArialRoundedMTBold` →
+Arial Rounded MT Bold).
+
+The heuristic also gives the family, weight and slant stored on PSD import when
+the exact face is absent. A legacy family whose name ends in a style word and
+has no `MT` tag before it (`CooperBlack`) is then stored as the shorter family
+(Cooper, 900) until the face is installed.
+
+## Missing fonts
+
+Opening a PSD or Affinity file already replaces a run's guessed family with the
+installed family its PostScript name resolves to. A guess still stays on a run
+when the face was absent at import and the document is reopened from `.pcraft`
+after the font is installed, when fonts are registered after opening, or when a
+command sets `font` and `postscriptName` together.
+
+Missing-font detection (`missing_fonts` and `missing_fonts_in_layer`) and Replace
+Missing Fonts therefore use the same decision as layout: a run is missing only
+when neither its stored family, its exact PostScript face nor the heuristic
+family is installed. A run that resolves is not replaced because an unresolved
+run shares its family label.
+
+## Cost
+
+Detection resolves the PostScript name only for runs whose stored family is not
+installed. The first such lookup reads the name tables of installed faces; the
+result is cached until fonts are registered or system fonts are loaded, and
+layout performs the same lookup for those runs.
diff --git a/docs/gaps.md b/docs/gaps.md
index 7937e66640..25a286aab8 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where PhotoCraft falls short of Photoshop
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (G8: triple-, quadruple- and five-click type selection landed, TYPE-218-8 done; Czech UI localization evidence added to G13; G14: D5100 crop and Camera Raw tuning validation) · **Target:** Adobe Photoshop 2026
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** minor (G7: Field Blur's on-canvas pins, #3373; G4: Hue Jitter amount track, #3825 partial; G4: minimum field interaction, #3825 partial; G1: CMYK Invert, Posterize and Threshold on the inks, 16-bit Lab Invert; Photoshop-oracle floor 145/258; G11: `.atn` import maps 112 events: Select and Mask, Filter Gallery Spatter, Ripple, Crystallize, Pattern Fill layers, mask targeting, Step Backward, nudges in points, Bitmap mode; G5: Free Transform H/V skew fields; G9: toolbar tool shortcut editing; refreshed against main: G2, G5, G7, G9, G10, G13, G14, G17 items that landed; G10: DPX read and write, #1049; G4: checkbox-only Brush Settings rows; G11: Load/Save Actions `.atn` landed, AUTO-219-2 partial; G5: hold-a-key spring-loaded tools landed, #2672; G1: #2465 fixed) · **Target:** Adobe Photoshop 2026
 
 Every known shortfall against Photoshop 2026 (27.11.0), one entry each, ranked by user impact
 on the way to beta. This is the work list agents pick from: take the highest-ranked entry that
@@ -43,11 +43,11 @@ what an agent can't finish alone.
 - **Missing:** PSDs we write are not always accepted by Photoshop, and Photoshop-authored files
   don't always render as Photoshop renders them.
 - **Evidence:** corpus floors (`crates/io/tests/corpus.rs`, scorecard): Photoshop-authored
-  oracles 133/256 (52%), io corpus 146/170 (86%), psd-tools 236/309 (76%); round trips ~100%
+  oracles 145/258 (56%; CMYK Invert, Posterize and Threshold on the inks 2026-10-12), io corpus 146/170 (86%), psd-tools 236/309 (76%); round trips ~100%
   within the corpus. Smart-filter re-render matches 5/30. User reports: a PSD with text layers
   re-saved unmodified would not reopen (#2374, closed 2026-10-10), Photoshop 26.6 cannot reopen our files (#1281), "PSD not
-  opening in Photoshop" (#2469), a CS2-era smart object unavailable (#2465), PSB smart object
-  blank (#1764), perspective placed layers flattened (#579), PSB > 4 GB fails on Windows (#375).
+  opening in Photoshop" (#2469), a CS2-era smart object unavailable (#2465, fixed 2026-10-12), PSB smart object
+  blank (#1764), perspective placed layers flattened (#579, fixed by #426), PSB > 4 GB fails on Windows (#375).
   No test opens our exports in a third-party editor (FILE-216-4).
 - **Impact:** PSD is the format professionals exchange. Beta requires it to be reliable.
 - **Estimate:** 150–250 h. **Human:** opening exports in Photoshop on the owner's Mac (or a
@@ -67,8 +67,11 @@ what an agent can't finish alone.
 ### G7. Workspaces shown as parameter dialogs
 - **Missing:** Select and Mask workspace layout
   (TOOL-214-1, Refine Hair #2671; its view modes preview live since #1754, Refine Edge Brush #2972); Content-Aware Fill workspace with a paintable sampling area
-  (TOOL-214-15); Vanishing Point plane editor (TOOL-214-14); Content-Aware Scale through the
-  transform box (TOOL-214-7); Content-Aware Move's Transform On Drop (TOOL-213-4).
+  (TOOL-214-15); Vanishing Point plane editor (TOOL-214-14); Content-Aware Move's live preview
+  of the result (TOOL-213-4; Transform On Drop and Content-Aware Scale through the transform box,
+  TOOL-214-7, are done).
+  Blur Gallery: Field Blur has its on-canvas pins (2026-10-11, #3373); Iris, Tilt-Shift, Spin and
+  Path Blur still edit their pins as parameter dialogs.
 - **Evidence:** scorecard rows above, all partial or missing.
 - **Impact:** these are the tools retouchers and compositors use daily; a slider dialog is not a
   substitute.
@@ -76,8 +79,9 @@ what an agent can't finish alone.
 
 ### G8. Type depth
 - **Missing:** type on a path (TYPE-218-1), paragraph direction UI (TYPE-218-2), complex-script
-  fallback fonts and golden tests (TYPE-218-3), OpenType panel UI (TYPE-218-5), live Warp Text
-  preview (TYPE-218-7, #2689), "rasterize and continue" for distort/perspective on type
+  fallback fonts and golden tests (TYPE-218-3), OpenType Numerals and Stylistic Sets submenus
+  (TYPE-218-5; the Character panel buttons landed 2026-10-11, #3752), live Warp Text preview
+  (TYPE-218-7, #2689), "rasterize and continue" for distort/perspective on type
   (TYPE-218-9), text free transform (#2630). Done since the re-measure: manual and optical kerning
   with PSD round trip (TYPE-218-6, #206), variable-font axes (TYPE-218-4, #2985).
 - **Evidence:** scorecard Type: 3 done, 2 partial, 4 missing. 2026-10-11: 2/3/4/5 clicks select
@@ -86,9 +90,32 @@ what an agent can't finish alone.
 - **Estimate:** 120–200 h.
 
 ### G11. Actions and scripting
-- **Missing:** document-independent action recording (AUTO-219-1), a full Actions panel with
-  step toggles and .atn import (AUTO-219-2), replay tests (AUTO-219-4), Batch recursion and
-  naming (AUTO-219-5), ExtendScript/UXP compatibility.
+- **2026-10-13 evidence:** Batch supports [output naming templates](batch-naming.md) using
+  `{name}`, `{serial}` and a captured UTC `{date}`, with a starting serial number. Colliding
+  names remain errors; custom output names cannot replace inputs. AUTO-219-5 stays partial.
+- **Missing:** document-independent action recording (AUTO-219-1), Batch recursion, open-document inputs, progress/cancel and an error-log file
+  (AUTO-219-5), ExtendScript/UXP compatibility. `.atn` steps outside the
+  mapped events (paths, scripts, Generative Fill, Filter Gallery effects other than Spatter,
+  Duplicate Layers into a new document, Bitmap halftone screens…) load as kept Photoshop steps
+  that fail at playback by name.
+- **Done 2026-10-12:** Load/Save Actions `.atn` in the panel menu, `batch --actions set.atn`
+  and `actions.load`/`actions.save`; 112 Photoshop events map to commands both ways (Transform,
+  Apply Image, Save for Web, smart-object edits, Gradient Map, Quick Mask, polygon selections,
+  Place, Open, Image Size in percent, the Paint Bucket and Insert Conditional since the third
+  and fourth PRs; Select and Mask, Filter Gallery Spatter, Ripple, Crystallize, Pattern Fill
+  layers, targeting the layer mask or composite channel, loading the targeted channel, Step
+  Backward/Forward, removing a layer from the selection, nudges in points, Layer From Background,
+  Grayscale and Bitmap mode objects and Image Size with Resample keeping the print size since the
+  fifth), Play, Stop and conditional steps included; layer steps replay by layer name in any
+  document. Four TrueGrit Texture Supply sets (Debaser, Distress Press, Halftone Zine Machine,
+  Transparency) import with 3 of 533 steps unmapped and play end to end. Filter Gallery Spatter's Smoothness
+  now smooths the spray's displacement, so high values tear an edge without detaching specks, as
+  Photoshop's does (calibrated by eye on the Distress Press guide's screenshots). Crystallize
+  fills each cell with the colour at its point instead of the cell's average, so a black-and-white
+  mask keeps hard edges (not yet checked against a Photoshop render). The panel groups actions
+  in set folders, has the dialog toggle column (playback pauses on the step's dialog and resumes
+  on OK) and Insert Stop…; `actions.insert`, `actions.dialog`, `actions.assignSet` for agents
+  (AUTO-219-2 done).
 - **Ahead of Photoshop:** CLI, MCP and the JSON control channel drive every command.
 - **Estimate:** 120–200 h. **Human:** whether to support a JavaScript scripting dialect at all
   (AGENTS.md forbids JS in the app).
@@ -97,7 +124,7 @@ what an agent can't finish alone.
 - **Missing:** CR3 (detected, unsupported), compressed RAF, lossy DNG (FILE-215-11), .xmp
   sidecars, masking and calibration in the Camera Raw dialog, per-camera colour for non-DNG
   cameras, lens profiles.
-- **Evidence:** `crates/raw/src/lib.rs:219` (CR3), scorecard FILE-215-11/12, #50.
+- **Evidence:** `crates/raw/src/lib.rs:228` (CR3), scorecard FILE-215-11/12, #50.
 - **Progress (2026-10-11):** on the embedded-JPEG rendering work in #2135, Camera Raw
   tuning retains the fitted look and applies user gains afterwards. Three D5100 NEFs
   establish a guarded 4928 × 3264 image area. This is an estimated rendering, not a
@@ -129,6 +156,15 @@ what an agent can't finish alone.
 - **Estimate:** 250–400 h (many overlap with other gaps; count each fix once).
 
 ### G4. Brush feel
+- **Progress (2026-10-13, #3825 partial):** Hue Jitter shows a standard themed
+  percentage-amount track rather than a hue spectrum. Other Brush Settings layout
+  and brush-behaviour gaps remain open.
+- **Progress (2026-10-13, #3825 partial):** Shape Dynamics' Minimum Diameter / Minimum
+  Roundness and Transfer's four Minimum rows disable editing when their Control is Off,
+  retaining the configured values. The other layout and control gaps in #3825 remain open.
+- **Progress (2026-10-12, #4283):** the five checkbox-only Brush Settings rows keep the open
+  controls selected; Smoothing can be disabled without discarding its amount or mode. This
+  closes that panel interaction gap, not the stroke-quality or performance gaps below.
 - **Missing:** lag with big brushes (#2619, #1994) and under the cursor (#2566, #1343); jumpy
   pressure on Windows (#2046) and tap sensitivity (#1933); stair-stepped line weights (#1776),
   interpolation and smoothing problems (#2138), edge falloff (#2149), pixelated cursor vs
@@ -139,23 +175,27 @@ what an agent can't finish alone.
 - **Estimate:** 100–180 h. **Human:** checking feel on real tablets.
 
 ### G5. Transform, handles and modifiers
-- **Missing:** right-click menu during Free Transform (TOOL-214-5); commit/cancel buttons in the
-  options bar (#2442); H/V skew fields and the full interpolation list; transform keeps layer
-  order and blend mode in its preview (#2439); Hand tool interrupting a transform (#2302);
-  blend mode/opacity edits during a transform (#1384); locked layers refused before the drag
-  (#2585); ⌘-drag temporary Move without box or snapping (#2681), Auto-Select box follows the
-  previous layer (#2666); ⌘-arrow layer nudge (#2474); path-point nudge; polygonal lasso Shift
-  angles (#2352); autoscroll at the edge while selecting (#2231); hold-a-key spring-loaded tools
-  (#2672); double-click Zoom tool to 100% (#2508); wheel and pinch behaviour (#2485, #2463,
-  #1989); toolbar press-and-hold flyouts (#2301); tool-key memory in a group (#2608).
+- **Missing:** the full interpolation list; blend mode/opacity edits during
+  a transform (#1384); path-point nudge; autoscroll at the edge while selecting (#2231);
+  wheel and pinch behaviour (#2485, #2463, #1989);
+  toolbar press-and-hold flyouts (#2301).
+- **Done since the re-measure (2026-10-10 to 12):** right-click menu during Free Transform
+  (TOOL-214-5); commit/cancel buttons in the options bar (#2442); transform keeps the layer's
+  place in the stack (#2439, #2480); Hand tool no longer interrupts a transform (#2302, #2327);
+  locked layers refused before the drag (#2585, #2609); ⌘-drag temporary Move with box and
+  snapping (#2681, #2684); Auto-Select box follows the picked layer (#2666, #2675); ⌘-arrow
+  layer nudge (#2474, #2556); polygonal lasso Shift angles (#2352, #2396); double-click Zoom tool
+  to 100% (#2508, #2527); tool-key memory in a group (#2608, #2625); hold-a-key spring-loaded
+  tools (#2672); H/V skew fields in the Free Transform options bar.
 - **Detail:** [`ui-parity.md`](ui-parity.md).
 - **Estimate:** 60–110 h.
 
 ### G9. Panels, preferences and workspace
-- **Missing:** 46 of 149 preferences do nothing (scorecard prefs audit); panel groups can't
+- **Progress (2026-10-12):** toolbar tool shortcuts can be reassigned, removed and reset (#4086),
+  with saved bindings, matching toolbar hints and regression coverage (`ui-egui/src/tool_shortcuts.rs`).
+- **Missing:** 27 of 156 preferences do nothing (scorecard prefs audit); panel groups can't
   float or tear off into OS windows (UI-217-5, #1828, #1213, #2305); Color panel lacks wheel and
-  slider modes (UI-217-17, #2569); UI scale presets (UI-217-9, #2492); more themes (UI-217-11,
-  #2661); Stamp Visible (UI-217-22); layer clipboard
+  slider modes (UI-217-17, #2569); more themes (UI-217-11, #2661); layer clipboard
   (UI-217-23, #2670); tool-specific context menus beyond brushes, selections and Pen
   ([context-menu-parity.md](context-menu-parity.md)); Libraries, Comments, Contextual Task Bar
   panels.
@@ -172,8 +212,7 @@ what an agent can't finish alone.
   loaded machine): layer move with styles 321 ms p50 against 25 ms, opacity change 276 ms
   against 20 ms, paste 12 MP 1.2 s against 100 ms, layer move on 15000×10000 16-bit 2.7 s,
   Content-Aware Scale 24 MP 954 s against 3 s, Select Subject 559 ms against 100 ms; the
-  150-layer nudge crashes the GPU compositor (P12); a 50 MP PSB with feathered masks redraws in
-  ~10 s (#2377); menus slow with thousands of layers (#2460); old machines lag (#2687).
+  150-layer nudge crashes the GPU compositor (P12); menus slow with thousands of layers (#2460); old machines lag (#2687).
 - **Estimate:** 200–350 h. Serial in places (compositor architecture).
 
 ## File-format gaps
@@ -181,9 +220,9 @@ what an agent can't finish alone.
 ### G10. Missing and partial file formats
 - **Missing:** JPEG Options dialog (FILE-215-19), Photoshop PDF read and write and multi-page PDF
   (FILE-215-10, #2541), AVIF read (#463) and default-build AVIF write, JPEG XL, JPEG 2000 (#1047),
-  DPX/Cineon (#1049), DICOM, EPS/DCS, PCX, Pixar, IFF, WBMP, MPO/JPS, PICT, Scitex CT, Photoshop
+  Cineon (DPX landed, #1049), DICOM, EPS/DCS, PCX, Pixar, IFF, WBMP, MPO/JPS, PICT, Scitex CT, Photoshop
   Raw; layered TIFF extra alpha channels (FILE-215-7); spot plates (FILE-215-17); .atn, .asl,
-  .shc, .csh presets (FILE-215-15); TGA/PNG alpha channels on open (#2225); C2PA (#1050).
+  .shc, .csh presets (FILE-215-15); C2PA (#1050).
 - **Detail:** [`file-format-parity.md`](file-format-parity.md).
 - **Estimate:** 120–220 h.
 
@@ -202,7 +241,7 @@ what an agent can't finish alone.
 
 ### G13. Hindi, Arabic, Vietnamese, RTL and engine messages
 - **Missing:** catalogs for Hindi, Arabic and Vietnamese (3 of the 12 key languages); right-to-
-  left UI layout; Devanagari/Thai/Khmer fallback fonts; engine error and status messages in
+  left UI layout; Devanagari fallback fonts (Thai #1909 and Khmer, Lao and Myanmar #3259 landed); engine error and status messages in
   English in every language; browser-locale detection and CJK fonts on the web; Japanese IME on
   Windows (#590); installed Japanese fonts missing from the font list (#2330); Arabic layer names
   as tofu (#1408, #1693).
@@ -214,8 +253,8 @@ what an agent can't finish alone.
 ## Platform gaps
 
 ### G17. Platforms and distribution
-- **Missing:** Windows code signing (material not obtained), Windows ARM64 (DIST-220-2), in-app
-  update check (DIST-220-1, #2650, #2375), in-app bug report (DIST-220-3), Flathub (#173),
+- **Missing:** Windows code signing (material not obtained), in-app update check (DIST-220-1,
+  #2650, #2375), in-app bug report (DIST-220-3), Flathub (#173),
   starting without a GPU adapter (#2519, #2412), Windows 7 (#2310, out of scope), Intel Macs with
   OpenCore (#1859).
 - **Estimate:** 30–60 h. **Human:** signing certificates.
@@ -224,9 +263,23 @@ what an agent can't finish alone.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-13 | minor | G4: Hue Jitter amount-track appearance (#3825, partial); no readiness percentage or estimate changed |
+| 2026-10-13 | minor | G4: minimum inputs in Shape Dynamics and Transfer follow their Control (#3825, partial); no readiness percentage or estimate changed |
+| 2026-10-12 | minor | G5: Free Transform options bar H/V skew fields done |
+| 2026-10-12 | minor | G11: `.atn` import maps 112 events (Select and Mask, Spatter, Ripple, Crystallize, Pattern Fill, mask targeting, Step Backward, points, Bitmap) |
+| 2026-10-12 | minor | G9: toolbar tool shortcut editing (#4086); the remaining workspace gaps stay open |
+| 2026-10-12 | minor | G1: #2465 (CS2 `PlLd`-only smart objects) marked fixed |
+| 2026-10-12 | minor | G1: CMYK Invert, Posterize and Threshold work on the inks, 16-bit Lab Invert keeps greys neutral; Photoshop-oracle floor 133 → 145 of 258 (145 already passed on main) |
+| 2026-10-12 | minor | G5: spring-loaded tool letters done (#2672) |
+| 2026-10-12 | minor | G10: DPX read and write (#1049); Cineon remains open |
+| 2026-10-12 | minor | G4: checkbox-only Brush Settings rows preserve the open controls and Smoothing settings (#4283); no readiness percentage or estimate changed |
+| 2026-10-12 | minor | G11: Load/Save Actions `.atn` landed (AUTO-219-2 partial); remaining panel work listed |
+| 2026-10-12 | minor | Refreshed against main: G5 items fixed by #2480, #2327, #2609, #2684, #2675, #2556, #2396, #2527, #2625 and TOOL-214-5/#2442; G7 TOOL-214-7 and Transform On Drop done; G2 #2377 fixed (#2417); G9 UI scale (UI-217-9) and Stamp Visible (UI-217-22) done, prefs 27 of 156; G10 #2225 done (#2482); G13 Khmer, Lao, Myanmar fallback (#3259); G14 CR3 line; G17 Windows ARM64 done (DIST-220-2) |
+| 2026-10-11 | minor | G7: Field Blur pins are placed, dragged and tuned on the image (#3373); the other Blur Gallery filters remain dialogs |
 | 2026-10-11 | minor | D5100 image area and Camera Raw tuning validation; G14 remains open |
 | 2026-10-11 | minor | G13: Czech dynamic UI text localized; engine messages and native review remain open |
 | 2026-10-11 | minor | G8: triple/quadruple/five-click type selection done (TYPE-218-8, #3493); Type evidence recounted |
+| 2026-10-11 | minor | G8: Character panel OpenType buttons landed (TYPE-218-5, #3752); Numerals and Stylistic Sets submenus still missing |
 | 2026-10-10 | minor | G2: recorded Tilt-Shift computation/filtered-proxy measurements and limits; gap and estimate remain open |
 | 2026-10-10 | minor | Checked against the alpha gate (no alpha blockers); #2374 marked closed |
 | 2026-10-10 | major | First version, from the full re-measure against Photoshop 2026 27.11.0 and the open issues |
diff --git a/docs/gpu-composite-reuse.md b/docs/gpu-composite-reuse.md
index 47b1f5c06d..39dad36107 100644
--- a/docs/gpu-composite-reuse.md
+++ b/docs/gpu-composite-reuse.md
@@ -13,10 +13,12 @@ existing planner before this boundary. Only the accumulated backdrop is live the
 it into the checkpoint's slot is sufficient to execute the remaining passes. No checkpoint is
 placed inside a group, clipping unit or adjustment program.
 
-Blend-If currently returns `Unsupported` from the GPU planner and uses the existing CPU path.
-The same holds for Advanced Blending (on main since b0680fd): it must keep falling back to the
-CPU, or keep the checkpoint boundary rule — a later GPU implementation of advanced blending
-preserves the boundary invariant either way.
+Blend If runs on the GPU (#4395) within this rule: like channel restrictions, it reads only the
+backdrop from before its own unit (retained across the unit, released at its end), so nothing
+else is live at the boundary. Advanced Blending (on main since b0680fd) returns `Unsupported`
+from the GPU planner and uses the CPU path: it must keep falling back to the CPU, or keep the
+checkpoint boundary rule — a later GPU implementation of advanced blending preserves the
+boundary invariant either way.
 
 ## Invalidation
 
diff --git a/docs/kra.md b/docs/kra.md
new file mode 100644
index 0000000000..847a1f32d2
--- /dev/null
+++ b/docs/kra.md
@@ -0,0 +1,77 @@
+# Krita documents
+
+PhotoCraft opens Krita's native documents (`.kra`, and the `.krz` archive variant) with their
+layers. File › Open, recent files, drops, the CLI (`convert`, `info`, `batch`) and automation
+(`doc.open`, MCP) all use the reader in `photocraft-io`; the browser build accepts them too. A
+file is recognised by its `mimetype` entry (`application/x-krita`). Krita files are import-only:
+Save suggests OpenRaster (`.ora`), which Krita opens with its layers, and `.pcraft` keeps
+everything.
+
+## What is read
+
+| Krita | PhotoCraft |
+|---|---|
+| Paint layers, 8 and 16-bit RGBA, 8 and 16-bit gray | pixel layers, at the document's depth (a gray layer in an RGB document is converted) |
+| Layer position (`x`, `y`), tiles anywhere, also off-canvas | kept |
+| Groups, nested; pass-through groups; collapsed state | groups; pass-through; expanded state |
+| Names, visibility, opacity, lock | kept |
+| Blend modes | Krita's ids, mapped as for OpenRaster (`docs/ora.md`); a few are approximations, reported |
+| Transparency masks | the layer mask (the first one; more are reported and left out) |
+| Selection masks | ignored (a layer's local selection, not part of its look) |
+| The image's ICC profile, resolution | kept |
+
+Left out with a warning per layer: vector, filter, fill, file and clone layers, filter, transform
+and colorize masks, layers in another colour space than those above, Inherit Alpha, per-channel
+blending flags (channel locks), and animation beyond the frame saved in the layer. Drawing
+assistants and reference images are reported as left out. Krita's merged image still shows
+the original look, so the result can differ where those were used.
+
+Documents whose image colour space we don't read yet (CMYK, Lab, XYZ, YCbCr, 16 and 32-bit
+float) open as Krita's merged image (`mergedimage.png`), flagged as a preview, with a warning.
+
+## The format, as observed
+
+A ZIP whose first, stored entry is `mimetype`; `maindoc.xml` holds the node tree (topmost first)
+and points each paint layer and mask at a file under `<image name>/layers/`. Those files are a
+text header (`VERSION 2`, `TILEWIDTH`, `TILEHEIGHT`, `PIXELSIZE`, `DATA <tiles>`) and per tile a
+`x,y,LZF,<bytes>` line followed by a compression flag and the tile's pixels in byte planes, LZF
+compressed. RGB pixels are B, G, R, A; 16-bit samples are little-endian. A `.defaultpixel` file
+next to each holds the colour outside its tiles. A group's own `x`/`y` does not move its
+children (checked against Krita's merged image).
+
+## Limits and safety
+
+The reader uses the bounded ZIP reader of `photocraft-format` (no ZIP64, CRC-checked), parses
+`maindoc.xml` with `roxmltree` (32 MiB cap; the DTD is declared by public id and not fetched),
+and decodes tiles with a bounds-checked LZF decoder that must produce exactly one tile. Tiles
+are at most 1024 px a side; canvases at most 300,000 px a side and 1 GiB of decoded pixels;
+8,192 nodes; nesting at most `MAX_GROUP_DEPTH`. Version 1 tile files (Krita 1.x) are refused.
+Malformed archives, XML, numbers, tile headers and tile data return errors; truncated and
+corrupted files are covered by tests.
+
+## Verification
+
+Unit tests (`crates/io/src/kra/tests.rs`) build Krita archives in code (raw and LZF tiles) and
+check layers, groups, pass-through, offsets, opacity, visibility, locks, masks, default pixels,
+16-bit and gray conversion, the merged-image fallback, LZF edge cases and malformed input.
+`crates/automation/tests/krita.rs` opens a `.kra` through the agent surface, edits it and saves
+it as OpenRaster. `crates/engine/tests/kra.rs` (opt-in) opens a Krita-authored 16-bit file in a
+session, checks it is read-only, edits with undo and saves as `.ora` and `.pcraft`.
+
+Real-file checks use the Krita-authored oracles in
+[photocraft-corpus](https://github.com/storytold/photocraft-corpus) (`krita/`, made by
+`tools/krita-oracles/generate.py`, which removes Krita's embedded third-party ICC profiles so
+the files are sRGB):
+
+```sh
+KRITA_TEST_DIR=/path/to/photocraft-corpus/krita cargo test -p photocraft-io --test krita_corpus -- --ignored --nocapture
+KRITA_TEST_DIR=/path/to/photocraft-corpus/krita cargo test -p photocraft-engine --test kra -- --ignored
+```
+
+2026-10-09, Krita 5.2.9: 31 of 35 `.kra` files render within 3/255 of Krita's merged image; the
+others differ for known reasons (the three blend-mode tie-breaks as for OpenRaster, and the
+file with a vector layer, which is left out). Before the profiles were stripped, a linear-light
+16-bit document with its embedded profile matched Krita's merged image within 0.5/255 after
+flattening and converting to sRGB.
+
+The reader is written from files Krita writes; no Krita code was used.
diff --git a/docs/localization-it.md b/docs/localization-it.md
new file mode 100644
index 0000000000..7b0444410e
--- /dev/null
+++ b/docs/localization-it.md
@@ -0,0 +1,73 @@
+# Italian terminology and dynamic UI labels
+
+This note goes with the completion of the Italian catalog (`crates/ui-egui/src/i18n/it.tsv`).
+The catalog already covered every key `cargo xtask i18n-coverage` measures, but it lacked 1,287
+labels that only exist at runtime and that other catalogs (Brazilian Portuguese, Dutch, Czech)
+already translate: filter and adjustment parameter names, Camera Raw panels, lighting effects,
+History, Layers, path and channel menu labels, metadata fields, status messages, System Info and
+dialog text. In Italian those showed in English.
+They are now translated, and a review pass fixed mistranslations and inconsistent terms in the
+existing entries. Translations are written from the meaning of PhotoCraft's English labels; no
+proprietary translation resources, fonts, screenshots or user documents are included.
+
+## Register and style
+
+Commands are imperatives in the second person singular (*Elimina*, *Applica*, *Crea
+pacchetto*); text addresses the user as *tu*. Only the first word is capitalised, except in
+command names joined by a slash, which keep both capitals (*Luminosità/Contrasto*,
+*HSL/Scala di grigio*). Decimals use a comma.
+
+## Terminology
+
+| English source | Italian | Note |
+|---|---|---|
+| Layer | Livello | |
+| Canvas | Quadro | also in *Come il quadro*, *Applica ai limiti del quadro* |
+| Preset | Predefinito | *Salva come predefinito* |
+| Default(s) | Predefinito / Predefiniti | never *default* or *valori predefiniti* |
+| Stroke | Traccia | contour and painterly strokes alike (*Tracce angolate*, *Direzione traccia*); a dash stays *Tratto* |
+| Sharpen | Contrasta / Contrasto | also in Camera Raw (*Quantità contrasto*) |
+| Noise | Disturbo | *Riduzione disturbo di luminanza*, *Riduzione disturbo cromatico* |
+| Highlights | Luci | pairs with *Ombre* |
+| Snapshot | Istantanea | |
+| Smart Filters | Filtri avanzati | |
+| Pattern | Pattern | *Timbro pattern* |
+| Gradient stops | Punti della sfumatura | |
+| Spot color | Tinta piatta | *Canale tinta piatta* |
+| Click | clic | *Fai clic*, *{key}-clic*, *doppio clic* |
+| Keyboard shortcut | Scorciatoia da tastiera | |
+| Footage | Filmato | *Interpreta filmato*, *Sostituisci filmato* |
+| Facet | Sfaccetta | |
+| SemiBold / ExtraBold / ExtraLight | Semigrassetto / Extragrassetto / Extraleggero | one spelling for every weight |
+| (Color) Mode | Metodo | *Cambia metodo condizionale*, never *modo* |
+| Trap | Trapping | the prepress term; *Sovrastampa* is overprint, a different thing |
+| HDR Toning | Mappatura tonale HDR | tone mapping; *Viraggio* stays for colour toning (*Viraggio separato*) |
+| Bevel & Emboss | Smusso e rilievo | pairs with *Rilievo* (Emboss) |
+| Linked (smart object) | Oggetto collegato | *Inserisci oggetto collegato*, *Converti in oggetto collegato* |
+
+## Native review
+
+2026-10-12: a native Italian speaker read the catalog and fixed mistranslations (Trap, HDR
+Toning, Display Text, Vine Color, Override Action "Save" Commands) and unnatural phrasing (Bevel &
+Emboss, East Asian / Middle Eastern Features, linked smart objects, bit depth labels).
+
+## Not covered
+
+Engine error and status messages, user document, layer and preset names, and automation
+command IDs stay in English, as in every language. A few dynamic labels the other catalogs carry
+(`Ask Before Saving Saved Embedded`, `Clear Selection`, the `Heal` family) are not used by the
+current code; they are translated to stay aligned with the other catalogs.
+
+## Validation
+
+- `italian_covers_generated_filter_options_and_gallery_names` (`crates/ui-egui/src/filter_dialog.rs`)
+  enumerates every filter and adjustment parameter, symbolic choice and gallery name, like the
+  Korean test, and requires an Italian row for each. With the catalog on `main` before this change
+  it lists 388 missing labels; now none.
+- `cargo test -p photocraft-ui-egui --lib`: the catalog tests pass. Two layout tests,
+  `type_controls_fill_the_panel_at_every_width_and_scale` and
+  `properties_edit_shown_metrics_and_paragraphs_with_a_non_type_primary`, fail on `main` as well
+  without this change.
+- `cargo xtask i18n-coverage`: 1,726 / 1,726 for `it`.
+- The offscreen `snapshot` example with `PHOTOCRAFT_LOCALE=it` rendered Lighting Effects, the
+  Camera Raw filter and Wind with Italian labels, without missing glyphs or clipped text.
diff --git a/docs/localization-parity.md b/docs/localization-parity.md
index e5ec2dbdad..9c73eb094b 100644
--- a/docs/localization-parity.md
+++ b/docs/localization-parity.md
@@ -1,10 +1,10 @@
 # Localization parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Czech review follow-ups) · **Target:** Adobe Photoshop 2026
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (Serbian catalog; previously minor: Italian native review) · **Target:** Adobe Photoshop 2026
 
 Per-language status of PhotoCraft's UI. How catalogs work and how to add one:
 [`localization.md`](localization.md). Language notes: [Korean](localization-ko.md), [Spanish](localization-es.md),
-[Simplified Chinese](localization-zh-hans.md).
+[Simplified Chinese](localization-zh-hans.md), [Italian](localization-it.md).
 
 **How measured.** `cargo xtask i18n-coverage` (`xtask/src/i18n_coverage.rs`) defines the key
 universe: `tl!("…")` literals and `trn(` plurals in `ui-egui` (tests excluded), menu-catalog
@@ -23,8 +23,8 @@ composer, and its text engine handles RTL, Devanagari and Indic scripts.
 
 **Summary.** 7 of the 12 key languages at 100% of measured keys (status `partial` because of the
 engine messages), 3 absent (Hindi, Arabic, Vietnamese), plus 8 other languages. Weighted by
-speakers, ~55% ready. Remaining: 80–140 h, plus native-speaker review (none recorded for any
-catalog).
+speakers, ~55% ready. Remaining: 80–140 h, plus native-speaker review (recorded only for Italian,
+2026-10-12).
 
 ## The twelve key languages
 
@@ -47,7 +47,11 @@ catalog).
 
 8 more, each at 1,608 / 1,608 measured keys, status `partial` for the same reason: Traditional
 Chinese `zh-hant` (2,329 rows), Russian `ru` (2,544), Ukrainian `uk` (3,375), Czech `cs` (3,522),
-Polish `pl` (3,366), Greek `el` (3,481), Dutch `nl` (3,568), Italian `it` (2,411).
+Polish `pl` (3,366), Greek `el` (3,481), Dutch `nl` (3,568), Italian `it` (3,928; also every dynamic label the
+other catalogs translate; reviewed by a native speaker, [notes](localization-it.md)). Turkish `tr`
+(3,731 rows) also covers every measured key. Serbian `sr` (4,022 rows, Latin script, Ekavian, added 2026-10-12) covers every
+measured key and the union of the other catalogs' dynamic labels; its one/few/many plurals reuse
+the Russian rule.
 
 Czech UI follow-up (2026-10-11): status and notice wrappers, hardware labels, brush and
 transform accessibility names, rasterization prompts, profile mismatch messages and preset
@@ -77,3 +81,7 @@ engine localization or native review is complete.
 | 2026-10-10 | minor | Right-to-left shell layout (menu bar, title, options and status bars, toolbox and dock sides) |
 | 2026-10-11 | minor | Czech dynamic status/notice and hardware text, render labels and Navigator zoom context; engine messages remain English |
 | 2026-10-11 | minor | Czech review follow-ups: English System Info diagnostics, id-aware shortcut labels, display-only auto translation, warning punctuation and wording; catalog row count refreshed |
+| 2026-10-11 | minor | Italian: 1,287 dynamic labels added (filter parameters, Camera Raw, lighting, panels, dialogs) and terminology made consistent |
+| 2026-10-12 | minor | Added Turkish (`tr`) catalog with 100% measured UI coverage |
+| 2026-10-12 | minor | Italian native-speaker review: mistranslations (Trap, HDR Toning, Display Text) and phrasing fixed |
+| 2026-10-12 | minor | Serbian (`sr`, Latin, Ekavian) catalog: every measured key plus the dynamic labels of the other catalogs |
diff --git a/docs/localization.md b/docs/localization.md
index 31737bf7a8..36e09f8a55 100644
--- a/docs/localization.md
+++ b/docs/localization.md
@@ -25,7 +25,9 @@ contextual, command-ID and plural translations; missing entries fall back to Eng
 | Polski | `pl` | one / few (2–4, not 12–14) / many |
 | Ελληνικά | `el` | one / other |
 | Nederlands | `nl` | one / other |
+| Magyar | `hu` | one form |
 | Tiếng Việt | `vi` | one form |
+| Srpski | `sr` | one / few / many (teens use many) |
 
 Languages registered with `complete_menus` cover the current menu labels, `tl!` literals, blend
 mode names, and generated preference labels; tests enforce that coverage. Vietnamese (`vi`) is
@@ -46,7 +48,8 @@ The existing preference store saves the selection for future launches. `auto` fo
 native system locale; an unsupported code follows the same fallback. Regional tags such as
 `fr-CA`, `ko-KR`, `vi-VN` and `zh-CN` resolve to the corresponding registered catalog. Traditional and
 Simplified Chinese remain distinct. Every Portuguese locale (`pt`, `pt-BR`, `pt-PT`) uses the
-Brazilian Portuguese catalog.
+Brazilian Portuguese catalog. The Serbian catalog is written in Latin script (Ekavian); every
+Serbian locale (`sr-RS`, `sr-Latn-RS`, `sr_RS@latin`, and Cyrillic `sr-Cyrl-RS`) resolves to it.
 
 ### First launch and system language
 
diff --git a/docs/mcp.md b/docs/mcp.md
index 4f7e9cc704..3046a669bc 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -13,7 +13,9 @@ described in [development.md](development.md). UI tools require a running deskto
 ## Tools and resources
 
 - `command_list`: discover engine ids, parameter docs and current enabled state; accepts
-  `filter` and `enabled_only`.
+  `filter` and `enabled_only`. Returns a bare JSON array of
+  `{id, label, menu, shortcut, params, enabled, disabledReason, needsDocument}` objects (see
+  [Command list replies](control-protocol.md#command-list-replies)).
 - `command_run`: `id`, optional `params` and `wait`. Command parameters remain engine-defined.
 - `command_batch`: ordered `steps`, optional `stop_on_error` (default true); stops at the first
   error unless false. Not an atomic transaction: earlier successful steps stay applied, with
diff --git a/docs/ora.md b/docs/ora.md
index ac83b847b8..19f3c7503e 100644
--- a/docs/ora.md
+++ b/docs/ora.md
@@ -23,10 +23,18 @@ entry, so an OpenRaster file with another extension still opens as one.
 Saving reports what OpenRaster can't hold, layer by layer: pixel masks are applied to the
 layer's pixels, fill opacity is folded into the pixels, text, shape, fill and smart object layers
 are written as their rendered pixels, and adjustment layers, layer styles, vector masks,
-clipping, alpha channels, metadata and the colour profile are left out. Xor and Paint.NET's
+clipping, alpha channels, metadata and a colour profile other than sRGB are left out. Xor and Paint.NET's
 Color Burn and Color Dodge variants have no OpenRaster name and are saved as Normal. CMYK, Lab
 and other modes are refused with a message to convert first; Grayscale saves as RGB.
 
+An OpenRaster file is the document's own file only while it holds everything in it (#3806).
+`photocraft_io::ora_losses` lists what a save would leave out, from the same checks the writer
+warns with, without encoding anything. When that list isn't empty, File › Save doesn't overwrite
+the `.ora`: Save As opens on a PSD of the same name, with a notice listing what OpenRaster would
+drop. A save to an `.ora` path then writes a copy, as Photoshop does for formats that can't keep
+everything: the document keeps its file and its unsaved changes. Automation follows the same rule
+(`doc.save` and `app.save` without a path refuse, saying why).
+
 OpenRaster elements other than `stack` and `layer` (MyPaint's text, for example), missing
 layer images and unknown composite operations open with a warning instead of failing the file.
 Krita's W3C Soft Light (`svg:soft-light`, `krita:soft_light_svg`) and its own Hard Mix open as
@@ -46,7 +54,8 @@ are covered by tests.
 Unit tests (`crates/io/src/ora/tests.rs`) round-trip layers, groups, pass-through, offsets,
 opacity, visibility, locks and every blend mode at 8 and 16 bit, check masks, rendered layer
 kinds, the archive layout and malformed input. `crates/automation/tests/openraster.rs` saves,
-reopens, edits and saves in place through the agent surface; the CLI test converts both ways.
+reopens, edits and saves in place through the agent surface, and checks that a document with an
+adjustment layer never overwrites its `.ora`; the CLI test converts both ways.
 
 Real-file checks use Krita-authored oracles from
 [photocraft-corpus](https://github.com/storytold/photocraft-corpus) (`krita/`, made by
@@ -57,13 +66,12 @@ Real-file checks use Krita-authored oracles from
 KRITA_TEST_DIR=/path/to/photocraft-corpus/krita cargo test -p photocraft-io --test krita_corpus -- --ignored --nocapture
 ```
 
-2026-10-09, Krita 5.2.9: 30 of 34 `.ora` files render within 3/255 of Krita's merged image; the
-other four differ for known reasons listed in `crates/io/tests/krita_corpus.rs` (Krita's
-tie-break in Darker and Lighter Color, Hard Mix at a channel sum of exactly 1, and a
-linear-light 16-bit document that Krita blends in linear light). In the other direction,
-Krita opened every PhotoCraft re-export of those files and rendered 33 of them identically to
-its original; the exception is Photoshop's Soft Light, which is written as `svg:soft-light`.
-MyPaint and GIMP files have not been checked yet.
+2026-10-09, Krita 5.2.9: 32 of 35 `.ora` files render within 3/255 of Krita's merged image; the
+other three differ for known reasons listed in `crates/io/tests/krita_corpus.rs` (Krita's
+tie-break in Darker and Lighter Color, and Hard Mix at a channel sum of exactly 1). In the other
+direction, Krita opened every PhotoCraft re-export of the first 34 of those files and rendered 33
+of them identically to its original; the exception is Photoshop's Soft Light, which is written
+as `svg:soft-light`. MyPaint and GIMP files have not been checked yet.
 
 Format reference: the [OpenRaster specification](https://www.openraster.org/). The reader and
 writer are written from the specification and from files Krita writes; no application code
diff --git a/docs/roadmap.md b/docs/roadmap.md
index e14a05113e..bca91616c7 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -1,6 +1,6 @@
 # Roadmap
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** minor (Photomerge implementation status corrected; real-world quality validation remains open) · **Target:** Adobe Photoshop 2026
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-11 · **Change:** minor (adaptive Unsharp Mask performance evidence linked; Photomerge status correction retained; alpha gate, focus and estimates unchanged) · **Target:** Adobe Photoshop 2026
 
 - UI.5: Panels can detach, join other tab groups, split, resize and redock through shared docking transactions. Custom layouts persist with workspaces, respect workspace locking, and retain collapse flags for intact native groups.
 
@@ -72,6 +72,9 @@ Ranked; each item links to its gap entry. Pick from the top unless an issue is a
    Photoshop re-open check (FILE-216-4); Photoshop-oracle floor 133/256 → 200+. 150–250 h.
 2. **Performance budgets** ([G2](gaps.md#g2-interactive-performance)): the 22 over-budget
    scenarios, the P12 GPU crash at 150 layers, brush and cursor lag (#2619, #2566). 200–350 h.
+   Local adaptive [Unsharp Mask optimisation](unsharp-mask-performance.md) improves native
+   threshold-zero 24 MP RGBA CPU application by 37–102x at radii 300–1000, with measured
+   rounding differences and an exact fallback; no published budget is closed by that measurement.
 3. **User bug backlog** ([G3](gaps.md#g3-user-reported-bug-backlog)): 579 open issues, most from
    0.5/0.6 users; triage weekly, fix regressions first. 250–400 h.
 4. **Brush and transform feel** ([G4](gaps.md#g4-brush-feel), [G5](gaps.md#g5-transform-handles-and-modifiers)):
@@ -113,6 +116,7 @@ Each milestone has a **definition of done (DoD)** and must leave `main` green on
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | minor | Linked adaptive Unsharp Mask performance and quality evidence; milestones, alpha gate and estimates unchanged |
 | 2026-10-10 | minor | Photomerge is implemented; real-world quality validation remains open |
 | 2026-10-10 | minor | Alpha gate table (core-workflow gate from the progress-docs standard): passes, stage stays alpha |
 | 2026-10-10 | major | Progress-docs standard: honest assessment and dated measurements moved to `target-app-parity.md`, Affinity notes to `file-format-parity.md`; new Current focus and estimates; `parity.md` renamed `parity-checklist.md` |
diff --git a/docs/scorecard.md b/docs/scorecard.md
index 0e8a58c75c..92f9315ebd 100644
--- a/docs/scorecard.md
+++ b/docs/scorecard.md
@@ -7,11 +7,11 @@ Generated by `cargo xtask scorecard` from `perf/budgets.toml`, `perf/baseline.js
 | Area | Done | Partial | Missing | Key numbers |
 |---|---:|---:|---:|---|
 | [Performance](#performance) | 3 | 22 | 22 | 56 scenarios: 3 within budget, 22 over budget or failing, 9 tracked only, 17 not run, 5 not measurable yet (baseline 2026-10-05) |
-| [File compatibility](#file-compatibility) | 6 | 13 | 8 | io corpus: oracle ≥ 146/170, round trip ≥ 169/170; psd-tools corpus: oracle ≥ 236/309, round trip ≥ 308/309; photoshop oracles: oracle ≥ 133/256, round trip ≥ 258/256 |
+| [File compatibility](#file-compatibility) | 7 | 13 | 7 | io corpus: oracle ≥ 146/170, round trip ≥ 169/170; psd-tools corpus: oracle ≥ 236/309, round trip ≥ 308/309; photoshop oracles: oracle ≥ 145/256, round trip ≥ 258/256 |
 | [Tools](#tools) | 28 | 14 | 1 |  |
-| [Workspace and UI](#workspace-and-ui) | 13 | 5 | 5 | settings that do nothing: 30 of 155 (target 0) |
-| [Type](#type) | 4 | 2 | 3 |  |
-| [Automation](#automation) | 3 | 2 | 6 | 631 of 631 menu items live (100.0%) |
+| [Workspace and UI](#workspace-and-ui) | 13 | 6 | 4 | settings that do nothing: 26 of 157 (target 0) |
+| [Type](#type) | 4 | 3 | 2 |  |
+| [Automation](#automation) | 5 | 2 | 4 | 631 of 631 menu items live (100.0%) |
 | [Reliability](#reliability) | 5 | 2 | 0 | never-crash lints on 28 of 28 crates; panic_hunt present |
 | [Distribution](#distribution) | 5 | 4 | 2 |  |
 | [Open bugs](#open-bugs) | 29 | 2 | 1 |  |
@@ -94,7 +94,7 @@ Corpus floors (`crates/io/tests/corpus.rs`): the enforced minimums; the corpus t
 |---|---|---:|---:|---:|
 | io corpus | `corpus/psd` | 170 | 146 | 169 |
 | psd-tools corpus | `corpus/psd-tools` | 309 | 236 | 308 |
-| photoshop oracles | `corpus/photoshop` | 256 | 133 | 258 |
+| photoshop oracles | `corpus/photoshop` | 256 | 145 | 258 |
 
 | Id | Target | Status | Issue | Note |
 |---|---|---|---|---|
@@ -103,7 +103,7 @@ Corpus floors (`crates/io/tests/corpus.rs`): the enforced minimums; the corpus t
 | FILE-215-3 | Filter mask can be painted directly, with undo | missing | [#215](https://github.com/storytold/photocraft/issues/215) | smart_cmds.rs:382 mask only from the selection |
 | FILE-215-4 | Adjustments (Hue/Sat + Colorize, Curves, Levels, Shadows/Highlights) apply as Smart Filters | done | [#215](https://github.com/storytold/photocraft/issues/215) | Image › Adjustments on a smart object records image.adjustments.<kind> as a smart filter (adjust_cmds.rs adjust_as_smart_filter; the selection becomes the filter mask), re-rendered from the source by adjust_as_filter and re-editable with layer.smartFilter.setParams; PSD maps Levels/Curves/Shadows-Highlights both ways (smart_map.rs). Opening the editor from the smart-filter row is FILE-215-5's row work |
 | FILE-215-5 | Smart Filter rows: collapse, mask thumb, blend icon, drag reorder, context menu, live preview | partial | [#215](https://github.com/storytold/photocraft/issues/215) | smart_ui.rs:31 rows + visibility + editor; no collapse, drag or context menu |
-| FILE-215-6 | Smart Object corner skew and perspective (quad or homography transform) | missing | [#215](https://github.com/storytold/photocraft/issues/215) | doc lib.rs:312 SmartObject.transform is an Affine |
+| FILE-215-6 | Smart Object corner skew and perspective (quad or homography transform) | done | [#215](https://github.com/storytold/photocraft/issues/215) | #426: SmartObject.perspective holds the projective map (transform keeps its affine approximation); Distort / Perspective on a smart object set it (transform_cmds.rs, smart_cmds::set_placement), it re-renders from the source through the homography, Warp composes with it, and the PSD placement reads and writes nonAffineTransform / Trnf (io/blocks.rs placed_projective, smart_map.rs); tests distort_survives_edit_contents, warp_on_a_distorted_smart_object_follows_the_corners, placement survives the save |
 | FILE-215-7 | Layered TIFF read and write (tag 37724), honouring the ask-before-saving pref | partial | [#215](https://github.com/storytold/photocraft/issues/215) | psd tiff.rs (ImageSourceData, both byte orders), io tiff_layers.rs, ui tiff_options_ui.rs (Discard Layers and Save a Copy); extra alpha channels and a Quick Mask are not written (the TIFF codec holds one transparency sample) |
 | FILE-215-8 | Large and BigTIFF import with banded decode across all IFDs | done | [#215](https://github.com/storytold/photocraft/issues/215) | codecs tiff_ifd.rs (bounds-checked IFD chain + SubIFD walk, classic and BigTIFF, cycle-safe; tiff_info / decode_tiff_page), tiff.rs banded parallel strip/tile decode, planar 1 and 2, BigTIFF write (tiff_bigtiff or > 4 GiB); io import_tiff_page; 30 MP RGB8 Deflate 345 -> 32 ms; no page picker in the UI yet |
 | FILE-215-9 | SVG opens and places as shape layers or a vector Smart Object | done | [#215](https://github.com/storytold/photocraft/issues/215) | io svg.rs: paths, groups, text outlines as shape layers (gradients approximated; clip/mask/filter/pattern/image subtrees rasterised); smart_cmds.rs renders an SVG source at its placement scale |
@@ -115,7 +115,7 @@ Corpus floors (`crates/io/tests/corpus.rs`): the enforced minimums; the corpus t
 | FILE-215-15 | Layer Style contour picker, curve editor, presets, .shc import/export | partial | [#2912](https://github.com/storytold/photocraft/issues/2912) | Layer Style dialog: contour thumbnail + preset picker (12 standard shapes, own control points) and Anti-aliased on Drop/Inner Shadow, Outer/Inner Glow, Satin, Bevel Gloss Contour and Contour element; Contour Editor (add/drag/delete, Corner, Input/Output, Preset, Load…/Save… .shc per Adobe's public spec, psd shc.rs); corner points render (compose contour_curve_lut) and map to PSD Cnty. Missing: a user contour library (New…, picker Load/Save/Replace Contours), Anti-aliased doesn't change the render yet, .shc not yet checked against a Photoshop-written file |
 | FILE-215-16 | Advanced Blending (knockout, blend as group, mask hides effects) end to end | partial | [#215](https://github.com/storytold/photocraft/issues/215) | doc advanced.rs + .pcraft + PSD/layered TIFF (knko infx clbl tsly lmgm vmgm), CPU compose advanced.rs (GPU falls back), blendingOptions command + dialog; 7 psd-tools knockout oracles now pass; knockout-isolated-groups (0.45 % AA edges), advanced-blending, blend-and-clipping still differ |
 | FILE-215-17 | CMYK/RGB documents preview spot inks; spot plates export (TIFF extra samples, PDF) | missing | [#215](https://github.com/storytold/photocraft/issues/215) | compose multichannel.rs:1 spot preview for Multichannel only |
-| FILE-215-18 | Save for Web per-slice settings remembered; Export As remembers and offers nearest scaling | partial | [#215](https://github.com/storytold/photocraft/issues/215) | file_ui.rs:188 last_web in-session only; export_dialog.rs:16 fixed defaults |
+| FILE-215-18 | Save for Web per-slice settings remembered; Export As remembers and offers nearest scaling | partial | [#215](https://github.com/storytold/photocraft/issues/215) | Save for Web settings survive a restart through the remembered dialog settings in prefs.dialogs (web_cmds::remember_web_settings stores them on a complete export, never the destination; file_ui.rs open_web seeds from the session's last export, else the preferences). export_dialog seeds Export As the same way (seed_remembered: format, quality, transparency, scale, metadata, TGA bits) and confirm remembers them as used. Missing: Export As nearest-neighbour scaling |
 | FILE-215-19 | Save As JPEG opens a JPEG Options dialog (quality 0-12, format options) | missing | [#215](https://github.com/storytold/photocraft/issues/215) | ExportSettings has jpeg_quality 1-100 only (lib.rs:118) |
 | FILE-215-20 | Artboard tool with handles and + buttons, Duplicate Artboard beside, vector PDF pages | partial | [#215](https://github.com/storytold/photocraft/issues/215) | artboard_tool.rs: Artboard tool draws, selects, moves and resizes boards by their handles (⇧ keeps proportions), its + buttons add a board or (⌥) a copy beside the selected one (#3033); Duplicate Artboard places the copy beside (#1584); raster PDF pages only |
 | FILE-215-21 | Local libraries of colours, patterns, images and layers, as linked items or copies | missing | [#215](https://github.com/storytold/photocraft/issues/215) | Only preset libraries (preset_store.rs) |
@@ -123,8 +123,8 @@ Corpus floors (`crates/io/tests/corpus.rs`): the enforced minimums; the corpus t
 | FILE-216-2 | Large-file fixtures: 20 MP, 150-layer, generated 2 GB PSD and 4-5 GB PSB stress tests | partial | [#216](https://github.com/storytold/photocraft/issues/216) | 4-5 GB PSB fixtures: psd example big_psb writes them (raw and RLE, planes past 2 GiB), io example big_psb_check opens and checks them; opt-in io tests/large_psb.rs (2.5 GB merged image). No 2 GB PSD, 150-layer or 20 MP fixture, nothing in CI |
 | FILE-216-3 | TIFF, RAW and EXR corpora read by tests; per-camera RAW coverage reported | partial | [#216](https://github.com/storytold/photocraft/issues/216) | EXR: corpus/exr (the OpenEXR deep test images, pinned) is read by codecs tests/deep_exr.rs in the CI corpus job, against the ID manifests of the upstream sidecars. corpus/tiff and corpus/raw are still copied in by hand and no test reads them; no per-camera RAW report |
 | FILE-216-4 | Exports re-open in a third-party oracle editor | missing | [#216](https://github.com/storytold/photocraft/issues/216) | The round trip is our export -> our import |
-| FILE-216-5 | Save-path tests: layered TIFF, PDF, SVG, ACO/ASE, .shc, Smart Filters, atomic-save failure | partial | [#216](https://github.com/storytold/photocraft/issues/216) | Every save path that exists is tested by saving and reading back: layered TIFF io tests/tiff_layers.rs (every_compression_keeps_the_layers, advanced_blending_survives_layered_tiff_in_both_byte_orders), print PDF engine print_cmds/tests.rs (print_dry_run_renders_a_pdf_and_reports_lp decodes the image back), ACO/ASE engine swatch_cmds/tests.rs (aco_round_trip_keeps_16_bit_values_and_books, ase_round_trip_keeps_groups_floats_and_kinds), .shc psd shc.rs shc_round_trips_and_rejects_hostile_input and engine layer_style.rs contour_presets_and_custom_curves_apply_in_one_undo_step, Smart Filters engine tests/smart_psd.rs (smart_filters_survive_psd_in_every_colour_model), atomic-save failure format/src/atomic/tests.rs (BUG-203-6). There is no SVG writer (SVG opens only) and no Photoshop PDF save (FILE-215-10), so those have nothing to test yet; the row stays partial until they exist |
-| FILE-216-6 | 30-50 end-to-end workflow acceptance tasks driven through MCP or commands | partial | [#216](https://github.com/storytold/photocraft/issues/216) | automation/tests/agent_tasks.rs: 10 MCP tasks |
+| FILE-216-5 | Save-path tests: layered TIFF, PDF, SVG, ACO/ASE, .shc, Smart Filters, atomic-save failure | partial | [#216](https://github.com/storytold/photocraft/issues/216) | Every save path that exists is tested by saving and reading back: layered TIFF io tests/tiff_layers.rs (every_compression_keeps_the_layers, advanced_blending_survives_layered_tiff_in_both_byte_orders), print PDF engine print_cmds/tests.rs (print_dry_run_renders_a_pdf_and_reports_the_platform_backend decodes the image back), ACO/ASE engine swatch_cmds/tests.rs (aco_round_trip_keeps_16_bit_values_and_books, ase_round_trip_keeps_groups_floats_and_kinds), .shc psd shc.rs shc_round_trips_and_rejects_hostile_input and engine layer_style.rs contour_presets_and_custom_curves_apply_in_one_undo_step, Smart Filters engine tests/smart_psd.rs (smart_filters_survive_psd_in_every_colour_model), atomic-save failure format/src/atomic/tests.rs (BUG-203-6). There is no SVG writer (SVG opens only) and no Photoshop PDF save (FILE-215-10), so those have nothing to test yet; the row stays partial until they exist |
+| FILE-216-6 | 30-50 end-to-end workflow acceptance tasks driven through MCP or commands | partial | [#216](https://github.com/storytold/photocraft/issues/216) | automation/tests/agent_tasks.rs: 20 MCP tasks |
 
 ## Tools
 
@@ -133,11 +133,11 @@ Corpus floors (`crates/io/tests/corpus.rs`): the enforced minimums; the corpus t
 | TOOL-213-1 | Pencil tool: aliased 1 px painting, square pixel-aligned cursor | done | [#213](https://github.com/storytold/photocraft/issues/213) | Tool::Pencil (B group): live aliased strokes on the pixel grid, square cursor, Auto Erase; pencil_tests.rs |
 | TOOL-213-2 | Mixer Brush tool on the toolbar | done | [#213](https://github.com/storytold/photocraft/issues/213) | Tool::MixerBrush in the Brush (B) flyout; Wet/Load/Mix/Flow/Sample All Layers options, command/control dispatch and selection-clipping tests |
 | TOOL-213-3 | Patch tool with a live preview of the patched area | done | [#213](https://github.com/storytold/photocraft/issues/213) | paint.patch (retouch_cmds/patch.rs, source/destination) + Tool::Patch (J group: lasso, then drag the selection); the drag shows the heal live (patch_preview.rs, coarse colour fit: 1000x1000 in 52 ms) |
-| TOOL-213-4 | Content-Aware Move tool reusing inpaint completion | partial | [#213](https://github.com/storytold/photocraft/issues/213) | paint.contentAwareMove (retouch_cmds/content_aware_move.rs: move/extend, Structure 1-7, Color 0-10, Sample All Layers, Transform On Drop's scaleX/scaleY/rotate; background job) + Tool::ContentAwareMove (J group: lasso, then drag; Transform On Drop puts a scale/rotate box on the dropped patch, cam_transform.rs: Enter commits as one step, Esc cancels). Missing: a live preview of the result (the drag and the box show the outline only) |
+| TOOL-213-4 | Content-Aware Move tool reusing inpaint completion | partial | [#213](https://github.com/storytold/photocraft/issues/213) | paint.contentAwareMove (retouch_cmds/content_aware_move.rs: move/extend, Structure 1-7, Color 0-10, Sample All Layers, Transform On Drop's scaleX/scaleY/rotate; background job) + Tool::ContentAwareMove (J group: lasso, then drag; Transform On Drop puts a scale/rotate box on the dropped patch, cam_transform.rs: Enter commits as one step, Esc cancels). cam_preview.rs: once the pointer or the box rests, the result shows (a cancellable background job on a smaller sampling window, small selections only, #4385). Missing: a progressive preview for big selections |
 | TOOL-213-5 | Painting a type/shape/smart/fill layer offers to rasterize, then continues the stroke | done | [#213](https://github.com/storytold/photocraft/issues/213) | rasterize_prompt.rs: OK rasterizes then paints (two history states), Cancel does nothing; drivable via ui.dialog.confirm |
 | TOOL-213-6 | Fill dialog: contents, blend, opacity, preserve transparency; remembered; Shift+Backspace | done | [#213](https://github.com/storytold/photocraft/issues/213) | fill_ui.rs dialog over edit.fill (fill_cmds.rs): all contents, mode, opacity, preserve; remembered in prefs; Shift+F5 / Shift+Backspace |
 | TOOL-213-7 | Live stroke preview for every brush-based retouch tool | partial | [#213](https://github.com/storytold/photocraft/issues/213) | Live (canvas.rs strokes_live): Brush, Pencil, Eraser, Blur, Sharpen, Smudge, Dodge, Burn, Sponge, Clone Stamp, Healing Brush, History Brush (#1026, #1040); the release commits the live stroke's pixels (P32). Not yet live: Spot Healing Brush, Mixer Brush, Background Eraser, Pattern Stamp |
-| TOOL-213-8 | Clone Source: W/H link, drawn overlay (opacity/blend/clip/auto-hide), Alt target cursor | partial | [#213](https://github.com/storytold/photocraft/issues/213) | Clone Source overlay drawn with opacity, inversion, circular clipping, auto-hide and the Normal/Darken/Lighten/Difference blend against the image under the brush (canvas.rs draw_clone_preview, clone_source::overlay_blend); W/H link (cloneSource.set linked, panel chain button, #3298); custom-tip clipping remains missing |
+| TOOL-213-8 | Clone Source: W/H link, drawn overlay (opacity/blend/clip/auto-hide), Alt target cursor | partial | [#213](https://github.com/storytold/photocraft/issues/213) | Clone Source overlay drawn with opacity, inversion, circular clipping, auto-hide and the Normal/Darken/Lighten/Difference blend against the image under the brush (canvas.rs draw_clone_preview, clone_source::overlay_blend); a shaped tip (sampled bitmap, rotation, roundness) clips the overlay to its outline (brush_cursor::tip_mask, #4372); W/H link (cloneSource.set linked, panel chain button, #3298) |
 | TOOL-213-9 | Eyedropper comparison ring (new colour above, current below) while sampling | done | [#213](https://github.com/storytold/photocraft/issues/213) | eyedropper_ring (canvas.rs): the sampled colour on the upper arc, the foreground below, drawn for the Eyedropper and Alt-sampling while the button is held; the Precise-cursor preference keeps the crosshair |
 | TOOL-213-10 | Ctrl+Alt drag resizes brush size/hardness with an on-canvas readout | done | [#213](https://github.com/storytold/photocraft/issues/213) | brush_resize.rs (#297, #370): Alt+right-drag, or Control+Option-drag on macOS (Control+Alt everywhere), sets diameter horizontally and hardness vertically, circle plus Diameter/Hardness readout, one coalesced tools.setBrush, no paint or history; 9 tests there |
 | TOOL-213-11 | Editable pressure curve, global and per control | partial | [#213](https://github.com/storytold/photocraft/issues/213) | Global: Preferences › Tools › Pressure Curve (prefs tools.pressureCurve; monotone cubic, engine prefs::PressureCurve; applied to every pen sample in ui-egui stylus.rs before any brush; editor pressure_curve_ui.rs with Linear/Soft/Hard presets). Missing: per-control curves (each brush dynamic's own response to pressure, tilt, rotation) |
@@ -171,14 +171,14 @@ Corpus floors (`crates/io/tests/corpus.rs`): the enforced minimums; the corpus t
 | TOOL-214-22 | Crop gear menu: Show Cropped Area (H), Enable Crop Shield with Match Canvas / custom colour, opacity and Auto Adjust Opacity | done | [#1919](https://github.com/storytold/photocraft/issues/1919) | crop_shield.rs: fill() resolves the shield (canvas.rs paints it around upright and turned frames), gear popup in the options bar, H ahead of the Hand key in shortcuts.rs, Custom… opens the Color Picker; ToolOptions crop_shield, ui.set cropShield. Use Classic Mode / Auto Center Preview: TOOL-214-23 |
 | TOOL-214-23 | Crop: Photoshop's default mode (the image turns and moves behind an upright box, Auto Center Preview keeps a resized box's centre in place and centres a drawn one) and Use Classic Mode (P) in the gear menu | done | [#1919](https://github.com/storytold/photocraft/issues/1919) | crop_mode.rs: the crop model (crop_rect + crop_angle) and image.crop are shared by both modes; default mode sets the view's rotation to -crop_angle while the tool shows a frame (picking the tool, in either mode, turns a Rotate View turn upright about the view centre, not restored after Enter/Esc or by P; Classic Mode keeps the camera upright with the frame drawn turned; as Photoshop 25.1), pivoting so the box stays put, moves view and frame together for drags inside and arrow keys, keeps a resized box's centre in place live (Auto Center Preview; a drawn box is centred on release, a moved one never), readout = the image's turn; gear menu order and Classic Mode greying as Photoshop 25.1; CropShield classic_mode / auto_center_preview (ui.set cropShield), P ahead of the Pen key |
 | TOOL-1053-1 | Shape stroke controls: solid/dashed/dotted, custom dash/gap/offset, caps, joins, alignment, miter limit and opacity | done | [#1053](https://github.com/storytold/photocraft/issues/1053) | shape_stroke_ui.rs: shared staged editor, renderer samples, cached Properties canvas preview; existing shape.create/edit/info; serde tool defaults, ui.set shapeStroke; pcraft and vstk style round trips. Gradient fill UI and saved stroke libraries remain open; Line retains filled-bar geometry |
-| TOOL-213-19 | Remove tool: paint over an object (or circle it) and it is filled from its surroundings | partial | [#213](https://github.com/storytold/photocraft/issues/213) | paint.remove (retouch_cmds/remove.rs, background job) + Tool::Remove in the J flyout; loops close over what they enclose; fill by non-local patch completion with texture features, onion-peel start, best-patch copy and gradient-domain seam hiding (algo/nonlocal.rs, Newson et al. IPOL 2017); sparse holes in tiles (algo/remove.rs). remove_quality on 20 holes in public-domain photos: the fill keeps 0.89 of the texture it replaces (0.54 with Content-Aware Fill's completion), edge gradient 1.03 of the original's; remove_bench 24 MP: 100 px ring 120 ms, 1000 px ring 2.5 s, 3000 px line 1.7 s. Missing: generative AI mode, Remove after each stroke off, live preview of the result |
+| TOOL-213-19 | Remove tool: paint over an object (or circle it) and it is filled from its surroundings | partial | [#213](https://github.com/storytold/photocraft/issues/213) | paint.remove (retouch_cmds/remove.rs, background job) + Tool::Remove in the J flyout; loops close over what they enclose; fill by non-local patch completion with texture features, onion-peel start, best-patch copy and gradient-domain seam hiding (algo/nonlocal.rs, Newson et al. IPOL 2017); sparse holes in tiles (algo/remove.rs). remove_quality on 20 holes in public-domain photos: the fill keeps 0.89 of the texture it replaces (0.54 with Content-Aware Fill's completion), edge gradient 1.03 of the original's; remove_bench 24 MP: 100 px ring 120 ms, 1000 px ring 2.5 s, 3000 px line 1.7 s. Options bar: Sample All Layers, Create a new layer (the fill on a new layer above, `newLayer`), Remove after each stroke off (strokes collect as a tint and ↩ applies them as one `strokes` job, Esc drops them). Missing: generative AI mode, live preview of the result |
 | TOOL-1045-1 | Color Replacement tool on the toolbar | done | [#1045](https://github.com/storytold/photocraft/issues/1045) | Tool::ColorReplacement in the Brush (B) flyout after the Mixer Brush; Mode/Sampling/Limits/Tolerance/Anti-alias options drive paint.colorReplacement with the foreground colour; live preview (LiveDab with the stroke's finishing dab), one History step; color_replacement_tests.rs |
 
 ## Workspace and UI
 
-**Settings that do nothing: 30 of 155** (target 0, #204). Counted by the prefs audit (`xtask/src/scorecard.rs`): a `Preferences` field counts as read when code outside the prefs model (`prefs.rs` except its `impl Session` blocks; tests excluded; the schema-driven dialog never names a field) accesses `section.field`, or `.section` and `.field` in the same file, or calls a section method that reads `self.field`. It is a heuristic lower bound: a generic name can look read when it isn't.
+**Settings that do nothing: 26 of 157** (target 0, #204). Counted by the prefs audit (`xtask/src/scorecard.rs`): a `Preferences` field counts as read when code outside the prefs model (`prefs.rs` except its `impl Session` blocks; tests excluded; the schema-driven dialog never names a field) accesses `section.field`, or `.section` and `.field` in the same file, or calls a section method that reads `self.field`. It is a heuristic lower bound: a generic name can look read when it isn't.
 
-Unread: `general.color_picker`, `general.animated_zoom`, `general.zoom_resizes_windows`, `workspace.auto_collapse_icon_panels`, `workspace.auto_show_hidden_panels`, `workspace.enable_floating_document_window_docking`, `workspace.enable_narrow_options_bar`, `file_handling.save_in_background`, `file_handling.maximize_psd_compatibility`, `performance.cache_levels`, `performance.legacy_compositing`, `scratch_disks.disks`, `units_and_rulers.column_width`, `units_and_rulers.gutter`, `plug_ins.show_extension_panels`, `plug_ins.allow_scripts_to_connect`, `plug_ins.generator_enabled`, `type_.missing_glyph_protection`, `type_.text_engine`, `type_.recent_fonts`, `enhanced_controls.scrubby_slider_acceleration`, `enhanced_controls.touch_gestures`, `raw_defaults.color_space`, `raw_defaults.bit_depth`, `raw_defaults.resolution`, `raw_defaults.sharpen_for`, `raw_defaults.open_as_smart_object`, `raw_defaults.apply_auto_tone`, `integrations.allow_agent_control`, `integrations.control_port`.
+Unread: `general.color_picker`, `general.animated_zoom`, `general.zoom_resizes_windows`, `workspace.auto_show_hidden_panels`, `workspace.enable_floating_document_window_docking`, `file_handling.save_in_background`, `performance.cache_levels`, `performance.legacy_compositing`, `scratch_disks.disks`, `units_and_rulers.column_width`, `units_and_rulers.gutter`, `plug_ins.show_extension_panels`, `plug_ins.allow_scripts_to_connect`, `plug_ins.generator_enabled`, `type_.text_engine`, `type_.recent_fonts`, `enhanced_controls.scrubby_slider_acceleration`, `enhanced_controls.touch_gestures`, `raw_defaults.color_space`, `raw_defaults.bit_depth`, `raw_defaults.resolution`, `raw_defaults.sharpen_for`, `raw_defaults.open_as_smart_object`, `raw_defaults.apply_auto_tone`, `integrations.allow_agent_control`, `integrations.control_port`.
 
 | Id | Target | Status | Issue | Note |
 |---|---|---|---|---|
@@ -189,10 +189,10 @@ Unread: `general.color_picker`, `general.animated_zoom`, `general.zoom_resizes_w
 | UI-217-5 | Panel groups can float (menu + drag out of the dock) and are restored at launch | missing | [#217](https://github.com/storytold/photocraft/issues/217) | No floating groups in dock.rs/panels.rs |
 | UI-217-6 | Document tabs: overflow list, context menu (Close/Others/All/Reveal), drag to reorder | done | [#217](https://github.com/storytold/photocraft/issues/217) | canvas.rs: Close/Others/All menu with unsaved prompt; Reveal reuses file.revealInFinder (engine layer_menu_cmds::reveal); the » chevron (tab_strip) lists overflow; dragging a tab reorders via document.move |
 | UI-217-7 | Command palette shows recently run commands on an empty query | done | [#217](https://github.com/storytold/photocraft/issues/217) | palette.rs: note_recent from menus::invoke keeps the last 8 commands (dedup, newest first); an empty query lists them via recent_hits; the_palette_records_and_replays_recent_commands_on_an_empty_query covers record -> empty query -> replay |
-| UI-217-8 | Tool-specific canvas right-click menu; right-click spelling suggestions in text fields | partial | [#217](https://github.com/storytold/photocraft/issues/217) | paint_mouse.rs brush picker and canvas_tool_menu.rs selection actions; text_field_menu.rs gives every text field its right-click Undo/Cut/Copy/Paste/Delete/Select All menu (#2921); other tools missing; spelling suggestions (edit.checkSpelling suggest) not in the text-field menu yet |
+| UI-217-8 | Tool-specific canvas right-click menu; right-click spelling suggestions in text fields | partial | [#217](https://github.com/storytold/photocraft/issues/217) | paint_mouse.rs brush picker and canvas_tool_menu.rs selection actions; text_field_menu.rs gives every text field its right-click Undo/Cut/Copy/Paste/Delete/Select All menu (#2921); other tools missing; the Type tool's edit menu starts with spelling suggestions and Add to Dictionary over a misspelled word (#4370); Ignore / Ignore All, suggestions in the non-editing type menu and in generic text fields are not there yet |
 | UI-217-9 | UI scale presets 100/115/125/150/200 % through zoom_factor, remembered | done | [#217](https://github.com/storytold/photocraft/issues/217) | prefs::UiScale offers Auto plus 75 to 300 percent (13 presets, more than the five this row lists); prefs_ui.rs display_scale resolves it (Auto follows the system scale, fractional and unscaled 4K included, #1072/#1278) and sync_display_scale applies it with ctx.set_zoom_factor. It is a preference, so it is remembered. The zoom_factor assert in input_tests.rs is about canvas zoom not scaling the interface, not about this setting |
 | UI-217-10 | Appearance: animation toggle, canvas pattern toggle per theme, start-screen recents | partial | [#217](https://github.com/storytold/photocraft/issues/217) | interface.enableAnimations (prefs_ui.rs sync_animations, #3273) zeroes egui animation_time and scroll animation in both styles; the Home screen lists recent files (canvas.rs home_recent, #2691); no canvas pattern toggle yet (#2264) and no option to hide the Home screen recents |
-| UI-217-11 | Soft dark and soft light themes with picker previews; outlined knobs in light themes | missing | [#217](https://github.com/storytold/photocraft/issues/217) | theme.rs ThemeKind has twelve themes (the four Pro brightness levels, Studio and Studio Light, Classic, Adwaita and Adwaita Dark, Solarized Dark, Breeze Light and Breeze Dark); no Soft dark or Soft light, and no outlined knobs in the light themes |
+| UI-217-11 | Soft dark and soft light themes with picker previews; outlined knobs in light themes | partial | [#217](https://github.com/storytold/photocraft/issues/217) | theme.rs ThemeKind has fourteen themes: the twelve earlier ones plus Soft Dark and Soft Light (low-contrast Studio-layout palettes, text at 4.5:1, selectable in Preferences with the existing theme-card previews, ui.set {theme}, Window > Theme); outlined knobs in the light themes are still missing |
 | UI-217-12 | Save custom New Document presets; a real Recent category | done | [#217](https://github.com/storytold/photocraft/issues/217) | document_preset_cmds.rs and new_doc_ui.rs: named presets save/select/delete through preferences; Recent lists Clipboard, the last 20 documents created in the dialog (document.recent.*, persisted with the presets, newest first, deduplicated) and the uncovered defaults (#3131); created_documents_fill_the_recent_category |
 | UI-217-13 | Numeric fields accept arithmetic and units; scrubby labels; double-click resets a slider | done | [#217](https://github.com/storytold/photocraft/issues/217) | widgets::value_field: arithmetic plus units (1in, 5mm, 72pt, 50%) converted at the document resolution (#3099); widgets::scrub_label makes options-bar, slider-row and Character labels scrubby (Shift x10, Alt fine); slider rows with a known default reset on double-click |
 | UI-217-14 | Layers panel: wheel steps blend modes, drop on New/Trash duplicates/deletes, checker behind art | done | [#217](https://github.com/storytold/photocraft/issues/217) | panels.rs: the wheel steps the blend-mode dropdown (widgets::dropdown_wheel_hovered, #1747); rows dropped on New Layer/Group/Delete duplicate/group/delete them (footer_drop, #736), effect rows dropped on Delete delete that effect or the whole style (fx_trash_drop, #3102); pixel thumbnails draw widgets::checker behind the art; Shift+Plus/Minus step the layer's or the painting tool's blend mode (blend_keys.rs, #3102) |
@@ -210,11 +210,11 @@ Unread: `general.color_picker`, `general.animated_zoom`, `general.zoom_resizes_w
 
 | Id | Target | Status | Issue | Note |
 |---|---|---|---|---|
-| TYPE-218-1 | Type on a path: path shape, glyphs along the curve, caret follows, PSD round trip | missing | [#218](https://github.com/storytold/photocraft/issues/218) | doc text.rs:209 TextShape has Point and Box only |
+| TYPE-218-1 | Type on a path: path shape, glyphs along the curve, caret follows, PSD round trip | partial | [#218](https://github.com/storytold/photocraft/issues/218) | TextShape::Path (doc text.rs) with glyphs placed rigidly along the curve by arc length (text warp.rs PathFrame), type.attachToPath and type.detachFromPath (#4365), .pcraft round trip. Missing: clicking a path with the Type tool, the caret and selection following the curve, and PSD path text (it saves as point text) |
 | TYPE-218-2 | Paragraph direction (Auto/LTR/RTL) in the panel and options bar; visual RTL caret | missing | [#218](https://github.com/storytold/photocraft/issues/218) | Engine has TextDirection (text.rs:155); no UI |
-| TYPE-218-3 | Thai/Khmer/Indic fallback fonts; golden shaping tests for complex scripts and RTL | partial | [#218](https://github.com/storytold/photocraft/issues/218) | Thai is covered: THAI_FAMILIES (fonts.rs) lists the Windows, macOS and Linux families and thai_in_latin_font_falls_back_to_installed_thai_font checks a sample with above and below marks (#1909); Arabic and Hebrew fall back too. Khmer and Indic have no fallback list, and there are no per-script golden shaping tests (only a bidi test) |
+| TYPE-218-3 | Thai/Khmer/Indic fallback fonts; golden shaping tests for complex scripts and RTL | partial | [#218](https://github.com/storytold/photocraft/issues/218) | Fallback fonts are covered for Thai, Khmer, Lao, Myanmar (THAI_FAMILIES, KHMER_FAMILIES, LAO_FAMILIES, MYANMAR_FAMILIES in fonts.rs; #1909, #3259), the nine Indic scripts (INDIC_FAMILIES: Nirmala UI, Kohinoor and Sangam MN, Noto Sans) and Arabic and Hebrew. Still missing: per-script golden shaping tests against reference output (only smoke tests that an installed font shapes without .notdef, plus a bidi test) |
 | TYPE-218-4 | Variable font axis sliders from the font's axes; opsz follows the point size | done | [#218](https://github.com/storytold/photocraft/issues/218) | One slider per axis of the style's font in the Character section (Properties and Window > Character), setting type.setStyle variations; opsz follows the type size unless set (layout.rs variation_list); a style or weight resets the wght axis (#2985). PSD does not round-trip axis values yet |
-| TYPE-218-5 | OpenType UI: Character panel buttons, Numerals and Stylistic Sets submenus | partial | [#218](https://github.com/storytold/photocraft/issues/218) | Type > OpenType toggles (type_extra_cmds.rs:512); no panel buttons or submenus |
+| TYPE-218-5 | OpenType UI: Character panel buttons, Numerals and Stylistic Sets submenus | partial | [#218](https://github.com/storytold/photocraft/issues/218) | Type > OpenType toggles (type_extra_cmds.rs:512). Character panel (and the Properties Character section) has Photoshop's eight OpenType buttons: Standard Ligatures, Contextual Alternates, Discretionary Ligatures, Swash, Stylistic Alternates, Titling Alternates, Ordinals, Fractions, pressed while the feature is on at the selection and dispatching the type.openType.* commands (type_tool.rs opentype_row; character_panel_opentype_buttons_toggle_and_show_the_feature, #3752). Still missing: the Numerals and Stylistic Sets submenus, and greying out features the font lacks |
 | TYPE-218-6 | Manual pair kerning (Alt+arrows), optical kerning rendered, both round-trip PSD (#206) | done | [#218](https://github.com/storytold/photocraft/issues/218) | Alt+Left/Right at a collapsed caret kerns the pair (type_tool.rs kern_pair, 20 per step and 100 with Cmd; type_tool_alt_arrows_kern_the_pair). Optical kerning is computed from the glyph outlines in text/src/optical.rs and applied by layout.rs when the run's mode is Optical (optical_matches_photoshop, optical_kerning_tightens_open_pairs). Both modes and manual values round-trip through PSD (io/tests/psd_kerning.rs; the optical mode travels in Txt2, txt2_carries_optical_kerning) |
 | TYPE-218-7 | Warp Text dialog previews live and opens with the layer's current warp | missing | [#218](https://github.com/storytold/photocraft/issues/218) | view_cmds.rs:834 always seeds arc, bend 50 |
 | TYPE-218-8 | Text editing: select all, double/triple/quadruple-click selection, paste, with tests | done | [#218](https://github.com/storytold/photocraft/issues/218) | Like Photoshop, 2 clicks select the word, 3 the laid-out line (a column in vertical type), 4 the paragraph up to the hard return, 5 all text, and the next quick click starts over (#3493; type_tool.rs next_click_count, click_selection, multi_click). Tested through real canvas clicks in point, paragraph and vertical type, with paste replacing the selection and Cmd+A selecting all (type_tool_tests.rs multi_click_selects_word_line_paragraph_and_all_in_point_text, multi_click_separates_wrapped_lines_from_paragraphs, click_counts_cycle_and_restart, click_selection_without_layout_and_on_hostile_input, multi_click_without_a_session_does_nothing) |
@@ -228,10 +228,10 @@ Menu wiring (`docs/parity-checklist.md`): 631 of 631 menu items live (100.0%). T
 |---|---|---|---|---|
 | AUTO-1 | Every menu item dispatches a command id (UI, CLI, control channel and MCP share them) | done |  | docs/parity-checklist.md: all menu items live; menus.rs is_live |
 | AUTO-219-1 | Record actions in a document-independent form (implicit layer, merged type keystrokes) | missing | [#219](https://github.com/storytold/photocraft/issues/219) | actions.rs:47 copies raw journal entries with explicit layer ids |
-| AUTO-219-2 | Actions panel: step and dialog toggles, reorder, delete a step, Stop, sets, .atn import | missing | [#219](https://github.com/storytold/photocraft/issues/219) | Panel deletes whole actions only (actions.rs:146) |
+| AUTO-219-2 | Actions panel: step and dialog toggles, reorder, delete a step, Stop, sets, .atn import | done | [#219](https://github.com/storytold/photocraft/issues/219) | 2026-10-12: set folders (collapsible, drag between sets, actions.assignSet), dialog toggle column (playback opens the step's dialog seeded with its values and resumes on OK; actions.dialog), Insert Stop… (actions.insert), step toggles, reorder, delete a step; Load/Save Actions (.atn) in the panel menu, CLI batch and actions.load/save (atn_cmds.rs): 90 Photoshop events map to commands both ways, the rest are kept verbatim and fail at playback by name; step toggles, reorder and delete a step done; Stop steps play (actions.stopMessage) but there is no Insert Stop menu item; sets and dialog toggles are stored and round-trip but the panel neither groups by set nor edits the dialog toggle |
 | AUTO-219-3 | actions.record/stop/play/list commands for agents and the CLI | done | [#219](https://github.com/storytold/photocraft/issues/219) | actions.list/get/record/stop/play/delete in actions_cmds.rs; the panel, CLI and MCP share them. Nested steps pass the session authorize hook. |
-| AUTO-219-4 | Replay tests for crop, filters, selections and styled text on a second document | missing | [#219](https://github.com/storytold/photocraft/issues/219) | One replay test (actions.rs:171: new layer, rect select, fill) |
-| AUTO-219-5 | Batch: subfolders, open documents, naming template, progress/cancel, error log, stop | partial | [#219](https://github.com/storytold/photocraft/issues/219) | file_cmds.rs:590-631 folder/array input, per-file errors; no recursion, template or cancel |
+| AUTO-219-4 | Replay tests for crop, filters, selections and styled text on a second document | done | [#219](https://github.com/storytold/photocraft/issues/219) | actions_cmds.rs: a_recorded_edit_run_replays_on_a_second_document records a crop, a Gaussian Blur, a selection fill and faux-bold type on one document and replays all of them onto a second (plus the original layer/select/fill replay) |
+| AUTO-219-5 | Batch: subfolders, open documents, naming template, progress/cancel, error log, stop | partial | [#219](https://github.com/storytold/photocraft/issues/219) | file_cmds.rs and file_cmds/batch_naming.rs: folder/array input, per-file errors, {name}/{serial}/{date} output templates and starting serial; no recursion, open-documents source, cancel or error-log file |
 | AUTO-219-6 | Plug-in ABI v2: panel kind, progress/cancel calls, read other layers, Last Filter repeats | missing | [#219](https://github.com/storytold/photocraft/issues/219) | runtime.rs:15 ABI_VERSION = 1; manifest.rs:18 Kind::Filter only |
 | AUTO-219-7 | Local ONNX models behind a flag, managed in Preferences; subject select, background removal | missing | [#219](https://github.com/storytold/photocraft/issues/219) | No ONNX runtime dependency |
 | AUTO-219-8 | xtask check that every panel button routes through a command id | missing | [#219](https://github.com/storytold/photocraft/issues/219) | No such xtask check |
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 472a0f7cfc..a7c802904b 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # PhotoCraft vs Adobe Photoshop: target-app parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** minor (Tilt-Shift measurements added; earlier the same day: major, full re-measure against Photoshop 2026 27.11.0; merged `parity-estimate.md` and the roadmap's honest assessment) · **Target:** Adobe Photoshop 2026
+> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-12 · **Change:** minor (`.atn` import maps 112 events; Free Transform H/V skew fields; stale rows corrected against `main` and the scorecard, estimates unchanged; Photoshop Actions `.atn` load and save; 2026-10-10: Tilt-Shift measurements added; earlier the same day: major, full re-measure against Photoshop 2026 27.11.0; merged `parity-estimate.md` and the roadmap's honest assessment) · **Target:** Adobe Photoshop 2026
 
 The authoritative answer to "how close is PhotoCraft to Photoshop, and how much work is left". The
 one-page summary is [`ROADMAP.md`](../ROADMAP.md); the ranked work list is [`gaps.md`](gaps.md);
@@ -49,7 +49,7 @@ architecture and the PSD writer are the serial parts.
   `Locales/` language packs, `Default Keyboard Shortcuts.kys` (67 toolbox tools, 107 menu commands
   with default shortcuts), `Required/` plug-ins (85 filter entries, 12 format plug-ins), presets,
   and strings in the main binary (81 "… Tool" titles; HDR/EDR, Metal, Touch Bar, pen features).
-- PhotoCraft's own Photoshop menu tree (`crates/ui-egui/src/menu_catalog.rs`, 628 items) was
+- PhotoCraft's own Photoshop menu tree (`crates/ui-egui/src/menu_catalog.rs`, 628 items on 2026-10-10, 631 on 2026-10-12) was
   written from Photoshop's menus; it is the denominator of the menu number. Photoshop's binary
   `Default Menus.mnu` was not parsed, so items added in 27.x that the catalog lacks would not show
   (Generative and cloud items are the likely ones).
@@ -60,13 +60,13 @@ architecture and the PSD writer are the serial parts.
 
 | Component | Weight | Ours / Photoshop | % | Kind |
 |---|---:|---|---:|---|
-| Menu commands | 30% | 628 / 628 catalog items dispatch a live command | 100% | measured (`cargo xtask parity`) |
+| Menu commands | 30% | 631 / 631 catalog items dispatch a live command (628 / 628 on 2026-10-10) | 100% | measured (`cargo xtask parity`) |
 | Toolbox tools | 15% | 59 / 68 (Photoshop's 67 `.kys` tools plus Remove, Triangle, Curvature Pen; minus legacy Rounded Rectangle and Targeted Adjustment) | 87% | measured (`Tool` enum in `ui-egui/src/state.rs`, `TOOL_SECTIONS` in `panels.rs`) |
 | Panels | 10% | 30 / 35 Window-menu panels | 86% | measured (`view_cmds.rs`, panel modules) |
 | Filters and adjustments | 10% | every Filter and Image › Adjustments item live; Filter Gallery 47 looks | 100% | measured (menu catalog) |
 | File formats (usage-weighted) | 15% | 13 of 31 Photoshop formats supported in Photoshop's directions, 4 partial; the common ones (PSD/PSB, TIFF, JPEG, PNG, WebP) all present | ~80% (48% by count) | measured list, estimated weights ([file-format-parity.md](file-format-parity.md)) |
 | AI / generative | 10% | classical Select Subject/Sky, Remove tool, Content-Aware; no Generative Fill/Expand, Neural Filters, Sky Replacement, Super Zoom | ~15% | estimated |
-| Ecosystem (plug-ins, scripting, libraries) | 10% | WebAssembly plug-ins, CLI, MCP, actions; no .8BF, UXP/ExtendScript, .atn import, Libraries | ~20% | estimated |
+| Ecosystem (plug-ins, scripting, libraries) | 10% | WebAssembly plug-ins, CLI, MCP, actions, `.atn` load/save (112 events); no .8BF, UXP/ExtendScript, Libraries | ~20% | estimated |
 | **Weighted** | 100% | | **~76%** | |
 
 ## Ready for real work: ~45% (weighted)
@@ -76,14 +76,14 @@ Weights reflect what a working Photoshop user depends on (photographers, retouch
 | Dimension | Weight | % ready | Remaining (agent-h) | Evidence | Detail |
 |---|---:|---:|---:|---|---|
 | Features in depth (tools, layers, selections, type, filters, transforms) | 25% | 55% | 600–1,000 | Scorecard checklists: Tools 20 done / 15 partial / 6 missing, Type 0 / 3 / 6, Automation 3 / 2 / 6. 14 tools missing; Select and Mask, Vanishing Point and Content-Aware Fill are parameter dialogs, not workspaces; type on a path, manual kerning, RTL paragraphs missing | [gaps.md](gaps.md) |
-| UI / UX fidelity and feel | 15% | 40% | 350–600 | ~150 open UI issues; Workspace checklist 5 / 7 / 11; 46 of 149 preferences do nothing; no floating panel groups, thin Color panel, no transform context menu, brush lag and pressure jumps reported | [ui-parity.md](ui-parity.md), [brush-parity.md](brush-parity.md) |
+| UI / UX fidelity and feel | 15% | 40% | 350–600 | ~150 open UI issues; Workspace checklist 13 / 5 / 5 (2026-10-12; 5 / 7 / 11 on 2026-10-10); 27 of 156 preferences do nothing (was 46 of 149); no floating panel groups, thin Color panel, brush lag and pressure jumps reported | [ui-parity.md](ui-parity.md), [brush-parity.md](brush-parity.md) |
 | File formats and fidelity | 15% | 60% | 300–500 | PSD oracle on Photoshop-authored files 133/256 (52%); io corpus 146/170 (86%); psd-tools 236/309 (76%); round trips ~100% of corpus; but users report Photoshop refusing our files (#1281, #2469; a text-layer case, #2374, was fixed 2026-10-10); no Photoshop PDF, EPS, JPEG 2000, JPEG XL, AVIF read, CR3 | [file-format-parity.md](file-format-parity.md) |
 | Performance | 10% | 25% | 200–350 | 3 of 25 budgeted scenarios meet budget (baseline 2026-10-05); 150-layer nudge crashes the GPU path (P12); layer move on 15000×10000 16-bit 2.7 s p50; users report brush and cursor lag (#2619, #2566, #1994) | [scorecard.md](scorecard.md#performance) |
 | Stability | 10% | 45% | 150–250 | Never-crash lints on 28/28 crates, `panic_hunt` in the gate, atomic saves; but field reports of freezes (#2518 Type tool 60 s on macOS), GPU panics (#2020, #1215), no-GPU start failures (#2519, #2412) | [gaps.md](gaps.md) |
 | Hardware | 5% | 50% | 80–150 | GPU compositor (wgpu), pen pressure on all desktops but tilt/rotation not on Windows, Wayland pen broken (#2622), no HDR/EDR output, monitor profile auto-detected on macOS only | [hardware-parity.md](hardware-parity.md) |
-| Localization | 5% | 55% | 80–140 | 7 of the 12 key languages at 100% of measured UI keys; Hindi, Arabic, Vietnamese absent; no RTL UI; engine messages English | [localization-parity.md](localization-parity.md) |
-| Platforms | 5% | 80% | 30–60 | macOS (notarized), Windows (unsigned), Linux (AppImage/deb/rpm/Flatpak), web, FreeBSD partial; no Windows ARM64, no in-app updates | [scorecard.md](scorecard.md#distribution) |
-| Ecosystem (plug-ins, scripting, presets, libraries) | 5% | 15% | 250–450 | No .8BF hosting (#2647), no UXP/ExtendScript, no .atn import; .abr/.grd/.pat/.aco/.ase/.cube supported | [gaps.md](gaps.md) |
+| Localization | 5% | 55% | 80–140 | 7 of the 12 key languages at 100% of measured UI keys; Hindi and Arabic absent, Vietnamese catalog added 2026-10-12 (#2636, coverage not re-measured); no RTL UI; engine messages English | [localization-parity.md](localization-parity.md) |
+| Platforms | 5% | 80% | 30–60 | macOS (notarized), Windows (unsigned), Linux (AppImage/deb/rpm/Flatpak), web, FreeBSD partial; Windows ARM64 is packaged and install-checked by `.github/workflows/windows-arm64.yml` (DIST-220-2); no in-app updates | [scorecard.md](scorecard.md#distribution) |
+| Ecosystem (plug-ins, scripting, presets, libraries) | 5% | 15% | 250–450 | No .8BF hosting (#2647), no UXP/ExtendScript; .atn load/save (2026-10-12, 112 events, the rest kept verbatim), .abr/.grd/.pat/.aco/.ase/.cube supported | [gaps.md](gaps.md) |
 | AI features | 5% | 10% | 300–600 | No ML runtime at all (scorecard AUTO-219-7); classical substitutes only. Needs an owner decision and openly licensed models (#41) | [gaps.md](gaps.md) |
 | **Weighted** | 100% | **~46%** | **2,340–4,100** | | |
 
@@ -114,7 +114,7 @@ Discounts for what still stops real work (estimated, each with evidence):
 
 | Discount | Factor | Evidence |
 |---|---:|---|
-| Interaction fidelity | ×0.92 | ~150 open UI issues; transform context menu, spring-loaded tools, panel tear-off missing ([ui-parity.md](ui-parity.md)); brush lag and pressure reports ([brush-parity.md](brush-parity.md)) |
+| Interaction fidelity | ×0.92 | ~150 open UI issues; spring-loaded tools, panel tear-off missing ([ui-parity.md](ui-parity.md)); brush lag and pressure reports ([brush-parity.md](brush-parity.md)) |
 | Stability and speed on real machines | ×0.88 | 3 of 25 performance budgets met; 150-layer GPU crash (P12); Type tool freeze (#2518); GPU start failures (#2519, #2412, #2020); 41 open performance issues |
 | Exchanging files with Photoshop users | ×0.92 | Photoshop-authored oracle 133/256; exports refused by Photoshop (#1281, #2469); smart-filter re-render 5/30 |
 
@@ -144,7 +144,7 @@ workflows, PSD exchange edge cases, and everything excluded above.
 | Layers (add, reorder, hide, opacity) | 12% | 80% | |
 | New / open a photo | 10% | 90% | |
 | Select (marquee, lasso, magic wand, object) | 10% | 75% | |
-| Move and Free Transform | 10% | 70% | no commit/cancel buttons (#2442) |
+| Move and Free Transform | 10% | 70% | commit and cancel buttons in the options bar (#2442, closed) |
 | Brush and eraser | 10% | 70% | lag with big brushes (#2619) |
 | Undo, History | 8% | 90% | |
 | Basic adjustments (brightness, levels, curves, hue/saturation) | 8% | 80% | |
@@ -167,23 +167,25 @@ parity for the area and are already contained in the dimension rows above.
 
 | Area | % | Hours | Notes |
 |---|---:|---:|---|
-| Layers, groups, masks, blend modes, smart objects, layer styles | 65% | 150–250 | Broad and GPU-accelerated. Open: multi-layer Smart Object conversion (#2604, #2648), layer clipboard between documents (UI-217-23), Stamp Visible, contour editor, smart-object perspective (FILE-215-6), mask targeting by command (#2458) |
-| Selections, Select and Mask, channels | 55% | 120–200 | All selection tools, single row/column marquee included (#2837). Select and Mask is a generic dialog (TOOL-214-1), no Refine Hair (#2671); Select Subject/Sky classical, 559 ms p50 on 24 MP vs a 100 ms budget |
+| Layers, groups, masks, blend modes, smart objects, layer styles | 65% | 150–250 | Broad and GPU-accelerated. Open: layer clipboard between documents (UI-217-23: `layer.copyToDocument` exists, no copy/paste), smart-object perspective (FILE-215-6), a user contour library (FILE-215-15). Multi-layer Smart Object conversion (#2052, #2651), Stamp Visible (UI-217-22) and mask targeting by command (#2458) are done |
+| Selections, Select and Mask, channels | 55% | 120–200 | All selection tools, single row/column marquee included (#2837). Select and Mask is a dialog with Photoshop's view modes, a Refine Edge Brush and six outputs, not a workspace (TOOL-214-1), no Refine Hair (#2671); Select Subject/Sky classical, 559 ms p50 on 24 MP vs a 100 ms budget |
 | Painting and brush engine | 55% | 150–250 | Every Brush Settings section exists; feel is the gap: lag on big brushes, pressure jumps, smoothing and edge quality reports ([brush-parity.md](brush-parity.md)) |
 | Retouching (healing, clone, patch, remove, content-aware) | 50% | 100–180 | Remove tool non-generative; Content-Aware Fill has no workspace (TOOL-214-15); live stroke preview only for Brush/Eraser (TOOL-213-7) |
-| Transform, warp, puppet, perspective, liquify | 55% | 100–180 | Free Transform modifiers right; no transform context menu (TOOL-214-5), no skew fields, puppet mesh is a block grid (TOOL-214-6), Liquify called "useless" by a user (#2606) |
+| Transform, warp, puppet, perspective, liquify | 55% | 100–180 | Free Transform modifiers right, with a right-click transform menu (TOOL-214-5) and H/V skew fields; Puppet Warp mesh follows the object outline (TOOL-214-6); Liquify called "useless" by a user (#2606) |
 | Adjustments and filters | 70% | 120–200 | All present; smart-filter re-render matches Photoshop on 5 of 30 files; Filter Gallery looks approximate; no Neural Filters |
 | Type | 40% | 120–200 | Engine works; no type on a path, manual kerning, RTL paragraphs, OpenType panel UI, live Warp Text preview; Type tool freeze on macOS (#2518) |
-| Vector shapes and paths | 55% | 80–140 | Pen, Direct/Path Selection, shapes, shape strokes. Freeform and Curvature Pen (#1054). Missing anchor tools, on-canvas corner radius, path-point nudge; shape parity tracking issue #2496 |
+| Vector shapes and paths | 55% | 80–140 | Pen, Direct/Path Selection, shapes, shape strokes. Freeform and Curvature Pen (#1054). Add/Delete Anchor Point and Convert Point tools exist (`Tool` enum); missing on-canvas corner radius (TOOL-214-12), path-point nudge; shape parity tracking issue #2496 |
 | Colour management and modes | 70% | 60–100 | Own ICC engine, soft proof, CMYK/Lab/Indexed/Duotone/Multichannel; no Adobe CMYK profiles, no spot plates (FILE-215-17), monitor profile only at launch |
 | Camera Raw and computational photo (Photomerge, HDR, lens) | 45% | 120–200 | Raw for DNG/CR2/NEF/ARW/RW2/ORF/RAF(uncompressed)/PEF; no CR3; ACR dialog partial (no masking, calibration); generic lens profiles only |
-| Automation, actions, batch, scripting | 45% | 120–200 | CLI/MCP/control channel ahead of Photoshop; Actions panel and recording not document-independent (AUTO-219-1/2), no .atn, no ExtendScript/UXP |
+| Automation, actions, batch, scripting | 45% | 120–200 | CLI/MCP/control channel ahead of Photoshop; Actions panel and recording not document-independent (AUTO-219-1/2); `.atn` load/save since 2026-10-12 (112 events mapped, the rest kept verbatim); no ExtendScript/UXP |
 | File I/O | 60% | 300–500 | See [file-format-parity.md](file-format-parity.md) |
 | Print, export, Save for Web | 50% | 60–100 | JPEG Options dialog missing (FILE-215-19), no Photoshop PDF, no separations, Save for Web settings not remembered |
 | Video / timeline, data-driven graphics | 30% | 100–200 | Menu items live; frame model persists in `.pcraft`; no PSD video-layer mapping |
 | Workspace, panels, preferences | 40% | 150–250 | 46 of 149 prefs do nothing; no floating/OS-window panel groups; Libraries, Comments, Contextual Task Bar missing |
 | AI / generative | 10% | 300–600 | See the dimension row |
 
+Batch supports [output naming templates](batch-naming.md); AUTO-219-5 remains partial.
+
 ## Remaining effort and calibration
 
 **Calibration.** The repository's history from the first commit (2026-09-30) to 2026-10-10: 1,152
@@ -450,7 +452,7 @@ filled bar. This extends UI reachability and does not claim Photoshop-authored s
 | Stability | Never-crash lint series, crash guard, `panic_hunt` fuzzing in the gate | medium-high | No field crash data yet. |
 | Camera RAW | DNG, CR2, Sony ARW (lossless + compressed), Nikon NEF (lossless + lossy compressed), RW2, uncompressed ORF; 2026-10-09: uncompressed Fujifilm RAF, Bayer and X-Trans (edge-directed X-Trans demosaic; 26 MP X-Trans develop 306 ms on 12 cores) | medium | CR3, compressed RAF and Nikon "lossy after split" still open (#50). Non-DNG cameras have no calibration: their colour (matrix + tone curve) is fitted per file to the camera's embedded JPEG, with the neutral sRGB-primaries fallback when the fit doesn't clearly help (2026-10-08: 8 D3200 NEFs, mean ΔE vs the camera JPEG 11.6–26.0 → 1.0–7.5); measured per-model calibration still open. |
 | AI / generative | none | ~0% | Deferred by decision (#41). |
-| Ecosystem | Sandboxed WebAssembly plug-ins instead of .8BF; no ExtendScript/UXP/.atn; no Adobe Fonts/Libraries/cloud docs | low | By design for 8BF; scripting compatibility open. |
+| Ecosystem | Sandboxed WebAssembly plug-ins instead of .8BF; `.atn` actions load and save (2026-10-12); no ExtendScript/UXP; no Adobe Fonts/Libraries/cloud docs | low | By design for 8BF; scripting compatibility open. |
 | Platforms | macOS (notarized), Windows, Linux (AppImage/deb/rpm/Flatpak bundle), web | medium-high | Flathub later (#173); Windows signing material pending. |
 | Localisation | 2026-10-07: 10 UI languages; menu, `tl!`, blend mode, preference and brush-section coverage enforced by tests; live switching and scoped Preferences previews | medium | Engine errors/status messages still partly English; CJK web fonts, browser-locale detection, and RTL remain open. |
 
@@ -481,7 +483,10 @@ best-patch copy and gradient-domain seam hiding. On 20 holes in public-domain ph
 original's texture (Wexler/PatchMatch completion as Content-Aware Fill uses it: 0.54). On a 24 MP
 document a 100 px ring takes 120 ms and a 1000 px ring 2.5 s (`remove_bench`). It is not
 generative: large objects over complex structure fill less convincingly than Photoshop's AI mode
-(#41).
+(#41). 2026-10-12: the options bar has Photoshop's three options: Sample All Layers, Create a new
+layer (the fill lands on a new layer above the target, `paint.remove` `newLayer`) and Remove after
+each stroke; off, the strokes collect as a tint and ↩ (or ✓) applies them together as one job and
+one undo step (`strokes`), Esc (or ⊘) drops them (#1750).
 
 2026-10-08: the tools update above is checked against the current toolbar groups in
 [`panels.rs`](../crates/ui-egui/src/panels.rs), the Pencil and tool-cycle tests in
@@ -560,6 +565,10 @@ See [method, raw measurements and reproduction](five-algorithm-performance.md).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-12 | minor | Free Transform options bar H/V skew fields; percentages unchanged |
+| 2026-10-12 | minor | `.atn` import: 112 events mapped (TrueGrit Texture Supply sets play end to end); percentages unchanged |
+| 2026-10-12 | minor | Photoshop Actions `.atn` load and save (90 events mapped both ways); percentages unchanged |
+| 2026-10-12 | minor | Rows checked against `main` and the regenerated scorecard: menu count 631, Workspace checklist and preference count, transform context menu, Puppet Warp mesh, Select and Mask, anchor-point tools, Smart Object conversion, Stamp Visible, mask targeting, Free Transform commit/cancel, Vietnamese catalog, Windows ARM64; percentages, weights and hours not re-measured |
 | 2026-10-10 | minor | Added measured Tilt-Shift computation/filtered-proxy gains and inconclusive cases; parity percentages and budgets unchanged |
 | 2026-10-10 | minor | Readiness-by-audience table: percent and hours for full, mainstream and essentials; full number confirmed as the additive weighted sum over dimensions (46%, reported ~45%) |
 | 2026-10-10 | minor | Added mainstream-practitioner (~43%) and essentials-user (~61%) numbers with written weights and discounts; full ready-for-real-work rechecked against its written weights (46%, reported ~45%), unchanged |
diff --git a/docs/ui-design.md b/docs/ui-design.md
index f3193b2687..13fd8b99f1 100644
--- a/docs/ui-design.md
+++ b/docs/ui-design.md
@@ -14,19 +14,22 @@
 | Solarized Dark | Ethan Schoonover's Solarized palette: base03 canvas, base02 panels, base0 text, Solarized blue accent |
 | Breeze Light | An adaptation of KDE Plasma's Breeze Light on the Studio layout: cool light blue-grey surfaces a few levels from Breeze's so the app blends into a Plasma desktop, Breeze-style blue accent, 5 px radii, red close button on hover; text and status colours are darker than Breeze's for contrast |
 | Breeze Dark | The same for Breeze Dark: cool dark blue-grey surfaces (darkest canvas, then dock, cards, chrome and controls) near Breeze's, blue accent, 5 px radii; secondary text and status colours are lighter than Breeze's for contrast |
+| Soft Dark | Low-contrast dark on the Studio layout: muted violet-grey surfaces (never near-black), softened off-white text, periwinkle accent, generous 7/10/14 px radii; text still holds 4.5:1 on every surface (`theme.rs` tests) |
+| Soft Light | The light counterpart: pale violet-grey surfaces, softened dark-violet text instead of black, periwinkle accent, the same radii |
 
 Both Breeze themes are our own values close to Plasma's (not a copy of its colour schemes) and put text readability first: every text colour holds 4.5:1 on every surface and on hovered, pressed and selected states (`theme.rs` tests), so their secondary text, accent and status colours are darker (Light) or lighter (Dark) than Breeze's own, and the primary button is a deeper blue with white text.
 
-Edit → Preferences → Interface shows an Appearance Mode selector (Sync with system, Dark, Light) above separate light and dark theme cards with PhotoCraft editor previews and radio choices. Auto is opt-in and follows the operating system while the app is running. On Linux it reads the desktop portal once and then listens for its `SettingChanged` signal (no polling, and the UI repaints only when the value changes); `gsettings` runs at most once at start-up, by absolute path, when the portal gives no answer. A missing system appearance falls back to Dark. New installs keep Photoshop's default: Dark mode with Pro Medium (Studio Light is the saved light theme). Existing saved single-theme preferences migrate to a fixed Dark or Light mode with their chosen theme. The header appearance button cycles Auto → Light → Dark; its icon shows a monitor, moon or sun for the selected mode. Window → Theme and `ui.set {"theme":"classic"}` select a theme and fix the mode to its light or dark family.
+Edit → Preferences → Interface shows an Appearance Mode selector (Sync with system, Dark, Light) above separate light and dark theme cards with PhotoCraft editor previews and radio choices. Auto is opt-in and follows the operating system while the app is running. On Linux it reads the desktop portal once and then listens for its `SettingChanged` signal (no polling, and the UI repaints only when the value changes); `gsettings` runs at most once at start-up, by absolute path, when the portal gives no answer. A missing system appearance falls back to Dark. New installs keep Photoshop's default: Dark mode with Pro Medium (Pro Light is the saved light theme). Existing saved single-theme preferences migrate to a fixed Dark or Light mode with their chosen theme. The header appearance button cycles Auto → Light → Dark; its icon shows a monitor, moon or sun for the selected mode. Window → Theme and `ui.set {"theme":"classic"}` select a theme and fix the mode to its light or dark family.
 
 Window → Theme and macOS PhotoCraft → Appearance also offer Sync with system. Its checkmark follows the saved Auto mode rather than the displayed palette; choosing a manual theme selects its fixed appearance mode.
 
-The toolbar's foreground and background colour chips follow the `Tokens::round_chips` flag. Pro and Classic leave it off and draw Photoshop's overlapping squares with Default Colors and Switch Colors above them. Studio, Studio Light, Solarized Dark, Adwaita, Adwaita Dark, Breeze Light and Breeze Dark (the Studio-layout themes) turn it on and draw large round chips with a curved Switch Colors arrow centred right under them, its heads touching the chips: stacked vertically in one tool column, with Default Colors at their top-right, and side by side in two tool columns, with Default Colors at the toolbar's left edge. Another non-Pro theme can opt in by setting the flag.
+The toolbar's foreground and background colour chips follow the `Tokens::round_chips` flag. Pro and Classic leave it off and draw Photoshop's overlapping squares with Default Colors and Switch Colors above them. Studio, Studio Light, Solarized Dark, Adwaita, Adwaita Dark, Breeze Light, Breeze Dark, Soft Dark and Soft Light (the Studio-layout themes) turn it on and draw large round chips with a curved Switch Colors arrow centred right under them, its heads touching the chips: stacked vertically in one tool column, with Default Colors at their top-right, and side by side in two tool columns, with Default Colors at the toolbar's left edge. Another non-Pro theme can opt in by setting the flag.
 
 ## Rules
 
 - **Colours and radii come from tokens.** Read them with `Tokens::get(ctx)`; never hard-code a colour in a widget.
-- **Shared widgets live in `widgets.rs`:** `card` (panel group; Pro renders a Photoshop tab strip), `value_field`, `slider`/`slider_row`, `toggle`/`checkbox`, `primary_button`/`secondary_button`, `dropdown` (with a chevron icon), `hairline`/`vline`.
+- **Shared widgets live in `widgets.rs`:** `card` (panel group; Pro renders a Photoshop tab strip), `value_field`, `slider`/`slider_row`, `toggle`/`checkbox`, `primary_button`/`secondary_button`, `dropdown` (with a chevron icon), `hairline`/`vline`, `elided_label`.
+- **A label never overflows its row.** Wrap by default. Beside a fixed-width control, or anywhere the row cannot reflow, use `widgets::elided_label(ui, text, max_w)`: a longer translation shrinks with `…` and shows the full string on hover instead of running over its neighbours (#3580). A *redundant* caption may be dropped on a narrow dock where its control already carries the meaning (e.g. the Layers lock icons); an *essential* one elides. This mirrors Photoshop: a fixed layout with elision and tooltips, not per-locale reflow.
 - **Icons:** Lucide SVGs in `assets/icons` (ISC licence), embedded via `icon_data.rs`. Regenerate that file when you add icons.
 - **Fonts:** Inter (UI) and JetBrains Mono (numbers), both OFL. Named families `medium` and `semibold` are available via `theme::medium()` and `theme::semibold()`.
 - **Photoshop layout grammar (Pro):**
diff --git a/docs/ui-dialogs.md b/docs/ui-dialogs.md
new file mode 100644
index 0000000000..032edfde5d
--- /dev/null
+++ b/docs/ui-dialogs.md
@@ -0,0 +1,219 @@
+# Dialogs
+
+Modal and modeless parameter windows in the egui shell. They mirror Photoshop: no dimmed backdrop,
+canvas pan/zoom under an open dialog, Tab cycles text and number fields only, Esc cancels, Enter
+confirms when OK is enabled. Automation drives the same `fields` map as the UI (`ui.dialog.*` in
+[`control-protocol.md`](control-protocol.md)).
+
+## Architecture
+
+| Piece | Location | Role |
+|---|---|---|
+| Frame, routing, OK/Cancel/Esc, stacking | `crates/ui-egui/src/dialogs.rs` | Single hub for every `UiState::dialogs` entry |
+| Alt+Cancel → Reset (opt-in) | `crates/ui-egui/src/dialog_alt_reset.rs` | Relabels Cancel while Alt is held; dispatches per-marker `reset` |
+| Tab-through-fields | `crates/ui-egui/src/field_tab.rs` | Photoshop-style Tab / ⇧Tab (tests in same file) |
+| State | `crates/ui-egui/src/state.rs` | `Dialog`, `DialogKind`, `open_dialog` |
+| Button row | `crates/ui-egui/src/widgets.rs` | `dialog_buttons`, `focus_first_field`; `number_edit` registers for Tab |
+| Menu / command entry | `dialogs::open_command_dialog`, `menus.rs` | Picks a dedicated module, schema dialog, or bare confirm |
+| Filters | `filter_dialog.rs` | Schema from engine params, live preview |
+| Adjustments | `adjust_dialog.rs` | Shared editors with Properties; preview via `adjust_preview` |
+| Generic forms | `view_cmds.rs` | `__form` grids for simple command params |
+| Dedicated bodies | See **Command routing** below | `body` + usually `open` / `confirm` |
+
+**Routing.** Non-command kinds use `DialogKind` alone. `DialogKind::Command` bodies are chosen by
+marker keys on `fields` (`owns()` or `contains_key("__export")`, etc.); **first match in
+`dialogs::show` wins**, so new markers must not collide with an earlier arm. `show`, `confirm`, and
+`cancel` share the same dispatch table—wire all three when adding a dialog.
+
+**Field contract.** `Dialog.fields` is a JSON map: command parameters agents read and write, plus
+private keys prefixed with `__`. Never use `__` for user-facing or engine params.
+
+### `DialogKind` (top-level stack)
+
+| Kind | Body module | Typical entry |
+|---|---|---|
+| `NewDocument` | `new_doc_ui.rs` | File › New, `file.new` with no size params |
+| `About` | `dialogs.rs` (About / Contributors / Models tabs) | Help › About PhotoCraft; `systemInfo: true` → System Info variant |
+| `Command` | Routed—see below | Most menu commands with parameters |
+| `LayerStyle` | `layer_style.rs` | Layer › Layer Style… |
+| `Error` | inline in `dialogs.rs` | `message` field only (e.g. move lock, locked transform) |
+
+### Command routing (`DialogKind::Command`)
+
+Dispatch order matches `dialogs::show` in `dialogs.rs` (check earlier rows before adding a marker).
+
+| Match | Module | Role |
+|---|---|---|
+| `__guideLayout` | `guide_layout_ui.rs` | View › New Guide Layout… |
+| `__fill` | `fill_ui.rs` | Edit › Fill… |
+| `__patternFill` | `pattern_fill_ui.rs` | Pattern Fill layer / New Fill Layer › Pattern… |
+| `__stroke` | `stroke_ui.rs` | Edit › Stroke… |
+| `__createShape` | `shape_dialog.rs` | Click-with-shape-tool creation (rectangle, ellipse, …) |
+| `__deleteLayer` | `delete_layer_prompt.rs` | Layers panel trash confirmation |
+| `__newLayer` | `new_layer_ui.rs` | Layer › New › Layer… (⇧⌘N; ⌥⇧⌘N makes the layer without it) |
+| `__rasterize` | `rasterize_prompt.rs` | Rasterize-before-paint prompt |
+| `__resetAllTools` | `tool_reset.rs` | Reset All Tools confirmation |
+| `__cropPresetNew` / `__cropPresetDelete` | `crop_presets.rs` | New / delete crop preset |
+| `__variables` | `variables_ui.rs` | Image › Variables (Define, Data Sets, Apply) |
+| `__web` / `__print` | `file_ui.rs` | Save for Web, Print |
+| `__colorPicker` | `color_picker_ui.rs` | Foreground/background, nested field/command pickers (see nested keys below) |
+| `__colorRange` | `color_range_ui.rs` | Select › Color Range… |
+| `__prefsui` | `prefs_ui.rs` | Edit › Preferences… and related preset/import subdialogs |
+| `__export` | `export_dialog.rs` | Export As (document or layer) |
+| `__sizing` | `sizing.rs` | Image › Image Size… / Canvas Size… |
+| `__adjust` | `adjust_dialog.rs` | Image › Adjustments… (also sets `__filter` + `__preview` for live preview) |
+| `__filter` | `filter_dialog.rs` (+ `select_mask_view.rs` when `__command` is `select.refineEdge`) | Filter Gallery commands, Edit › Color Settings…, Select and Mask, and other schema dialogs |
+| `__form` | `view_cmds.rs` | Simple param grids (e.g. slice options, many Image › Apply Image-style commands) |
+| (none of the above) | — | **Bare confirm**: title + OK/Cancel only; OK runs `__command` with fields via generic `confirm` |
+
+**Menu shortcut.** `dialogs::open_command_dialog` opens guide layout, stroke, and color range
+directly; then tries `adjust_dialog::open`, then `filter_dialog::open`; otherwise a bare confirm
+with `__command` + `__label`. Other dedicated modules are opened from `menus.rs`, tools, or panel
+actions with their marker already set.
+
+### Shared private keys
+
+| Key | Meaning |
+|---|---|
+| `__command` | Engine command id run on OK (bare confirm, filters, sizing, …) |
+| `__label` | Menu/catalog label for the title |
+| `__document` | Target document id (validate staleness) |
+| `__dialog` / `__field` | Nested color picker: parent dialog id and field name to write on OK |
+| `__params` | Extra command params for command-targeted color pickers |
+| `__preview` | Live canvas preview enabled (filters and adjustments) |
+| `__choices` | Dropdown options for `__form` dialogs |
+| `__filter` | Filter-schema body (`filter_dialog`); also set on adjustments for preview plumbing |
+| `__adjust` | Image › Adjustments editor kind (`adjust_dialog`) |
+| `__form` | Generic `view_cmds::form_body` |
+| `__formOrig` | Snapshot of non-`__` params at open; Alt+Reset restores it for `__form` dialogs |
+| `__variablesOrig` | Snapshot of `__variables` at open; Alt+Reset restores it |
+| `__altReset` | Set to `false` to opt a dialog out of Alt+Cancel → Reset |
+| `__export` | Export As |
+| `__sizing` | Image Size / Canvas Size |
+
+### Routing markers (dedicated `Command` bodies)
+
+| Key | Module |
+|---|---|
+| `__guideLayout` | `guide_layout_ui` |
+| `__fill` | `fill_ui` |
+| `__patternFill` | `pattern_fill_ui` |
+| `__stroke` | `stroke_ui` |
+| `__createShape` | `shape_dialog` |
+| `__deleteLayer` | `delete_layer_prompt` |
+| `__newLayer` | `new_layer_ui` |
+| `__rasterize` | `rasterize_prompt` |
+| `__resetAllTools` | `tool_reset` |
+| `__cropPresetNew`, `__cropPresetDelete` | `crop_presets` |
+| `__variables` | `variables_ui` |
+| `__web`, `__print` | `file_ui` |
+| `__colorPicker` | `color_picker_ui` |
+| `__colorRange` | `color_range_ui` |
+| `__prefsui` | `prefs_ui` (string sub-kind: `prefs`, `presetsIO`, …) |
+
+### Nested color pickers (`__colorPicker` on the stack)
+
+Same hub entry as standalone pickers; `color_picker_ui::confirm` branches on extra keys:
+
+| Extra key | Behaviour |
+|---|---|
+| `__layerStyleColor` | Layer Style child; OK writes effect colour on parent `LayerStyle` dialog |
+| `__textStyleColor` | Character/paragraph style colour (type panels) |
+| `__shapeFill` | Shape layer solid fill via `shape.edit` |
+| `__command` = `layer.fill.solidColor.set` | Solid Color fill layer (no `__shapeFill`) |
+| `__dialog` + `__field` | OK updates one field on a parent command dialog (e.g. Fill › Color…) |
+
+## Parallel modal systems (not the main stack)
+
+| System | Location | When |
+|---|---|---|
+| Unsaved changes | `discard_ui.rs` | Close, Revert, Close Others/All, Exit—Save / Don't Save / Cancel |
+| Shell dialog | `control.rs`, `ui.inspect` id `"shell"` | Workspace, custom pixel aspect, show-extras options |
+| Camera Raw | `camera_raw_ui.rs` | Separate OS window on desktop; see control-protocol § Camera Raw |
+| Error message | `DialogKind::Error` | e.g. `move_lock`—message + OK |
+| Nested pickers | `color_picker_ui` (+ markers in **Nested color pickers**) | Stack on parent; parent confirm refused while child open |
+
+## Rules
+
+### Architecture and commands
+
+1. **Thin UI, engine command on OK.** Run `app.run` or a dedicated `*_ui::confirm`; one history step unless the command itself batches.
+2. **Register in the hub.** Add `owns()` (or a stable marker), `body()`, `open()` if needed, and matching arms in `dialogs::show`, `confirm`, and `cancel` (and `open_command_dialog` when menu-driven).
+3. **Extend existing paths first.** Filters → `filter_dialog`; adjustments → `adjust_dialog`; simple param grids → `__form`; avoid a second modal stack unless product needs Camera Raw–level UX.
+4. **`fields` is the automation contract.** Anything agents must drive lives in named fields, not only in local egui state.
+5. **Remember last-used values** after successful OK where Photoshop does (`filter_dialog::remember`, prefs `dialogs["…"]`, module-specific helpers).
+
+### Chrome and layout
+
+6. **Use `dialog_buttons`** for OK / Cancel / Apply—platform order via `ButtonRole` (macOS default action in the corner).
+7. **Respect width rules** in `dialogs::show` unless `file_ui::dialog_width`, color picker, or kind-specific mins apply (typical 380–440; Layer Style / export / picker up to 600; New Document 800).
+8. **Scroll long bodies** inside the content (`DIALOG_CHROME` for filters); title and button row stay visible.
+9. **Transparent backdrop**—no dimming; previews are judged at true contrast.
+10. **Position:** first open centered; then persist offset (`place_id` per command or kind); title bar drag; clamp on screen.
+11. **Stacking:** only the **top** dialog is interactive; non-top instances render disabled; raise the live dialog if an older modal steals focus.
+
+### Keyboard and focus
+
+12. **Tab / ⇧Tab:** text and number fields only. Frame calls `field_tab::begin` / `end`; each field calls `field_tab::register` (`number_edit` does this; custom `TextEdit` must register manually).
+13. **Do not rely on egui default Tab** through sliders, dropdowns, checkboxes, or preset cards.
+14. **Open on first value:** `first_field_focused` + `widgets::focus_first_field` for value-first dialogs (most filters; Image/Canvas Size; not Select and Mask view keys).
+15. **Select-all on focus** when reached via Tab or field arrows (`field_tab::select_all`; see `value_field`, `new_doc_ui`).
+16. **Enter** confirms when OK is enabled (`can_ok`); exceptions must be explicit (`guide_layout_ui`, color picker).
+17. **Esc** on topmost dialog with no popup open → Cancel. **Click outside does not dismiss** (canvas may still pan/zoom via `free_pointer_over`, `pan_delta`, `free_press`). Esc ignores Alt (it does not become Reset).
+18. **Alt** turns Cancel into **Reset** when the dialog opts in via `dialog_alt_reset::supported` (dialog stays open). Opt-in markers: `__guideLayout`, `__fill`, `__variables`, `__colorPicker`, `__sizing`, `__adjust` (all kinds), `__filter`, `__form`. Each module implements its own `reset`; set `"__altReset": false` to disable.
+
+### Canvas and preview
+
+19. **Live preview** for filters/adjustments uses `filter_preview` / `adjust_preview`; `cancel()` clears preview and related shell state.
+20. **Under-dialog canvas** respects dialog rects and open popups; Hand / Space / middle-button pan on free canvas only.
+
+### Labels and i18n
+
+21. **Titles:** command dialogs use `__label` (catalogued; trailing `…` stripped in chrome); fixed kinds use `dialogs::title` + `tl!`.
+22. **User-visible strings:** `tl!("…")`; command labels from the menu catalog where possible.
+
+### Confirm / cancel safety
+
+23. **Child dialogs first**—refuse parent confirm if a nested color picker is open; cancel parent closes children where implemented.
+24. **Validate before close** when params can be inconsistent (`guide_layout_ui::validate` in `confirm`).
+25. **Disable OK** when required input is missing (`crop_presets::can_confirm`, Preferences Apply when unchanged).
+26. **Preferences over control:** whole-dialog OK/Apply may be refused; safe single prefs via `prefs.set` (see control-protocol).
+
+### Testing
+
+27. **egui_kittest:** open dialog, `run_steps`, key presses, assert `fields` or accessibility roles (`field_tab` tests are the reference harness).
+28. **Tab-order regressions:** add tests when a dialog gains multiple text/number fields.
+29. **Filter preview:** `dialogs.rs` tests for preview persistence across background jobs.
+
+### Anti-patterns
+
+30. No panics in `body` / `confirm` on bad input—errors to status or validation.
+31. No hard-coded colours or radii—`theme::Tokens` and `widgets.rs`.
+32. Do not skip `confirm` dispatch—Enter and `ui.dialog.confirm` use it.
+33. Do not expect click-outside-to-close on `egui::Modal`.
+34. Do not register sliders or dropdowns for `field_tab` unless product explicitly changes Photoshop parity.
+
+## Adding a command dialog (checklist)
+
+1. Choose path: see **Command routing** (`adjust_dialog`, `filter_dialog`, `__form`, `__sizing`, …, or new `*_ui` with a unique marker).
+2. `open`: build `fields` (`__command`, `__label`, params, marker); `app.ui.open_dialog(DialogKind::Command, f)`.
+3. `body(app, ui, &mut fields)`—mutate `fields` only; use shared widgets.
+4. `confirm` / `cancel` arms in `dialogs.rs` (or delegate to module `confirm`).
+5. Tab: register every text/number field; use `value_field` / `number_edit` where possible.
+6. **Alt+Reset (optional):** implement `reset` on the module and add an arm in `dialog_alt_reset` (same dispatch order as `dialogs::show`). Snapshot open values under a `__*Orig` key when Reset should restore “as opened” rather than factory defaults.
+7. Tests: at least open + confirm or Tab sequence if non-trivial; if Alt+Reset is supported, assert Reset restores fields and leaves the dialog open.
+8. If menu-visible: command already in engine; menu id opens dialog via existing menu wiring.
+
+## Known gaps
+
+- **Tab registration** for plain `TextEdit` is manual; generic `__form` string fields may not join `field_tab` unless wired.
+- **“Dialog module”** is any UI routed from `dialogs::show`, not only files named `*dialog*`.
+- **Numeric field parity** (units in expressions, scrubby labels) is tracked in [`ui-parity.md`](ui-parity.md) (Navigation / numeric fields), not duplicated here.
+
+## Revision history
+
+| Date | Change |
+|---|---|
+| 2026-10-11 | Initial doc from dialog codebase audit |
+| 2026-10-11 | Document all `DialogKind` values and `Command` routing markers |
+| 2026-10-11 | Alt+Cancel → Reset hub (`dialog_alt_reset`); opt-in markers |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 1471255196..f2092fd3e2 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity: tools, handles, modifiers and feel
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (History snapshots) · **Target:** Adobe Photoshop 2026
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** minor (smart filter reordering by drag; smart object perspective row corrected to done, #426; Free Transform H/V skew fields; toolbar tool shortcuts can be reassigned; ⇧-dragged guides land on ruler ticks; layer and selection keys; tool keys; spring-loaded tool letters; type formatting keys; Pen Auto Add/Delete, #4144; smart filter rows) · **Target:** Adobe Photoshop 2026
 
 How PhotoCraft's direct manipulation compares with Photoshop 2026 (27.11.0): the toolbox, the
 handles and modifier keys of each gesture, nudging, snapping, numeric precision, navigation,
@@ -29,7 +29,7 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme
 | Move, artboard | Move, Artboard | |
 | Marquee | Rectangular, Elliptical, Single Row, Single Column | |
 | Lasso | Lasso, Polygonal, Magnetic | |
-| Selection | Object Selection, Quick Selection, Magic Wand | |
+| Selection | Object Selection, Quick Selection, Magic Wand | Object Selection's Object Finder (on by default in its options bar): resting the pointer highlights the object a click selects (`select.object` with `point`; ⇧ adds, ⌥ subtracts, ⇧⌥ intersects); dragging keeps the rectangle mode (#4087). Heuristic, not a learned segmenter (#2788). |
 | Crop and slice | Crop, Perspective Crop, Slice, Slice Select | |
 | Frame | Frame (frames are groups clipped by a rectangular or elliptical mask) | |
 | Eyedropper | Eyedropper, Color Sampler, Ruler, Note, Count | |
@@ -66,7 +66,7 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme
 | ⌘-corner distort, ⌘-edge skew, ⌘⌥⇧ perspective, ⇧ rotate in 15° steps | done | |
 | Warp: presets, bend, split crosswise/vertical/horizontal, 3×3–5×5 and custom grids | done | |
 | Options bar X/Y, W/H % with link, angle | done | |
-| Options bar H/V skew fields | missing | |
+| Options bar H/V skew fields | done | `transform_tool.rs` (`Parts`, `skew_about_pivot`): W/H, angle and skew read as Photoshop decomposes the box; `skew_fields_lean_the_box_about_the_reference_point` |
 | Interpolation in the options bar | partial | Bicubic/Bilinear/Nearest; no Bicubic Smoother/Sharper/Automatic, Preserve Details |
 | Commit/cancel buttons in the options bar | missing | #2442 |
 | Right-click menu during transform (Scale, Rotate, Skew, Distort, Perspective, Warp, flips, rotates) | missing | TOOL-214-5 |
@@ -78,7 +78,7 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme
 | Locked layer refused before the drag | missing | fails only at commit (#2585) |
 | Transform a copy (⌥⌘T), step and repeat (⌥⇧⌘T) | done | 2026-10-07 |
 | Transform a targeted alpha channel | missing | BUG-207-4 |
-| Smart object perspective (non-affine) | missing | FILE-215-6, #579 |
+| Smart object perspective (non-affine) | done | FILE-215-6; #579 fixed by #426: Distort / Perspective keep a projective placement, re-rendered from the source, read and written as the PSD `nonAffineTransform` |
 | Type-layer transform while editing (⌘ held), no ⌘-corner distort on type | done | `ui-design.md` |
 | Puppet Warp mesh follows the outline | missing | block grid (TOOL-214-6) |
 
@@ -118,6 +118,7 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme
 |---|---|---|
 | Click corner, drag smooth, ⌥ breaks a handle, ⌘ direct-selects, ⇧ 45° | partial | TOOL-214-10 |
 | Handle on the last point, close-drag handle | partial | #1482 |
+| Pen Auto Add/Delete: click a segment of the active path to add, an anchor to delete; ⇧ suspends it | done | #4144 |
 | Path operations in the options bar (combine, subtract, intersect, exclude) | partial | `layer.combineShapes.*`; Pen options #1397 |
 | On-canvas corner-radius handles on live shapes | missing | TOOL-214-12 |
 | Shape stroke controls (dash, caps, joins, align) | done | TOOL-1053-1, [`shape-strokes.md`](shape-strokes.md) |
@@ -149,6 +150,7 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme
 | Smart guides (magenta alignment lines) | done | |
 | Smart guide distance and spacing labels | missing | |
 | Ruler units px/in/cm/mm/pt/pica/% | done | |
+| ⇧-drag a guide out of a ruler: it lands on the nearest ruler tick | done | `rulers.rs` `snap_to_tick` (#3770) |
 | Status bar follows the ruler unit | partial | #2602 |
 | Ruler corner and gaps drawn as Photoshop | partial | #2600, #2601, #2551 |
 | Guides stored as f64 | missing | `Vec<f32>` (UI-217-20) |
@@ -160,7 +162,7 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme
 | Behaviour | Status | Evidence |
 |---|---|---|
 | Space = Hand, ⌘Space / ⌘⌥Space = zoom in/out, spring-loaded while held | done | `hold_keys.rs` |
-| Hold any tool letter for a temporary tool | missing | #2672 |
+| Hold any tool letter for a temporary tool | done | `spring_tools.rs`: held ≥ 300 ms or used on the canvas, release gives the previous tool back; ⇧ never springs (#2672) |
 | Scrubby zoom | done | `zoom_tool.rs` |
 | Flick panning | done | `flick_pan.rs` (Preferences › Tools › Enable Flick Panning) |
 | Animated zoom | missing | unread pref; #566 |
@@ -181,7 +183,11 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme
 | Shortcut audit | 214 → 0 failures (2026-10-07) | measured then; not re-run here |
 | `.kys` import | done (`engine/src/kys.rs`) | |
 | Shortcut glyphs per platform | done (UI-217-19) | |
+| Toolbar tool shortcut editing | done (#4086): each tool has a row under Tools; assignments persist, removed tools leave the default key group, and unchanged tools keep Shift cycling. Toolbar and flyout hints follow the binding | `tool_shortcuts.rs`, `shortcut_capture_tests.rs` |
 | Brush size/hardness keys on non-US layouts | done (#3109): `[` `]` need AltGr on many layouts, so Photoshop uses other keys there (German: Ö / #, ⇧ for hardness). `layout_keys.rs` has a data table of such layouts (`LAYOUTS`, add rows to support one more) and a fallback for all others: the keys at the US `[` / `]` positions act as `[` / `]` when they don't type brackets. Off once a real bracket is typed; Edit › Keyboard Shortcuts overrides still apply | |
+| Layer and selection keys: ⌘, toggles visibility, ⌘\ targets the mask, / locks transparency, ⌘⌥2 loads luminosity, ⌘⌥⌫ fills from history, Tab / ⇧Tab rename the next layer, ⌥-click a thumbnail fits the layer | done (2026-10-11) | |
+| Tool keys: ← / → turn the brush tip (1°, ⇧ 15°), ⇧-click with Type starts new text over old, Space+F / ⇧Space+F cycle the pasteboard colour | done (2026-10-11) | |
+| Type formatting keys while editing text | done: ⇧⌘K, U, B, I and / toggle All Caps, Underline, Faux Bold, Faux Italic, Strikethrough (off when every selected character has it, else on); ⌥↑/↓ leading ∓2 pt, ⇧⌥↑/↓ baseline shift ±2 pt (10 with ⌘); ⌥←/→ tracking ±20 over a selection (100 with ⌘; a collapsed caret still kerns); ⌥⇧⌘H toggles Hyphenate for the touched paragraphs. One `type.setStyle` step per press (new `leadingBy`/`baselineShiftBy`/`trackingBy`; auto leading starts from its laid-out value); the global ⇧⌘K/U/B/I never fire while typing. Differs: a collapsed caret in non-empty text changes nothing, since the model can't hold a pending style for the next characters typed (empty text takes it as its typing style) (`type_tool.rs`, `input_tests.rs` `type_tool_format_keys_*`) | |
 
 ## Panels and workspace
 
@@ -204,12 +210,25 @@ Paragraph; the rest open as in-app floating windows.
 | Themes: Photoshop's four greys | partial | five themes; #2661 |
 | Document tabs: overflow, context menu, reorder | done | UI-217-6; middle-click close #2570 |
 | Layers panel: wheel steps blend modes, drop on New/Trash | partial | UI-217-14 |
+| Smart filter rows: click selects, drag onto another smart object moves, ⌥-drag copies, drag onto Delete removes | done | `smart_ui.rs`, `layer.smartFilter.transfer` (#4271) |
+| Smart filter rows: drag up or down the stack to reorder (a line marks the drop; the bottom filter is applied first) | done | `smart_ui.rs` `reorder_drop`, `layer.smartFilter.move` |
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-13 | minor | Smart object perspective (non-affine) corrected to done: #426 landed four-corner placements with PSD round trip; scorecard FILE-215-6 flipped |
 | 2026-10-10 | major | First version, from a source audit against Photoshop 2026 27.11.0's shortcuts file and the open issues |
 | 2026-10-10 | minor | Fixed Crop live resize snapping feedback and outdated-camera rendering, applied ratios immediately to centred inscribed previews, and removed two-point options-bar overflow; added pointer, rendering, dropdown/Enter, Swap/X and scrolling regressions |
 | 2026-10-11 | minor | Flick panning done: releasing a moving Hand drag (tool, Space or middle button) glides and decays, gated by Enable Flick Panning |
 | 2026-10-11 | minor | History snapshots: the camera button takes one, snapshot rows return to it as a new state, rename and delete it (#2966) |
+| 2026-10-11 | minor | ⇧-drag a guide out of a ruler lands on the nearest ruler tick (#3770) |
+| 2026-10-11 | minor | Layer and selection keys from Photoshop's shortcut set: ⌘, toggles, ⌘\, /, ⌘⌥2, ⌘⌥⌫, Tab rename-next, ⌥-click thumbnail to fit |
+| 2026-10-11 | minor | Tool keys from Photoshop's shortcut set: ← / → rotate the brush tip, ⇧-click for new type, Space+F canvas colour |
+| 2026-10-11 | minor | Spring-loaded tool letters done (#2672): holding any tool letter (Z included) past 300 ms, or using the canvas while it is down, makes the tool temporary until release |
+| 2026-10-11 | minor | Type formatting keys done: ⇧⌘K, U, B, I and /, ⌥↑/↓, ⇧⌥↑/↓, ⌥←/→ over a selection and ⌥⇧⌘H format the selected type while editing, and no longer reach Color Settings, Desaturate, Auto Color or Inverse |
+| 2026-10-12 | minor | Pen Auto Add/Delete on the active path, with its options-bar checkbox, hover feedback and + / − cursor badge (#4144) |
+| 2026-10-12 | minor | Toolbar tool shortcuts can be reassigned, removed and reset in Keyboard Shortcuts (#4086); capture, restart, group cycling, conflict and text-focus regressions |
+| 2026-10-12 | minor | Smart filter rows can be selected, and dragged (⌥: copied) onto another smart object or onto Delete (#4271) |
+| 2026-10-12 | minor | Free Transform options bar: H and V skew fields; a sheared box reads as skew instead of a taller H |
+| 2026-10-13 | minor | Smart filter rows can be dragged up or down their stack to reorder the filters |
diff --git a/docs/unsharp-mask-performance.md b/docs/unsharp-mask-performance.md
new file mode 100644
index 0000000000..d530cf2f93
--- /dev/null
+++ b/docs/unsharp-mask-performance.md
@@ -0,0 +1,23 @@
+# Unsharp Mask performance
+
+Large-radius native Unsharp Mask uses separable FFT convolution with the original
+discrete Gaussian coefficients and the existing `rustfft` dependency. A streamed
+separable path preserves the original tap order for exact processing.
+
+FFT is eligible for radii 64–1000 with at least 65,536 output pixels, a nonzero
+amount and a zero or negative threshold. Positive thresholds, unstable samples,
+unsupported geometry and insufficient scratch use the exact path. WebAssembly
+retains exact processing. Alpha, selections, edges and cancellation are preserved.
+Smart Sharpen, High Pass and shared blur math are unchanged.
+
+FFT changes summation order and permits small rounding differences. The measured
+maximum was one 8-bit storage level, approximately one 16-bit level, and 8.762e-6
+for the HDR fixture. Exact-path comparisons were byte-identical. Transform axes
+are capped at 32,768; FFT scratch grouping has a 1 GiB budget, excluding document
+tiles. This is not a whole-process memory limit.
+
+Before/after numbers, benchmark methodology, numerical tolerances and preview
+measurement limits are recorded in [PR #2987](https://github.com/storytold/photocraft/pull/2987).
+The comparisons use synthetic images and measure CPU computation, not slider
+event-to-screen latency. No published performance budget or rendering-parity
+floor is raised by these measurements.
diff --git a/packaging/linux/AppRun b/packaging/linux/AppRun
index e8543ee2bb..f04c5f4eab 100755
--- a/packaging/linux/AppRun
+++ b/packaging/linux/AppRun
@@ -35,25 +35,49 @@ integrate() {
   src_desktop="$APPDIR/usr/share/applications/$DESK_ID.desktop"
   [ -f "$src_desktop" ] || return 0
 
-  # Rewrite Exec to this AppImage (the binary is not on the host PATH) and drop
-  # TryExec, which would hide the entry; everything else is shipped as packaged.
+  # If an external AppImage integrator (AppImageLauncher, appimaged, Gear Lever) is
+  # already managing this AppImage, do not write a second launcher (#3623); remove our
+  # own if left over from an earlier run, and still install the hicolor icons below.
   apps="$data/applications"
   mkdir -p "$apps" 2>/dev/null || return 0
-  tmp="$apps/.$DESK_ID.tmp.$$"
-  esc="$(printf '%s' "$appimage" | sed 's/[\\&|]/\\&/g')"
-  if sed -e "s|^Exec=.*|Exec=\"$esc\" %F|" -e '/^TryExec=/d' "$src_desktop" 2>/dev/null >"$tmp"; then
-    if cmp -s "$tmp" "$apps/$DESK_ID.desktop"; then
-      rm -f "$tmp"
-    else
-      if mv -f "$tmp" "$apps/$DESK_ID.desktop" 2>/dev/null; then
-        command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database "$apps" >/dev/null 2>&1
-      else
-        rm -f "$tmp"
+  external=0
+  if [ -n "${DESKTOPINTEGRATION:-}" ]; then
+    external=1
+  else
+    for f in "$apps"/*.desktop; do
+      if [ ! -f "$f" ] || [ "$f" = "$apps/$DESK_ID.desktop" ]; then
+        continue
       fi
+      if grep '^Exec=' "$f" 2>/dev/null | grep -Fq "$appimage"; then
+        external=1
+        break
+      fi
+    done
+  fi
+  if [ "$external" = 1 ]; then
+    if [ -f "$apps/$DESK_ID.desktop" ]; then
+      rm -f "$apps/$DESK_ID.desktop" 2>/dev/null || true
+      command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database "$apps" >/dev/null 2>&1
     fi
   else
-    rm -f "$tmp"
-    return 0
+    # Rewrite Exec to this AppImage (the binary is not on the host PATH) and drop
+    # TryExec, which would hide the entry; everything else is shipped as packaged.
+    tmp="$apps/.$DESK_ID.tmp.$$"
+    esc="$(printf '%s' "$appimage" | sed 's/[\\&|]/\\&/g')"
+    if sed -e "s|^Exec=.*|Exec=\"$esc\" %F|" -e '/^TryExec=/d' "$src_desktop" 2>/dev/null >"$tmp"; then
+      if cmp -s "$tmp" "$apps/$DESK_ID.desktop"; then
+        rm -f "$tmp"
+      else
+        if mv -f "$tmp" "$apps/$DESK_ID.desktop" 2>/dev/null; then
+          command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database "$apps" >/dev/null 2>&1
+        else
+          rm -f "$tmp"
+        fi
+      fi
+    else
+      rm -f "$tmp"
+      return 0
+    fi
   fi
 
   # Icons: per-file compare so an unchanged install costs a handful of cmp calls.
diff --git a/packaging/linux/ai.storyteller.photocraft.desktop b/packaging/linux/ai.storyteller.photocraft.desktop
index d1fb15ce84..bee0496f39 100644
--- a/packaging/linux/ai.storyteller.photocraft.desktop
+++ b/packaging/linux/ai.storyteller.photocraft.desktop
@@ -9,7 +9,10 @@ Icon=ai.storyteller.photocraft
 Terminal=false
 # The native runner does not complete desktop startup-notification handshakes.
 StartupNotify=false
-StartupWMClass=photocraft
+StartupWMClass=ai.storyteller.photocraft
 Categories=Graphics;2DGraphics;RasterGraphics;Photography;
 Keywords=photo;image;editor;psd;layers;retouch;paint;
-MimeType=application/x-photocraft;image/x-paintnet;image/openraster;image/vnd.adobe.photoshop;image/x-psd;image/x-psb;image/png;image/jpeg;image/tiff;image/webp;image/gif;image/bmp;image/x-tga;image/x-icon;image/vnd.microsoft.icon;image/x-portable-anymap;image/x-portable-bitmap;image/x-portable-graymap;image/x-portable-pixmap;image/x-exr;image/vnd.radiance;image/avif;image/qoi;
+MimeType=application/x-photocraft;image/x-paintnet;image/openraster;application/x-krita;image/vnd.adobe.photoshop;image/x-psd;image/x-psb;image/png;image/jpeg;image/tiff;image/webp;image/gif;image/bmp;image/x-tga;image/x-icon;image/vnd.microsoft.icon;image/x-portable-anymap;image/x-portable-bitmap;image/x-portable-graymap;image/x-portable-pixmap;image/x-exr;image/vnd.radiance;image/avif;image/qoi;
+# AppRun registers the desktop entry and icons itself (#593); tell external
+# AppImage integrators (AppImageLauncher, appimaged) not to add a duplicate (#3623).
+X-AppImage-Integrate=false
diff --git a/packaging/linux/ai.storyteller.photocraft.metainfo.xml.in b/packaging/linux/ai.storyteller.photocraft.metainfo.xml.in
index 6fbba13511..932ff44e4c 100644
--- a/packaging/linux/ai.storyteller.photocraft.metainfo.xml.in
+++ b/packaging/linux/ai.storyteller.photocraft.metainfo.xml.in
@@ -64,6 +64,7 @@
     <mediatype>application/x-photocraft</mediatype>
     <mediatype>image/x-paintnet</mediatype>
     <mediatype>image/openraster</mediatype>
+    <mediatype>application/x-krita</mediatype>
     <mediatype>image/vnd.adobe.photoshop</mediatype>
     <mediatype>image/x-psb</mediatype>
   </provides>
diff --git a/packaging/linux/apprun-test.sh b/packaging/linux/apprun-test.sh
index 0c81a04052..475fb5ee5e 100755
--- a/packaging/linux/apprun-test.sh
+++ b/packaging/linux/apprun-test.sh
@@ -48,6 +48,7 @@ expected_exec="Exec=\"$(readlink -f "$APPIMAGE")\" %F"
 grep -Fxq "$expected_exec" "$DESKTOP" || fail "Exec not rewritten: $(grep '^Exec=' "$DESKTOP")"
 grep -q '^TryExec=' "$DESKTOP" && fail "TryExec kept, the entry would be hidden"
 grep -Fxq "Icon=$APP_ID" "$DESKTOP" || fail "Icon line lost"
+grep -Fxq "X-AppImage-Integrate=false" "$DESKTOP" || fail "X-AppImage-Integrate=false missing (#3623)"
 grep -Fxq 'Categories=Graphics;2DGraphics;RasterGraphics;Photography;' "$DESKTOP" || fail "metadata lines lost"
 if command -v desktop-file-validate >/dev/null; then
   desktop-file-validate "$DESKTOP" || fail "generated desktop entry is invalid"
@@ -71,23 +72,40 @@ export APPIMAGE="$TMP/moved.AppImage"
 "$APPDIR/AppRun" >/dev/null || fail "launch after move exited non-zero"
 grep -Fxq "Exec=\"$(readlink -f "$APPIMAGE")\" %F" "$DESKTOP" || fail "Exec not refreshed after move"
 
-# 6. Opt-out installs nothing.
+# 6. External AppImage integrator (#3623): if another .desktop file in $XDG_DATA_HOME/applications
+#    already launches this AppImage (e.g. AppImageLauncher's appimagekit-*.desktop), AppRun removes
+#    its own duplicate .desktop entry while keeping the hicolor icons installed.
+ext_desktop="$XDG_DATA_HOME/applications/appimagekit-photocraft.desktop"
+printf '[Desktop Entry]\nType=Application\nName=PhotoCraft\nExec="%s" %%F\nIcon=%s\n' "$(readlink -f "$APPIMAGE")" "$APP_ID" >"$ext_desktop"
+"$APPDIR/AppRun" >/dev/null || fail "launch with external integrator desktop entry exited non-zero"
+[ ! -e "$DESKTOP" ] || fail "duplicate desktop entry kept alongside external integrator entry"
+[ -f "$ext_desktop" ] || fail "external integrator desktop entry removed"
+[ -f "$XDG_DATA_HOME/icons/hicolor/256x256/apps/$APP_ID.png" ] || fail "icons missing with external integrator"
+rm -f "$ext_desktop"
+
+# 7. DESKTOPINTEGRATION set by an external integrator skips creating a second .desktop entry.
+rm -rf "$XDG_DATA_HOME"
+DESKTOPINTEGRATION=AppImageLauncher "$APPDIR/AppRun" >/dev/null || fail "DESKTOPINTEGRATION launch exited non-zero"
+[ ! -e "$DESKTOP" ] || fail "DESKTOPINTEGRATION still wrote duplicate desktop entry"
+[ -f "$XDG_DATA_HOME/icons/hicolor/256x256/apps/$APP_ID.png" ] || fail "icons not installed under DESKTOPINTEGRATION"
+
+# 8. Opt-out installs nothing.
 rm -rf "$XDG_DATA_HOME"
 PHOTOCRAFT_NO_DESKTOP_INTEGRATION=1 "$APPDIR/AppRun" >/dev/null || fail "opt-out launch exited non-zero"
 [ ! -e "$XDG_DATA_HOME" ] || fail "opt-out still integrated"
 
-# 7. An unwritable data dir never blocks the launch.
+# 9. An unwritable data dir never blocks the launch.
 mkdir -p "$TMP/ro" && chmod a-w "$TMP/ro"
 out="$(XDG_DATA_HOME="$TMP/ro/data" "$APPDIR/AppRun" out.txt)" || fail "launch blocked by unwritable data dir"
 [ "$out" = "stub: out.txt" ] || fail "stub not run against unwritable data dir: $out"
 chmod u+w "$TMP/ro"
 
-# 8. No $APPIMAGE (extracted AppDir): launch only, nothing installed.
+# 10. No $APPIMAGE (extracted AppDir): launch only, nothing installed.
 rm -rf "$XDG_DATA_HOME"
 env -u APPIMAGE "$APPDIR/AppRun" >/dev/null || fail "extracted-AppDir launch exited non-zero"
 [ ! -e "$XDG_DATA_HOME" ] || fail "integrated without $APPIMAGE"
 
-# 9. A path that would need Exec escaping (here a `$`): launch only, nothing installed.
+# 11. A path that would need Exec escaping (here a `$`): launch only, nothing installed.
 rm -rf "$XDG_DATA_HOME"
 odd="$TMP/odd\$(id).AppImage"
 : >"$odd"
diff --git a/packaging/macos/Info.plist.in b/packaging/macos/Info.plist.in
index 5dec67ee2e..d325b2b9d6 100644
--- a/packaging/macos/Info.plist.in
+++ b/packaging/macos/Info.plist.in
@@ -6,6 +6,32 @@
 <dict>
   <key>CFBundleDevelopmentRegion</key>
   <string>en</string>
+  <!-- UI translations are embedded in Rust; declare them for AppKit's system dialogs.
+       Keep in sync with LANGUAGES in crates/ui-egui/src/i18n/mod.rs. -->
+  <key>CFBundleLocalizations</key>
+  <array>
+    <string>en</string>
+    <string>ja</string>
+    <string>zh-Hans</string>
+    <string>zh-Hant</string>
+    <string>es</string>
+    <string>ru</string>
+    <string>uk</string>
+    <string>sr</string>
+    <string>cs</string>
+    <string>fr</string>
+    <string>id</string>
+    <string>ko</string>
+    <string>pl</string>
+    <string>de</string>
+    <string>pt-BR</string>
+    <string>el</string>
+    <string>nl</string>
+    <string>it</string>
+    <string>hu</string>
+    <string>tr</string>
+    <string>vi</string>
+  </array>
   <key>CFBundleDisplayName</key>
   <string>PhotoCraft</string>
   <key>CFBundleName</key>
@@ -87,6 +113,21 @@
         <array><string>image/openraster</string></array>
       </dict>
     </dict>
+    <dict>
+      <key>UTTypeIdentifier</key>
+      <string>ai.storyteller.photocraft.kra</string>
+      <key>UTTypeDescription</key>
+      <string>Krita Document</string>
+      <key>UTTypeConformsTo</key>
+      <array><string>public.data</string><string>public.image</string></array>
+      <key>UTTypeTagSpecification</key>
+      <dict>
+        <key>public.filename-extension</key>
+        <array><string>kra</string><string>krz</string></array>
+        <key>public.mime-type</key>
+        <array><string>application/x-krita</string></array>
+      </dict>
+    </dict>
     <dict>
       <key>UTTypeIdentifier</key>
       <string>ai.storyteller.photocraft.pdn</string>
@@ -187,6 +228,7 @@
         <string>ai.storyteller.photocraft.qoi</string>
         <string>ai.storyteller.photocraft.pdn</string>
         <string>ai.storyteller.photocraft.ora</string>
+        <string>ai.storyteller.photocraft.kra</string>
       </array>
     </dict>
   </array>
diff --git a/packaging/web/README.md b/packaging/web/README.md
index 4079c838f6..5ca375f6cc 100644
--- a/packaging/web/README.md
+++ b/packaging/web/README.md
@@ -7,7 +7,7 @@ static site in `photocraft-web-<version>/`:
 |---|---|
 | `index.html` | The page. It loads everything through relative URLs. |
 | `photocraft-web-<hash>.js` | wasm-bindgen glue (generated, ES module) |
-| `photocraft-web-<hash>_bg.wasm` | The app: about 19 MiB raw, 8 MiB with gzip, 5.6 MiB with Brotli (see [Sizes](#sizes)) |
+| `photocraft-web-<hash>_bg.wasm` | The app: about 23 MiB raw, 10.5 MiB with gzip (see [Sizes](#sizes)) |
 | `_headers`, `.htaccess` | Sample header rules for Netlify/Cloudflare Pages and Apache |
 | `fonts/` (optional) | Fonts loaded on demand, listed in `fonts/manifest.txt` (see [Fonts](#fonts)) |
 
@@ -74,19 +74,20 @@ To verify the browser deployment, open the page, open an image and save/export i
 
 ## Sizes
 
-Measured on the 0.2.x build (`packaging/web/package.sh`; gzip `-9`, Brotli quality 11):
+Measured on 2026-10-12 (0.8.0, `packaging/web/package.sh`; gzip `-9`):
 
-| File | Raw | gzip | Brotli |
-|---|---|---|---|
-| `photocraft-web-<hash>_bg.wasm` | 19,680,726 bytes (18.8 MiB) | 8,177,260 (7.8 MiB) | 5,868,731 (5.6 MiB) |
-| `photocraft-web-<hash>.js` | about 160 KB | about 23 KB | about 20 KB |
+| File | Raw | gzip |
+|---|---|---|
+| `photocraft-web-<hash>_bg.wasm` | 24,167,186 bytes (23.0 MiB) | 10,998,053 (10.5 MiB) |
+| `photocraft-web-<hash>.js` | about 170 KB | about 26 KB |
 
 Per-file upload limits: Cloudflare Pages and Workers static assets reject any file over
 **25 MiB** (26,214,400 bytes). The wasm fits, and `packaging/web/package.sh` fails the build if
 it ever grows past 24 MiB, so a release can't ship a file a common host refuses. (Releases up to
 0.2.0 shipped a 25.8 MiB wasm, which Cloudflare rejected; issue #198.) The size comes from the
-`wasm-release` Cargo profile (fat LTO, size-optimized code with the pixel crates kept at full
-speed) plus `wasm-opt -Oz`.
+`wasm-release` Cargo profile (fat LTO, size-optimized code with the pixel and file-decoding
+crates kept at speed) plus `wasm-opt -Oz`, and from storing the bundled fonts (PhotoCraft's and
+egui's) and the translation catalogs compressed, unpacked on first use.
 
 ## Any path works
 
diff --git a/packaging/windows/photocraft.en-us.wxl b/packaging/windows/photocraft.en-us.wxl
index 8c14594d13..faa2835abf 100644
--- a/packaging/windows/photocraft.en-us.wxl
+++ b/packaging/windows/photocraft.en-us.wxl
@@ -7,6 +7,5 @@
   <String Id="WelcomeDlgTitle" Value="{\WixUI_Font_Bigger}Welcome to the [ProductName] [PhotocraftVersion] Setup Wizard" />
   <String Id="WelcomeDlgDescription" Value="The Setup Wizard will install [ProductName] version [PhotocraftVersion] on your computer. Click Next to continue or Cancel to exit the Setup Wizard." />
   <String Id="VerifyReadyDlgInstallTitle" Value="{\WixUI_Font_Title}Ready to install [ProductName] [PhotocraftVersion]" />
-  <String Id="RequiresWindows10" Value="PhotoCraft needs Windows 10 or later. This version of Windows can't run it." />
   <String Id="ExitDialogTitle" Value="{\WixUI_Font_Bigger}Completed the [ProductName] [PhotocraftVersion] Setup Wizard" />
 </WixLocalization>
diff --git a/packaging/windows/photocraft.wxs b/packaging/windows/photocraft.wxs
index d0b490950f..8be9ff893c 100644
--- a/packaging/windows/photocraft.wxs
+++ b/packaging/windows/photocraft.wxs
@@ -31,18 +31,6 @@
         DowngradeErrorMessage="A newer version of PhotoCraft is already installed." />
     <MediaTemplate EmbedCab="yes" CompressionLevel="high" />
 
-    <!-- Windows 10 or later. The Rust standard library has needed it since 1.78: on Windows 7 and
-         8 the app fails at launch with "The procedure entry point ProcessPrng could not be located
-         in bcryptprimitives.dll" (#2310), so the installer says so instead of installing it.
-         `CurrentMajorVersionNumber` exists only from Windows 10 on, in the 32- and 64-bit
-         registry views alike; MSI's own VersionNT has reported both 603 and 1000 there.
-         `Installed` keeps repair and uninstall working on any Windows. -->
-    <Property Id="WINDOWS10ORLATER" Secure="yes">
-      <RegistrySearch Id="WindowsMajorVersion" Root="HKLM" Key="SOFTWARE\Microsoft\Windows NT\CurrentVersion"
-          Name="CurrentMajorVersionNumber" Type="raw" />
-    </Property>
-    <Launch Condition="Installed OR WINDOWS10ORLATER" Message="!(loc.RequiresWindows10)" />
-
     <!-- MSI caches this icon using its Id as the filename. Advertised shortcuts to an
          .exe need an .exe icon identifier (ICE50), even when the source is an ICO. -->
     <Icon Id="PhotocraftIcon.exe" SourceFile="$(var.IconPath)" />
@@ -115,6 +103,8 @@
         <RegistryValue Root="HKLM" Key="Software\Classes\.psb\OpenWithProgids" Name="Photocraft.PhotoshopDocument" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\.pdn\OpenWithProgids" Name="Photocraft.Image" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\.ora\OpenWithProgids" Name="Photocraft.Image" Value="" Type="string" />
+        <RegistryValue Root="HKLM" Key="Software\Classes\.kra\OpenWithProgids" Name="Photocraft.Image" Value="" Type="string" />
+        <RegistryValue Root="HKLM" Key="Software\Classes\.krz\OpenWithProgids" Name="Photocraft.Image" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\.png\OpenWithProgids" Name="Photocraft.Image" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\.jpg\OpenWithProgids" Name="Photocraft.Image" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\.jpeg\OpenWithProgids" Name="Photocraft.Image" Value="" Type="string" />
@@ -138,6 +128,8 @@
         <RegistryValue Root="HKLM" Key="Software\Classes\Applications\photocraft.exe\SupportedTypes" Name=".psb" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\Applications\photocraft.exe\SupportedTypes" Name=".pdn" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\Applications\photocraft.exe\SupportedTypes" Name=".ora" Value="" Type="string" />
+        <RegistryValue Root="HKLM" Key="Software\Classes\Applications\photocraft.exe\SupportedTypes" Name=".kra" Value="" Type="string" />
+        <RegistryValue Root="HKLM" Key="Software\Classes\Applications\photocraft.exe\SupportedTypes" Name=".krz" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\Applications\photocraft.exe\SupportedTypes" Name=".png" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\Applications\photocraft.exe\SupportedTypes" Name=".jpg" Value="" Type="string" />
         <RegistryValue Root="HKLM" Key="Software\Classes\Applications\photocraft.exe\SupportedTypes" Name=".jpeg" Value="" Type="string" />
diff --git a/scorecard/automation.toml b/scorecard/automation.toml
index 002adc76db..7bec4ab443 100644
--- a/scorecard/automation.toml
+++ b/scorecard/automation.toml
@@ -21,9 +21,9 @@ note = "actions.rs:47 copies raw journal entries with explicit layer ids"
 [[item]]
 id = "AUTO-219-2"
 target = "Actions panel: step and dialog toggles, reorder, delete a step, Stop, sets, .atn import"
-status = "missing"
+status = "done"
 issue = 219
-note = "Panel deletes whole actions only (actions.rs:146)"
+note = "2026-10-12: set folders (collapsible, drag between sets, actions.assignSet), dialog toggle column (playback opens the step's dialog seeded with its values and resumes on OK; actions.dialog), Insert Stop… (actions.insert), step toggles, reorder, delete a step; Load/Save Actions (.atn) in the panel menu, CLI batch and actions.load/save (atn_cmds.rs): 90 Photoshop events map to commands both ways, the rest are kept verbatim and fail at playback by name; step toggles, reorder and delete a step done; Stop steps play (actions.stopMessage) but there is no Insert Stop menu item; sets and dialog toggles are stored and round-trip but the panel neither groups by set nor edits the dialog toggle"
 
 [[item]]
 id = "AUTO-219-3"
@@ -35,16 +35,16 @@ note = "actions.list/get/record/stop/play/delete in actions_cmds.rs; the panel,
 [[item]]
 id = "AUTO-219-4"
 target = "Replay tests for crop, filters, selections and styled text on a second document"
-status = "missing"
+status = "done"
 issue = 219
-note = "One replay test (actions.rs:171: new layer, rect select, fill)"
+note = "actions_cmds.rs: a_recorded_edit_run_replays_on_a_second_document records a crop, a Gaussian Blur, a selection fill and faux-bold type on one document and replays all of them onto a second (plus the original layer/select/fill replay)"
 
 [[item]]
 id = "AUTO-219-5"
 target = "Batch: subfolders, open documents, naming template, progress/cancel, error log, stop"
 status = "partial"
 issue = 219
-note = "file_cmds.rs:590-631 folder/array input, per-file errors; no recursion, template or cancel"
+note = "file_cmds.rs and file_cmds/batch_naming.rs: folder/array input, per-file errors, {name}/{serial}/{date} output templates and starting serial; no recursion, open-documents source, cancel or error-log file"
 
 [[item]]
 id = "AUTO-219-6"
diff --git a/scorecard/file_compat.toml b/scorecard/file_compat.toml
index 51f40c3a1b..40b242ea53 100644
--- a/scorecard/file_compat.toml
+++ b/scorecard/file_compat.toml
@@ -43,9 +43,9 @@ note = "smart_ui.rs:31 rows + visibility + editor; no collapse, drag or context
 [[item]]
 id = "FILE-215-6"
 target = "Smart Object corner skew and perspective (quad or homography transform)"
-status = "missing"
+status = "done"
 issue = 215
-note = "doc lib.rs:312 SmartObject.transform is an Affine"
+note = "#426: SmartObject.perspective holds the projective map (transform keeps its affine approximation); Distort / Perspective on a smart object set it (transform_cmds.rs, smart_cmds::set_placement), it re-renders from the source through the homography, Warp composes with it, and the PSD placement reads and writes nonAffineTransform / Trnf (io/blocks.rs placed_projective, smart_map.rs); tests distort_survives_edit_contents, warp_on_a_distorted_smart_object_follows_the_corners, placement survives the save"
 
 [[item]]
 id = "FILE-215-7"
@@ -129,7 +129,7 @@ id = "FILE-215-18"
 target = "Save for Web per-slice settings remembered; Export As remembers and offers nearest scaling"
 status = "partial"
 issue = 215
-note = "file_ui.rs:188 last_web in-session only; export_dialog.rs:16 fixed defaults"
+note = "Save for Web settings survive a restart through the remembered dialog settings in prefs.dialogs (web_cmds::remember_web_settings stores them on a complete export, never the destination; file_ui.rs open_web seeds from the session's last export, else the preferences). export_dialog seeds Export As the same way (seed_remembered: format, quality, transparency, scale, metadata, TGA bits) and confirm remembers them as used. Missing: Export As nearest-neighbour scaling"
 
 [[item]]
 id = "FILE-215-19"
@@ -185,11 +185,11 @@ id = "FILE-216-5"
 target = "Save-path tests: layered TIFF, PDF, SVG, ACO/ASE, .shc, Smart Filters, atomic-save failure"
 status = "partial"
 issue = 216
-note = "Every save path that exists is tested by saving and reading back: layered TIFF io tests/tiff_layers.rs (every_compression_keeps_the_layers, advanced_blending_survives_layered_tiff_in_both_byte_orders), print PDF engine print_cmds/tests.rs (print_dry_run_renders_a_pdf_and_reports_lp decodes the image back), ACO/ASE engine swatch_cmds/tests.rs (aco_round_trip_keeps_16_bit_values_and_books, ase_round_trip_keeps_groups_floats_and_kinds), .shc psd shc.rs shc_round_trips_and_rejects_hostile_input and engine layer_style.rs contour_presets_and_custom_curves_apply_in_one_undo_step, Smart Filters engine tests/smart_psd.rs (smart_filters_survive_psd_in_every_colour_model), atomic-save failure format/src/atomic/tests.rs (BUG-203-6). There is no SVG writer (SVG opens only) and no Photoshop PDF save (FILE-215-10), so those have nothing to test yet; the row stays partial until they exist"
+note = "Every save path that exists is tested by saving and reading back: layered TIFF io tests/tiff_layers.rs (every_compression_keeps_the_layers, advanced_blending_survives_layered_tiff_in_both_byte_orders), print PDF engine print_cmds/tests.rs (print_dry_run_renders_a_pdf_and_reports_the_platform_backend decodes the image back), ACO/ASE engine swatch_cmds/tests.rs (aco_round_trip_keeps_16_bit_values_and_books, ase_round_trip_keeps_groups_floats_and_kinds), .shc psd shc.rs shc_round_trips_and_rejects_hostile_input and engine layer_style.rs contour_presets_and_custom_curves_apply_in_one_undo_step, Smart Filters engine tests/smart_psd.rs (smart_filters_survive_psd_in_every_colour_model), atomic-save failure format/src/atomic/tests.rs (BUG-203-6). There is no SVG writer (SVG opens only) and no Photoshop PDF save (FILE-215-10), so those have nothing to test yet; the row stays partial until they exist"
 
 [[item]]
 id = "FILE-216-6"
 target = "30-50 end-to-end workflow acceptance tasks driven through MCP or commands"
 status = "partial"
 issue = 216
-note = "automation/tests/agent_tasks.rs: 10 MCP tasks"
+note = "automation/tests/agent_tasks.rs: 20 MCP tasks"
diff --git a/scorecard/tools.toml b/scorecard/tools.toml
index ec9bc2a7e9..cbff50e333 100644
--- a/scorecard/tools.toml
+++ b/scorecard/tools.toml
@@ -31,7 +31,7 @@ id = "TOOL-213-4"
 target = "Content-Aware Move tool reusing inpaint completion"
 status = "partial"
 issue = 213
-note = "paint.contentAwareMove (retouch_cmds/content_aware_move.rs: move/extend, Structure 1-7, Color 0-10, Sample All Layers, Transform On Drop's scaleX/scaleY/rotate; background job) + Tool::ContentAwareMove (J group: lasso, then drag; Transform On Drop puts a scale/rotate box on the dropped patch, cam_transform.rs: Enter commits as one step, Esc cancels). Missing: a live preview of the result (the drag and the box show the outline only)"
+note = "paint.contentAwareMove (retouch_cmds/content_aware_move.rs: move/extend, Structure 1-7, Color 0-10, Sample All Layers, Transform On Drop's scaleX/scaleY/rotate; background job) + Tool::ContentAwareMove (J group: lasso, then drag; Transform On Drop puts a scale/rotate box on the dropped patch, cam_transform.rs: Enter commits as one step, Esc cancels). cam_preview.rs: once the pointer or the box rests, the result shows (a cancellable background job on a smaller sampling window, small selections only, #4385). Missing: a progressive preview for big selections"
 
 [[item]]
 id = "TOOL-213-5"
@@ -59,7 +59,7 @@ id = "TOOL-213-8"
 target = "Clone Source: W/H link, drawn overlay (opacity/blend/clip/auto-hide), Alt target cursor"
 status = "partial"
 issue = 213
-note = "Clone Source overlay drawn with opacity, inversion, circular clipping, auto-hide and the Normal/Darken/Lighten/Difference blend against the image under the brush (canvas.rs draw_clone_preview, clone_source::overlay_blend); W/H link (cloneSource.set linked, panel chain button, #3298); custom-tip clipping remains missing"
+note = "Clone Source overlay drawn with opacity, inversion, circular clipping, auto-hide and the Normal/Darken/Lighten/Difference blend against the image under the brush (canvas.rs draw_clone_preview, clone_source::overlay_blend); a shaped tip (sampled bitmap, rotation, roundness) clips the overlay to its outline (brush_cursor::tip_mask, #4372); W/H link (cloneSource.set linked, panel chain button, #3298)"
 
 [[item]]
 id = "TOOL-213-9"
@@ -297,7 +297,7 @@ id = "TOOL-213-19"
 target = "Remove tool: paint over an object (or circle it) and it is filled from its surroundings"
 status = "partial"
 issue = 213
-note = "paint.remove (retouch_cmds/remove.rs, background job) + Tool::Remove in the J flyout; loops close over what they enclose; fill by non-local patch completion with texture features, onion-peel start, best-patch copy and gradient-domain seam hiding (algo/nonlocal.rs, Newson et al. IPOL 2017); sparse holes in tiles (algo/remove.rs). remove_quality on 20 holes in public-domain photos: the fill keeps 0.89 of the texture it replaces (0.54 with Content-Aware Fill's completion), edge gradient 1.03 of the original's; remove_bench 24 MP: 100 px ring 120 ms, 1000 px ring 2.5 s, 3000 px line 1.7 s. Missing: generative AI mode, Remove after each stroke off, live preview of the result"
+note = "paint.remove (retouch_cmds/remove.rs, background job) + Tool::Remove in the J flyout; loops close over what they enclose; fill by non-local patch completion with texture features, onion-peel start, best-patch copy and gradient-domain seam hiding (algo/nonlocal.rs, Newson et al. IPOL 2017); sparse holes in tiles (algo/remove.rs). remove_quality on 20 holes in public-domain photos: the fill keeps 0.89 of the texture it replaces (0.54 with Content-Aware Fill's completion), edge gradient 1.03 of the original's; remove_bench 24 MP: 100 px ring 120 ms, 1000 px ring 2.5 s, 3000 px line 1.7 s. Options bar: Sample All Layers, Create a new layer (the fill on a new layer above, `newLayer`), Remove after each stroke off (strokes collect as a tint and ↩ applies them as one `strokes` job, Esc drops them). Missing: generative AI mode, live preview of the result"
 
 [[item]]
 id = "TOOL-1045-1"
diff --git a/scorecard/type.toml b/scorecard/type.toml
index ea1b35d6b6..ee8a876a41 100644
--- a/scorecard/type.toml
+++ b/scorecard/type.toml
@@ -7,9 +7,9 @@ order = 5
 [[item]]
 id = "TYPE-218-1"
 target = "Type on a path: path shape, glyphs along the curve, caret follows, PSD round trip"
-status = "missing"
+status = "partial"
 issue = 218
-note = "doc text.rs:209 TextShape has Point and Box only"
+note = "TextShape::Path (doc text.rs) with glyphs placed rigidly along the curve by arc length (text warp.rs PathFrame), type.attachToPath and type.detachFromPath (#4365), .pcraft round trip. Missing: clicking a path with the Type tool, the caret and selection following the curve, and PSD path text (it saves as point text)"
 
 [[item]]
 id = "TYPE-218-2"
@@ -23,7 +23,7 @@ id = "TYPE-218-3"
 target = "Thai/Khmer/Indic fallback fonts; golden shaping tests for complex scripts and RTL"
 status = "partial"
 issue = 218
-note = "Thai is covered: THAI_FAMILIES (fonts.rs) lists the Windows, macOS and Linux families and thai_in_latin_font_falls_back_to_installed_thai_font checks a sample with above and below marks (#1909); Arabic and Hebrew fall back too. Khmer and Indic have no fallback list, and there are no per-script golden shaping tests (only a bidi test)"
+note = "Fallback fonts are covered for Thai, Khmer, Lao, Myanmar (THAI_FAMILIES, KHMER_FAMILIES, LAO_FAMILIES, MYANMAR_FAMILIES in fonts.rs; #1909, #3259), the nine Indic scripts (INDIC_FAMILIES: Nirmala UI, Kohinoor and Sangam MN, Noto Sans) and Arabic and Hebrew. Still missing: per-script golden shaping tests against reference output (only smoke tests that an installed font shapes without .notdef, plus a bidi test)"
 
 [[item]]
 id = "TYPE-218-4"
@@ -37,7 +37,7 @@ id = "TYPE-218-5"
 target = "OpenType UI: Character panel buttons, Numerals and Stylistic Sets submenus"
 status = "partial"
 issue = 218
-note = "Type > OpenType toggles (type_extra_cmds.rs:512); no panel buttons or submenus"
+note = "Type > OpenType toggles (type_extra_cmds.rs:512). Character panel (and the Properties Character section) has Photoshop's eight OpenType buttons: Standard Ligatures, Contextual Alternates, Discretionary Ligatures, Swash, Stylistic Alternates, Titling Alternates, Ordinals, Fractions, pressed while the feature is on at the selection and dispatching the type.openType.* commands (type_tool.rs opentype_row; character_panel_opentype_buttons_toggle_and_show_the_feature, #3752). Still missing: the Numerals and Stylistic Sets submenus, and greying out features the font lacks"
 
 [[item]]
 id = "TYPE-218-6"
diff --git a/scorecard/ui.toml b/scorecard/ui.toml
index 3fa79b59fa..84f071b4a2 100644
--- a/scorecard/ui.toml
+++ b/scorecard/ui.toml
@@ -59,7 +59,7 @@ id = "UI-217-8"
 target = "Tool-specific canvas right-click menu; right-click spelling suggestions in text fields"
 status = "partial"
 issue = 217
-note = "paint_mouse.rs brush picker and canvas_tool_menu.rs selection actions; text_field_menu.rs gives every text field its right-click Undo/Cut/Copy/Paste/Delete/Select All menu (#2921); other tools missing; spelling suggestions (edit.checkSpelling suggest) not in the text-field menu yet"
+note = "paint_mouse.rs brush picker and canvas_tool_menu.rs selection actions; text_field_menu.rs gives every text field its right-click Undo/Cut/Copy/Paste/Delete/Select All menu (#2921); other tools missing; the Type tool's edit menu starts with spelling suggestions and Add to Dictionary over a misspelled word (#4370); Ignore / Ignore All, suggestions in the non-editing type menu and in generic text fields are not there yet"
 
 [[item]]
 id = "UI-217-9"
@@ -78,9 +78,9 @@ note = "interface.enableAnimations (prefs_ui.rs sync_animations, #3273) zeroes e
 [[item]]
 id = "UI-217-11"
 target = "Soft dark and soft light themes with picker previews; outlined knobs in light themes"
-status = "missing"
+status = "partial"
 issue = 217
-note = "theme.rs ThemeKind has twelve themes (the four Pro brightness levels, Studio and Studio Light, Classic, Adwaita and Adwaita Dark, Solarized Dark, Breeze Light and Breeze Dark); no Soft dark or Soft light, and no outlined knobs in the light themes"
+note = "theme.rs ThemeKind has fourteen themes: the twelve earlier ones plus Soft Dark and Soft Light (low-contrast Studio-layout palettes, text at 4.5:1, selectable in Preferences with the existing theme-card previews, ui.set {theme}, Window > Theme); outlined knobs in the light themes are still missing"
 
 [[item]]
 id = "UI-217-12"
diff --git a/xtask/pngsuite.sha256 b/xtask/pngsuite.sha256
new file mode 100644
index 0000000000..a13873a568
--- /dev/null
+++ b/xtask/pngsuite.sha256
@@ -0,0 +1,178 @@
+71e1f5bf865131b5d9996e76a78372146283e5089e50f900ae927a6458b62101  PngSuite.LICENSE
+a2853f2be68e460dcb9992819125b74503a01383e79f79a04b971ffa9d248544  PngSuite.README
+6cf3bcd1757bfad2a7ce9c9659d4f609297a0828cafc7c9eddee18c5576ba9e9  PngSuite.png
+9bf1c4610280efecc291361e2b7b026d602d03a7137f476ff84af626bb7b3a62  basi0g01.png
+50ed4ff9c1c80578ae58ead6fb28ea2e44016b5b56a7b3e95c235ec86f97c0d8  basi0g02.png
+0cce4212157dae7c0f71f5f72cef39cecab3347de455da0ace7de83eebd47849  basi0g04.png
+b9300750e7414c9fed68cc7f4f531f5e2cdd2724f50142e8aa3a0070836bece9  basi0g08.png
+d354026bdd0aa6ed7bedea7c92e5eef2ebbd4854848b8a0a48f562cc71bfe80f  basi0g16.png
+b2690d4475cdc39faf5a7d2de20de4e14eb96c6360fa791ec2003b4085ecacde  basi2c08.png
+ae13eba5fabbf7cbe8c01ec4458cdaa7e6bfdfcbd5109e831efaac9f39096027  basi2c16.png
+8e1edfbc0382e0b545c70209271cedead2d530df1ce40f5296f0749226b36006  basi3p01.png
+85f304eaaf6831b2bcc2c08892b947fef52f06337aaf23312d6326e367d73f77  basi3p02.png
+78890ee2c4da71e460b5a1527efe7dc17d673ebe997f49ca1b4dcd7347d21e56  basi3p04.png
+ca103eef7a7c50abc7af9d5ec0dc9fdc07668e2f030adbce226e050dcec9eea3  basi3p08.png
+dfae01a4548e30519157bb51ce29d4de3b35b74288e9568b4d5911de01c6048b  basi4a08.png
+ef7df23ccd912309a4f89ca3c3094bf5ab55add25218e571e51cc6cb11cfad9e  basi4a16.png
+fe70ea20c8447e82abb7bc9dd05344a61a4631cc69e0974378df8f6263af0337  basi6a08.png
+7fdd6bf08f04692bcf06b5c4262e7f76c49d8adb992789fd3f05aa0435645cd8  basi6a16.png
+c8b1364d7771dd2f5a1b2d7d633abcf3f48dafee608558ecd2e5fc98f61894cd  basn0g01.png
+ca172e92d179c77b3d321ad501e452a59bdaafafde8ebd74fd0669c4eae58efc  basn0g02.png
+fb2d42c4c8f5c51590e675994a9b0c718fbf71c80e28142f231cfa7c5b0e26e8  basn0g04.png
+268d061075d1dd2eeec62b31303d09f6998549e1bfb447a5f09c80a2b0978ac3  basn0g08.png
+1a1fe155f40c11d79350b3f84c7eb2b29719037e57073cb7ae2ab9e8323f9360  basn0g16.png
+c90e86090a625661b19960cafdde6e347d6e32d73837aaae533f66dd3f099506  basn2c08.png
+1e1c28ec0ee5da6224404b4005076dd30e2335a1a80c0ca722046a245c4a2b3b  basn2c16.png
+c2d7cd682df5f74506b33a5d70c344aaee248fda79fdfef8e873426fd6f2b75b  basn3p01.png
+0466bb7ed9984cf03b70704564bcffab1df8ec0e8167473ba0f75e4fedce5a8f  basn3p02.png
+e1fc7be978d3149b98533d0076245ae64353b7967290f4204c1282ecb4ec1aba  basn3p04.png
+d58256cd2eb16b5740d4c1403d25ce43d8dd03e270627ab709d2fb141e3d904c  basn3p08.png
+7be24b618bfd437b921ae0caf9341d112338c6290cc62466deb19d2c7a512968  basn4a08.png
+1c92ffd11d2fc89a36f170d0239668436407f5c8e3f8d93483fb3fc6bca361d7  basn4a16.png
+559c594166eb156f461c9beff0f053196730dc998fdb0d2b801c89e6680860a5  basn6a08.png
+8f9d81060aebf4576461403c5057de7f23f73157016b659402b906df805845aa  basn6a16.png
+dfae01a4548e30519157bb51ce29d4de3b35b74288e9568b4d5911de01c6048b  bgai4a08.png
+ef7df23ccd912309a4f89ca3c3094bf5ab55add25218e571e51cc6cb11cfad9e  bgai4a16.png
+559c594166eb156f461c9beff0f053196730dc998fdb0d2b801c89e6680860a5  bgan6a08.png
+8f9d81060aebf4576461403c5057de7f23f73157016b659402b906df805845aa  bgan6a16.png
+71d041df5c8949ce07d5e93b3c9f752cefc75ef7326c49df05ae73915f1a755f  bgbn4a08.png
+c45de44d3442bd33072d68456541b10e0cc57c5d8bfc809208995d939091eb2d  bggn4a16.png
+2da3c3efa01bf166958852a104ece92daaede8ffb5e0452a55d40526258a8bf5  bgwn6a08.png
+875bc2b44a4355551c51260def9664da68be1af8c14b82f76173aaf01ddb1929  bgyn6a16.png
+c88909e74e039dd3df829bf24144b487171e53b17f5c5c07cbc08688247d24b5  ccwn2c08.png
+dc365b39d49c287669d837872dd59aef30763a611dfc8c046c481e35e49a390a  ccwn3p08.png
+438018f19c85e582cb586ac7cca2220008ecb7fc70ce50e8f2a76b494c128a20  cdfn2c08.png
+a068eaf1f7040490e08eda3259befb6689849dd0ff8bb4cc03c705d117cb2b9f  cdhn2c08.png
+ee08dfa303a3c09171280fc1821180dc0a4c3591af7e9077e8ce0435642c76d2  cdsn2c08.png
+a849d89ba3d92146940d7c56d2fe74c9c3ec96725c7f24eefaf44160a6304de2  cdun2c08.png
+587a8624228d3f605f475bd751a1f3a97f0bbab590c0ff518bce5da3abcb6f2b  ch1n3p04.png
+e3cace549047c6e5e693b9b135d53f7f9ca5b1088bf30cc408634598ba53758a  ch2n3p08.png
+79ccaf4abe5091e1f65f8a61496363ed3312ebb9ea1aaa98affadac3d98507de  cm0n0g04.png
+127bb50d224ac3ebff36160482a03b9e6686072e86c8ff4cd43e3ce2271b2315  cm7n0g04.png
+774b384d0ad73698e7d93fc5a29976b332c619045e5966276c609b11459a4152  cm9n0g04.png
+bc812de2b83abc9ae2a6d1ae01e91f9090214b9ed8fee1d56cdfea58f4f259d0  cs3n2c16.png
+267104dced0858dd828cdd41edc0e87042c7094c77191565192a67045064b23f  cs3n3p08.png
+028fa49fbba3954c2eba27a4c3607196e87c1dae74192df3b3ad7afe5e0a3f0c  cs5n2c08.png
+a7a4021983d6b22685529cbafb65cd087c9e1af1c5d205c2e13e3efc4ae87b6a  cs5n3p08.png
+d90ddab7313e4e1fd7f20f16a6c546b449697fbcac1a7776298a74896f4662da  cs8n2c08.png
+5bffdb88e307a851f8e85b137a69c59e557a881db816e990061934c0155c894c  cs8n3p08.png
+081d1ec26b4157fbc032b76dc716321420f2d032a425de046557c7842766826d  ct0n0g04.png
+259116f8ecf849d83d824688eb02b4575aed11980f02ab6fb123281c25a6459d  ct1n0g04.png
+4583e63d1bdfa18b6abb47439dee9a73bed311ed1b0a71d22bed75fe4767832b  cten0g04.png
+d0607280c3539a8934c5cfd22788b382cdc31321cdedc75ae8a29e3948580ba6  ctfn0g04.png
+5f4c87f5a8f589d029a908050880ac5d6aed3810e55e75444802d6d3fb27cf33  ctgn0g04.png
+8ef799e59871755578e563c5b411bc3895c2f7112c115aaa921b6c04fe255bf2  cthn0g04.png
+ca91332ecc04e5faac1f39ca4df4996b072a93f3e574e7f4b50d52aafbfe67b6  ctjn0g04.png
+c0765e635a6423ec64f0314400c3df20745c4a4469ffcc323c7b00ba66b4aceb  ctzn0g04.png
+d04140d74bc60597c47b5aac371a3553d3add9354437bbd8c57007d94e197809  exif2c08.png
+d055cc0bb505b37c6ecf88a808d71675eca5dd0ee683d70ebc9c0be0e1bb8e57  f00n0g08.png
+0fe92b2aa2da04c885d1dbd85c834716f6cdd946364d97dcd597bb79d9e14427  f00n2c08.png
+956ddaf133e6d9a8d36f1e00604d87fbc2d0295e933bb8caaef517e7d87e5342  f01n0g08.png
+ef072ec6815ebf9b33e0553d2e4e4e7ed6911860a2512c67bcd10a9f0f09b9de  f01n2c08.png
+1f5b49c06ecc2a1756f0423b3de936bd18497866d035ac8eded78a6f17408a2c  f02n0g08.png
+ca4b937b3c587d5c007f193a2eec14dc96b0d23ff7d6aa9004e3badd1af9fe8f  f02n2c08.png
+d0563ae30c6ce7a01eae7a5cdc0ef780175bfa7653888ed93f17bef5fe4b2107  f03n0g08.png
+2d101e3ef4f78a69437034671e93fe11faac0cfc4d44210dcca1b944caa886f7  f03n2c08.png
+fec1a3c53833d0ddefa4486a98934c393cb4335b2dc31da70e6540a4686f1457  f04n0g08.png
+c365c24153cb69fd3c162f00b296ae23a71a1595645d1aeb0ad23af680d7b4be  f04n2c08.png
+8ac0f095d2a943157e820fa121bccde08d5230af1b5830c3041d5f4da3524eba  f99n0g04.png
+3494b914dd1b094afa9a74a89bfa75219030e21af6fca3ed66c9d45032a047e9  g03n0g16.png
+abce774b9624952c2d0c57ff681790ba620cf5616fe7e0ef0600600cdce3c22a  g03n2c08.png
+541389db0c72721c6c49501e1dbf6e32df41b4fcfa318676955e278f3f4332b3  g03n3p04.png
+72350a2d9db2df09b626f1f1dd48061e9c749d471bf19814d2c5c10acbf007e5  g04n0g16.png
+bfd3edfc4d85a43383556a51023533fa3888184aa53a6b43769910782beebfce  g04n2c08.png
+5ea85ebefb58b2ab113fc05bf1cb79ffb068359e3a5620843590a0a7b59bd49a  g04n3p04.png
+be19721d28e0b268af1e29e8190c952b94315bd08899383ae2c91e6dc8c4f889  g05n0g16.png
+74ab5b8477992d65e220eeaff8df466522c1b392fa90c6f9935da5bdb7113c9d  g05n2c08.png
+2f46afd7ec15836b523cbce6965f34d89833b8d777afffaf0f53bce620d5f65e  g05n3p04.png
+9070f843981f765cc8e26a63751be5d58631d85a8a7b4e826358f80e8a679d03  g07n0g16.png
+ca4cd32d222f65fb7beb7c9f40d8b6833b36d552b830ff1a1d67dae73b8ed0d8  g07n2c08.png
+b8e7abeabcfd50b71cca78b6cdff7372310cfc179cd63304c3e904f469b333cb  g07n3p04.png
+a22486acb74ee5f947db3a20b1f314a9dd8aca3339840049ee559f4d676a6b5c  g10n0g16.png
+4ac23729aea109e8f6b1e831448115cf02dcd97559e9403847cbe6dd7e5c7347  g10n2c08.png
+36cc2ea4b5b33cd18e0a01c7de85dbcaf7161d258cd0f2265a90cd835b15cf6d  g10n3p04.png
+1fae707d809296d2cf0d6aa653bead6199644fb1c859558ec7d2d69e709a423a  g25n0g16.png
+9b128cfa1bb417dd99251914d729062621fcea9f346168549b16a75fe030b0f6  g25n2c08.png
+4197a0a25c4f74d42c2285d75b9fabe1eedbed45bc224ff1ec1784f5797e9dbf  g25n3p04.png
+1a1fe155f40c11d79350b3f84c7eb2b29719037e57073cb7ae2ab9e8323f9360  oi1n0g16.png
+1e1c28ec0ee5da6224404b4005076dd30e2335a1a80c0ca722046a245c4a2b3b  oi1n2c16.png
+142bc4b1e9f8a9e3b0ba3d2c2025e485bf7e76df88f914bf8c9041b4562cc080  oi2n0g16.png
+2c523f138e0ade1bed8f31d59ec0f34b82660b192d6af8b8f395f82b9ba9dabb  oi2n2c16.png
+aa2d77723ba44f654a41a2ab97e01271fe942fecd2f299c0a81da90acb2887ac  oi4n0g16.png
+661220a0ed03ca6d63ec8dcaac738d4a9fd089b491c40dd896267ffb6cf5015d  oi4n2c16.png
+ae70c9effd0d9957a0d42771bc987529a1f3715e068057fae63f0c7e50d5c53a  oi9n0g16.png
+fef98e9bebe6c4046c29f2568f7a735305c8661aa01f9c37a718135e5bc4f941  oi9n2c16.png
+72406b6173ec20dd059e8cea594ef5bc8f81bac5e416e2b53058d2debd51d195  pp0n2c16.png
+d5a6f964a601a5e1815525117c12c32b61e2aa09fd6040776d35f2f7115b7110  pp0n6a08.png
+b321b9ac8f2aa641475b6936365954181726dcb8662dbf641284d82a83cc22a5  ps1n0g08.png
+6c59d673032fe2d04dbd2ea91cc9bc7bebe7d5ab84911f00e36fb28994793576  ps1n2c16.png
+bd2ae1b45fd771aaa8c57dccd183f3834fc9742f6dfc692606865049efb116e5  ps2n0g08.png
+120c62ce9d014f7772c4b38a446991b5bbe6a22ef5ea59239d32e023bc167585  ps2n2c16.png
+235eb82f1337e3fcefbdca566a53af3d3523db7588ba3cd7fa5dab19afe48a41  s01i3p01.png
+6a4f6da9fe36d195219ad2beeac1a0423e2ee6de03dfb064a3b6fa31623eb230  s01n3p01.png
+e7d26ab4b31e7066b0674a4374c093967a9f1761b96836aa3dbe624acd73ab52  s02i3p01.png
+f4b324f2b1d013ee77f632e42129c7cd3eca55da846e775e744a1f224ad1efcd  s02n3p01.png
+4513dec80f54ffd04a28834b114254d6e6d66e52e32e0059174474f2fb15d6bc  s03i3p01.png
+4dee297bd7f747f87488509af11a1e1e0531fa67e6e8d0f8ab7f4df7940f0ff3  s03n3p01.png
+918f94f3557e10de91efa680df507c8eafc347fa5023af43037701398128ad0f  s04i3p01.png
+e73c52f764b684ec5133cce11f7f18cc60065acdd308e2c3d871e0a792a1080e  s04n3p01.png
+77fe040e17167f9656afe46cf0031832e635745e4e7f19ba12dee32f5ec03d96  s05i3p02.png
+1b9e244a5c1d6cc9830391fff4eac565ada026d000e60faf7525c8add6bdc726  s05n3p02.png
+cf8d5fdb34c0afd38b1b4745bed6167771767ccdfe847c4d8766f7fcc5c41176  s06i3p02.png
+5caabfc4b147fad5e49e558143faaab91888324240acf45e5db8fc49f7a7f667  s06n3p02.png
+d9874bfad10353a9ea2876ee388c3e7f81f697ed141d0d79c5c2019d62a7a698  s07i3p02.png
+e7d447394f5fa64c27353216af387352a77a1fb534922a2d974e60d965d4e414  s07n3p02.png
+62adf855c6b1e3a007f9dcf3ce2ba244616c089269a511dd939e89a4b0853453  s08i3p02.png
+544fdd476e566e8aef4c98604124ae05acef48be20d1aebb9b6674b08b2abbb6  s08n3p02.png
+f2cf5b3109690704d106a0b22ea079e36064cc6077e1fb9a1ba87397d0bbcca1  s09i3p02.png
+6be8f58b638e7f7114750f5796f66f650db8fb7242a36183850f02117f4eaa65  s09n3p02.png
+a27e0dbf923ef868e7399560b76c23a50b2d8926cddd9775e2bc4e050273f205  s32i3p04.png
+c80d9fc7ded0b7834ec11d0e324540c7be74016b61bc302a1d167218fa35fbf9  s32n3p04.png
+cc6ad98dcf686d92f1165d951f90fac70e568cedb1fcbba33e8890d0e6cdad4d  s33i3p04.png
+998d08e084e3eea288984475bfed0d48ee2d8250e20b96755898b59152e36a34  s33n3p04.png
+83eb2e82eb14ae3c608833ef371a6f472c4c6e63b7e9f4f92f5472f975793b97  s34i3p04.png
+a25451168c0b03ab8f52dcc60c6b9c12bc5df5d55afabe1892b87d0a856bb4a0  s34n3p04.png
+db5988c27ad577de1e494cb50229dc2772678531adde2db84493907eae003e54  s35i3p04.png
+cd99fc4cc69bda1ff8e8697d8b423ae8d9e84a58ba1d2b480751953b6869e3b3  s35n3p04.png
+a36b40927b730a31d60c7818fb4a32e67ace06393cdaa26edc09520b6cee066d  s36i3p04.png
+ebc08f6a1e0918c5d3a9a08e184c23019a3cf90d8843e4b71bf2ae16040b1a84  s36n3p04.png
+565c79404c4b9e46c27edb2f93d7b26b93ec0a0481ab7a21fc405152a21f53ba  s37i3p04.png
+964078b1f3f472268b8ac97a8976b4d1cdb6a47e6243d67eddcb0205e65b9f61  s37n3p04.png
+b107f120ffaffcb949ac4547e0f91555ac681f78c7e68c724e7ceddfd8e5387b  s38i3p04.png
+045b0f5ea35874741bf6cac40f2e63ec8726450ab241475df4b7e9303c39e339  s38n3p04.png
+4b5a6d8c04c8c70e1de3bcb6f7b5cc3ba359b13e28de6f52e21a291d4bc8a937  s39i3p04.png
+2115b6cad0140ea97fe6ec056b47307ef1e8b5c00db5f08707a0572b165e5f08  s39n3p04.png
+48a3f19b5c3b2f7eca17fd34765a2a3e385d770f24c357bc66bd74417eb60a5a  s40i3p04.png
+c4598ea73b1ec015bef7dcfd7f67bc7bfc41546619953d1a92cd9b8657a7033a  s40n3p04.png
+c5e7eeaffa677bfac002ee968a0423e0fea3be7701d39ccd6a015df1d2d85e40  tbbn0g04.png
+8fcfd031a5b716201854fdab25691feed6cd3ed7b713a51b94e1f43fc63fe0c1  tbbn2c16.png
+8eb43a6020fda8ed7c8c9b88b974ef794ee8452db29212ae7e5c11003bfd76a3  tbbn3p08.png
+49711ee271f96099521b83b75d58ed2f76d42ed46cb3c06656fde2cad697cf59  tbgn2c16.png
+6f798628935a021fe446dce3d62861d1f7369aaf01bad10daa4917c5abccad7d  tbgn3p08.png
+8223d8b0c5f84b149f0c1f0e1f658346e07fcbd03ffc02b2e9eeea1481eb19bf  tbrn2c08.png
+01e86f108b244bdee4d72e384aced8a62369965ca2993ee6ef88f131c647f7d1  tbwn0g16.png
+978b28cec43bd219517083b63661bb30a7b9cdf9fd4476ab4e70844565980d51  tbwn3p08.png
+7b4eb64b4bd7eb36417752873ddaca027ce77a07f474b2af569f4eea1e984111  tbyn3p08.png
+f05e317f64a038123faf96fdbd6fc3ab3eec14e1fc1eb87fd7da4d996be63526  tm3n3p02.png
+a253e055d8cd94049cd95e9392e7aa60f3d5c922a8f0cccb84762b0c5f547545  tp0n0g08.png
+5dced3fde56b950e61ce86f4ad54458336f66389ce8ca68524d4fd8ec546ff5b  tp0n2c08.png
+da40ddb18bd45db32ed03dc89e2250b096d808efe975a88477e4f5a91a4677c9  tp0n3p08.png
+50bc927fe6cf1816454a7c27f8c743734be8db45e37e5ee3ede540f4e895e6c5  tp1n3p08.png
+4059f7e6a1c5bac1801f70e09f9ec1e1297dcdce34055c13ab2703d6d9613c7e  xc1n0g08.png
+e252a0e7df3e794e52ce4a831edafef76e7043d0d8d84019db0f7fd0b30e20f4  xc9n2c08.png
+3c0c2a68dd416a7be79400e0e2ceb358ba3191d5309d4bad9dd04b32ff6d5b60  xcrn0g04.png
+71e4b2826f61556eda39f3a93c8769b14d3ac90f135177b9373061199dbef39a  xcsn0g01.png
+c1287690808e809dc5d4fb89d8a7fd69ed93521f290abd42021ca00a061a1ba4  xd0n2c08.png
+00b53c3bbd0641454521b982bc6f6bcfda7c91f1874cefb3a9bac37d80a1a269  xd3n2c08.png
+16e5b40fb2600db1af20fb79ff715c2869255e2d4bef20702f16534e5dd6a847  xd9n2c08.png
+f9d1fb2a708703518368c392c74765a6e3e5b49dbb9717df3974452291032df9  xdtn0g01.png
+318864720c8fc0dbe4884035f2183cc3bd3d92ec60d447879982942600e9fe2e  xhdn0g08.png
+968fd21abb8acf40fbca90676de3abcb3a6e35b01ba7a3b9190184eafb99c83d  xlfn0g04.png
+776701227c7094dd10b78f508430b8ea4f03471d072096382cbcca628dea1d2b  xs1n0g01.png
+9dd7e93ba9211f0caee09d8f12e37742936c469f45fcad21e577c9f0640cf99e  xs2n0g01.png
+166c8633d116d1c26631cb98f3a75340cf4385fa7ae6a67913bc78e709bcb30d  xs4n0g01.png
+7a380568beeac969908196ac89cd2347c96ac2f26fdc2b8e0314b62c59f0e308  xs7n0g01.png
+e4767d3259e1b331c9ece9fb07fc30f385879ac12b3cd0e1cb923f3bfac81dcf  z00n2c08.png
+939abfc6e0a3e349bb5bcd8c4e427a6cdb2c7e0c23a773aefa1c4fc9f07e4cb4  z03n2c08.png
+21652fe42f472acd83dcb207806add5737db0020b21d6b38b0a00be3e9e37990  z06n2c08.png
+98d90a7e61aa1a9ac9d99af44dd25c70cd5a7b4a11a85da60f82923e18a78f9f  z09n2c08.png
diff --git a/xtask/src/corpus.rs b/xtask/src/corpus.rs
index 43f943c807..e6c929a1be 100644
--- a/xtask/src/corpus.rs
+++ b/xtask/src/corpus.rs
@@ -1,10 +1,15 @@
 //! `cargo xtask corpus [...]` (fetch test corpora) and `cargo xtask test-corpus [...]` (fetch,
 //! then run the corpus tests). Pins: `corpus_pins.rs`. Docs: `docs/development.md` › Test corpora.
 
-use std::path::PathBuf;
-use std::process::Command;
+use std::collections::BTreeMap;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command, Stdio};
+use std::sync::atomic::{AtomicU64, Ordering};
 
-use crate::corpus_pins::{self, AG_PSD_COMMIT, HEIC_RS_COMMIT, OPENEXR_COMMIT, PHOTOCRAFT_CORPUS_COMMIT, PILLOW_HEIF_COMMIT, PNGSUITE_URL, PSD_TOOLS_COMMIT};
+use crate::corpus_pins::{
+    self, AG_PSD_COMMIT, HEIC_RS_COMMIT, OPENEXR_COMMIT, PHOTOCRAFT_CORPUS_COMMIT, PILLOW_HEIF_COMMIT, PNGSUITE_SHA256, PNGSUITE_URL, PSD_TOOLS_COMMIT,
+};
 use crate::pinned::{PinnedCorpus, USER_AGENT};
 use crate::{cargo, root, run};
 
@@ -119,7 +124,7 @@ fn status(present: bool) -> &'static str {
 fn list() {
     let corpus = root().join("corpus");
     let png = corpus.join("pngsuite");
-    let png_ok = pngsuite_count(&png) > 0;
+    let png_ok = verify_pngsuite(&png, PNGSUITE_MANIFEST).is_ok();
     println!(
         "Test corpora live under {} (gitignored, never committed). The corpus tests are opt-in
 (cargo feature `corpus`) and fail, not skip, when a corpus is missing. CI always runs them.
@@ -162,31 +167,212 @@ Pins: xtask/src/corpus_pins.rs. Moving one: change it, then --<name> --update-ma
     );
 }
 
-fn pngsuite_count(dir: &std::path::Path) -> usize {
-    std::fs::read_dir(dir).map(|d| d.flatten().filter(|e| e.path().extension().is_some_and(|x| x == "png")).count()).unwrap_or(0)
+const PNGSUITE_MANIFEST: &str = include_str!("../pngsuite.sha256");
+const PNGSUITE_MAX_ARCHIVE_BYTES: u64 = 1024 * 1024;
+const PNGSUITE_MAX_FILE_BYTES: u64 = 4 * 1024 * 1024;
+static PNGSUITE_STAGE_ID: AtomicU64 = AtomicU64::new(0);
+
+/// Do not trust cached filenames, symlinks, or a file's size remaining unchanged during a read.
+fn pngsuite_bytes(path: &Path, limit: u64) -> Result<Vec<u8>, String> {
+    let meta = std::fs::symlink_metadata(path).map_err(|e| format!("{}: {e}", path.display()))?;
+    if !meta.is_file() || meta.len() > limit {
+        return Err(format!("{}: expected a regular file of at most {limit} bytes", path.display()));
+    }
+    let mut bytes = Vec::new();
+    std::fs::File::open(path)
+        .map_err(|e| format!("{}: {e}", path.display()))?
+        .take(limit + 1)
+        .read_to_end(&mut bytes)
+        .map_err(|e| format!("{}: {e}", path.display()))?;
+    if bytes.len() as u64 > limit {
+        return Err(format!("{}: exceeds {limit} bytes", path.display()));
+    }
+    Ok(bytes)
 }
 
-/// PngSuite: 175 PNGs from a fixed release archive (skipped when already present).
-fn fetch_pngsuite() -> Result<(), String> {
-    let corpus = root().join("corpus");
+fn verify_pngsuite(dir: &Path, manifest: &str) -> Result<(), String> {
+    let mut expected = BTreeMap::new();
+    for line in manifest.lines() {
+        let Some((hash, name)) = line.split_once("  ") else { return Err("pngsuite: invalid manifest line".into()) };
+        if hash.len() != 64
+            || !hash.bytes().all(|c| c.is_ascii_hexdigit())
+            || name.is_empty()
+            || name.contains("..")
+            || !name.bytes().all(|c| c.is_ascii_alphanumeric() || b"._-".contains(&c))
+            || expected.insert(name, hash).is_some()
+        {
+            return Err("pngsuite: invalid manifest entry".into());
+        }
+    }
+    if expected.is_empty() {
+        return Err("pngsuite: empty manifest".into());
+    }
+    let meta = std::fs::symlink_metadata(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    if !meta.is_dir() {
+        return Err(format!("{}: expected a regular directory", dir.display()));
+    }
+    let entries = std::fs::read_dir(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let mut seen = 0;
+    for entry in entries {
+        let entry = entry.map_err(|e| format!("{}: {e}", dir.display()))?;
+        let name = entry.file_name();
+        let hash = name.to_str().and_then(|n| expected.get(n)).ok_or_else(|| format!("pngsuite: unexpected file {}", entry.path().display()))?;
+        let bytes = pngsuite_bytes(&entry.path(), PNGSUITE_MAX_FILE_BYTES)?;
+        if crate::sha256::hex(&bytes) != **hash {
+            return Err(format!("pngsuite: {}: sha256 mismatch", entry.path().display()));
+        }
+        seen += 1;
+    }
+    if seen != expected.len() {
+        return Err(format!("pngsuite: missing files ({seen} of {})", expected.len()));
+    }
+    Ok(())
+}
+
+struct PngSuiteStage {
+    path: PathBuf,
+    keep: bool,
+}
+
+impl PngSuiteStage {
+    fn new(corpus: &Path) -> Result<Self, String> {
+        std::fs::create_dir_all(corpus).map_err(|e| format!("create {}: {e}", corpus.display()))?;
+        for _ in 0..100 {
+            let id = PNGSUITE_STAGE_ID.fetch_add(1, Ordering::Relaxed);
+            let path = corpus.join(format!(".pngsuite-{}-{id}", std::process::id()));
+            match std::fs::create_dir(&path) {
+                Ok(()) => return Ok(Self { path, keep: false }),
+                Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}
+                Err(e) => return Err(format!("create {}: {e}", path.display())),
+            }
+        }
+        Err("pngsuite: could not create a staging directory".into())
+    }
+}
+
+impl Drop for PngSuiteStage {
+    fn drop(&mut self) {
+        if !self.keep {
+            let _ = std::fs::remove_dir_all(&self.path);
+        }
+    }
+}
+
+/// Keep the old cache until the verified replacement is in place. On a failed rollback its
+/// backup remains in staging and the error names it, rather than deleting the only copy.
+fn install_pngsuite(
+    dest: &Path,
+    files: &Path,
+    backup: &Path,
+    backup_retained: &mut bool,
+    mut rename: impl FnMut(&Path, &Path) -> std::io::Result<()>,
+) -> Result<(), String> {
+    let had_cache = match std::fs::symlink_metadata(dest) {
+        Ok(_) => true,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => false,
+        Err(e) => return Err(format!("{}: {e}", dest.display())),
+    };
+    if had_cache {
+        rename(dest, backup).map_err(|e| format!("pngsuite: preserve {}: {e}", dest.display()))?;
+        *backup_retained = true;
+    }
+    if let Err(e) = rename(files, dest) {
+        if had_cache && let Err(restore) = rename(backup, dest) {
+            return Err(format!("pngsuite: install failed ({e}); restore failed ({restore}); old cache retained at {}", backup.display()));
+        }
+        *backup_retained = false;
+        return Err(format!("pngsuite: install failed: {e}"));
+    }
+    *backup_retained = false;
+    Ok(())
+}
+
+fn fetch_pngsuite_in(
+    corpus: &Path,
+    archive_hash: &str,
+    manifest: &str,
+    download: impl FnOnce(&Path) -> Result<(), String>,
+    extract: impl FnOnce(&Path, &Path) -> Result<(), String>,
+    rename: impl FnMut(&Path, &Path) -> std::io::Result<()>,
+) -> Result<(), String> {
     let dest = corpus.join("pngsuite");
-    let have = pngsuite_count(&dest);
-    if have >= 175 {
-        println!("pngsuite: {have} PNG files in {} already", dest.display());
+    if verify_pngsuite(&dest, manifest).is_ok() {
+        println!("pngsuite: {} already matches its manifest", dest.display());
         return Ok(());
     }
-    std::fs::create_dir_all(&dest).map_err(|e| format!("create {}: {e}", dest.display()))?;
-    let tgz = corpus.join("PngSuite-2017jul19.tgz");
-    let mut curl = Command::new("curl");
-    curl.args(["-fsSL", "--retry", "3", "-A", USER_AGENT, "-o"]).arg(&tgz).arg(PNGSUITE_URL);
-    run(curl, &format!("curl {PNGSUITE_URL}"))?;
-    let mut tar = Command::new("tar");
-    tar.arg("-xzf").arg(&tgz).arg("-C").arg(&dest);
-    run(tar, "tar -xzf PngSuite-2017jul19.tgz")?;
-    let _ = std::fs::remove_file(&tgz);
-    let n = pngsuite_count(&dest);
-    println!("pngsuite: {n} PNG files in {}", dest.display());
-    if n == 0 { Err("no PNG files extracted".into()) } else { Ok(()) }
+    let mut stage = PngSuiteStage::new(corpus)?;
+    let archive = stage.path.join("archive.tgz");
+    download(&archive)?;
+    let bytes = pngsuite_bytes(&archive, PNGSUITE_MAX_ARCHIVE_BYTES)?;
+    if crate::sha256::hex(&bytes) != archive_hash {
+        return Err("pngsuite: archive sha256 mismatch; nothing extracted".into());
+    }
+    let files = stage.path.join("files");
+    std::fs::create_dir(&files).map_err(|e| format!("create {}: {e}", files.display()))?;
+    extract(&archive, &files)?;
+    verify_pngsuite(&files, manifest)?;
+    let backup = stage.path.join("previous");
+    install_pngsuite(&dest, &files, &backup, &mut stage.keep, rename)?;
+    println!("pngsuite: verified {}", dest.display());
+    Ok(())
+}
+
+/// Older curl versions cannot enforce --max-filesize for unknown-length responses. Write
+/// only the allowed prefix, then probe for excess without spooling that byte to disk.
+fn copy_pngsuite_download(reader: &mut impl Read, writer: &mut impl Write) -> std::io::Result<()> {
+    std::io::copy(&mut reader.take(PNGSUITE_MAX_ARCHIVE_BYTES), writer)?;
+    let mut extra = [0; 1];
+    loop {
+        match reader.read(&mut extra) {
+            Ok(0) => return Ok(()),
+            Ok(_) => return Err(std::io::Error::other(format!("pngsuite: archive exceeds {PNGSUITE_MAX_ARCHIVE_BYTES} bytes"))),
+            Err(e) if e.kind() == std::io::ErrorKind::Interrupted => {}
+            Err(e) => return Err(e),
+        }
+    }
+}
+
+fn finish_pngsuite_download(child: &mut Child, mut reader: impl Read, writer: &mut impl Write) -> Result<(), String> {
+    let result = copy_pngsuite_download(&mut reader, writer).map_err(|e| format!("pngsuite: download: {e}")).and_then(|()| {
+        let status = child.wait().map_err(|e| format!("pngsuite: wait for curl: {e}"))?;
+        if status.success() { Ok(()) } else { Err(format!("pngsuite: curl failed: {status}")) }
+    });
+    if result.is_err() {
+        let _ = child.kill();
+        let _ = child.wait();
+    }
+    result
+}
+
+fn download_pngsuite(mut curl: Command, archive: &Path) -> Result<(), String> {
+    let mut file = std::fs::File::create(archive).map_err(|e| format!("create {}: {e}", archive.display()))?;
+    let mut child = curl.stdout(Stdio::piped()).spawn().map_err(|e| format!("pngsuite: start curl: {e}"))?;
+    let Some(stdout) = child.stdout.take() else {
+        let _ = child.kill();
+        let _ = child.wait();
+        return Err("pngsuite: curl stdout unavailable".into());
+    };
+    finish_pngsuite_download(&mut child, stdout, &mut file)
+}
+
+/// PngSuite: fixed archive checked before tar; every cached file checked on each invocation.
+fn fetch_pngsuite() -> Result<(), String> {
+    fetch_pngsuite_in(
+        &root().join("corpus"),
+        PNGSUITE_SHA256,
+        PNGSUITE_MANIFEST,
+        |archive| {
+            let mut curl = Command::new("curl");
+            curl.args(["-fsSL", "--retry", "3", "--max-filesize", &PNGSUITE_MAX_ARCHIVE_BYTES.to_string(), "-A", USER_AGENT, "-o", "-", PNGSUITE_URL]);
+            download_pngsuite(curl, archive)
+        },
+        |archive, files| {
+            let mut tar = Command::new("tar");
+            tar.arg("-xzf").arg(archive).arg("-C").arg(files);
+            run(tar, "tar -xzf PngSuite-2017jul19.tgz")
+        },
+        |from, to| std::fs::rename(from, to),
+    )
 }
 
 /// Files changed relative to `origin/main` (committed, staged or not).
@@ -286,4 +472,308 @@ mod tests {
     fn all_without_update_manifest_only_verifies() {
         assert!(calls(false, false).iter().all(|(_, u)| !*u));
     }
+
+    const FIXTURE_FILES: &[(&str, &[u8])] = &[("a.png", b"alpha"), ("b.png", b"beta"), ("PngSuite.LICENSE", b"fixture licence")];
+    const FIXTURE_ARCHIVE: &[u8] = b"owned archive fixture";
+
+    struct Fixture(PathBuf);
+
+    impl Fixture {
+        fn new() -> Self {
+            let id = PNGSUITE_STAGE_ID.fetch_add(1, Ordering::Relaxed);
+            let path = std::env::temp_dir().join(format!("photocraft-pngsuite-test-{}-{id}", std::process::id()));
+            std::fs::create_dir(&path).unwrap();
+            Self(path)
+        }
+
+        fn cache(&self) -> PathBuf {
+            self.0.join("pngsuite")
+        }
+
+        fn old_cache(&self) {
+            std::fs::create_dir(self.cache()).unwrap();
+            std::fs::write(self.cache().join("old.png"), b"old cache bytes").unwrap();
+        }
+
+        fn assert_old_cache(&self) {
+            assert_eq!(std::fs::read(self.cache().join("old.png")).unwrap(), b"old cache bytes");
+            assert_eq!(std::fs::read_dir(&self.0).unwrap().count(), 1, "staging was not cleaned");
+        }
+    }
+
+    impl Drop for Fixture {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_dir_all(&self.0);
+        }
+    }
+
+    fn fixture_manifest() -> String {
+        FIXTURE_FILES.iter().map(|(name, bytes)| format!("{}  {name}\n", crate::sha256::hex(bytes))).collect()
+    }
+
+    fn fixture_extract(_: &Path, files: &Path) -> Result<(), String> {
+        for (name, bytes) in FIXTURE_FILES {
+            std::fs::write(files.join(name), bytes).map_err(|e| e.to_string())?;
+        }
+        Ok(())
+    }
+
+    fn fixture_download(archive: &Path) -> Result<(), String> {
+        std::fs::write(archive, FIXTURE_ARCHIVE).map_err(|e| e.to_string())
+    }
+
+    fn fixture_fetch(corpus: &Path) -> Result<(), String> {
+        fetch_pngsuite_in(corpus, &crate::sha256::hex(FIXTURE_ARCHIVE), &fixture_manifest(), fixture_download, fixture_extract, |from, to| {
+            std::fs::rename(from, to)
+        })
+    }
+
+    #[test]
+    fn pngsuite_cache_checks_bytes_names_and_regular_files() {
+        let f = Fixture::new();
+        std::fs::create_dir(f.cache()).unwrap();
+        fixture_extract(Path::new("unused"), &f.cache()).unwrap();
+        assert!(verify_pngsuite(&f.cache(), &fixture_manifest()).is_ok());
+        std::fs::write(f.cache().join("a.png"), b"changed").unwrap();
+        assert!(verify_pngsuite(&f.cache(), &fixture_manifest()).unwrap_err().contains("sha256 mismatch"));
+        fixture_extract(Path::new("unused"), &f.cache()).unwrap();
+        std::fs::remove_file(f.cache().join("a.png")).unwrap();
+        assert!(verify_pngsuite(&f.cache(), &fixture_manifest()).unwrap_err().contains("missing files"));
+        fixture_extract(Path::new("unused"), &f.cache()).unwrap();
+        std::fs::write(f.cache().join("extra.png"), b"extra").unwrap();
+        assert!(verify_pngsuite(&f.cache(), &fixture_manifest()).unwrap_err().contains("unexpected file"));
+        std::fs::remove_file(f.cache().join("extra.png")).unwrap();
+        std::fs::remove_file(f.cache().join("a.png")).unwrap();
+        std::fs::create_dir(f.cache().join("a.png")).unwrap();
+        assert!(verify_pngsuite(&f.cache(), &fixture_manifest()).unwrap_err().contains("regular file"));
+    }
+
+    #[test]
+    fn pngsuite_valid_cache_needs_no_download_or_extraction() {
+        let f = Fixture::new();
+        fixture_fetch(&f.0).unwrap();
+        fetch_pngsuite_in(
+            &f.0,
+            "unused",
+            &fixture_manifest(),
+            |_| panic!("valid cache downloaded"),
+            |_, _| panic!("valid cache extracted"),
+            |_, _| panic!("valid cache renamed"),
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn pngsuite_repairs_unverified_175_file_cache_and_removes_extras() {
+        let f = Fixture::new();
+        std::fs::create_dir(f.cache()).unwrap();
+        for i in 0..175 {
+            std::fs::write(f.cache().join(format!("fake-{i}.png")), b"not a PNG").unwrap();
+        }
+        fixture_fetch(&f.0).unwrap();
+        assert!(verify_pngsuite(&f.cache(), &fixture_manifest()).is_ok());
+        assert_eq!(std::fs::read_dir(f.cache()).unwrap().count(), FIXTURE_FILES.len());
+        assert_eq!(std::fs::read_dir(&f.0).unwrap().count(), 1);
+    }
+
+    #[test]
+    fn pngsuite_unexpected_or_truncated_archive_never_reaches_extractor() {
+        for bad in [b"unexpected".as_slice(), &FIXTURE_ARCHIVE[..4]] {
+            let f = Fixture::new();
+            f.old_cache();
+            let e = fetch_pngsuite_in(
+                &f.0,
+                &crate::sha256::hex(FIXTURE_ARCHIVE),
+                &fixture_manifest(),
+                |a| std::fs::write(a, bad).map_err(|e| e.to_string()),
+                |_, _| panic!("unverified archive reached extractor"),
+                |_, _| panic!("unverified archive reached installation"),
+            )
+            .unwrap_err();
+            assert!(e.contains("archive sha256 mismatch"));
+            f.assert_old_cache();
+        }
+    }
+
+    #[test]
+    fn pngsuite_download_or_extraction_failure_keeps_old_cache() {
+        let f = Fixture::new();
+        f.old_cache();
+        assert!(
+            fetch_pngsuite_in(
+                &f.0,
+                "unused",
+                &fixture_manifest(),
+                |_| Err("offline".into()),
+                |_, _| panic!("failed download extracted"),
+                |_, _| panic!("failed download installed")
+            )
+            .unwrap_err()
+            .contains("offline")
+        );
+        f.assert_old_cache();
+        assert!(
+            fetch_pngsuite_in(
+                &f.0,
+                &crate::sha256::hex(FIXTURE_ARCHIVE),
+                &fixture_manifest(),
+                fixture_download,
+                |_, files| {
+                    std::fs::write(files.join("partial.png"), b"partial").unwrap();
+                    Err("extract failed".into())
+                },
+                |_, _| panic!("failed extraction installed")
+            )
+            .unwrap_err()
+            .contains("extract failed")
+        );
+        f.assert_old_cache();
+        for extra in [false, true] {
+            let e = fetch_pngsuite_in(
+                &f.0,
+                &crate::sha256::hex(FIXTURE_ARCHIVE),
+                &fixture_manifest(),
+                fixture_download,
+                |a, files| {
+                    fixture_extract(a, files)?;
+                    if extra {
+                        std::fs::write(files.join("extra.png"), b"extra").unwrap();
+                    } else {
+                        std::fs::remove_file(files.join("a.png")).unwrap();
+                    }
+                    Ok(())
+                },
+                |_, _| panic!("unverified extraction installed"),
+            )
+            .unwrap_err();
+            assert!(e.contains(if extra { "unexpected file" } else { "missing files" }));
+            f.assert_old_cache();
+        }
+    }
+
+    #[test]
+    fn pngsuite_failed_installation_restores_old_cache() {
+        for fail_backup in [false, true] {
+            let f = Fixture::new();
+            f.old_cache();
+            let e = fetch_pngsuite_in(&f.0, &crate::sha256::hex(FIXTURE_ARCHIVE), &fixture_manifest(), fixture_download, fixture_extract, |from, to| {
+                if (fail_backup && from == f.cache()) || (!fail_backup && from.file_name().is_some_and(|n| n == "files")) {
+                    Err(std::io::Error::other("injected rename failure"))
+                } else {
+                    std::fs::rename(from, to)
+                }
+            })
+            .unwrap_err();
+            assert!(e.contains("injected rename failure"));
+            f.assert_old_cache();
+        }
+    }
+
+    #[test]
+    fn pngsuite_failed_rollback_retains_and_names_the_backup() {
+        let f = Fixture::new();
+        f.old_cache();
+        let e = fetch_pngsuite_in(&f.0, &crate::sha256::hex(FIXTURE_ARCHIVE), &fixture_manifest(), fixture_download, fixture_extract, |from, to| {
+            if from == f.cache() { std::fs::rename(from, to) } else { Err(std::io::Error::other("injected install and rollback failure")) }
+        })
+        .unwrap_err();
+        let stage = std::fs::read_dir(&f.0).unwrap().next().unwrap().unwrap().path();
+        let backup = stage.join("previous");
+        assert!(e.contains(&backup.display().to_string()), "{e}");
+        assert_eq!(std::fs::read(backup.join("old.png")).unwrap(), b"old cache bytes");
+        std::fs::rename(backup, f.cache()).unwrap();
+    }
+
+    #[test]
+    fn pngsuite_reads_are_bounded_and_malformed_manifests_are_rejected() {
+        let f = Fixture::new();
+        let file = f.0.join("large");
+        std::fs::File::create(&file).unwrap().set_len(PNGSUITE_MAX_ARCHIVE_BYTES + 1).unwrap();
+        assert!(pngsuite_bytes(&file, PNGSUITE_MAX_ARCHIVE_BYTES).unwrap_err().contains("regular file"));
+        for malformed in ["", "invalid", "00  a.png", &format!("{}  ../outside\n", crate::sha256::hex(b""))] {
+            assert!(verify_pngsuite(&f.0, malformed).is_err());
+        }
+    }
+
+    #[test]
+    fn pngsuite_download_copy_accepts_boundary_and_never_writes_excess() {
+        let limit = PNGSUITE_MAX_ARCHIVE_BYTES as usize;
+        for len in [limit - 1, limit, limit + 1, limit * 2] {
+            let data = vec![0xa5; len];
+            let mut out = Vec::new();
+            let result = copy_pngsuite_download(&mut std::io::Cursor::new(&data), &mut out);
+            assert_eq!(result.is_ok(), len <= limit);
+            assert_eq!(out, data[..len.min(limit)]);
+        }
+    }
+
+    // The ordinary test invocation returns immediately. Only this test's child command
+    // enables emission; it stays alive so cleanup must kill and reap that particular child.
+    #[test]
+    fn pngsuite_stream_fixture() {
+        if std::env::var_os("PHOTOCRAFT_PNGSUITE_STREAM_TEST").is_some() {
+            let mut out = std::io::stdout().lock();
+            for _ in 0..256 {
+                let _ = out.write_all(&[0xa5; 8192]);
+            }
+            std::thread::park();
+        }
+    }
+
+    fn stream_child() -> Child {
+        Command::new(std::env::current_exe().unwrap())
+            .args(["--exact", "corpus::tests::pngsuite_stream_fixture", "--nocapture"])
+            .env("PHOTOCRAFT_PNGSUITE_STREAM_TEST", "1")
+            .stdout(Stdio::piped())
+            .stderr(Stdio::null())
+            .spawn()
+            .unwrap()
+    }
+
+    #[test]
+    fn pngsuite_oversize_and_io_failures_kill_and_reap_only_the_download_child() {
+        struct FailedRead;
+        impl Read for FailedRead {
+            fn read(&mut self, _: &mut [u8]) -> std::io::Result<usize> {
+                Err(std::io::Error::other("injected read failure"))
+            }
+        }
+        struct FailedWrite;
+        impl Write for FailedWrite {
+            fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {
+                Err(std::io::Error::other("injected write failure"))
+            }
+            fn flush(&mut self) -> std::io::Result<()> {
+                Ok(())
+            }
+        }
+        let mut child = stream_child();
+        let stdout = child.stdout.take().unwrap();
+        let mut out = Vec::new();
+        assert!(finish_pngsuite_download(&mut child, stdout, &mut out).unwrap_err().contains("archive exceeds"));
+        assert_eq!(out.len() as u64, PNGSUITE_MAX_ARCHIVE_BYTES);
+        assert!(child.try_wait().unwrap().is_some());
+
+        let mut child = stream_child();
+        assert!(child.try_wait().unwrap().is_none());
+        assert!(finish_pngsuite_download(&mut child, FailedRead, &mut Vec::new()).unwrap_err().contains("injected read failure"));
+        assert!(child.try_wait().unwrap().is_some());
+
+        let mut child = stream_child();
+        let stdout = child.stdout.take().unwrap();
+        assert!(finish_pngsuite_download(&mut child, stdout, &mut FailedWrite).unwrap_err().contains("injected write failure"));
+        assert!(child.try_wait().unwrap().is_some());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn pngsuite_cache_rejects_symlinks_even_when_target_bytes_match() {
+        let f = Fixture::new();
+        std::fs::create_dir(f.cache()).unwrap();
+        fixture_extract(Path::new("unused"), &f.cache()).unwrap();
+        std::fs::write(f.0.join("target"), b"alpha").unwrap();
+        std::fs::remove_file(f.cache().join("a.png")).unwrap();
+        std::os::unix::fs::symlink(f.0.join("target"), f.cache().join("a.png")).unwrap();
+        assert!(verify_pngsuite(&f.cache(), &fixture_manifest()).unwrap_err().contains("regular file"));
+    }
 }
diff --git a/xtask/src/corpus_pins.rs b/xtask/src/corpus_pins.rs
index b8d3770493..917412709a 100644
--- a/xtask/src/corpus_pins.rs
+++ b/xtask/src/corpus_pins.rs
@@ -40,6 +40,10 @@ pub const ASSET_STORE_TEMPLATE_COMMIT: &str = "f671981ee89d15526285b3cc87b4393d3
 pub const AFFINITY_SAMPLES_COMMIT: &str = "96aca6bd86bbe7a677f1cf0630bd832d23943be8";
 /// PngSuite (public domain), a fixed release archive.
 pub const PNGSUITE_URL: &str = "http://www.schaik.com/pngsuite/PngSuite-2017jul19.tgz";
+/// Fixed archive, corroborated by HTTPS records in opencodecs at 6f070029 and rivet-png at
+/// 134faad8 (corpus/checksums.json and tests/pngsuite/SHA256SUMS). Check the legacy HTTP
+/// download against this committed digest before extraction.
+pub const PNGSUITE_SHA256: &str = "0294b244c95a8342c01b00010cf34abdcabc7c6a34fd0fe1bd963917537bfdc8";
 
 /// `corpus/photoshop`: 258 PSDs authored with Photoshop by the photocraft-corpus generator.
 pub const PHOTOSHOP: PinnedCorpus = PinnedCorpus {
diff --git a/xtask/src/i18n_coverage.rs b/xtask/src/i18n_coverage.rs
index 105f927435..ee337c0b9b 100644
--- a/xtask/src/i18n_coverage.rs
+++ b/xtask/src/i18n_coverage.rs
@@ -94,7 +94,7 @@ fn registered_languages(source: &str) -> Result<Vec<Language>, String> {
         let catalog = if code == "en" {
             None
         } else {
-            // `catalog!("xx")` embeds `xx.tsv` (deflated by ui-egui's build.rs).
+            // `catalog!("xx")` embeds `xx.tsv` (packed by ui-egui's build.rs).
             let marker = "catalog!(\"";
             let start = block.find(marker).ok_or_else(|| format!("language `{code}` has no catalog! entry"))? + marker.len();
             let rest = block.get(start..).ok_or_else(|| format!("language `{code}` has a malformed catalog path"))?;
@@ -579,7 +579,10 @@ mod tests {
             ("el", "el.tsv"),
             ("uk", "uk.tsv"),
             ("nl", "nl.tsv"),
+            ("hu", "hu.tsv"),
+            ("tr", "tr.tsv"),
             ("vi", "vi.tsv"),
+            ("sr", "sr.tsv"),
         ] {
             let catalog_path = root.join("crates/ui-egui/src/i18n").join(path);
             let text = fs::read_to_string(&catalog_path).unwrap_or_default();
@@ -588,4 +591,14 @@ mod tests {
             assert!(missing.is_empty(), "{code}: missing source keys: {missing:#?}");
         }
     }
+    #[test]
+    fn plural_forms_follow_count_expressions_and_dynamic_forms_are_not_literal_keys() {
+        let sources = vec![(
+            PathBuf::from("ui.rs"),
+            r#"trn(lang, r["files"].as_array().map_or(0, Vec::len) as u64, "Saved {n} file", "Saved {n} files");
+               trn(lang, count, one, other);"#
+                .into(),
+        )];
+        assert_eq!(plural_keys(&sources), BTreeSet::from([Key { context: "@plural".into(), source: "Saved {n} file|Saved {n} files".into() }]));
+    }
 }